开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
loaders.c
资源名称：ijb20.zip　[点击查看]
上传用户：qunlip
上传日期：2007-01-04
资源大小：203k
文件大小：24k
源码类别：

代理服务器

开发平台：

Visual C++

loaders.c：源码内容
  1. char *loaders_rcs = "$Id: loaders.c,v 1.24 1998/10/22 15:30:38 ACJC Exp $";
  2. /* Written and copyright 1997 Anonymous Coders and Junkbusters Corporation.
  3.  * Distributed under the GNU General Public License; see the README file.
  4.  * This code comes with NO WARRANTY. http://www.junkbusters.com/ht/en/gpl.html
  5.  */
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <sys/types.h>
  10. #include <string.h>
  11. #include <malloc.h>
  12. #include <errno.h>
  13. #include <sys/stat.h>
  14. #include <ctype.h>
  16. #ifndef _WIN32
  17. #include <unistd.h>
  18. #endif
  20. #ifdef REGEX
  21. #include <gnu_regex.h>
  22. #endif
  24. #include "jcc.h"
  27. /* sweep() is basically a mark and sweep garbage collector.
  28.  * it is run (by the parent thread) every once in a while to reclaim memory.
  29.  *
  30.  * it uses a mark and sweep strategy:
  31.  *   1) mark all files as inactive
  32.  *
  33.  *   2) check with each client:
  34.  *       if it is active,   mark its files as active
  35.  *       if it is inactive, free its resources
  36.  *
  37.  *   3) free the resources of all of the files that
  38.  *      are still marked as inactive (and are obsolete).
  39.  *
  40.  *   N.B. files that are not obsolete don't have an unloader defined.
  41.  */
  43. void
  44. sweep()
  45. {
  46. struct file_list *fl, *nfl;
  47. struct client_state *csp, *ncsp;
  49. /* clear all of the file's active flags */
  50. for(fl = files->next; fl ; fl = fl->next) {
  51. fl->active = 0;
  52. }
  54. for(csp = clients; csp && (ncsp = csp->next) ; csp = csp->next) {
  55. if(ncsp->active) {
  56. /* mark this client's files as active */
  57. if(ncsp->alist) ncsp->alist->active = 1;
  58. if(ncsp->blist) ncsp->blist->active = 1;
  59. if(ncsp->clist) ncsp->clist->active = 1;
  60. if(ncsp->tlist) ncsp->tlist->active = 1;
  61. } else {
  62. /* this client one is not active,
  63.  * release its resources
  64.  */
  65. csp->next = ncsp->next;
  67. freez(ncsp->ip_addr_str);
  68. freez(ncsp->referrer);
  69. freez(ncsp->x_forwarded);
  70. freez(ncsp->ip_addr_str);
  71. freez(ncsp->iob->buf);
  73. free_http_request(ncsp->http);
  75. destroy_list(ncsp->headers);
  76. destroy_list(ncsp->cookie_list);
  78. freez(ncsp);
  79. }
  80. }
  82. for(fl = files; fl && (nfl = fl->next) ; fl = fl->next) {
  83. if(nfl->active == 0) {
  84. if(nfl->unloader) {
  85. fl->next = nfl->next;
  87. (nfl->unloader)(nfl->f);
  89. freez(nfl->proxy_args);
  91. freez(nfl);
  92. }
  93. }
  94. }
  95. }
  97. void
  98. unload_url(struct url_spec *url)
  99. {
  100. if(url == NULL) return;
  102. freez(url->spec);
  103. freez(url->domain);
  104. freez(url->dbuf);
  105. freez(url->dvec);
  106. freez(url->path);
  107. #ifdef REGEX
  108. if(url->preg) {
  109. regfree(url->preg);
  110. freez(url->preg);
  111. }
  112. #endif
  113. }
  115. void
  116. unload_blockfile(struct block_spec *b)
  117. {
  118. if(b == NULL) return;
  120. unload_blockfile(b->next);
  122. unload_url(b->url);
  124. freez(b);
  125. }
  127. void
  128. unload_cookiefile(struct cookie_spec *b)
  129. {
  130. if(b == NULL) return;
  132. unload_cookiefile(b->next);
  134. unload_url(b->url);
  136. freez(b);
  137. }
  139. void
  140. unload_trustfile(struct block_spec *b)
  141. {
  142. if(b == NULL) return;
  144. unload_trustfile(b->next);
  146. unload_url(b->url);
  148. freez(b);
  149. }
  151. void
  152. unload_forwardfile(struct forward_spec *b)
  153. {
  154. if(b == NULL) return;
  156. unload_forwardfile(b->next);
  158. unload_url(b->url);
  160. freez(b->gw->gateway_host);
  161. freez(b->gw->forward_host);
  163. freez(b);
  164. }
  166. static struct file_list *current_blockfile;
  167. static struct file_list *current_cookiefile;
  168. static struct file_list *current_trustfile;
  169. static struct file_list *current_forwardfile;
  171. int
  172. load_blockfile(struct client_state *csp)
  173. {
  174. FILE *fp;
  176. struct block_spec *b, *bl;
  177. char  buf[BUFSIZ], *p, *q;
  178. int port, reject;
  179. struct file_list *fs;
  180. static struct stat prev[1], curr[1];
  181. struct url_spec url[1];
  183. if(stat(blockfile, curr) < 0) {
  184. goto load_blockfile_error;
  185. }
  187. if(current_blockfile && (prev->st_mtime == curr->st_mtime)) {
  188. csp->blist = current_blockfile;
  189. return(0);
  190. }
  192. fs = (struct file_list  *) zalloc(sizeof(*fs));
  193. bl = (struct block_spec *) zalloc(sizeof(*bl));
  195. if((fs == NULL) || (bl == NULL)) {
  196. goto load_blockfile_error;
  197. }
  199. fs->f = bl;
  201. fs->next    = files->next;
  202. files->next = fs;
  204. if(csp) {
  205. csp->blist = fs;
  206. }
  208. *prev = *curr;
  210. if((fp = fopen(blockfile, "r")) == NULL) {
  211. goto load_blockfile_error;
  212. }
  214. p = url_encode(html_code_map, blockfile);
  216. sprintf(buf, "<h2>The file `%s' contains the following patterns</h2>n", p);
  217. freez(p);
  219. fs->proxy_args = strsav(fs->proxy_args, buf);
  221. fs->proxy_args = strsav(fs->proxy_args, "<pre>");
  223. while(fgets(buf, sizeof(buf), fp)) {
  225. if((p = url_encode(html_code_map, buf))) {
  226. fs->proxy_args = strsav(fs->proxy_args, p);
  227. }
  228. freez(p);
  229. fs->proxy_args = strsav(fs->proxy_args, "<br>");
  231. if((p = strpbrk(buf, "rn")) != NULL) {
  232. *p = '';
  233. }
  235. /* comments */
  236. if((p = strchr(buf, '#'))) *p = '';
  238. /* elide white-space */
  239. for(p = q = buf; *q ; q++) {
  240. if(!isspace(*q)) *p++ = *q;
  241. }
  243. *p = '';
  245. reject = 1;
  247. if(*buf == '~') {
  248. reject = 0;
  249. p = buf;
  250. q = p+1;
  251. while ((*p++ = *q++)) {
  252. /* nop */
  253. }
  254. }
  256. /* skip blank lines */
  257. if(*buf == '') continue;
  259. /* allocate a new node */
  260. if(((b            = zalloc(sizeof(*b)))            == NULL)
  261. #ifdef REGEX
  262. || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL)
  263. #endif
  264. ) {
  265. fclose(fp);
  266. goto load_blockfile_error;
  267. }
  269. /* add it to the list */
  270. b->next  = bl->next;
  271. bl->next = b;
  273. /* save a copy of the orignal specification */
  274. if((b->url->spec = strdup(buf)) == NULL) {
  275. fclose(fp);
  276. goto load_blockfile_error;
  277. }
  279. b->reject = reject;
  281. if((p = strchr(buf, '/'))) {
  282. b->url->path    = strdup(p);
  283. b->url->pathlen = strlen(b->url->path);
  284. *p = '';
  285. } else {
  286. b->url->path    = NULL;
  287. b->url->pathlen = 0;
  288. }
  289. #ifdef REGEX
  290. if(b->url->path) {
  291. int errcode;
  292. char rebuf[BUFSIZ];
  294. sprintf(rebuf, "^(%s)", b->url->path);
  296. errcode = regcomp(b->url->preg, rebuf,
  297. (REG_EXTENDED|REG_NOSUB|REG_ICASE));
  299. if(errcode) {
  300. size_t errlen =
  301. regerror(errcode,
  302. b->url->preg, buf, sizeof(buf));
  304. buf[errlen] = '';
  306. fprintf(logfp,
  307. "%s: error compiling %s: %sn",
  308. prog, b->url->spec, buf);
  309. fclose(fp);
  310. goto load_blockfile_error;
  311. }
  312. } else {
  313. freez(b->url->preg);
  314. }
  315. #endif
  316. if((p = strchr(buf, ':')) == NULL) {
  317. port = 0;
  318. } else {
  319. *p++ = '';
  320. port = atoi(p);
  321. }
  323. b->url->port = port;
  325. if((b->url->domain = strdup(buf)) == NULL) {
  326. fclose(fp);
  327. goto load_blockfile_error;
  328. }
  330. /* split domain into components */
  331. *url = dsplit(b->url->domain);
  332. b->url->dbuf = url->dbuf;
  333. b->url->dcnt = url->dcnt;
  334. b->url->dvec = url->dvec;
  335. }
  336. fs->proxy_args = strsav(fs->proxy_args, "</pre>");
  338. fclose(fp);
  340. /* the old one is now obsolete */
  341. if(current_blockfile) {
  342. current_blockfile->unloader = unload_blockfile;
  343. }
  345. current_blockfile = fs;
  347. return(0);
  349. load_blockfile_error:
  350. fprintf(logfp, "%s: can't load blockfile '%s': ",
  351. prog, blockfile);
  352. fperror(logfp, "");
  353. return(-1);
  354. }
  356. int
  357. load_cookiefile(struct client_state *csp)
  358. {
  359. FILE *fp;
  361. struct cookie_spec *b, *bl;
  362. char  buf[BUFSIZ], *p, *q;
  363. char *tmp_vec[BUFSIZ];
  364. int port, user_cookie, server_cookie;
  365. static struct stat prev[1], curr[1];
  366. static struct file_list *fs;
  367. struct url_spec url[1];
  369. if(stat(cookiefile, curr) < 0) {
  370. goto load_cookie_error;
  371. }
  373. if(current_cookiefile && (prev->st_mtime == curr->st_mtime)) {
  374. csp->clist = current_cookiefile;
  375. return(0);
  376. }
  378. fs = (struct file_list   *) zalloc(sizeof(*fs));
  379.         bl = (struct cookie_spec *) zalloc(sizeof(*bl));
  381. if((fs == NULL) || (bl == NULL)) {
  382. goto load_cookie_error;
  383. }
  385. fs->f = bl;
  387. fs->next    = files->next;
  388. files->next = fs;
  390. if(csp) {
  391. csp->clist = fs;
  392. }
  394. *prev = *curr;
  396. if((fp = fopen(cookiefile, "r")) == NULL) {
  397. goto load_cookie_error;
  398. }
  400. p = url_encode(html_code_map, cookiefile);
  402. sprintf(buf, "<h2>The file `%s' contains the following patterns</h2>n", p);
  404. freez(p);
  406. fs->proxy_args = strsav(fs->proxy_args, buf);
  408. fs->proxy_args = strsav(fs->proxy_args, "<pre>");
  410. while(fgets(buf, sizeof(buf), fp)) {
  412. if((p = url_encode(html_code_map, buf))) {
  413. fs->proxy_args = strsav(fs->proxy_args, p);
  414. }
  415. freez(p);
  416. fs->proxy_args = strsav(fs->proxy_args, "<br>");
  418. if((p = strpbrk(buf, "rn")) != NULL) {
  419. *p = '';
  420. }
  422. /* comments */
  423. if((p = strchr(buf, '#'))) *p = '';
  425. /* elide white-space */
  426. for(p = q = buf; *q ; q++) {
  427. if(!isspace(*q)) *p++ = *q;
  428. }
  430. *p = '';
  432. p = buf;
  434. switch((int)*p) {
  435. case '>':
  436. server_cookie = 0;
  437. user_cookie   = 1;
  438. p++;
  439. break;
  440. case '<':
  441. server_cookie = 1;
  442. user_cookie   = 0;
  443. p++;
  444. break;
  445. case '~':
  446. server_cookie = 0;
  447. user_cookie   = 0;
  448. p++;
  449. break;
  450. default:
  451. server_cookie = 1;
  452. user_cookie   = 1;
  453. break;
  454. }
  456. /* elide any of the "special" chars from the
  457.  * front of the pattern
  458.  */
  459. q = buf;
  460. if(p > q) while ((*q++ = *p++)) {
  461. /* nop */
  462. }
  464. /* skip blank lines */
  465. if(*buf == '') continue;
  467. /* allocate a new node */
  468. if(((b            = zalloc(sizeof(*b)))            == NULL)
  469. #ifdef REGEX
  470. || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL)
  471. #endif
  472. ) {
  473. fclose(fp);
  474. goto load_cookie_error;
  475. }
  477. /* add it to the list */
  478. b->next  = bl->next;
  479. bl->next = b;
  481. /* save a copy of the orignal specification */
  482. if((b->url->spec = strdup(buf)) == NULL) {
  483. fclose(fp);
  484. goto load_cookie_error;
  485. }
  487. b->send_user_cookie     = user_cookie;
  488. b->accept_server_cookie = server_cookie;
  490. if((p = strchr(buf, '/'))) {
  491. b->url->path    = strdup(p);
  492. b->url->pathlen = strlen(b->url->path);
  493. *p = '';
  494. } else {
  495. b->url->path    = NULL;
  496. b->url->pathlen = 0;
  497. }
  498. #ifdef REGEX
  499. if(b->url->path) {
  500. int errcode;
  501. char rebuf[BUFSIZ];
  503. sprintf(rebuf, "^(%s)", b->url->path);
  505. errcode = regcomp(b->url->preg, rebuf,
  506. (REG_EXTENDED|REG_NOSUB|REG_ICASE));
  507. if(errcode) {
  508. size_t errlen =
  509. regerror(errcode,
  510. b->url->preg, buf, sizeof(buf));
  512. buf[errlen] = '';
  514. fprintf(logfp,
  515. "%s: error compiling %s: %sn",
  516. prog, b->url->spec, buf);
  517. fclose(fp);
  518. goto load_cookie_error;
  519. }
  520. } else {
  521. freez(b->url->preg);
  522. }
  523. #endif
  524. if((p = strchr(buf, ':')) == NULL) {
  525. port = 0;
  526. } else {
  527. *p++ = '';
  528. port = atoi(p);
  529. }
  531. b->url->port = port;
  533. if((b->url->domain = strdup(buf)) == NULL) {
  534. fclose(fp);
  535. goto load_cookie_error;
  536. }
  538. /* split domain into components */
  539. *url = dsplit(b->url->domain, tmp_vec);
  540. b->url->dbuf = url->dbuf;
  541. b->url->dcnt = url->dcnt;
  542. b->url->dvec = url->dvec;
  543. }
  545. fs->proxy_args = strsav(fs->proxy_args, "</pre>");
  547. fclose(fp);
  549. /* the old one is now obsolete */
  550. if(current_cookiefile) {
  551. current_cookiefile->unloader = unload_cookiefile;
  552. }
  554. current_cookiefile = fs;
  556. return(0);
  558. load_cookie_error:
  559. fprintf(logfp, "%s: can't load cookiefile '%s': ",
  560. prog, cookiefile);
  561. fperror(logfp, "");
  562. return(-1);
  563. }
  565. int
  566. load_trustfile(struct client_state *csp)
  567. {
  568. FILE *fp;
  570. struct block_spec *b, *bl;
  571. struct url_spec **tl;
  573. char  buf[BUFSIZ], *p, *q;
  574. int port, reject, trusted;
  575. struct file_list *fs;
  576. static struct stat prev[1], curr[1];
  577. struct url_spec url[1];
  579. if(stat(trustfile, curr) < 0) {
  580. goto load_trustfile_error;
  581. }
  583. if(current_trustfile && (prev->st_mtime == curr->st_mtime)) {
  584. csp->tlist = current_trustfile;
  585. return(0);
  586. }
  588. fs = (struct file_list  *) zalloc(sizeof(*fs));
  589. bl = (struct block_spec *) zalloc(sizeof(*bl));
  591. if((fs == NULL) || (bl == NULL)) {
  592. goto load_trustfile_error;
  593. }
  595. fs->f = bl;
  597. fs->next    = files->next;
  598. files->next = fs;
  600. if(csp) {
  601. csp->tlist = fs;
  602. }
  604. *prev = *curr;
  606. if((fp = fopen(trustfile, "r")) == NULL) {
  607. goto load_trustfile_error;
  608. }
  610. p = url_encode(html_code_map, trustfile);
  612. sprintf(buf, "<h2>The file `%s' contains the following patterns</h2>n", p);
  614. freez(p);
  616. fs->proxy_args = strsav(fs->proxy_args, buf);
  618. fs->proxy_args = strsav(fs->proxy_args, "<pre>");
  620. tl = trust_list;
  622. while(fgets(buf, sizeof(buf), fp)) {
  624. if((p = url_encode(html_code_map, buf))) {
  625. fs->proxy_args = strsav(fs->proxy_args, p);
  626. }
  627. freez(p);
  628. fs->proxy_args = strsav(fs->proxy_args, "<br>");
  630. if((p = strpbrk(buf, "rn")) != NULL) {
  631. *p = '';
  632. }
  634. /* comments */
  635. if((p = strchr(buf, '#'))) *p = '';
  637. /* elide white-space */
  638. for(p = q = buf; *q ; q++) {
  639. if(!isspace(*q)) *p++ = *q;
  640. }
  642. *p = '';
  644. trusted = 0;
  645. reject  = 1;
  647. if(*buf == '+') {
  648. trusted = 1;
  649. *buf = '~';
  650. }
  652. if(*buf == '~') {
  653. reject = 0;
  654. p = buf;
  655. q = p+1;
  656. while ((*p++ = *q++)) {
  657. /* nop */
  658. }
  659. }
  661. /* skip blank lines */
  662. if(*buf == '') continue;
  664. /* allocate a new node */
  665. if(((b            = zalloc(sizeof(*b)))            == NULL)
  666. #ifdef REGEX
  667. || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL)
  668. #endif
  669. ) {
  670. fclose(fp);
  671. goto load_trustfile_error;
  672. }
  674. /* add it to the list */
  675. b->next  = bl->next;
  676. bl->next = b;
  678. /* save a copy of the orignal specification */
  679. if((b->url->spec = strdup(buf)) == NULL) {
  680. fclose(fp);
  681. goto load_trustfile_error;
  682. }
  684. b->reject = reject;
  686. if((p = strchr(buf, '/'))) {
  687. b->url->path    = strdup(p);
  688. b->url->pathlen = strlen(b->url->path);
  689. *p = '';
  690. } else {
  691. b->url->path    = NULL;
  692. b->url->pathlen = 0;
  693. }
  694. #ifdef REGEX
  695. if(b->url->path) {
  696. int errcode;
  697. char rebuf[BUFSIZ];
  699. sprintf(rebuf, "^(%s)", b->url->path);
  701. errcode = regcomp(b->url->preg, rebuf,
  702. (REG_EXTENDED|REG_NOSUB|REG_ICASE));
  704. if(errcode) {
  705. size_t errlen =
  706. regerror(errcode,
  707. b->url->preg, buf, sizeof(buf));
  709. buf[errlen] = '';
  711. fprintf(logfp,
  712. "%s: error compiling %s: %sn",
  713. prog, b->url->spec, buf);
  714. fclose(fp);
  715. goto load_trustfile_error;
  716. }
  717. } else {
  718. freez(b->url->preg);
  719. }
  720. #endif
  721. if((p = strchr(buf, ':')) == NULL) {
  722. port = 0;
  723. } else {
  724. *p++ = '';
  725. port = atoi(p);
  726. }
  728. b->url->port = port;
  730. if((b->url->domain = strdup(buf)) == NULL) {
  731. fclose(fp);
  732. goto load_trustfile_error;
  733. }
  735. /* split domain into components */
  736. *url = dsplit(b->url->domain);
  737. b->url->dbuf = url->dbuf;
  738. b->url->dcnt = url->dcnt;
  739. b->url->dvec = url->dvec;
  741. /* save a pointer to URL's spec
  742.  * in the list of trusted URL's, too
  743.  */
  744. if(trusted) *tl++ = b->url;
  745. }
  747. fs->proxy_args = strsav(fs->proxy_args, "</pre>");
  749. *tl = NULL;
  751. fclose(fp);
  753. /* the old one is now obsolete */
  754. if(current_trustfile) {
  755. current_trustfile->unloader = unload_trustfile;
  756. }
  758. current_trustfile = fs;
  760. return(0);
  762. load_trustfile_error:
  763. fprintf(logfp, "%s: can't load trustfile '%s': ",
  764. prog, trustfile);
  765. fperror(logfp, "");
  766. return(-1);
  767. }
  769. int
  770. load_forwardfile(struct client_state *csp)
  771. {
  772. FILE *fp;
  774. struct forward_spec *b, *bl;
  775. char  buf[BUFSIZ], *p, *q, *tmp;
  776. char  *vec[4];
  777. int port, n, reject;
  778. struct file_list *fs;
  779. struct gateway *gw;
  780. static struct stat prev[1], curr[1];
  781. struct url_spec url[1];
  783. if(stat(forwardfile, curr) < 0) {
  784. goto load_forwardfile_error;
  785. }
  787. if(current_forwardfile && (prev->st_mtime == curr->st_mtime)) {
  788. csp->flist = current_forwardfile;
  789. return(0);
  790. }
  792. fs = (struct file_list    *) zalloc(sizeof(*fs));
  793. bl = (struct forward_spec *) zalloc(sizeof(*bl));
  795. if((fs == NULL) || (bl == NULL)) {
  796. goto load_forwardfile_error;
  797. }
  799. memset(fs, '', sizeof(*fs));
  800. memset(bl, '', sizeof(*bl));
  802. fs->f = bl;
  804. fs->next    = files->next;
  805. files->next = fs;
  807. if(csp) {
  808. csp->flist = fs;
  809. }
  811. *prev = *curr;
  813. if((fp = fopen(forwardfile, "r")) == NULL) {
  814. goto load_forwardfile_error;
  815. }
  817. p = url_encode(html_code_map, forwardfile);
  819. sprintf(buf, "<h2>The file `%s' contains the following patterns</h2>n", p);
  821. freez(p);
  823. fs->proxy_args = strsav(fs->proxy_args, buf);
  825. tmp = NULL;
  827. fs->proxy_args = strsav(fs->proxy_args, "<pre>");
  829. while(fgets(buf, sizeof(buf), fp)) {
  831. freez(tmp);
  833. if((p = url_encode(html_code_map, buf))) {
  834. fs->proxy_args = strsav(fs->proxy_args, p);
  835. }
  836. freez(p);
  837. fs->proxy_args = strsav(fs->proxy_args, "<br>");
  839. if((p = strpbrk(buf, "rn")) != NULL) {
  840. *p = '';
  841. }
  843. /* comments */
  844. if((p = strchr(buf, '#'))) *p = '';
  846. /* skip blank lines */
  847. if(*buf == '') continue;
  849. tmp = strdup(buf);
  851. n = ssplit(tmp, " t", vec, SZ(vec), 1, 1);
  853. if(n != 4) {
  854. fprintf(stderr, "error in forwardfile: %sn", buf);
  855. continue;
  856. }
  858. strcpy(buf, vec[0]);
  860. reject = 1;
  862. if(*buf == '~') {
  863. reject = 0;
  864. p = buf;
  865. q = p+1;
  866. while ((*p++ = *q++)) {
  867. /* nop */
  868. }
  869. }
  871. /* skip blank lines */
  872. if(*buf == '') continue;
  874. /* allocate a new node */
  875. if(((b            = zalloc(sizeof(*b)))            == NULL)
  876. #ifdef REGEX
  877. || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL)
  878. #endif
  879. ) {
  880. fclose(fp);
  881. goto load_forwardfile_error;
  882. }
  884. /* add it to the list */
  885. b->next  = bl->next;
  886. bl->next = b;
  888. /* save a copy of the orignal specification */
  889. if((b->url->spec = strdup(buf)) == NULL) {
  890. fclose(fp);
  891. goto load_forwardfile_error;
  892. }
  894. b->reject = reject;
  896. if((p = strchr(buf, '/'))) {
  897. b->url->path    = strdup(p);
  898. b->url->pathlen = strlen(b->url->path);
  899. *p = '';
  900. } else {
  901. b->url->path    = NULL;
  902. b->url->pathlen = 0;
  903. }
  904. #ifdef REGEX
  905. if(b->url->path) {
  906. int errcode;
  907. char rebuf[BUFSIZ];
  909. sprintf(rebuf, "^(%s)", b->url->path);
  911. errcode = regcomp(b->url->preg, rebuf,
  912. (REG_EXTENDED|REG_NOSUB|REG_ICASE));
  914. if(errcode) {
  915. size_t errlen =
  916. regerror(errcode,
  917. b->url->preg, buf, sizeof(buf));
  919. buf[errlen] = '';
  921. fprintf(logfp,
  922. "%s: error compiling %s: %sn",
  923. prog, b->url->spec, buf);
  924. fclose(fp);
  925. goto load_forwardfile_error;
  926. }
  927. } else {
  928. freez(b->url->preg);
  929. }
  930. #endif
  931. if((p = strchr(buf, ':')) == NULL) {
  932. port = 0;
  933. } else {
  934. *p++ = '';
  935. port = atoi(p);
  936. }
  938. b->url->port = port;
  940. if((b->url->domain = strdup(buf)) == NULL) {
  941. fclose(fp);
  942. goto load_forwardfile_error;
  943. }
  945. /* split domain into components */
  946. *url = dsplit(b->url->domain);
  947. b->url->dbuf = url->dbuf;
  948. b->url->dcnt = url->dcnt;
  949. b->url->dvec = url->dvec;
  951. /* now parse the gateway specs */
  953. p = vec[2];
  955. for(gw = gateways; gw->name; gw++) {
  956. if(strcmp(gw->name, p) == 0) {
  957. break;
  958. }
  959. }
  961. if(gw->name == NULL) {
  962. goto load_forwardfile_error;
  963. }
  965. /* save this as the gateway type */
  966. *b->gw = *gw;
  968. /* now parse the gateway host[:port] spec */
  969. p = vec[3];
  971. if(strcmp(p, ".") != 0) {
  972. b->gw->gateway_host = strdup(p);
  974. if((p = strchr(b->gw->gateway_host, ':'))) {
  975. *p++ = '';
  976. b->gw->gateway_port = atoi(p);
  977. }
  979. if(b->gw->gateway_port <= 0) {
  980. goto load_forwardfile_error;
  981. }
  982. }
  984. /* now parse the forwarding spec */
  985. p = vec[1];
  987. if(strcmp(p, ".") != 0) {
  988. b->gw->forward_host = strdup(p);
  990. if((p = strchr(b->gw->forward_host, ':'))) {
  991. *p++ = '';
  992. b->gw->forward_port = atoi(p);
  993. }
  995. if(b->gw->forward_port <= 0) {
  996. b->gw->forward_port = 8000;
  997. }
  998. }
  999. }
  1001. fs->proxy_args = strsav(fs->proxy_args, "</pre>");
  1003. freez(tmp);
  1005. fclose(fp);
  1007. /* the old one is now obsolete */
  1008. if(current_forwardfile) {
  1009. current_forwardfile->unloader = unload_forwardfile;
  1010. }
  1012. current_forwardfile = fs;
  1014. return(0);
  1016. load_forwardfile_error:
  1017. fprintf(logfp, "%s: can't load forwardfile '%s': ",
  1018. prog, forwardfile);
  1019. fperror(logfp, "");
  1020. return(-1);
  1021. }
  1023. #define JUNKBUSTERS "http://www.junkbusters.com"
  1024. #define OPT "href="" JUNKBUSTERS "/ht/en/ijb" VERSION_MAJOR "man.html#"
  1026. /* strsav() takes a pointer to a string stored in a dynamically allocated
  1027.  * buffer and a pointer to a string and returns a pointer to a new dynamically
  1028.  * allocated space that contains the concatenation of the two input strings
  1029.  * the previous space is free()'d by realloc().
  1030.  */
  1031. char *
  1032. strsav(char *old, char *text_to_append)
  1033. {
  1034. int old_len, new_len;
  1035. char *p;
  1037. if(( text_to_append == NULL)
  1038. || (*text_to_append == '')) {
  1039. return(old);
  1040. }
  1042. if(old) {
  1043. old_len = strlen(old);
  1044. } else {
  1045. old_len = 0;
  1046. }
  1048. new_len = old_len + strlen(text_to_append) + 1;
  1050. if(old) {
  1051. if((p = realloc(old, new_len)) == NULL) {
  1052. fprintf(logfp, "%s: realloc(%d) bytes for proxy_args failed!n", prog, new_len);
  1053. exit(1);
  1054. }
  1055. } else {
  1056. if((p = malloc(new_len)) == NULL) {
  1057. fprintf(logfp, "%s: malloc(%d) bytes for proxy_args failed!n", prog, new_len);
  1058. exit(1);
  1059. }
  1060. }
  1062. strcpy(p + old_len, text_to_append);
  1063. return(p);
  1064. }
  1066. void
  1067. savearg(char *c, char *o)
  1068. {
  1069. char buf[BUFSIZ];
  1070. static int one_shot = 1;
  1072. if(one_shot) {
  1073. one_shot = 0;
  1074. proxy_args->invocation = strsav(proxy_args->invocation,
  1075. "<br>n"
  1076. "and the following options were set "
  1077. "in the configuration file"
  1078. "<br><br>n"
  1079. );
  1080. }
  1082. *buf = '';
  1084. if(c && *c) {
  1085. if((c = url_encode(html_code_map, c))) {
  1086. sprintf(buf, "<a " OPT "%s">%s</a> ", c, c);
  1087. }
  1088. freez(c);
  1089. }
  1090. if(o && *o) { 
  1091. if((o = url_encode(html_code_map, o))) {
  1092. if(strncmpic(o, "http://", 7) == 0) {
  1093. strcat(buf, "<a href="");
  1094. strcat(buf, o);
  1095. strcat(buf, "">");
  1096. strcat(buf, o);
  1097. strcat(buf, "</a>");
  1098. } else {
  1099. strcat(buf, o);
  1100. }
  1101. }
  1102. freez(o);
  1103. }
  1105. strcat(buf, "<br>n");
  1107. proxy_args->invocation = strsav(proxy_args->invocation, buf);
  1108. }
  1111. void
  1112. init_proxy_args(int argc, char *argv[])
  1113. {
  1114. struct gateway *g;
  1115. int i;
  1117. proxy_args->header = strsav(proxy_args->header,
  1118. "HTTP/1.0 200 OKn"
  1119. "Server: IJ/" VERSION "n"
  1120. "Content-type: text/htmlnn"
  1122. "<html>"
  1123. "<head>"
  1124. "<title>Internet Junkbuster Proxy Status</title>"
  1125. "</head>n"
  1126. "<body bgcolor="#f8f8f0" link="#000078" alink="#ff0022" vlink="#787878">n"
  1127. "<center>n"
  1128. "<h1>" BANNER "n"
  1129. "<a href="" JUNKBUSTERS "/ht/en/ijb" VERSION_MAJOR "faq.html#show">Proxy Status</a>n"
  1130. "</h1></center>n"
  1131. "<h2>You are using the " BANNER " <sup><small><small>TM</small></small></sup></h2>n"
  1132. "Version: IJ/" VERSION "n"
  1133. "<p>n"
  1134. );
  1136. proxy_args->header = strsav(proxy_args->header,
  1137. "<h2>The program was invoked as follows</h2>n");
  1139. for(i=0; i < argc; i++) {
  1140. proxy_args->header = strsav(proxy_args->header, argv[i]);
  1141. proxy_args->header = strsav(proxy_args->header, " ");
  1142. }
  1143. proxy_args->header = strsav(proxy_args->header, "<br>n");
  1145. proxy_args->gateways = strsav(proxy_args->gateways,
  1146. "<h2>It supports the following gateway protocols:</h2>n");
  1148. for(g = gateways; g->name; g++) {
  1149. proxy_args->gateways = strsav(proxy_args->gateways, g->name);
  1150. proxy_args->gateways = strsav(proxy_args->gateways, " ");
  1151. }
  1152. proxy_args->gateways = strsav(proxy_args->gateways, "<br>n");
  1153. }
  1155. void
  1156. end_proxy_args()
  1157. {
  1158. char buf[BUFSIZ];
  1159. char *b = NULL;
  1161. extern char *acl_rcs, *bind_rcs, *conn_rcs, *encode_rcs,
  1162. *jcc_rcs, *loaders_rcs, *parsers_rcs, *filters_rcs,
  1163. *socks4_rcs, *ssplit_rcs, *gnu_regex_rcs, *win32_rcs;
  1165. b = strsav(b, "<h2>Source versions:</h2>n");
  1166. b = strsav(b, "<pre>");
  1167. sprintf(buf, "%sn", jcc_rcs       ); b = strsav(b, buf);
  1168. sprintf(buf, "%sn", parsers_rcs   ); b = strsav(b, buf);
  1169. sprintf(buf, "%sn", filters_rcs   ); b = strsav(b, buf);
  1170. sprintf(buf, "%sn", loaders_rcs   ); b = strsav(b, buf);
  1171. sprintf(buf, "%sn", conn_rcs      ); b = strsav(b, buf);
  1172. sprintf(buf, "%sn", bind_rcs      ); b = strsav(b, buf);
  1173. sprintf(buf, "%sn", encode_rcs    ); b = strsav(b, buf);
  1174. sprintf(buf, "%sn", socks4_rcs    ); b = strsav(b, buf);
  1175. sprintf(buf, "%sn", ssplit_rcs    ); b = strsav(b, buf);
  1176. sprintf(buf, "%sn", acl_rcs       ); b = strsav(b, buf);
  1177. sprintf(buf, "%sn", gnu_regex_rcs ); b = strsav(b, buf);
  1178. sprintf(buf, "%sn", win32_rcs     ); b = strsav(b, buf);
  1179. b = strsav(b, "</pre>");
  1181. #ifdef REGEX
  1182. b = strsav(b, "<p>This " BANNER " supports POSIX regular expressions in the path specs.n");
  1183. #endif
  1186. b = strsav(b,
  1187. "<small><small><p>n"
  1188. "Code and documentation of the " BANNER " Proxy"
  1189. "<sup><small>TM</small></sup>n"
  1190. "<a href=""  JUNKBUSTERS "/ht/en/legal.html#copy">n" "Copyright</a>&#169; 1997 Junkbusters Corporationn"
  1191. "<a href="" JUNKBUSTERS "/ht/en/legal.html#marks"><sup><small>TM</small></sup></a><br>n"
  1192. "Copying and distribution permitted under the"
  1193. "<a href=""  JUNKBUSTERS "/ht/en/gpl.html">n"
  1194. "<small>GNU</small></a> "
  1195. "General Public License.n"
  1196. "</small>"
  1197. "<address><kbd>webmaster@junkbusters.com</kbd></address>"
  1198. "</small>"
  1199. "</body></html>n"
  1200. );
  1202. proxy_args->trailer = b;
  1203. }
  1205. void
  1206. add_loader(int (*loader)())
  1207. {
  1208. int i;
  1210. for(i=0; i < NLOADERS; i++) {
  1211. if(loaders[i] == NULL) {
  1212. loaders[i] = loader;
  1213. break;
  1214. }
  1215. }
  1216. }
  1218. int
  1219. run_loader(struct client_state *csp)
  1220. {
  1221. int ret = 0;
  1222. int i;
  1224. for(i=0; i < NLOADERS; i++) {
  1225. if(loaders[i] == NULL) break;
  1226. ret |= (loaders[i])(csp);
  1227. }
  1228. return(ret);
  1229. }
  1231. /* the way calloc() ought to be -acjc */
  1232. void *
  1233. zalloc(int size)
  1234. {
  1235. void *ret;
  1237. if((ret = malloc(size))) {
  1238. memset(ret, '', size);
  1239. }
  1240. return(ret);
  1241. }