Annotation of embedaddon/libpdel/http/http_connection_cache.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/queue.h>
43:
44: #include <netinet/in.h>
45: #include <arpa/inet.h>
46:
47: #include <stdio.h>
48: #include <stdlib.h>
49: #include <stdarg.h>
50: #include <string.h>
51: #include <unistd.h>
52: #include <assert.h>
53: #include <syslog.h>
54: #include <errno.h>
55: #include <pthread.h>
56: #include <poll.h>
57:
58: #include <openssl/ssl.h>
59:
60: #include "structs/structs.h"
61: #include "structs/type/array.h"
62: #include "sys/alog.h"
63: #include "util/pevent.h"
64: #include "util/typed_mem.h"
65:
66: #include "http/http_server.h"
67: #include "http/http_internal.h"
68:
69: #define MEM_TYPE_CACHE "http_connection_cache"
70: #define MEM_TYPE_CONN "http_connection_cache.connection"
71:
72: /* Connection cache structure */
73: struct http_connection_cache {
74: struct pevent_ctx *ctx; /* event context */
75: u_int max_num; /* max # in cache */
76: u_int max_idle; /* max socket idle */
77: u_int num; /* # in the cache now */
78: struct pevent *timer; /* exipiration timer */
79: pthread_mutex_t mutex; /* mutex */
80: TAILQ_HEAD(, cached_connection) list; /* connection list */
81: };
82:
83: /* Cached connection structure */
84: struct cached_connection {
85: struct sockaddr_in peer; /* peer ip and port */
86: const SSL_CTX *ssl; /* ssl context */
87: time_t expiry; /* when connection expires */
88: int sock; /* connected tcp socket */
89: FILE *fp; /* connected tcp stream */
90: TAILQ_ENTRY(cached_connection) next; /* next in list */
91: };
92:
93: /* Internal functions */
94: static void http_connection_cache_extract(
95: struct http_connection_cache *cache,
96: struct cached_connection *conn, FILE **fpp, int *sockp);
97: static void http_connection_cache_start_timer(
98: struct http_connection_cache *cache);
99: static void http_connection_cache_timeout(void *arg);
100: static int http_connection_cache_check(int sock);
101:
102: /*********************************************************************
103: PUBLIC API FUNCTIONS
104: *********************************************************************/
105:
106: /*
107: * Create a new connection cache.
108: */
109: struct http_connection_cache *
110: _http_connection_cache_create(struct pevent_ctx *ctx,
111: u_int max_num, u_int max_idle)
112: {
113: struct http_connection_cache *cache;
114:
115: /* Sanity check */
116: if (max_num == 0 || max_idle == 0) {
117: errno = EINVAL;
118: return (NULL);
119: }
120:
121: /* Create new cache */
122: if ((cache = MALLOC(MEM_TYPE_CACHE, sizeof(*cache))) == NULL) {
123: alogf(LOG_ERR, "%s: %m", "malloc");
124: return (NULL);
125: }
126:
127: /* Initialize it */
128: memset(cache, 0, sizeof(*cache));
129: TAILQ_INIT(&cache->list);
130: cache->ctx = ctx;
131: cache->max_num = max_num;
132: cache->max_idle = max_idle;
133:
134: /* Initialize mutex */
135: if ((errno = pthread_mutex_init(&cache->mutex, NULL)) != 0) {
136: alogf(LOG_ERR, "%s: %m", "pthread_mutex_init");
137: FREE(MEM_TYPE_CACHE, cache);
138: return (NULL);
139: }
140:
141: /* Done */
142: return (cache);
143: }
144:
145: /*
146: * Destroy a connection cache.
147: */
148: void
149: _http_connection_cache_destroy(struct http_connection_cache **cachep)
150: {
151: struct http_connection_cache *const cache = *cachep;
152: int r;
153:
154: /* Sanity */
155: if (cache == NULL)
156: return;
157: *cachep = NULL;
158:
159: /* Lock cache */
160: r = pthread_mutex_lock(&cache->mutex);
161: assert(r == 0);
162:
163: /* Close all cached connections */
164: while (!TAILQ_EMPTY(&cache->list)) {
165: http_connection_cache_extract(cache,
166: TAILQ_FIRST(&cache->list), NULL, NULL);
167: }
168:
169: /* Cleanup */
170: r = pthread_mutex_unlock(&cache->mutex);
171: assert(r == 0);
172: pthread_mutex_destroy(&cache->mutex);
173: FREE(MEM_TYPE_CACHE, cache);
174: }
175:
176: /*
177: * Get a connection item from the connection cache.
178: *
179: * Returns 0 and sets *fp and *sock if found (and the connection
180: * is removed from the cache), else -1 and errno will be ENOENT.
181: */
182: int
183: _http_connection_cache_get(struct http_connection_cache *cache,
184: const struct sockaddr_in *peer, const SSL_CTX *ssl,
185: FILE **fpp, int *sockp)
186: {
187: struct cached_connection *conn;
188: struct cached_connection *next;
189: int r;
190:
191: /* Cache enabled? */
192: if (cache == NULL)
193: goto not_found;
194: DBG(HTTP_CONNECTION_CACHE, "looking in cache (%d entries)"
195: " for %s:%u, ssl=%p", cache->num, inet_ntoa(peer->sin_addr),
196: ntohs(peer->sin_port), ssl);
197:
198: /* Lock cache */
199: r = pthread_mutex_lock(&cache->mutex);
200: assert(r == 0);
201:
202: /* Find oldest matching connection */
203: for (conn = TAILQ_FIRST(&cache->list); conn != NULL; conn = next) {
204: FILE *fp;
205: int sock;
206:
207: /* Get next element in list */
208: next = TAILQ_NEXT(conn, next);
209:
210: /* See if this element matches */
211: if (conn->peer.sin_addr.s_addr != peer->sin_addr.s_addr
212: || conn->peer.sin_port != peer->sin_port
213: || conn->ssl != ssl)
214: continue;
215:
216: /* Remove element from list */
217: http_connection_cache_extract(cache, conn, &fp, &sock);
218:
219: /* If connection is no longer valid, close and skip it */
220: if (!http_connection_cache_check(sock)) {
221: DBG(HTTP_CONNECTION_CACHE, "old connection fp=%p"
222: " for %s:%u is no longer valid", fp,
223: inet_ntoa(peer->sin_addr), ntohs(peer->sin_port));
224: fclose(fp);
225: continue;
226: }
227: DBG(HTTP_CONNECTION_CACHE, "found connection fp=%p for %s:%u",
228: fp, inet_ntoa(peer->sin_addr), ntohs(peer->sin_port));
229:
230: /* Return it */
231: *fpp = fp;
232: *sockp = sock;
233:
234: /* Done */
235: r = pthread_mutex_unlock(&cache->mutex);
236: assert(r == 0);
237: return (0);
238: }
239:
240: /* Unlock cache */
241: r = pthread_mutex_unlock(&cache->mutex);
242: assert(r == 0);
243:
244: not_found:
245: DBG(HTTP_CONNECTION_CACHE, "nothing found for %s:%u, ssl=%p",
246: inet_ntoa(peer->sin_addr), ntohs(peer->sin_port), ssl);
247: errno = ENOENT;
248: return (-1);
249: }
250:
251: /*
252: * Store a connection in the cache. It is assumed that
253: * calling 'fclose(fp)' implicitly closes 'sock' as well.
254: *
255: * Returns zero if stored, else -1 and sets errno (in which case
256: * caller is responsible for dealing with 'fp' and 'sock').
257: */
258: int
259: _http_connection_cache_put(struct http_connection_cache *cache,
260: const struct sockaddr_in *peer, const SSL_CTX *ssl, FILE *fp, int sock)
261: {
262: struct cached_connection *conn;
263: int r;
264:
265: /* Is cache enabled? */
266: if (cache == NULL) {
267: errno = ENXIO;
268: return (-1);
269: }
270:
271: /* Get a new connection holder */
272: if ((conn = MALLOC(MEM_TYPE_CONN, sizeof(*conn))) == NULL)
273: return (-1);
274: memset(conn, 0, sizeof(*conn));
275: conn->peer = *peer;
276: conn->ssl = ssl;
277: conn->fp = fp;
278: conn->sock = sock;
279:
280: /* Set expiration time */
281: conn->expiry = time(NULL) + cache->max_idle;
282:
283: /* Lock cache */
284: r = pthread_mutex_lock(&cache->mutex);
285: assert(r == 0);
286:
287: /* Is there room in the cache? If not, drop oldest one. */
288: if (cache->num >= cache->max_num) {
289: http_connection_cache_extract(cache,
290: TAILQ_FIRST(&cache->list), NULL, NULL);
291: }
292:
293: /* Add connection to the cache */
294: TAILQ_INSERT_TAIL(&cache->list, conn, next);
295: cache->num++;
296: DBG(HTTP_CONNECTION_CACHE, "connection fp=%p for %s:%u ssl=%p"
297: " cached (%d total)", fp, inet_ntoa(conn->peer.sin_addr),
298: ntohs(conn->peer.sin_port), ssl, cache->num);
299:
300: /* Make sure the timer is running */
301: if (cache->num == 1)
302: http_connection_cache_start_timer(cache);
303:
304: /* Unlock cache */
305: r = pthread_mutex_unlock(&cache->mutex);
306: assert(r == 0);
307:
308: /* Done */
309: return (0);
310: }
311:
312: /*********************************************************************
313: INTERNAL FUNCTIONS
314: *********************************************************************/
315:
316: /*
317: * Remove a cached item from the cache.
318: *
319: * This assumes the cache is locked.
320: */
321: static void
322: http_connection_cache_extract(struct http_connection_cache *cache,
323: struct cached_connection *conn, FILE **fpp, int *sockp)
324: {
325: struct cached_connection *const oldest = TAILQ_FIRST(&cache->list);
326:
327: /* Remove item and decrement count */
328: TAILQ_REMOVE(&cache->list, conn, next);
329: cache->num--;
330:
331: /* If we are the oldest, kill timer in order to restart later */
332: if (conn == oldest)
333: pevent_unregister(&cache->timer);
334:
335: /* Restart timer if any connections left */
336: if (cache->num > 0)
337: http_connection_cache_start_timer(cache);
338:
339: /* Return or close connection */
340: if (fpp != NULL) {
341: *fpp = conn->fp;
342: *sockp = conn->sock;
343: } else
344: fclose(conn->fp);
345:
346: /* Free connection */
347: FREE(MEM_TYPE_CONN, conn);
348: }
349:
350: /*
351: * Start the idle timer based on the oldest item in the cache.
352: *
353: * This assumes the cache is locked.
354: */
355: static void
356: http_connection_cache_start_timer(struct http_connection_cache *cache)
357: {
358: struct cached_connection *const oldest = TAILQ_FIRST(&cache->list);
359: const time_t now = time(NULL);
360: int timeout;
361:
362: /* Don't start timer when not appropriate */
363: if (cache->num == 0
364: || cache->max_idle == 0
365: || cache->timer != NULL)
366: return;
367:
368: /* Get time until oldest connection expires */
369: timeout = (now < oldest->expiry) ? (oldest->expiry - now) * 1000 : 0;
370:
371: /* Start timer */
372: if (pevent_register(cache->ctx, &cache->timer, 0,
373: &cache->mutex, http_connection_cache_timeout, cache,
374: PEVENT_TIME, timeout) == -1)
375: alogf(LOG_ERR, "%s: %m", "pevent_register");
376: }
377:
378: /*
379: * Expire a cached connection from the cache.
380: *
381: * This assumes the cache is locked.
382: */
383: static void
384: http_connection_cache_timeout(void *arg)
385: {
386: struct http_connection_cache *cache = arg;
387: const time_t now = time(NULL);
388:
389: /* Remove exipred entries */
390: while (!TAILQ_EMPTY(&cache->list)) {
391: struct cached_connection *const oldest
392: = TAILQ_FIRST(&cache->list);
393:
394: if (oldest->expiry < now)
395: break;
396: http_connection_cache_extract(cache, oldest, NULL, NULL);
397: }
398:
399: /* Restart timer if any are left */
400: if (cache->num > 0)
401: http_connection_cache_start_timer(cache);
402: }
403:
404: /*
405: * http_connection_cache_check() checks whether a socket is invalid.
406: *
407: * NOTE: we are not checking if the socket is valid. All we can tell is we
408: * think the socket is supposed to be valid because the server said keep-alive.
409: * The connection should not be closed, but if it gracefully closed then the
410: * server would have sent a FIN, which we will translate in to an EOF. This
411: * will mean the socket is readable (because the EOF) is in the pipe. In all
412: * other cases, the socket should not be readable because we are not expecting
413: * data from the server. If the server sent us anything we should declare the
414: * socket invalid. We still don't know if the socket is valid or not because if
415: * the server crashed then nothing will be there for us, same as if the
416: * connection is still working.
417: */
418: static int
419: http_connection_cache_check(int sock)
420: {
421: struct pollfd myfd;
422:
423: /* Poll for readability */
424: memset(&myfd, 0, sizeof(myfd));
425: myfd.fd = sock;
426: myfd.events = POLLRDNORM;
427:
428: /* Return invalid if readable or other error */
429: return (poll(&myfd, 1, 0) == 0);
430: }
431:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_connection_cache.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