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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
cachemgr.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：20k
源码类别：

代理服务器

开发平台：

Unix_Linux

cachemgr.c：源码内容
  2. /*
  3.  * $Id: cachemgr.c,v 1.84.2.2 1999/02/12 19:38:23 wessels Exp $
  4.  *
  5.  * DEBUG: section 0     CGI Cache Manager
  6.  * AUTHOR: Duane Wessels
  7.  *
  8.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  9.  * ----------------------------------------------------------
  10.  *
  11.  *  Squid is the result of efforts by numerous individuals from the
  12.  *  Internet community.  Development is led by Duane Wessels of the
  13.  *  National Laboratory for Applied Network Research and funded by the
  14.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  15.  *  Duane Wessels and the University of California San Diego.  Please
  16.  *  see the COPYRIGHT file for full details.  Squid incorporates
  17.  *  software developed and/or copyrighted by other sources.  Please see
  18.  *  the CREDITS file for full details.
  19.  *
  20.  *  This program is free software; you can redistribute it and/or modify
  21.  *  it under the terms of the GNU General Public License as published by
  22.  *  the Free Software Foundation; either version 2 of the License, or
  23.  *  (at your option) any later version.
  24.  *  
  25.  *  This program is distributed in the hope that it will be useful,
  26.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  *  GNU General Public License for more details.
  29.  *  
  30.  *  You should have received a copy of the GNU General Public License
  31.  *  along with this program; if not, write to the Free Software
  32.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33.  *
  34.  */
  36. #include "config.h"
  38. #if HAVE_UNISTD_H
  39. #include <unistd.h>
  40. #endif
  41. #if HAVE_STDLIB_H
  42. #include <stdlib.h>
  43. #endif
  44. #if HAVE_STDIO_H
  45. #include <stdio.h>
  46. #endif
  47. #if HAVE_SYS_TYPES_H
  48. #include <sys/types.h>
  49. #endif
  50. #if HAVE_CTYPE_H
  51. #include <ctype.h>
  52. #endif
  53. #if HAVE_ERRNO_H
  54. #include <errno.h>
  55. #endif
  56. #if HAVE_FCNTL_H
  57. #include <fcntl.h>
  58. #endif
  59. #if HAVE_GRP_H
  60. #include <grp.h>
  61. #endif
  62. #if HAVE_GNUMALLOC_H
  63. #include <gnumalloc.h>
  64. #elif HAVE_MALLOC_H && !defined(_SQUID_FREEBSD_) && !defined(_SQUID_NEXT_)
  65. #include <malloc.h>
  66. #endif
  67. #if HAVE_MEMORY_H
  68. #include <memory.h>
  69. #endif
  70. #if HAVE_NETDB_H && !defined(_SQUID_NETDB_H_) /* protect NEXTSTEP */
  71. #define _SQUID_NETDB_H_
  72. #include <netdb.h>
  73. #endif
  74. #if HAVE_PWD_H
  75. #include <pwd.h>
  76. #endif
  77. #if HAVE_SIGNAL_H
  78. #include <signal.h>
  79. #endif
  80. #if HAVE_TIME_H
  81. #include <time.h>
  82. #endif
  83. #if HAVE_SYS_PARAM_H
  84. #include <sys/param.h>
  85. #endif
  86. #if HAVE_SYS_TIME_H
  87. #include <sys/time.h>
  88. #endif
  89. #if HAVE_SYS_RESOURCE_H
  90. #include <sys/resource.h> /* needs sys/time.h above it */
  91. #endif
  92. #if HAVE_SYS_SOCKET_H
  93. #include <sys/socket.h>
  94. #endif
  95. #if HAVE_NETINET_IN_H
  96. #include <netinet/in.h>
  97. #endif
  98. #if HAVE_ARPA_INET_H
  99. #include <arpa/inet.h>
  100. #endif
  101. #if HAVE_SYS_STAT_H
  102. #include <sys/stat.h>
  103. #endif
  104. #if HAVE_SYS_UN_H
  105. #include <sys/un.h>
  106. #endif
  107. #if HAVE_SYS_WAIT_H
  108. #include <sys/wait.h>
  109. #endif
  110. #if HAVE_LIBC_H
  111. #include <libc.h>
  112. #endif
  113. #if HAVE_STRING_H
  114. #include <string.h>
  115. #endif
  116. #if HAVE_STRINGS_H
  117. #include <strings.h>
  118. #endif
  119. #if HAVE_BSTRING_H
  120. #include <bstring.h>
  121. #endif
  122. #if HAVE_CRYPT_H
  123. #include <crypt.h>
  124. #endif
  125. #if HAVE_SYS_SELECT_H
  126. #include <sys/select.h>
  127. #endif
  129. #include "util.h"
  130. #include "snprintf.h"
  132. typedef struct {
  133.     char *hostname;
  134.     int port;
  135.     char *action;
  136.     char *user_name;
  137.     char *passwd;
  138.     char *pub_auth;
  139. } cachemgr_request;
  141. /*
  142.  * Debugging macros (info goes to error_log on your web server)
  143.  * Note: do not run cache manager with non zero debugging level 
  144.  *       if you do not debug, it may write a lot of [sensitive]
  145.  *       information to your error log.
  146.  */
  148. /* debugging level 0 (disabled) - 3 (max) */
  149. #define DEBUG_LEVEL 0
  150. #define debug(level) if ((level) <= DEBUG_LEVEL && DEBUG_LEVEL > 0)
  152. /*
  153.  * Static variables and constants
  154.  */
  155. static const time_t passwd_ttl = 60 * 60 * 3; /* in sec */
  156. static const char *script_name = "/cgi-bin/cachemgr.cgi";
  157. static const char *progname = NULL;
  158. static time_t now;
  159. static struct in_addr no_addr;
  161. /*
  162.  * Function prototypes
  163.  */
  164. #define safe_free(str) { if (str) { xfree(str); (str) = NULL; } }
  165. static const char *safe_str(const char *str);
  166. static char *xstrtok(char **str, char del);
  167. static void print_trailer(void);
  168. static void auth_html(char *host, int port, const char *user_name);
  169. static void error_html(const char *msg);
  170. static char *menu_url(cachemgr_request * req, const char *action);
  171. static int parse_status_line(const char *sline, const char **statusStr);
  172. static cachemgr_request *read_request(void);
  173. static char *read_get_request(void);
  174. static char *read_post_request(void);
  176. static void make_pub_auth(cachemgr_request * req);
  177. static void decode_pub_auth(cachemgr_request * req);
  178. static void reset_auth(cachemgr_request * req);
  179. static const char *make_auth_header(const cachemgr_request * req);
  182. static const char *
  183. safe_str(const char *str)
  184. {
  185.     return str ? str : "";
  186. }
  188. /* relaxed number format */
  189. static int
  190. is_number(const char *str)
  191. {
  192.     return strspn(str, "t -+01234567890./n") == strlen(str);
  193. }
  195. static char *
  196. xstrtok(char **str, char del)
  197. {
  198.     if (*str) {
  199. char *p = strchr(*str, del);
  200. char *tok = *str;
  201. int len;
  202. if (p) {
  203.     *str = p + 1;
  204.     *p = '';
  205. } else
  206.     *str = NULL;
  207. /* trim */
  208. len = strlen(tok);
  209. while (len && xisspace(tok[len - 1]))
  210.     tok[--len] = '';
  211. while (xisspace(*tok))
  212.     tok++;
  213. return tok;
  214.     } else
  215. return "";
  216. }
  218. static void
  219. print_trailer(void)
  220. {
  221.     printf("<HR>n");
  222.     printf("<ADDRESS>n");
  223.     printf("Generated %s, by %s/%s@%sn",
  224. mkrfc1123(now), progname, SQUID_VERSION, getfullhostname());
  225.     printf("</ADDRESS></BODY></HTML>n");
  226. }
  228. static void
  229. auth_html(char *host, int port, const char *user_name)
  230. {
  231.     if (!user_name)
  232. user_name = "";
  233.     if (!host || !strlen(host))
  234. host = "localhost";
  235.     printf("Content-type: text/htmlrnrn");
  236.     printf("<HTML><HEAD><TITLE>Cache Manager Interface</TITLE></HEAD>n");
  237.     printf("<BODY><H1>Cache Manager Interface</H1>n");
  238.     printf("<P>This is a WWW interface to the instrumentation interfacen");
  239.     printf("for the Squid object cache.</P>n");
  240.     printf("<HR>n");
  241.     printf("<FORM METHOD="GET" ACTION="%s">n", script_name);
  242.     printf("<TABLE BORDER=0>n");
  243.     printf("<TR><TH ALIGN="left">Cache Host:</TH><TD><INPUT NAME="host" ");
  244.     printf("SIZE=30 VALUE="%s"></TD></TR>n", host);
  245.     printf("<TR><TH ALIGN="left">Cache Port:</TH><TD><INPUT NAME="port" ");
  246.     printf("SIZE=30 VALUE="%d"></TD></TR>n", port);
  247.     printf("<TR><TH ALIGN="left">Manager name:</TH><TD><INPUT NAME="user_name" ");
  248.     printf("SIZE=30 VALUE="%s"></TD></TR>n", user_name);
  249.     printf("<TR><TH ALIGN="left">Password:</TH><TD><INPUT TYPE="password" NAME="passwd" ");
  250.     printf("SIZE=30 VALUE=""></TD></TR>n");
  251.     printf("</TABLE><BR CLEAR="all">n");
  252.     printf("<INPUT TYPE="submit" VALUE="Continue...">n");
  253.     printf("</FORM>n");
  254.     print_trailer();
  255. }
  257. static void
  258. error_html(const char *msg)
  259. {
  260.     printf("Content-type: text/htmlrnrn");
  261.     printf("<HTML><HEAD><TITLE>Cache Manager Error</TITLE></HEAD>n");
  262.     printf("<BODY><H1>Cache Manager Error</H1>n");
  263.     printf("<P>n%s</P>n", msg);
  264.     print_trailer();
  265. }
  267. /* returns http status extracted from status line or -1 on parsing failure */
  268. static int
  269. parse_status_line(const char *sline, const char **statusStr)
  270. {
  271.     const char *sp = strchr(sline, ' ');
  272.     if (statusStr)
  273. *statusStr = NULL;
  274.     if (strncasecmp(sline, "HTTP/", 5) || !sp)
  275. return -1;
  276.     while (xisspace(*++sp));
  277.     if (!xisdigit(*sp))
  278. return -1;
  279.     if (statusStr)
  280. *statusStr = sp;
  281.     return atoi(sp);
  282. }
  284. static char *
  285. menu_url(cachemgr_request * req, const char *action)
  286. {
  287.     static char url[1024];
  288.     snprintf(url, sizeof(url), "%s?host=%s&port=%d&user_name=%s&operation=%s&auth=%s",
  289. script_name,
  290. req->hostname,
  291. req->port,
  292. safe_str(req->user_name),
  293. action,
  294. safe_str(req->pub_auth));
  295.     return url;
  296. }
  298. static const char *
  299. munge_menu_line(const char *buf, cachemgr_request * req)
  300. {
  301.     char *x;
  302.     const char *a;
  303.     const char *d;
  304.     const char *p;
  305.     char *a_url;
  306.     char *buf_copy;
  307.     static char html[2 * 1024];
  308.     if (strlen(buf) < 1)
  309. return buf;
  310.     if (*buf != ' ')
  311. return buf;
  312.     buf_copy = x = xstrdup(buf);
  313.     a = xstrtok(&x, 't');
  314.     d = xstrtok(&x, 't');
  315.     p = xstrtok(&x, 't');
  316.     a_url = xstrdup(menu_url(req, a));
  317.     /* no reason to give a url for a disabled action */
  318.     if (!strcmp(p, "disabled"))
  319. snprintf(html, sizeof(html), "<LI type="circle">%s (disabled)<A HREF="%s">.</A>n", d, a_url);
  320.     else
  321. /* disable a hidden action (requires a password, but password is not in squid.conf) */
  322.     if (!strcmp(p, "hidden"))
  323. snprintf(html, sizeof(html), "<LI type="circle">%s (hidden)<A HREF="%s">.</A>n", d, a_url);
  324.     else
  325. /* disable link if authentication is required and we have no password */
  326.     if (!strcmp(p, "protected") && !req->passwd)
  327. snprintf(html, sizeof(html), "<LI type="circle">%s (requires <a href="%s">authentication</a>)<A HREF="%s">.</A>n",
  328.     d, menu_url(req, "authenticate"), a_url);
  329.     else
  330. /* highlight protected but probably available entries */
  331.     if (!strcmp(p, "protected"))
  332. snprintf(html, sizeof(html), "<LI type="square"><A HREF="%s"><font color="#FF0000">%s</font></A>n",
  333.     a_url, d);
  334.     /* public entry or unknown type of protection */
  335.     else
  336. snprintf(html, sizeof(html), "<LI type="disk"><A HREF="%s">%s</A>n", a_url, d);
  337.     xfree(a_url);
  338.     xfree(buf_copy);
  339.     return html;
  340. }
  342. static const char *
  343. munge_other_line(const char *buf, cachemgr_request * req)
  344. {
  345.     static const char *ttags[] =
  346.     {"td", "th"};
  347.     static char html[4096];
  348.     static int table_line_num = 0;
  349.     static int next_is_header = 0;
  350.     int is_header = 0;
  351.     const char *ttag;
  352.     char *buf_copy;
  353.     char *x, *p;
  354.     int l = 0;
  355.     /* does it look like a table? */
  356.     if (!strchr(buf, 't') || *buf == 't') {
  357. /* nope, just text */
  358. snprintf(html, sizeof(html), "%s%s",
  359.     table_line_num ? "</table>n<pre>" : "", buf);
  360. table_line_num = 0;
  361. return html;
  362.     }
  363.     /* start html table */
  364.     if (!table_line_num) {
  365. l += snprintf(html + l, sizeof(html) - l, "</pre><table border=1 cellpadding=2 cellspacing=1>n");
  366. next_is_header = 0;
  367.     }
  368.     /* remove 'n' */
  369.     is_header = (!table_line_num || next_is_header) && !strchr(buf, ':') && !is_number(buf);
  370.     ttag = ttags[is_header];
  371.     /* record starts */
  372.     l += snprintf(html + l, sizeof(html) - l, "<tr>");
  373.     /* substitute 't' */
  374.     buf_copy = x = xstrdup(buf);
  375.     if ((p = strchr(x, 'n')))
  376. *p = '';
  377.     while (x && strlen(x)) {
  378. int column_span = 1;
  379. const char *cell = xstrtok(&x, 't');
  380. while (x && *x == 't') {
  381.     column_span++;
  382.     x++;
  383. }
  384. l += snprintf(html + l, sizeof(html) - l, "<%s colspan=%d align="%s">%s</%s>",
  385.     ttag, column_span,
  386.     is_header ? "center" : is_number(cell) ? "right" : "left",
  387.     cell, ttag);
  388.     }
  389.     xfree(buf_copy);
  390.     /* record ends */
  391.     l += snprintf(html + l, sizeof(html) - l, "</tr>n");
  392.     next_is_header = is_header && strstr(buf, "tt");
  393.     table_line_num++;
  394.     return html;
  395. }
  397. static int
  398. read_reply(int s, cachemgr_request * req)
  399. {
  400.     char buf[4 * 1024];
  401.     FILE *fp = fdopen(s, "r");
  402.     /* interpretation states */
  403.     enum {
  404. isStatusLine, isHeaders, isBodyStart, isBody, isForward, isEof, isForwardEof, isSuccess, isError
  405.     } istate = isStatusLine;
  406.     int parse_menu = 0;
  407.     const char *action = req->action;
  408.     const char *statusStr = NULL;
  409.     int status = -1;
  410.     if (0 == strlen(req->action))
  411. parse_menu = 1;
  412.     else if (0 == strcasecmp(req->action, "menu"))
  413. parse_menu = 1;
  414.     if (fp == NULL) {
  415. perror("fdopen");
  416. return 1;
  417.     }
  418.     if (parse_menu)
  419. action = "menu";
  420.     /* read reply interpreting one line at a time depending on state */
  421.     while (istate < isEof) {
  422. if (!fgets(buf, sizeof(buf), fp))
  423.     istate = istate == isForward ? isForwardEof : isEof;
  424. switch (istate) {
  425. case isStatusLine:
  426.     /* get HTTP status */
  427.     /* uncomment the following if you want to debug headers */
  428.     /* fputs("rnrn", stdout); */
  429.     status = parse_status_line(buf, &statusStr);
  430.     istate = status == 200 ? isHeaders : isForward;
  431.     /* if cache asks for authentication, we have to reset our info */
  432.     if (status == 401 || status == 407) {
  433. reset_auth(req);
  434. status = 403; /* Forbiden, see comments in case isForward: */
  435.     }
  436.     /* this is a way to pass HTTP status to the Web server */
  437.     if (statusStr)
  438. printf("Status: %d %s", status, statusStr); /* statusStr has 'n' */
  439.     break;
  440. case isHeaders:
  441.     /* forward header field */
  442.     if (!strcmp(buf, "rn")) { /* end of headers */
  443. fputs("Content-Type: text/htmlrn", stdout); /* add our type */
  444. istate = isBodyStart;
  445.     }
  446.     if (strncasecmp(buf, "Content-Type:", 13)) /* filter out their type */
  447. fputs(buf, stdout);
  448.     break;
  449. case isBodyStart:
  450.     printf("<HTML><HEAD><TITLE>CacheMgr@%s: %s</TITLE></HEAD><BODY>n",
  451. req->hostname, action);
  452.     if (parse_menu) {
  453. printf("<H2><a href="%s">Cache Manager</a> menu for %s:</H2>",
  454.     menu_url(req, "authenticate"), req->hostname);
  455. printf("<UL>n");
  456.     } else {
  457. printf("<P><A HREF="%s">%s</A>n<HR>n",
  458.     menu_url(req, "menu"), "Cache Manager menu");
  459. printf("<PRE>n");
  460.     }
  461.     istate = isBody;
  462.     /* yes, fall through, we do not want to loose the first line */
  463. case isBody:
  464.     /* interpret [and reformat] cache response */
  465.     if (parse_menu)
  466. fputs(munge_menu_line(buf, req), stdout);
  467.     else
  468. fputs(munge_other_line(buf, req), stdout);
  469.     break;
  470. case isForward:
  471.     /* forward: no modifications allowed */
  472.     /*
  473.      * Note: we currently do not know any way to get browser.reply to
  474.      * 401 to .cgi because web server filters out all auth info. Thus we
  475.      * disable authentication headers for now.
  476.      */
  477.     if (!strncasecmp(buf, "WWW-Authenticate:", 17) || !strncasecmp(buf, "Proxy-Authenticate:", 19)); /* skip */
  478.     else
  479. fputs(buf, stdout);
  480.     break;
  481. case isEof:
  482.     /* print trailers */
  483.     if (parse_menu)
  484. printf("</UL>n");
  485.     else
  486. printf("</table></PRE>n");
  487.     print_trailer();
  488.     istate = isSuccess;
  489.     break;
  490. case isForwardEof:
  491.     /* indicate that we finished processing an "error" sequence */
  492.     istate = isError;
  493.     break;
  494. default:
  495.     printf("%s: internal bug: invalid state reached: %d", script_name, istate);
  496.     istate = isError;
  497. }
  498.     }
  499.     close(s);
  500.     return 0;
  501. }
  503. static int
  504. process_request(cachemgr_request * req)
  505. {
  506.     const struct hostent *hp;
  507.     static struct sockaddr_in S;
  508.     int s;
  509.     int l;
  510.     static char buf[2 * 1024];
  511.     if (req == NULL) {
  512. auth_html(CACHEMGR_HOSTNAME, CACHE_HTTP_PORT, "");
  513. return 1;
  514.     }
  515.     if (req->hostname == NULL) {
  516. req->hostname = xstrdup(CACHEMGR_HOSTNAME);
  517.     }
  518.     if (req->port == 0) {
  519. req->port = CACHE_HTTP_PORT;
  520.     }
  521.     if (req->action == NULL) {
  522. req->action = xstrdup("");
  523.     }
  524.     if (!strcmp(req->action, "authenticate")) {
  525. auth_html(req->hostname, req->port, req->user_name);
  526. return 0;
  527.     }
  528.     if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
  529. snprintf(buf, 1024, "socket: %sn", xstrerror());
  530. error_html(buf);
  531. return 1;
  532.     }
  533.     memset(&S, '', sizeof(struct sockaddr_in));
  534.     S.sin_family = AF_INET;
  535.     if ((hp = gethostbyname(req->hostname)) != NULL)
  536. xmemcpy(&S.sin_addr.s_addr, hp->h_addr, hp->h_length);
  537.     else if (safe_inet_addr(req->hostname, &S.sin_addr))
  538. (void) 0;
  539.     else {
  540. snprintf(buf, 1024, "Unknown host: %sn", req->hostname);
  541. error_html(buf);
  542. return 1;
  543.     }
  544.     S.sin_port = htons(req->port);
  545.     if (connect(s, (struct sockaddr *) &S, sizeof(struct sockaddr_in)) < 0) {
  546. snprintf(buf, 1024, "connect: %sn", xstrerror());
  547. error_html(buf);
  548. return 1;
  549.     }
  550.     l = snprintf(buf, sizeof(buf),
  551. "GET cache_object://%s/%s HTTP/1.0rn"
  552. "Accept: */*rn"
  553. "%s" /* Authentication info or nothing */
  554. "rn",
  555. req->hostname,
  556. req->action,
  557. make_auth_header(req));
  558.     write(s, buf, l);
  559.     debug(1) fprintf(stderr, "wrote request: '%s'n", buf);
  560.     return read_reply(s, req);
  561. }
  563. int
  564. main(int argc, char *argv[])
  565. {
  566.     char *s;
  567.     cachemgr_request *req;
  568.     safe_inet_addr("255.255.255.255", &no_addr);
  569.     now = time(NULL);
  570.     if ((s = strrchr(argv[0], '/')))
  571. progname = xstrdup(s + 1);
  572.     else
  573. progname = xstrdup(argv[0]);
  574.     if ((s = getenv("SCRIPT_NAME")) != NULL)
  575. script_name = xstrdup(s);
  576.     req = read_request();
  577.     return process_request(req);
  578. }
  580. static char *
  581. read_post_request(void)
  582. {
  583.     char *s;
  584.     char *buf;
  585.     int len;
  586.     if ((s = getenv("REQUEST_METHOD")) == NULL)
  587. return NULL;
  588.     if (0 != strcasecmp(s, "POST"))
  589. return NULL;
  590.     if ((s = getenv("CONTENT_LENGTH")) == NULL)
  591. return NULL;
  592.     if ((len = atoi(s)) <= 0)
  593. return NULL;
  594.     buf = xmalloc(len + 1);
  595.     fread(buf, len, 1, stdin);
  596.     buf[len] = '';
  597.     return buf;
  598. }
  600. static char *
  601. read_get_request(void)
  602. {
  603.     char *s;
  604.     if ((s = getenv("QUERY_STRING")) == NULL)
  605. return NULL;
  606.     return xstrdup(s);
  607. }
  609. static cachemgr_request *
  610. read_request(void)
  611. {
  612.     char *buf;
  613.     cachemgr_request *req;
  614.     char *s;
  615.     char *t;
  616.     char *q;
  617.     if ((buf = read_post_request()) != NULL)
  618. (void) 0;
  619.     else if ((buf = read_get_request()) != NULL)
  620. (void) 0;
  621.     else
  622. return NULL;
  623.     if (strlen(buf) == 0)
  624. return NULL;
  625.     req = xcalloc(1, sizeof(cachemgr_request));
  626.     for (s = strtok(buf, "&"); s != NULL; s = strtok(NULL, "&")) {
  627. t = xstrdup(s);
  628. if ((q = strchr(t, '=')) == NULL)
  629.     continue;
  630. *q++ = '';
  631. if (0 == strcasecmp(t, "host") && strlen(q))
  632.     req->hostname = xstrdup(q);
  633. else if (0 == strcasecmp(t, "port") && strlen(q))
  634.     req->port = atoi(q);
  635. else if (0 == strcasecmp(t, "user_name") && strlen(q))
  636.     req->user_name = xstrdup(q);
  637. else if (0 == strcasecmp(t, "passwd") && strlen(q))
  638.     req->passwd = xstrdup(q);
  639. else if (0 == strcasecmp(t, "auth") && strlen(q))
  640.     req->pub_auth = xstrdup(q), decode_pub_auth(req);
  641. else if (0 == strcasecmp(t, "operation"))
  642.     req->action = xstrdup(q);
  643.     }
  644.     make_pub_auth(req);
  645.     debug(1) fprintf(stderr, "cmgr: got req: host: '%s' port: %d uname: '%s' passwd: '%s' auth: '%s' oper: '%s'n",
  646. safe_str(req->hostname), req->port, safe_str(req->user_name), safe_str(req->passwd), safe_str(req->pub_auth), safe_str(req->action));
  647.     return req;
  648. }
  651. /* Routines to support authentication */
  653. /*
  654.  * Encodes auth info into a "public" form. 
  655.  * Currently no powerful encryption is used.
  656.  */
  657. static void
  658. make_pub_auth(cachemgr_request * req)
  659. {
  660.     static char buf[1024];
  661.     safe_free(req->pub_auth);
  662.     debug(3) fprintf(stderr, "cmgr: encoding for pub...n");
  663.     if (!req->passwd || !strlen(req->passwd))
  664. return;
  665.     /* host | time | user | passwd */
  666.     snprintf(buf, sizeof(buf), "%s|%d|%s|%s",
  667. req->hostname,
  668. (int) now,
  669. req->user_name ? req->user_name : "",
  670. req->passwd);
  671.     debug(3) fprintf(stderr, "cmgr: pre-encoded for pub: %sn", buf);
  672.     debug(3) fprintf(stderr, "cmgr: encoded: '%s'n", base64_encode(buf));
  673.     req->pub_auth = xstrdup(base64_encode(buf));
  674. }
  676. static void
  677. decode_pub_auth(cachemgr_request * req)
  678. {
  679.     char *buf;
  680.     const char *host_name;
  681.     const char *time_str;
  682.     const char *user_name;
  683.     const char *passwd;
  685.     debug(2) fprintf(stderr, "cmgr: decoding pub: '%s'n", safe_str(req->pub_auth));
  686.     safe_free(req->passwd);
  687.     if (!req->pub_auth || strlen(req->pub_auth) < 4 + strlen(safe_str(req->hostname)))
  688. return;
  689.     buf = xstrdup(base64_decode(req->pub_auth));
  690.     debug(3) fprintf(stderr, "cmgr: length okn");
  691.     /* parse ( a lot of memory leaks, but that is cachemgr style :) */
  692.     if ((host_name = strtok(buf, "|")) == NULL)
  693. return;
  694.     debug(3) fprintf(stderr, "cmgr: decoded host: '%s'n", host_name);
  695.     if ((time_str = strtok(NULL, "|")) == NULL)
  696. return;
  697.     debug(3) fprintf(stderr, "cmgr: decoded time: '%s' (now: %d)n", time_str, (int) now);
  698.     if ((user_name = strtok(NULL, "|")) == NULL)
  699. return;
  700.     debug(3) fprintf(stderr, "cmgr: decoded uname: '%s'n", user_name);
  701.     if ((passwd = strtok(NULL, "|")) == NULL)
  702. return;
  703.     debug(2) fprintf(stderr, "cmgr: decoded passwd: '%s'n", passwd);
  704.     /* verify freshness and validity */
  705.     if (atoi(time_str) + passwd_ttl < now)
  706. return;
  707.     if (strcasecmp(host_name, req->hostname))
  708. return;
  709.     debug(1) fprintf(stderr, "cmgr: verified auth. info.n");
  710.     /* ok, accept */
  711.     xfree(req->user_name);
  712.     req->user_name = xstrdup(user_name);
  713.     req->passwd = xstrdup(passwd);
  714.     xfree(buf);
  715. }
  717. static void
  718. reset_auth(cachemgr_request * req)
  719. {
  720.     safe_free(req->passwd);
  721.     safe_free(req->pub_auth);
  722. }
  724. static const char *
  725. make_auth_header(const cachemgr_request * req)
  726. {
  727.     static char buf[1024];
  728.     off_t l = 0;
  729.     const char *str64;
  730.     if (!req->passwd)
  731. return "";
  733.     snprintf(buf, sizeof(buf), "%s:%s",
  734. req->user_name ? req->user_name : "",
  735. req->passwd);
  737.     str64 = base64_encode(buf);
  738.     l += snprintf(buf, sizeof(buf), "Authorization: Basic %srn", str64);
  739.     l += snprintf(&buf[l], sizeof(buf) - l,
  740. "Proxy-Authorization: Basic %srn", str64);
  741.     return buf;
  742. }