Annotation of embedaddon/libpdel/http/http_client.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include <sys/types.h>
42: #include <sys/socket.h>
43: #include <sys/syslog.h>
44: #include <sys/queue.h>
45:
46: #include <netinet/in_systm.h>
47: #include <netinet/in.h>
48: #include <arpa/inet.h>
49:
50: #include <assert.h>
51: #include <stdio.h>
52: #include <stdlib.h>
53: #include <stdarg.h>
54: #include <string.h>
55: #include <unistd.h>
56: #include <pthread.h>
57:
58: #include <openssl/ssl.h>
59: #include <openssl/err.h>
60:
61: #include "structs/structs.h"
62: #include "structs/type/array.h"
63:
64: #include "io/ssl_fp.h"
65: #include "util/typed_mem.h"
66:
67: #include "http/http_defs.h"
68: #include "http/http_server.h"
69: #include "http/http_internal.h"
70:
71: #define HTTP_CLIENT_TIMEOUT 90 /* timeout in seconds */
72:
73: /* Cleanup state for http_client_connect() */
74: struct http_client_connect_state {
75: int sock;
76: };
77:
78: /* HTTP client */
79: struct http_client {
80: char *user_agent; /* client user agent name */
81: SSL_CTX *ssl; /* ssl context */
82: http_logger_t *logger; /* error logging routine */
83: struct http_connection_cache
84: *cache; /* cached connections */
85: u_int max_conn; /* max number of connections */
86: pthread_mutex_t mutex; /* mutex for "condvar" */
87: pthread_cond_t condvar; /* connection condition var */
88: u_int num_conn; /* number active connections */
89: TAILQ_HEAD(,http_client_connection)
90: list; /* active connections */
91: };
92:
93: /* HTTP client connection */
94: struct http_client_connection {
95: struct http_client *client; /* client who owns me */
96: struct sockaddr_in peer; /* peer address */
97: struct http_connection *conn; /* connection to server */
98: char *reason; /* reason for failure */
99: u_char got_response; /* response read from server */
100: TAILQ_ENTRY(http_client_connection)
101: next; /* next in client list */
102: };
103:
104: /* Internal functions */
105: static void http_client_connect_cleanup(void *arg);
106:
107: /*********************************************************************
108: HTTP_CLIENT FUNCTIONS
109: *********************************************************************/
110:
111: /*
112: * Create a new client.
113: */
114: struct http_client *
115: http_client_create(struct pevent_ctx *ctx, const char *user_agent,
116: u_int max_conn, u_int max_cache, u_int max_cache_idle,
117: http_logger_t *logger)
118: {
119: struct http_client *client;
120: int got_mutex = 0;
121: int got_cond = 0;
122:
123: /* Sanity check */
124: if (max_conn <= max_cache) {
125: errno = EINVAL;
126: return (NULL);
127: }
128:
129: /* Create new client */
130: if ((client = MALLOC("http_client", sizeof(*client))) == NULL)
131: return (NULL);
132: memset(client, 0, sizeof(*client));
133: client->logger = logger;
134: client->max_conn = max_conn;
135: TAILQ_INIT(&client->list);
136:
137: /* Copy user agent */
138: if ((client->user_agent = STRDUP("http_client.user_agent",
139: user_agent)) == NULL)
140: goto fail;
141:
142: /* Initialize connection cache */
143: if ((client->cache = _http_connection_cache_create(
144: ctx, max_cache, max_cache_idle)) == NULL)
145: goto fail;
146:
147: /* Initialize mutex */
148: if ((errno = pthread_mutex_init(&client->mutex, NULL)) != 0)
149: goto fail;
150: got_mutex = 1;
151:
152: /* Initialize condition variable */
153: if ((errno = pthread_cond_init(&client->condvar, NULL)) != 0)
154: goto fail;
155: got_cond = 1;
156:
157: /* Done */
158: return (client);
159:
160: fail:
161: /* Clean up after failure */
162: if (got_cond)
163: pthread_cond_destroy(&client->condvar);
164: if (got_mutex)
165: pthread_mutex_destroy(&client->mutex);
166: _http_connection_cache_destroy(&client->cache);
167: FREE("http_client.user_agent", client->user_agent);
168: return (NULL);
169: }
170:
171: /*
172: * Destroy an HTTP client.
173: *
174: * This will return -1 with errno = EBUSY if there are any
175: * associated connections still active.
176: */
177: int
178: http_client_destroy(struct http_client **clientp)
179: {
180: struct http_client *client = *clientp;
181: int r;
182:
183: /* Sanity */
184: if (client == NULL)
185: return (0);
186:
187: /* Acquire mutex */
188: r = pthread_mutex_lock(&client->mutex);
189: assert(r == 0);
190:
191: /* Check for active connections */
192: if (client->num_conn != 0) {
193: r = pthread_mutex_unlock(&client->mutex);
194: assert(r == 0);
195: errno = EBUSY;
196: return (-1);
197: }
198:
199: /* Shut it down */
200: if (client->ssl != NULL)
201: SSL_CTX_free(client->ssl);
202: _http_connection_cache_destroy(&client->cache);
203: r = pthread_mutex_unlock(&client->mutex);
204: assert(r == 0);
205: pthread_cond_destroy(&client->condvar);
206: pthread_mutex_destroy(&client->mutex);
207: FREE("http_client.user_agent", client->user_agent);
208: FREE("http_client", client);
209: *clientp = NULL;
210: return (0);
211: }
212:
213: /*********************************************************************
214: HTTP_CLIENT_CONNECTION FUNCTIONS
215: *********************************************************************/
216:
217: /*
218: * Create a new HTTP connection object from this client.
219: */
220: struct http_client_connection *
221: http_client_connect(struct http_client *client,
222: struct in_addr ip, u_int16_t port, int https)
223: {
224: struct http_client_connection *cc = NULL;
225: struct http_client_connect_state state;
226: struct sockaddr_in sin;
227: FILE *fp = NULL;
228: int sock = -1;
229: int ret;
230: int r;
231:
232: /* Acquire mutex, release if canceled */
233: r = pthread_mutex_lock(&client->mutex);
234: assert(r == 0);
235: pthread_cleanup_push((void (*)(void *))pthread_mutex_unlock,
236: &client->mutex);
237:
238: /* Initialize SSL context for this client if not already done */
239: if (https && client->ssl == NULL) {
240:
241: /* Initialize SSL stuff */
242: _http_ssl_init();
243:
244: /* Initialize new SSL context for this client */
245: if ((client->ssl = SSL_CTX_new(
246: SSLv23_client_method())) == NULL) {
247: ssl_log(NULL, NULL);
248: goto fail;
249: }
250: }
251:
252: /* Set up peer address */
253: memset(&sin, 0, sizeof(sin));
254: #if !defined(__linux__) && !defined(__sun__)
255: sin.sin_len = sizeof(sin);
256: #endif
257: sin.sin_family = AF_INET;
258: sin.sin_addr = ip;
259: sin.sin_port = htons(port);
260:
261: /* See if we have a cached connection to this server */
262: if (client->cache != NULL
263: && _http_connection_cache_get(client->cache, &sin,
264: https ? client->ssl : NULL, &fp, &sock) == 0)
265: goto connected;
266:
267: /* Wait if too many connections already exist */
268: while (client->num_conn >= client->max_conn)
269: pthread_cond_wait(&client->condvar, &client->mutex);
270:
271: /* Get socket */
272: if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
273: (*client->logger)(LOG_ERR,
274: "%s: %s", "socket", strerror(errno));
275: goto fail;
276: }
277:
278: /* Release mutex */
279: r = pthread_mutex_unlock(&client->mutex);
280: assert(r == 0);
281:
282: /* Don't leak socket if thread is canceled */
283: state.sock = sock;
284: pthread_cleanup_push(http_client_connect_cleanup, &state);
285:
286: /* Connect to peer */
287: ret = connect(sock, (struct sockaddr *)&sin, sizeof(sin));
288:
289: /* Remove cleanup hook */
290: pthread_cleanup_pop(0);
291:
292: /* Acquire mutex */
293: r = pthread_mutex_lock(&client->mutex);
294: assert(r == 0);
295:
296: /* Check if connected */
297: if (ret == -1) {
298: (*client->logger)(LOG_ERR, "failed to connect to %s:%u: %s",
299: inet_ntoa(ip), port, strerror(errno));
300: goto fail;
301: }
302:
303: connected:
304: /* Create new client connection object */
305: if ((cc = MALLOC("http_client_connection", sizeof(*cc))) == NULL)
306: goto fail;
307: memset(cc, 0, sizeof(*cc));
308: cc->client = client;
309: cc->peer = sin;
310:
311: /* Create new connection */
312: if ((cc->conn = _http_connection_create(fp, sock, 0, ip, port,
313: client->ssl, client->logger, HTTP_CLIENT_TIMEOUT)) == NULL)
314: goto fail;
315: fp = NULL;
316: sock = -1;
317:
318: /* Try to do keep-alive */
319: cc->conn->keep_alive = 1;
320:
321: /* Add to client connection list */
322: TAILQ_INSERT_TAIL(&client->list, cc, next);
323: client->num_conn++;
324:
325: /* Set some default request headers */
326: if (http_request_set_header(cc->conn->req, 0,
327: HTTP_HEADER_USER_AGENT, "%s", client->user_agent) == -1
328: || http_request_set_header(cc->conn->req, 0,
329: HTTP_HEADER_HOST, "%s:%u", inet_ntoa(ip), port) == -1
330: || http_request_set_header(cc->conn->req, 0,
331: HTTP_HEADER_ACCEPT, "*/*") == -1
332: || http_request_set_header(cc->conn->req, 0,
333: HTTP_HEADER_ACCEPT_CHARSET, "iso-8859-1") == -1
334: || http_request_set_header(cc->conn->req, 0,
335: HTTP_HEADER_ACCEPT_ENCODING, "identity") == -1)
336: goto fail;
337:
338: /* Done */
339: goto done;
340:
341: fail:
342: /* Cleanup after failure */
343: if (cc != NULL) {
344: if (cc->conn != NULL)
345: _http_connection_free(&cc->conn);
346: FREE("http_client_connection", cc);
347: cc = NULL;
348: }
349: if (fp != NULL)
350: fclose(fp);
351: else if (sock != -1)
352: (void)close(sock);
353:
354: done:;
355: /* Done */
356: pthread_cleanup_pop(1);
357: return (cc);
358: }
359:
360: /*
361: * Get local IP address.
362: */
363: struct in_addr
364: http_client_get_local_ip(struct http_client_connection *cc)
365: {
366: return (cc->conn->local_ip);
367: }
368:
369: /*
370: * Get local port.
371: */
372: u_int16_t
373: http_client_get_local_port(struct http_client_connection *cc)
374: {
375: return (cc->conn->local_port);
376: }
377:
378: /*
379: * Get request associated with client.
380: */
381: struct http_request *
382: http_client_get_request(struct http_client_connection *cc)
383: {
384: return (cc->conn->req);
385: }
386:
387: /*
388: * Get response associated with client connection.
389: */
390: struct http_response *
391: http_client_get_response(struct http_client_connection *cc)
392: {
393: struct http_request *const req = cc->conn->req;
394: struct http_response *resp = cc->conn->resp;
395: char buf[128];
396:
397: /* Already got it? */
398: if (cc->got_response)
399: return (resp);
400:
401: /* Send request headers (if not sent already) */
402: if (http_request_send_headers(req) == -1) {
403: snprintf(buf, sizeof(buf), "Error sending request: %s",
404: strerror(errno));
405: return (NULL);
406: }
407:
408: /* Send back body (it was buffered) */
409: _http_message_send_body(req->msg);
410:
411: /* Read response from server */
412: cc->got_response = 1;
413: if (_http_response_read(cc->conn, buf, sizeof(buf)) == -1)
414: resp = NULL;
415:
416: /* Save reason message */
417: cc->reason = STRDUP("http_client_connection.reason", buf);
418: return (resp);
419: }
420:
421: /*
422: * Close a client connection. The connection is cached if appropriate.
423: */
424: void
425: http_client_close(struct http_client_connection **ccp)
426: {
427: struct http_client_connection *const cc = *ccp;
428: struct http_connection *conn;
429: struct http_client *client;
430: struct http_response *resp;
431: int r;
432:
433: /* Sanity */
434: if (cc == NULL)
435: return;
436: *ccp = NULL;
437:
438: /* Get client and connection */
439: client = cc->client;
440: conn = cc->conn;
441:
442: /* Acquire client mutex */
443: r = pthread_mutex_lock(&client->mutex);
444: assert(r == 0);
445:
446: /* Cache connection socket if appropriate */
447: if (conn->keep_alive
448: && client->cache != NULL
449: && (resp = http_client_get_response(cc)) != NULL
450: && _http_head_want_keepalive(resp->msg->head)
451: && _http_connection_cache_put(client->cache,
452: &cc->peer, client->ssl, conn->fp, conn->sock) == 0) {
453: conn->fp = NULL;
454: conn->sock = -1;
455: }
456:
457: /* Remove from active connection list and wakeup next waiting thread */
458: TAILQ_REMOVE(&client->list, cc, next);
459: if (client->num_conn-- == client->max_conn)
460: pthread_cond_signal(&client->condvar);
461:
462: /* Release client mutex */
463: r = pthread_mutex_unlock(&client->mutex);
464: assert(r == 0);
465:
466: /* Shutdown this connection */
467: _http_connection_free(&cc->conn);
468: FREE("http_client_connection.reason", cc->reason);
469: FREE("http_client_connection", cc);
470: }
471:
472: /*
473: * Get response error/reason string.
474: */
475: const char *
476: http_client_get_reason(struct http_client_connection *cc)
477: {
478: if (cc->reason == NULL)
479: return ("Uknown error");
480: return (cc->reason);
481: }
482:
483: /*********************************************************************
484: INTERNAL FUNCTIONS
485: *********************************************************************/
486:
487: /*
488: * Cleanup for http_client_connect() if thread is canceled.
489: */
490: static void
491: http_client_connect_cleanup(void *arg)
492: {
493: const struct http_client_connect_state *const state = arg;
494:
495: close(state->sock);
496: }
497:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_client.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / http