Annotation of embedaddon/libpdel/http/servlet/http_servlet_file.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/param.h>
43: #include <sys/socket.h>
44: #include <sys/stat.h>
45: #include <sys/uio.h>
46: #ifdef __linux__
47: #include <sys/sendfile.h>
48: #endif
49:
50: #include <netinet/in.h>
51:
52: #include <stdlib.h>
53: #include <stdio.h>
54: #include <string.h>
55: #include <stdarg.h>
56: #include <syslog.h>
57: #include <fcntl.h>
58: #include <unistd.h>
59: #include <errno.h>
60: #include <assert.h>
61: #include <pthread.h>
62:
63: #include <openssl/ssl.h>
64:
65: #include "structs/structs.h"
66: #include "structs/type/array.h"
67:
68: #include "sys/alog.h"
69: #include "io/string_fp.h"
70: #include "tmpl/tmpl.h"
71: #include "util/ghash.h"
72: #include "util/typed_mem.h"
73:
74: #include "http/http_defs.h"
75: #include "http/http_server.h"
76: #include "http/http_servlet.h"
77: #include "http/servlet/tmpl.h"
78: #include "http/servlet/file.h"
79:
80: #define MEM_TYPE "http_servlet_file"
81: #define TMPL_SUFFIX ".tmpl"
82:
83: /* Cleanup state for http_servlet_file_serve() */
84: struct http_servlet_file_serve_state {
85: int fd;
86: };
87:
88: /* One cached template */
89: struct tmpl_cache {
90: char *path; /* file pathname */
91: struct http_servlet *servlet; /* tmpl servlet */
92: };
93:
94: /* Servlet state */
95: struct file_private {
96: struct http_servlet_file_info *info;
97: struct ghash *tmpls; /* cached tmpl servlets */
98: http_servlet_tmpl_free_t *freer; /* freer for tmpl arg */
99: };
100:
101: /* Directory -> file redirects */
102: static const char *http_servlet_file_dirindex[][2] = {
103: { "index.tmpl", "index" },
104: { "index.html", "index.html" },
105: { "index.htm", "index.htm" },
106: { NULL, NULL }
107: };
108:
109: /*
110: * Internal functions
111: */
112: static char *http_servlet_file_gen_filename(
113: struct http_servlet_file_info *finfo, const char *url,
114: const char *mtype);
115: static void http_servlet_file_tmpl(struct http_servlet *servlet,
116: const char *path, struct http_request *req,
117: struct http_response *resp);
118: static void http_servlet_file_serve_cleanup(void *arg);
119:
120: static http_servlet_run_t http_servlet_file_run;
121: static http_servlet_destroy_t http_servlet_file_destroy;
122:
123: static ghash_hash_t tmpl_cache_hash;
124: static ghash_equal_t tmpl_cache_equal;
125: static ghash_del_t tmpl_cache_del;
126:
127: /*
128: * Create a new file servlet.
129: */
130: struct http_servlet *
131: http_servlet_file_create(const struct http_servlet_file_info *info)
132: {
133: struct http_servlet *servlet = NULL;
134: struct file_private *priv = NULL;
135:
136: /* Create servlet */
137: if ((servlet = MALLOC(MEM_TYPE, sizeof(*servlet))) == NULL)
138: goto fail;
139: memset(servlet, 0, sizeof(*servlet));
140: servlet->run = http_servlet_file_run;
141: servlet->destroy = http_servlet_file_destroy;
142:
143: /* Initialize private info */
144: if ((priv = MALLOC(MEM_TYPE, sizeof(*priv))) == NULL)
145: goto fail;
146: memset(priv, 0, sizeof(*priv));
147:
148: /* Copy "info" */
149: if ((priv->info = MALLOC(MEM_TYPE, sizeof(*priv->info))) == NULL)
150: goto fail;
151: memset(priv->info, 0, sizeof(*priv->info));
152: if (info->docroot != NULL
153: && (priv->info->docroot = STRDUP(MEM_TYPE, info->docroot)) == NULL)
154: goto fail;
155: priv->info->allow_escape = info->allow_escape;
156: if (info->filename != NULL
157: && (priv->info->filename
158: = STRDUP(MEM_TYPE, info->filename)) == NULL)
159: goto fail;
160: if (info->prefix != NULL
161: && (priv->info->prefix = STRDUP(MEM_TYPE, info->prefix)) == NULL)
162: goto fail;
163: if (info->mime_type != NULL
164: && (priv->info->mime_type
165: = STRDUP(MEM_TYPE, info->mime_type)) == NULL)
166: goto fail;
167: if (info->mime_encoding != NULL
168: && (priv->info->mime_encoding
169: = STRDUP(MEM_TYPE, info->mime_encoding)) == NULL)
170: goto fail;
171: priv->info->logger = info->logger;
172: priv->info->hide = info->hide;
173: if (_http_servlet_tmpl_copy_tinfo(&priv->info->tinfo,
174: &info->tinfo) == -1)
175: goto fail;
176:
177: /* Only free the template argument once */
178: priv->freer = priv->info->tinfo.freer;
179: priv->info->tinfo.freer = NULL;
180:
181: /* Create template hash table */
182: if ((priv->tmpls = ghash_create(priv, 0, 200, MEM_TYPE,
183: tmpl_cache_hash, tmpl_cache_equal, NULL, tmpl_cache_del)) == NULL)
184: goto fail;
185: servlet->arg = priv;
186:
187: /* OK */
188: return (servlet);
189:
190: fail:
191: /* Clean up after failure */
192: if (priv != NULL) {
193: if (priv->info != NULL) {
194: FREE(MEM_TYPE, (char *)priv->info->filename);
195: FREE(MEM_TYPE, (char *)priv->info->docroot);
196: FREE(MEM_TYPE, (char *)priv->info->prefix);
197: FREE(MEM_TYPE, (char *)priv->info->mime_type);
198: FREE(MEM_TYPE, (char *)priv->info->mime_encoding);
199: _http_servlet_tmpl_free_tinfo(&priv->info->tinfo);
200: FREE(MEM_TYPE, priv->info);
201: }
202: ghash_destroy(&priv->tmpls);
203: FREE(MEM_TYPE, priv);
204: }
205: if (servlet != NULL)
206: FREE(MEM_TYPE, servlet);
207: return (NULL);
208: }
209:
210: /*
211: * Destroy a file servlet.
212: */
213: static void
214: http_servlet_file_destroy(struct http_servlet *servlet)
215: {
216: struct file_private *const priv = servlet->arg;
217:
218: /* Free template argument */
219: if (priv->freer != NULL)
220: (*priv->freer)(priv->info->tinfo.arg);
221:
222: /* Free private info */
223: FREE(MEM_TYPE, (char *)priv->info->filename);
224: FREE(MEM_TYPE, (char *)priv->info->docroot);
225: FREE(MEM_TYPE, (char *)priv->info->prefix);
226: FREE(MEM_TYPE, (char *)priv->info->mime_type);
227: FREE(MEM_TYPE, (char *)priv->info->mime_encoding);
228: _http_servlet_tmpl_free_tinfo(&priv->info->tinfo);
229: FREE(MEM_TYPE, priv->info);
230: ghash_destroy(&priv->tmpls);
231: FREE(MEM_TYPE, priv);
232:
233: /* Free servlet */
234: FREE(MEM_TYPE, servlet);
235: }
236:
237: /*
238: * Execute file servlet.
239: */
240: static int
241: http_servlet_file_run(struct http_servlet *servlet,
242: struct http_request *req, struct http_response *resp)
243: {
244: struct file_private *const priv = servlet->arg;
245: struct http_servlet_file_info *const info = priv->info;
246: const char *const urlpath = http_request_get_path(req);
247: char *path = NULL;
248: int got_tmpl = 0;
249: size_t len;
250:
251: /* Generate file name from URL; first try to find a template file */
252: if (info->tinfo.handler != NULL
253: && (len = strlen(urlpath)) < MAXPATHLEN - sizeof(TMPL_SUFFIX)) {
254: char tp[MAXPATHLEN];
255: struct stat sb;
256:
257: memcpy(tp, urlpath, len);
258: memcpy(tp + len, TMPL_SUFFIX, sizeof(TMPL_SUFFIX));
259: path = http_servlet_file_gen_filename(info, tp, TYPED_MEM_TEMP);
260: if (stat(path, &sb) == 0 && (sb.st_mode & S_IFMT) == S_IFREG)
261: got_tmpl = 1;
262: else {
263: FREE(TYPED_MEM_TEMP, path);
264: path = NULL;
265: }
266: }
267:
268: /* Generate file name from URL; now try a normal file */
269: if (!got_tmpl
270: && (path = http_servlet_file_gen_filename(info,
271: urlpath, TYPED_MEM_TEMP)) == NULL) {
272: http_response_send_errno_error(resp);
273: return (1);
274: }
275:
276: /* Handle templates */
277: if (got_tmpl) {
278: http_servlet_file_tmpl(servlet, path, req, resp);
279: goto done;
280: }
281:
282: /* Check whether to hide this file */
283: if (info->hide != NULL && (*info->hide)(info, req, resp, path)) {
284: FREE(TYPED_MEM_TEMP, path);
285: return (0); /* continue with next servlet */
286: }
287:
288: /* Use supplied MIME info, if any */
289: if (info->mime_type != NULL) {
290: http_response_set_header(resp, 0,
291: HTTP_HEADER_CONTENT_TYPE, "%s", info->mime_type);
292: if (info->mime_encoding != NULL) {
293: http_response_set_header(resp, 0,
294: HTTP_HEADER_CONTENT_ENCODING,
295: "%s", info->mime_encoding);
296: }
297: }
298:
299: /* Serve up file */
300: http_servlet_file_serve(path, info->logger, req, resp);
301:
302: done:
303: /* Done */
304: FREE(TYPED_MEM_TEMP, path);
305: return (1);
306: }
307:
308: #define MAX_ENCODINGS 10
309:
310: /*
311: * Serve up a file.
312: *
313: * This is a public function usable by other servlets.
314: */
315: void
316: http_servlet_file_serve(const char *path, http_logger_t *logger,
317: struct http_request *req, struct http_response *resp)
318: {
319: const char *hval;
320: struct stat sb;
321: char buf[1024];
322: FILE *output;
323: struct tm tm;
324: time_t when;
325: int sock;
326:
327: /* Stat file */
328: if (stat(path, &sb) == -1) {
329: fail_errno: http_response_send_errno_error(resp);
330: return;
331: }
332:
333: /* If file is a directory, redirect to default file if it exists */
334: if ((sb.st_mode & S_IFMT) == S_IFDIR) {
335: int i;
336:
337: for (i = 0; http_servlet_file_dirindex[i][0] != NULL; i++) {
338: const char *qs = http_request_get_query_string(req);
339: char *urlpath;
340: char *dfile;
341:
342: if (qs == NULL)
343: qs = "";
344: ASPRINTF(TYPED_MEM_TEMP, &dfile, "%s/%s", path,
345: http_servlet_file_dirindex[i][0]);
346: if (dfile == NULL)
347: goto fail_errno;
348: if (stat(dfile, &sb) == -1) {
349: FREE(TYPED_MEM_TEMP, dfile);
350: continue;
351: }
352: if ((urlpath = http_request_url_encode(TYPED_MEM_TEMP,
353: http_request_get_path(req))) == NULL) {
354: FREE(TYPED_MEM_TEMP, dfile);
355: goto fail_errno;
356: }
357: if (http_response_set_header(resp, 0,
358: HTTP_HEADER_LOCATION, "%s%s%s%s%s", urlpath,
359: "/" + (urlpath[strlen(urlpath) - 1] == '/'),
360: http_servlet_file_dirindex[i][1],
361: (*qs != '\0') ? "?" : "", qs) == -1) {
362: FREE(TYPED_MEM_TEMP, urlpath);
363: FREE(TYPED_MEM_TEMP, dfile);
364: goto fail_errno;
365: }
366: FREE(TYPED_MEM_TEMP, urlpath);
367: FREE(TYPED_MEM_TEMP, dfile);
368: http_response_send_error(resp,
369: HTTP_STATUS_FOUND, NULL);
370: return;
371: }
372: }
373:
374: /* File must be regular */
375: if ((sb.st_mode & S_IFMT) != S_IFREG) {
376: errno = ENOENT; /* hide non-regular files */
377: goto fail_errno;
378: }
379:
380: /* Set timestamp from stat(2) info */
381: strftime(buf, sizeof(buf), HTTP_TIME_FMT_RFC1123,
382: gmtime_r(&sb.st_mtime, &tm));
383: http_response_set_header(resp, 0, HTTP_HEADER_DATE, "%s", buf);
384:
385: /* Check for If-Modified-Since: header */
386: if ((hval = http_request_get_header(req,
387: HTTP_HEADER_IF_MODIFIED_SINCE)) != NULL) {
388: if ((when = http_request_parse_time(hval)) != (time_t)-1
389: && sb.st_mtime <= when) {
390: http_response_send_error(resp,
391: HTTP_STATUS_NOT_MODIFIED, NULL);
392: return;
393: }
394: }
395:
396: /* Set MIME type if not set already */
397: if (http_response_get_header(resp, HTTP_HEADER_CONTENT_TYPE) == NULL) {
398: const char *cencs[MAX_ENCODINGS];
399: const char *ctype;
400: int i;
401:
402: http_response_guess_mime(path, &ctype, cencs, MAX_ENCODINGS);
403: http_response_set_header(resp, 0,
404: HTTP_HEADER_CONTENT_TYPE, "%s", ctype);
405: for (i = 0; i < MAX_ENCODINGS && cencs[i] != NULL; i++) {
406: http_response_set_header(resp, i > 0,
407: HTTP_HEADER_CONTENT_ENCODING, "%s", cencs[i]);
408: }
409: }
410:
411: /* Set content length */
412: http_response_set_header(resp, 0,
413: HTTP_HEADER_CONTENT_LENGTH, "%lu", (u_long)sb.st_size);
414:
415: /* Get servlet output stream (unbuffered) */
416: if ((output = http_response_get_output(resp, 0)) == NULL) {
417: (*logger)(LOG_ERR, "can't get response output: %s",
418: strerror(errno));
419: return;
420: }
421:
422: /* Send file contents, using sendfile(2) if possible */
423: if ((sock = http_response_get_raw_socket(resp)) != -1) {
424: struct http_servlet_file_serve_state state;
425:
426: /* Open file */
427: if ((state.fd = open(path, O_RDONLY)) == -1)
428: goto fail_errno;
429:
430: /* Set cleanup hook in case thread is canceled */
431: pthread_cleanup_push(http_servlet_file_serve_cleanup, &state);
432:
433: /* Make sure headers are sent first */
434: http_response_send_headers(resp, 1);
435: fflush(output);
436:
437: /* Send file directly using sendfile(2) */
438: #ifndef __linux__
439: sendfile(state.fd, sock, 0, sb.st_size, NULL, NULL, 0);
440: #else
441: sendfile(sock, state.fd, NULL, sb.st_size);
442: #endif
443:
444: /* Close file */
445: pthread_cleanup_pop(1);
446: } else {
447: FILE *fp;
448: int ret;
449:
450: /* Open file */
451: if ((fp = fopen(path, "r")) == NULL)
452: goto fail_errno;
453:
454: /* Set cleanup hook in case thread is canceled */
455: pthread_cleanup_push((void (*)(void *))fclose, fp);
456:
457: /* Tranfer file contents */
458: while (1) {
459: if ((ret = fread(buf, 1, sizeof(buf), fp)) != 0) {
460: if (fwrite(buf, 1, ret, output) < ret)
461: break;
462: }
463: if (ret < sizeof(buf))
464: break;
465: }
466:
467: /* Close file */
468: pthread_cleanup_pop(1);
469: }
470: }
471:
472: /*
473: * Do a template file.
474: */
475: static void
476: http_servlet_file_tmpl(struct http_servlet *servlet, const char *path,
477: struct http_request *req, struct http_response *resp)
478: {
479: struct file_private *const priv = servlet->arg;
480: struct http_servlet_file_info *const info = priv->info;
481: struct http_servlet_tmpl_info ti;
482: char mimepath[MAXPATHLEN + 1];
483: struct tmpl_cache *t = NULL;
484: struct tmpl_cache key;
485: const char *s;
486:
487: /* See if template already cached */
488: key.path = (char *)path;
489: if ((t = ghash_get(priv->tmpls, &key)) != NULL)
490: goto found;
491:
492: /* Create new cached entry */
493: if ((t = MALLOC(MEM_TYPE, sizeof(*t))) == NULL)
494: goto fail;
495: memset(t, 0, sizeof(*t));
496: if ((t->path = STRDUP(MEM_TYPE, path)) == NULL)
497: goto fail;
498:
499: /* Set info required by the template servlet */
500: memset(&ti, 0, sizeof(ti));
501: ti.path = t->path;
502: ti.tinfo = info->tinfo;
503: ti.logger = info->logger;
504:
505: /* Figure out templates's output MIME type */
506: strlcat(mimepath, path, sizeof(mimepath));
507: mimepath[strlen(mimepath) - strlen(TMPL_SUFFIX)] = '\0';
508: if ((s = strrchr(mimepath, '.')) == NULL
509: || strchr(s, '/') != NULL) /* no suffix? assume html */
510: strlcat(mimepath, "x.html", sizeof(mimepath));
511: http_response_guess_mime(mimepath, &ti.mime_type, NULL, 0);
512:
513: /* Create template servlet */
514: if ((t->servlet = http_servlet_tmpl_create(&ti)) == NULL)
515: goto fail;
516:
517: /* Add it to hash table */
518: if (ghash_put(priv->tmpls, t) == -1) {
519: (*info->logger)(LOG_ERR,
520: "%s: %s", "ghash_put", strerror(errno));
521: fail: FREE(MEM_TYPE, t);
522: http_response_send_errno_error(resp);
523: return;
524: }
525:
526: found:
527: /* Invoke servlet */
528: (*t->servlet->run)(t->servlet, req, resp);
529: }
530:
531: static void
532: http_servlet_file_serve_cleanup(void *arg)
533: {
534: const struct http_servlet_file_serve_state *const state = arg;
535:
536: close(state->fd);
537: }
538:
539: static u_int32_t
540: tmpl_cache_hash(struct ghash *g, const void *item)
541: {
542: const struct tmpl_cache *const t = item;
543: u_int32_t hash;
544: const char *s;
545:
546: for (hash = 0, s = t->path; *s != '\0'; s++)
547: hash = (31 * hash) + (u_char)*s;
548: return (hash);
549: }
550:
551: static int
552: tmpl_cache_equal(struct ghash *g, const void *item1, const void *item2)
553: {
554: const struct tmpl_cache *const t1 = item1;
555: const struct tmpl_cache *const t2 = item2;
556:
557: return (strcmp(t1->path, t2->path) == 0);
558: }
559:
560: static void
561: tmpl_cache_del(struct ghash *g, void *item)
562: {
563: struct tmpl_cache *const t = item;
564:
565: http_server_destroy_servlet(&t->servlet);
566: FREE(MEM_TYPE, t->path);
567: FREE(MEM_TYPE, t);
568: }
569:
570: /*
571: * Compute a filename from supplied info and URL.
572: *
573: * Caller must free returned string, which is in a buffer of size MAXPATHLEN.
574: */
575: static char *
576: http_servlet_file_gen_filename(struct http_servlet_file_info *info,
577: const char *urlpath, const char *mtype)
578: {
579: char path[MAXPATHLEN];
580: char *rpath;
581: char *tok;
582: char *s;
583:
584: /* Sanity check */
585: assert(*urlpath == '/');
586:
587: /* Disallow all ".", "..", and empty components within urlpath */
588: strlcpy(path, urlpath, sizeof(path));
589: for (s = path + 1; (tok = strsep(&s, "/")) != NULL; ) {
590: if ((*tok == '\0' && s != NULL)
591: || strcmp(tok, ".") == 0 || strcmp(tok, "..") == 0) {
592: errno = ENOENT;
593: return (NULL);
594: }
595: }
596:
597: /* Prepend root directory, if any */
598: if (info->docroot != NULL) {
599: strlcpy(path, info->docroot, sizeof(path) - 1);
600: if (path[strlen(path) - 1] != '/')
601: strlcat(path, "/", sizeof(path));
602: } else
603: *path = '\0';
604:
605: /* Add fixed filename, if any */
606: if (info->filename != NULL) {
607: if (*info->filename == '/')
608: *path = '\0';
609: strlcat(path, info->filename, sizeof(path));
610: goto normalize;
611: }
612:
613: /* Strip URL prefix, if it matches */
614: if (info->prefix != NULL
615: && strncmp(urlpath, info->prefix, strlen(info->prefix)) == 0)
616: urlpath += strlen(info->prefix);
617:
618: /* Derive remainder of pathname from URL */
619: strlcat(path, urlpath + (*urlpath == '/'), sizeof(path));
620:
621: normalize:
622:
623: /* Normalize path */
624: if ((rpath = MALLOC(mtype, MAXPATHLEN)) == NULL)
625: return (NULL);
626: if (realpath(path, rpath) == NULL) {
627: FREE(mtype, rpath);
628: return (NULL);
629: }
630: rpath[MAXPATHLEN - 1] = '\0';
631:
632: /* Verify that file is within the document root directory hierarchy */
633: if (!info->allow_escape) {
634: const char *docroot;
635: char *dpath;
636: size_t rlen;
637: int within;
638:
639: /* Use current working directory if info->docroot is NULL */
640: if (info->docroot == NULL) {
641: getcwd(path, sizeof(path));
642: path[sizeof(path) - 1] = '\0';
643: docroot = path;
644: } else
645: docroot = info->docroot;
646:
647: /* Normalize docroot path */
648: if ((dpath = MALLOC(mtype, MAXPATHLEN)) == NULL) {
649: FREE(mtype, rpath);
650: return (NULL);
651: }
652: if (realpath(docroot, dpath) == NULL) {
653: FREE(mtype, dpath);
654: FREE(mtype, rpath);
655: return (NULL);
656: }
657: dpath[MAXPATHLEN - 1] = '\0';
658:
659: /* Verify that path is within the root */
660: rlen = strlen(dpath);
661: within = strncmp(rpath, dpath, rlen) == 0
662: && (rpath[rlen] == '\0' || rpath[rlen] == '/');
663: FREE(mtype, dpath);
664: if (!within) {
665: FREE(mtype, rpath);
666: errno = ENOENT;
667: return (NULL);
668: }
669: }
670:
671: /* Done */
672: return (rpath);
673: }
674:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_servlet_file.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 / servlet