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

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

代理服务器

开发平台：

Visual C++

filters.c：源码内容
  1. char *filters_rcs = "$Id: filters.c,v 1.15 1998/10/23 01:54:03 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 <sys/types.h>
  9. #include <stdlib.h>
  10. #include <ctype.h>
  11. #include <string.h>
  13. #ifndef _WIN32
  14. #include <unistd.h>
  15. #endif
  17. #ifdef REGEX
  18. #include <gnu_regex.h>
  19. #endif
  21. #include "jcc.h"
  23. #define URL(X) url_encode(url_code_map, (X))
  25. char CBLOCK[] = "HTTP/1.0 202 Request for blocked URLn"
  26.  "Pragma: no-cachen"
  27.  "Last-Modified: Thu Jul 31, 1997 07:42:22 pm GMTn"
  28.  "Expires:       Thu Jul 31, 1997 07:42:22 pm GMTn"
  29.  "Content-Type: text/htmlnn"
  30.  "<html>n"
  31.  "<head>n"
  32.  "<title>Internet Junkbuster: Request for blocked URL</title>n"
  33.  "</head>n"
  34.  WHITEBG
  35.  "<center>"
  36.  "<a href=http://internet.junkbuster.com/ij-blocked-url?%s+%s+%s>"
  37.  BANNER
  38.  "</a>"
  39.  "</center>"
  40.  "</body>n"
  41.  "</html>n"
  42.  ;
  44. char CTRUST[] = "HTTP/1.0 202 Request for untrusted URLn"
  45.  "Pragma: no-cachen"
  46.  "Last-Modified: Thu Jul 31, 1997 07:42:22 pm GMTn"
  47.  "Expires:       Thu Jul 31, 1997 07:42:22 pm GMTn"
  48.  "Content-Type: text/htmlnn"
  49.  "<html>n"
  50.  "<head>n"
  51.  "<title>Internet Junkbuster: Request for untrusted URL</title>n"
  52.  "</head>n"
  53.  WHITEBG
  54.  "<center>"
  55.  "<a href=http://internet.junkbuster.com/ij-untrusted-url?%s+%s+%s>"
  56.  BANNER
  57.  "</a>"
  58.  "</center>"
  59.  "</body>n"
  60.  "</html>n"
  61.  ;
  63. char *
  64. block_url(struct http_request *http, struct client_state *csp)
  65. {
  66. struct file_list *fl;
  67. struct block_spec *b;
  68. struct url_spec url[1];
  69. char *p;
  70. char *hostport, *path, *spec;
  71. int n;
  73. if(((fl = csp->blist) == NULL) || ((b  = fl->f) == NULL)) {
  74. return(NULL);
  75. }
  77. *url = dsplit(http->host);
  79. /* if splitting the domain fails, punt */
  80. if(url->dbuf == NULL) return(NULL);
  82. for(b = b->next; b ; b = b->next) {
  83. if((b->url->port == 0) || (b->url->port == http->port)) {
  84. if((b->url->domain[0] == '') || (domaincmp(b->url, url) == 0)) {
  85. if((b->url->path == NULL) ||
  86. #ifdef REGEX
  87.    (regexec(b->url->preg, http->path, 0, NULL, 0) == 0)
  88. #else
  89.    (strncmp(b->url->path, http->path, b->url->pathlen) == 0)
  90. #endif
  91. ) {
  92. freez(url->dbuf);
  93. freez(url->dvec);
  95. if(b->reject == 0) return(NULL);
  97. hostport = URL(http->hostport);
  98. path     = URL(http->path);
  99. spec     = URL(b->url->spec);
  101. n  = strlen(CBLOCK);
  102. n += strlen(hostport);
  103. n += strlen(path);
  104. n += strlen(spec);
  106. p = malloc(n);
  108. sprintf(p, CBLOCK,
  109. hostport, path, spec);
  111. freez(hostport);
  112. freez(path);
  113. freez(spec);
  115. return(p);
  116. }
  117. }
  118. }
  119. }
  120. freez(url->dbuf);
  121. freez(url->dvec);
  122. return(NULL);
  123. }
  125. char *
  126. trust_url(struct http_request *http, struct client_state *csp)
  127. {
  128. struct file_list *fl;
  129. struct block_spec *b;
  130. struct url_spec url[1], **tl, *t;
  131. char *p, *h;
  132. char *hostport, *path, *referrer;
  133. struct http_request rhttp[1];
  134. int n;
  136. if(((fl = csp->tlist) == NULL) || ((b  = fl->f) == NULL)) {
  137. return(NULL);
  138. }
  140. *url = dsplit(http->host);
  142. /* if splitting the domain fails, punt */
  143. if(url->dbuf == NULL) return(NULL);
  145. memset(rhttp, '', sizeof(*rhttp));
  147. for(b = b->next; b ; b = b->next) {
  149. if((b->url->port == 0) || (b->url->port == http->port)) {
  150. if((b->url->domain[0] == '') || (domaincmp(b->url, url) == 0)) {
  151. if((b->url->path == NULL) ||
  152. #ifdef REGEX
  153.    (regexec(b->url->preg, http->path, 0, NULL, 0) == 0)
  154. #else
  155.    (strncmp(b->url->path, http->path, b->url->pathlen) == 0)
  156. #endif
  157. ) {
  158. freez(url->dbuf);
  159. freez(url->dvec);
  161. if(b->reject == 0) return(NULL);
  163. hostport = URL(http->hostport);
  164. path     = URL(http->path);
  166. if(csp->referrer) {
  167. referrer = URL(csp->referrer);
  168. } else {
  169. referrer = URL("undefined");
  170. }
  172. n  = strlen(CTRUST);
  173. n += strlen(hostport);
  174. n += strlen(path);
  175. n += strlen(referrer);
  177. p = malloc(n);
  179. sprintf(p, CTRUST,
  180. hostport, path, referrer);
  182. freez(hostport);
  183. freez(path);
  184. freez(referrer);
  186. return(p);
  187. }
  188. }
  189. }
  190. }
  192. freez(url->dbuf);
  193. freez(url->dvec);
  195. if((csp->referrer == NULL)|| (strlen(csp->referrer) <= 9)) {
  196. /* no referrer was supplied */
  197. goto trust_url_not_trusted;
  198. }
  200. /* forge a URL from the referrer so we can use
  201.  * convert_url() to parse it into its components.
  202.  */
  204. p = NULL;
  205. p = strsav(p, "GET ");
  206. p = strsav(p, csp->referrer + 9); /* skip over "Referer: " */
  207. p = strsav(p, " HTTP/1.0");
  209. parse_http_request(p, rhttp, csp);
  211. if(rhttp->cmd == NULL) {
  212. freez(p);
  213. goto trust_url_not_trusted;
  214. }
  216. freez(p);
  218. *url = dsplit(rhttp->host);
  220. /* if splitting the domain fails, punt */
  221. if(url->dbuf == NULL) goto trust_url_not_trusted;
  223. for(tl = trust_list; (t = *tl) ; tl++) {
  224. if((t->port == 0) || (t->port == rhttp->port)) {
  225. if((t->domain[0] == '') || domaincmp(t, url) == 0) {
  226. if((t->path == NULL) ||
  227. #ifdef REGEX
  228.    (regexec(t->preg, rhttp->path, 0, NULL, 0) == 0)
  229. #else
  230.    (strncmp(t->path, rhttp->path, t->pathlen) == 0)
  231. #endif
  232. ) {
  233. /* if the URL's referrer is from a trusted referrer, then
  234.  * add the target spec to the trustfile as an unblocked
  235.  * domain and return NULL (which means it's OK).
  236.  */
  238. FILE *fp;
  240. freez(url->dbuf);
  241. freez(url->dvec);
  243. if((fp = fopen(trustfile, "a"))) {
  244. h = NULL;
  246. h = strsav(h, "~");
  247. h = strsav(h, http->hostport);
  249. p = http->path;
  250. if((*p++ == '/')
  251. && (*p++ == '~')) {
  252. /* since this path points into a user's home space
  253.  * be sure to include this spec in the trustfile.
  254.  */
  255. if((p = strchr(p, '/'))) {
  256. *p = '';
  257. h = strsav(h, http->path);
  258. h = strsav(h, "/");
  259. }
  260. }
  262. free_http_request(rhttp);
  264. fprintf(fp, "%sn", h);
  265. freez(h);
  266. fclose(fp);
  267. }
  268. return(NULL);
  269. }
  270. }
  271. }
  272. }
  274. trust_url_not_trusted:
  275. free_http_request(rhttp);
  277. hostport = URL(http->hostport);
  278. path     = URL(http->path);
  280. if(csp->referrer) {
  281. referrer = URL(csp->referrer);
  282. } else {
  283. referrer = URL("undefined");
  284. }
  286. n  = strlen(CTRUST);
  287. n += strlen(hostport);
  288. n += strlen(path);
  289. n += strlen(referrer);
  291. p = malloc(n);
  292. sprintf(p, CTRUST, hostport, path, referrer);
  294. freez(hostport);
  295. freez(path);
  296. freez(referrer);
  298. return(p);
  299. }
  301. /* intercept_url() checks the URL `basename' against a list of URLs
  302.  * to snarf.  If it matches, it calls the associated function which
  303.  * returns an HTML page to send back to the client.
  304.  */
  306. char *
  307. intercept_url(struct http_request *http, struct client_state *csp)
  308. {
  309. char *basename;
  310. struct interceptors *v;
  312. basename = strrchr(http->path, '/');
  314. if(basename == NULL) return(NULL);
  316. basename++; /* first char past the last slash */
  318. if(*basename) {
  319. for(v = intercept_patterns; v->str; v++) {
  320. if(strncmp(basename, v->str, v->len) == 0) {
  322. return((v->interceptor)(http, csp));
  323. }
  324. }
  325. }
  327. return(NULL);
  328. }
  330. struct cookie_spec *
  331. cookie_url(struct http_request *http, struct client_state *csp)
  332. {
  333. struct file_list *fl;
  334. struct cookie_spec *b;
  335. struct url_spec url[1];
  337. if(((fl = csp->clist) == NULL) || ((b  = fl->f) == NULL)) {
  338. return(NULL);
  339. }
  341. *url = dsplit(http->host);
  343. /* if splitting the domain fails, punt */
  344. if(url->dbuf == NULL) return(NULL);
  346. for(b = b->next; b ; b = b->next) {
  347. if((b->url->port == 0) || (b->url->port == http->port)) {
  348. if((b->url->domain[0] == '') || (domaincmp(b->url, url) == 0)) {
  349. if((b->url->path == NULL) ||
  350. #ifdef REGEX
  351.    (regexec(b->url->preg, http->path, 0, NULL, 0) == 0)
  352. #else
  353.    (strncmp(b->url->path, http->path, b->url->pathlen) == 0)
  354. #endif
  355. ) {
  356. freez(url->dbuf);
  357. freez(url->dvec);
  358. return(b);
  359. }
  360. }
  361. }
  362. }
  363. freez(url->dbuf);
  364. freez(url->dvec);
  365. return(NULL);
  366. }
  368. struct gateway *
  369. forward_url(struct http_request *http, struct client_state *csp)
  370. {
  371. struct file_list *fl;
  372. struct forward_spec *b;
  373. struct url_spec url[1];
  375. if(((fl = csp->flist) == NULL) || ((b  = fl->f) == NULL)) {
  376. return(gw_default);
  377. }
  379. *url = dsplit(http->host);
  381. /* if splitting the domain fails, punt */
  382. if(url->dbuf == NULL) return(gw_default);
  384. for(b = b->next; b ; b = b->next) {
  385. if((b->url->port == 0) || (b->url->port == http->port)) {
  386. if((b->url->domain[0] == '') || (domaincmp(b->url, url) == 0)) {
  387. if((b->url->path == NULL) ||
  388. #ifdef REGEX
  389.    (regexec(b->url->preg, http->path, 0, NULL, 0) == 0)
  390. #else
  391.    (strncmp(b->url->path, http->path, b->url->pathlen) == 0)
  392. #endif
  393. ) {
  394. freez(url->dbuf);
  395. freez(url->dvec);
  396. return(b->gw);
  397. }
  398. }
  399. }
  400. }
  401. freez(url->dbuf);
  402. freez(url->dvec);
  403. return(gw_default);
  404. }
  406. /* dsplit() takes a domain and returns a pointer to a url_spec
  407.  * structure populated with dbuf, dcnt and dvec.  the other fields
  408.  * in the structure that is returned are zero.
  409.  *
  410.  */
  412. struct url_spec
  413. dsplit(char *domain)
  414. {
  415. struct url_spec ret[1];
  416. char *v[BUFSIZ];
  417. int size;
  418. char *p;
  420. memset(ret, '', sizeof(*ret));
  422. if((p = strrchr(domain, '.'))) {
  423. if(*(++p) == '') {
  424. ret->toplevel = 1;
  425. }
  426. }
  428. ret->dbuf = strdup(domain);
  430. /* map to lower case */
  431. for(p = ret->dbuf; *p ; p++) *p = tolower(*p);
  433. /* split the domain name into components */
  434. ret->dcnt = ssplit(ret->dbuf, ".", v, SZ(v), 1, 1);
  436. if(ret->dcnt <= 0) {
  437. memset(ret, '', sizeof(ret));
  438. return(*ret);
  439. }
  441. /* save a copy of the pointers in dvec */
  442. size = ret->dcnt * sizeof(*ret->dvec);
  444. if((ret->dvec = malloc(size))) {
  445. memcpy(ret->dvec, v, size);
  446. }
  448. return(*ret);
  449. }
  451. /* the "pattern" is a domain that may contain a '*' as a wildcard.
  452.  * the "fqdn" is the domain name against which the patterns are compared.
  453.  *
  454.  * domaincmp("a.b.c" , "a.b.c") => 0 (MATCH)
  455.  * domaincmp("a*.b.c", "a.b.c") => 0 (MATCH)
  456.  * domaincmp("b.c"   , "a.b.c") => 0 (MATCH)
  457.  * domaincmp(""      , "a.b.c") => 0 (MATCH)
  458.  */
  460. int
  461. domaincmp(struct url_spec *pattern, struct url_spec *fqdn)
  462. {
  463. char **pv, **fv; /* vectors  */
  464. int    pn,   fn; /* counters */
  465. char  *p,   *f; /* chars    */
  467. pv = pattern->dvec;
  468. pn = pattern->dcnt;
  470. fv = fqdn->dvec;
  471. fn = fqdn->dcnt;
  473. while((pn > 0) && (fn > 0)) {
  474. p = pv[--pn];
  475. f = fv[--fn];
  477. while(*p && *f && (*p == tolower(*f))) {
  478. p++, f++;
  479. }
  481. if((*p != tolower(*f)) && (*p != '*')) return(1);
  482. }
  484. if(pn > 0) return(1);
  486. return(0);
  487. }
  489. /* intercept functions */
  491. char *
  492. show_proxy_args(struct http_request *http, struct client_state *csp)
  493. {
  494. char *s = NULL;
  496. s = strsav(s, proxy_args->header);
  497. s = strsav(s, proxy_args->invocation);
  498. s = strsav(s, proxy_args->gateways);
  500. if(csp->blist) {
  501. s = strsav(s, csp->blist->proxy_args);
  502. }
  504. if(csp->clist) {
  505. s = strsav(s, csp->clist->proxy_args);
  506. }
  508. if(csp->tlist) {
  509. s = strsav(s, csp->tlist->proxy_args);
  510. }
  512. if(csp->flist) {
  513. s = strsav(s, csp->flist->proxy_args);
  514. }
  515. s = strsav(s, proxy_args->trailer);
  517. return(s);
  518. }
  520. char *
  521. ij_blocked_url(struct http_request *http, struct client_state *csp)
  522. {
  523. int n;
  524. char *hostport, *path, *pattern, *p, *v[9];
  526. char *template =
  527. "HTTP/1.0 200 OKrn"
  528. "Pragma: no-cachen"
  529. "Last-Modified: Thu Jul 31, 1997 07:42:22 pm GMTn"
  530. "Expires:       Thu Jul 31, 1997 07:42:22 pm GMTn"
  531. "Content-Type: text/htmlnn"
  532. "<html>n"
  533. "<head>n"
  534. "<title>Internet Junkbuster: Request for blocked URL</title>n"
  535. "</head>n"
  536. BODY
  537. "<center><h1>"
  538. BANNER
  539. "</h1></center>"
  540. "The " BANNER " Proxy "
  541. "<A href="http://internet.junkbuster.com">"
  542. "(http://internet.junkbuster.com) </A>"
  543. "intercepted the request for %s%sn"
  544. "because the URL matches the following pattern "
  545. "in the blockfile: %sn"
  546. "</body>n"
  547. "</html>n"
  548. ;
  550. if((n = ssplit(http->path, "?+", v, SZ(v), 0, 0)) == 4) {
  551. hostport = url_decode(v[1]);
  552. path     = url_decode(v[2]);
  553. pattern  = url_decode(v[3]);
  554. } else {
  555. hostport = strdup("undefined_host");
  556. path     = strdup("/undefined_path");
  557. pattern  = strdup("undefined_pattern");
  558. }
  560. n  = strlen(template);
  561. n += strlen(hostport);
  562. n += strlen(path    );
  563. n += strlen(pattern );
  565. if((p = malloc(n))) {
  566. sprintf(p, template, hostport, path, pattern);
  567. }
  569. freez(hostport);
  570. freez(path    );
  571. freez(pattern );
  573. return(p);
  574. }
  576. char *
  577. ij_untrusted_url(struct http_request *http, struct client_state *csp)
  578. {
  579. int n;
  580. char *hostport, *path, *p, *v[9];
  581. char buf[BUFSIZ];
  582. struct url_spec **tl, *t;
  585. char *template =
  586. "HTTP/1.0 200 OKrn"
  587. "Pragma: no-cachen"
  588. "Last-Modified: Thu Jul 31, 1997 07:42:22 pm GMTn"
  589. "Expires:       Thu Jul 31, 1997 07:42:22 pm GMTn"
  590. "Content-Type: text/htmlnn"
  591. "<html>n"
  592. "<head>n"
  593. "<title>Internet Junkbuster: Request for untrusted URL</title>n"
  594. "</head>n"
  595. BODY
  596. "<center><h1>"
  597. BANNER
  598. "</h1></center>"
  599. "The " BANNER " Proxy "
  600. "<A href="http://internet.junkbuster.com">"
  601. "(http://internet.junkbuster.com) </A>"
  602. "intercepted the request for %s%sn"
  603. "because the URL is not trusted.n"
  604. "<br><br>n"
  605. ;
  607. if((n = ssplit(http->path, "?+", v, SZ(v), 0, 0)) == 4) {
  608. hostport = url_decode(v[1]);
  609. path     = url_decode(v[2]);
  610. referrer = url_decode(v[3]);
  611. } else {
  612. hostport = strdup("undefined_host");
  613. path     = strdup("/undefined_path");
  614. referrer = strdup("undefined");
  615. }
  617. n  = strlen(template);
  618. n += strlen(hostport);
  619. n += strlen(path    );
  621. if((p = malloc(n))) {
  622. sprintf(p, template, hostport, path);
  623. }
  625. freez(hostport);
  626. freez(path    );
  628. strsav(p, "The referrer in this request was <strong>");
  629. strsav(p, referrer);
  630. strsav(p, "</strong><br>n");
  632. p = strsav(p, "<h3>The following referrers are trusted</h3>n");
  634. for(tl = trust_list; (t = *tl) ; tl++) {
  635. sprintf(buf, "%s<br>n", t->spec);
  636. p = strsav(p, buf);
  637. }
  639. if(trust_info->next) {
  640. struct list *l;
  642. strcpy(buf,
  643. "<p>"
  644. "You can learn more about what this means "
  645. "and what you may be able to do about it by "
  646. "reading the following documents:<br>n"
  647. "<ol>n"
  648. );
  650. p = strsav(p, buf);
  652. for(l = trust_info->next; l ; l = l->next) {
  653. sprintf(buf,
  654. "<li> <a href=%s>%s</a><br>n",
  655. l->str, l->str);
  656. p = strsav(p, buf);
  657. }
  659. p = strsav(p, "</ol>n");
  660. }
  662. p = strsav(p, "</body>n" "</html>n");
  664. return(p);
  665. }