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

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

代理服务器

开发平台：

Unix_Linux

cf_gen.c：源码内容
  1. /*
  2.  * $Id: cf_gen.c,v 1.31.2.1 1999/02/12 19:38:24 wessels Exp $
  3.  *
  4.  * DEBUG: none
  5.  * AUTHOR: Max Okumoto
  6.  *
  7.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  8.  * ----------------------------------------------------------
  9.  *
  10.  *  Squid is the result of efforts by numerous individuals from the
  11.  *  Internet community.  Development is led by Duane Wessels of the
  12.  *  National Laboratory for Applied Network Research and funded by the
  13.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  14.  *  Duane Wessels and the University of California San Diego.  Please
  15.  *  see the COPYRIGHT file for full details.  Squid incorporates
  16.  *  software developed and/or copyrighted by other sources.  Please see
  17.  *  the CREDITS file for full details.
  18.  *
  19.  *  This program is free software; you can redistribute it and/or modify
  20.  *  it under the terms of the GNU General Public License as published by
  21.  *  the Free Software Foundation; either version 2 of the License, or
  22.  *  (at your option) any later version.
  23.  *  
  24.  *  This program is distributed in the hope that it will be useful,
  25.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27.  *  GNU General Public License for more details.
  28.  *  
  29.  *  You should have received a copy of the GNU General Public License
  30.  *  along with this program; if not, write to the Free Software
  31.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  32.  *
  33.  */
  35. /*****************************************************************************
  36.  * Abstract: This program parses the input file and generates code and
  37.  * files used to configure the variables in squid.
  38.  * (ie it creates the squid.conf file from the cf.data file)
  39.  *
  40.  * The output files are as follows:
  41.  * cf_parser.c - this file contains, default_all() which
  42.  *   initializes variables with the default
  43.  *   values, parse_line() that parses line from
  44.  *   squid.conf, dump_config that dumps the
  45.  *   current the values of the variables.
  46.  * squid.conf - default configuration file given to the server
  47.  *  administrator.
  48.  *****************************************************************************/
  50. #include "config.h"
  52. #if HAVE_STDIO_H
  53. #include <stdio.h>
  54. #endif
  55. #if HAVE_STRING_H
  56. #include <string.h>
  57. #endif
  58. #if HAVE_STDLIB_H
  59. #include <stdlib.h>
  60. #endif
  61. #if HAVE_CTYPE_H
  62. #include <ctype.h>
  63. #endif
  64. #if HAVE_ASSERT_H
  65. #include <assert.h>
  66. #endif
  68. #include "util.h"
  70. #define MAX_LINE 1024 /* longest configuration line */
  71. #define _PATH_PARSER "cf_parser.c"
  72. #define _PATH_SQUID_CONF "squid.conf"
  74. enum State {
  75.     sSTART,
  76.     s1,
  77.     sDOC,
  78.     sNOCOMMENT,
  79.     sEXIT
  80. };
  82. typedef struct Line {
  83.     char *data;
  84.     struct Line *next;
  85. } Line;
  87. typedef struct Entry {
  88.     char *name;
  89.     char *type;
  90.     char *loc;
  91.     char *default_value;
  92.     char *default_if_none;
  93.     char *comment;
  94.     char *ifdef;
  95.     Line *doc;
  96.     Line *nocomment;
  97.     struct Entry *next;
  98. } Entry;
  101. static const char WS[] = " t";
  102. static int gen_default(Entry *, FILE *);
  103. static void gen_parse(Entry *, FILE *);
  104. static void gen_dump(Entry *, FILE *);
  105. static void gen_free(Entry *, FILE *);
  106. static void gen_conf(Entry *, FILE *);
  107. static void gen_default_if_none(Entry *, FILE *);
  109. int
  110. main(int argc, char *argv[])
  111. {
  112.     FILE *fp;
  113.     char *input_filename = argv[1];
  114.     char *output_filename = _PATH_PARSER;
  115.     char *conf_filename = _PATH_SQUID_CONF;
  116.     int linenum = 0;
  117.     Entry *entries = NULL;
  118.     Entry *curr = NULL;
  119.     enum State state;
  120.     int rc = 0;
  121.     char *ptr = NULL;
  122. #ifdef _SQUID_OS2_
  123.     const char *rmode = "rt";
  124. #else
  125.     const char *rmode = "r";
  126. #endif
  128.     /*-------------------------------------------------------------------*
  129.      * Parse input file
  130.      *-------------------------------------------------------------------*/
  132.     /* Open input file */
  133.     if ((fp = fopen(input_filename, rmode)) == NULL) {
  134. perror(input_filename);
  135. exit(1);
  136.     }
  137.     state = sSTART;
  138.     while (feof(fp) == 0 && state != sEXIT) {
  139. char buff[MAX_LINE];
  140. char *t;
  141. if (NULL == fgets(buff, MAX_LINE, fp))
  142.     break;
  143. linenum++;
  144. if ((t = strchr(buff, 'n')))
  145.     *t = '';
  146. switch (state) {
  147. case sSTART:
  148.     if ((strlen(buff) == 0) || (!strncmp(buff, "#", 1))) {
  149. /* ignore empty and comment lines */
  150. (void) 0;
  151.     } else if (!strncmp(buff, "NAME:", 5)) {
  152. char *name;
  153. if ((name = strtok(buff + 5, WS)) == NULL) {
  154.     printf("Error in input filen");
  155.     exit(1);
  156. }
  157. curr = calloc(1, sizeof(Entry));
  158. curr->name = xstrdup(name);
  159. state = s1;
  160.     } else if (!strcmp(buff, "EOF")) {
  161. state = sEXIT;
  162.     } else if (!strcmp(buff, "COMMENT_START")) {
  163. curr = calloc(1, sizeof(Entry));
  164. curr->name = xstrdup("comment");
  165. curr->loc = xstrdup("none");
  166. state = sDOC;
  167.     } else {
  168. printf("Error on line %dn", linenum);
  169. printf("--> %sn", buff);
  170. exit(1);
  171.     }
  172.     break;
  174. case s1:
  175.     if ((strlen(buff) == 0) || (!strncmp(buff, "#", 1))) {
  176. /* ignore empty and comment lines */
  177. (void) 0;
  178.     } else if (!strncmp(buff, "COMMENT:", 8)) {
  179. ptr = buff + 8;
  180. while (xisspace(*ptr))
  181.     ptr++;
  182. curr->comment = xstrdup(ptr);
  183.     } else if (!strncmp(buff, "DEFAULT:", 8)) {
  184. ptr = buff + 8;
  185. while (xisspace(*ptr))
  186.     ptr++;
  187. curr->default_value = xstrdup(ptr);
  188.     } else if (!strncmp(buff, "DEFAULT_IF_NONE:", 16)) {
  189. ptr = buff + 16;
  190. while (xisspace(*ptr))
  191.     ptr++;
  192. curr->default_if_none = xstrdup(ptr);
  193.     } else if (!strncmp(buff, "LOC:", 4)) {
  194. if ((ptr = strtok(buff + 4, WS)) == NULL) {
  195.     printf("Error on line %dn", linenum);
  196.     exit(1);
  197. }
  198. curr->loc = xstrdup(ptr);
  199.     } else if (!strncmp(buff, "TYPE:", 5)) {
  200. if ((ptr = strtok(buff + 5, WS)) == NULL) {
  201.     printf("Error on line %dn", linenum);
  202.     exit(1);
  203. }
  204. curr->type = xstrdup(ptr);
  205.     } else if (!strncmp(buff, "IFDEF:", 6)) {
  206. if ((ptr = strtok(buff + 6, WS)) == NULL) {
  207.     printf("Error on line %dn", linenum);
  208.     exit(1);
  209. }
  210. curr->ifdef = xstrdup(ptr);
  211.     } else if (!strcmp(buff, "DOC_START")) {
  212. state = sDOC;
  213.     } else if (!strcmp(buff, "DOC_NONE")) {
  214. /* add to list of entries */
  215. curr->next = entries;
  216. entries = curr;
  217. state = sSTART;
  218.     } else {
  219. printf("Error on line %dn", linenum);
  220. exit(1);
  221.     }
  222.     break;
  224. case sDOC:
  225.     if (!strcmp(buff, "DOC_END") || !strcmp(buff, "COMMENT_END")) {
  226. Line *head = NULL;
  227. Line *line = curr->doc;
  228. /* reverse order of doc lines */
  229. while (line != NULL) {
  230.     Line *tmp;
  231.     tmp = line->next;
  232.     line->next = head;
  233.     head = line;
  234.     line = tmp;
  235. }
  236. curr->doc = head;
  237. /* add to list of entries */
  238. curr->next = entries;
  239. entries = curr;
  240. state = sSTART;
  241.     } else if (!strcmp(buff, "NOCOMMENT_START")) {
  242. state = sNOCOMMENT;
  243.     } else {
  244. Line *line = calloc(1, sizeof(Line));
  245. line->data = xstrdup(buff);
  246. line->next = curr->doc;
  247. curr->doc = line;
  248.     }
  249.     break;
  251. case sNOCOMMENT:
  252.     if (!strcmp(buff, "NOCOMMENT_END")) {
  253. Line *head = NULL;
  254. Line *line = curr->nocomment;
  255. /* reverse order of lines */
  256. while (line != NULL) {
  257.     Line *tmp;
  258.     tmp = line->next;
  259.     line->next = head;
  260.     head = line;
  261.     line = tmp;
  262. }
  263. curr->nocomment = head;
  264. state = sDOC;
  265.     } else {
  266. Line *line = calloc(1, sizeof(Line));
  267. line->data = xstrdup(buff);
  268. line->next = curr->nocomment;
  269. curr->nocomment = line;
  270.     }
  271.     break;
  273. case sEXIT:
  274.     assert(0); /* should never get here */
  275.     break;
  276. }
  277.     }
  278.     if (state != sEXIT) {
  279. printf("Error unexpected EOFn");
  280. exit(1);
  281.     } else {
  282. /* reverse order of entries */
  283. Entry *head = NULL;
  285. while (entries != NULL) {
  286.     Entry *tmp;
  288.     tmp = entries->next;
  289.     entries->next = head;
  290.     head = entries;
  291.     entries = tmp;
  292. }
  293. entries = head;
  294.     }
  295.     fclose(fp);
  297.     /*-------------------------------------------------------------------*
  298.      * Generate default_all()
  299.      * Generate parse_line()
  300.      * Generate dump_config()
  301.      * Generate free_all()
  302.      * Generate example squid.conf file
  303.      *-------------------------------------------------------------------*/
  305.     /* Open output x.c file */
  306.     if ((fp = fopen(output_filename, "w")) == NULL) {
  307. perror(output_filename);
  308. exit(1);
  309.     }
  310.     fprintf(fp,
  311. "/*n"
  312. " * Generated automatically from %s by %sn"
  313. " *n"
  314. " * Abstract: This file contains routines used to configure then"
  315. " *           variables in the squid server.n"
  316. " */n"
  317. "n",
  318. input_filename, argv[0]
  319. );
  320.     rc = gen_default(entries, fp);
  321.     gen_default_if_none(entries, fp);
  322.     gen_parse(entries, fp);
  323.     gen_dump(entries, fp);
  324.     gen_free(entries, fp);
  325.     fclose(fp);
  327.     /* Open output x.conf file */
  328.     if ((fp = fopen(conf_filename, "w")) == NULL) {
  329. perror(conf_filename);
  330. exit(1);
  331.     }
  332.     gen_conf(entries, fp);
  333.     fclose(fp);
  335.     return (rc);
  336. }
  338. static int
  339. gen_default(Entry * head, FILE * fp)
  340. {
  341.     Entry *entry;
  342.     int rc = 0;
  343.     fprintf(fp,
  344. "static voidn"
  345. "default_line(const char *s)n"
  346. "{n"
  347. "tLOCAL_ARRAY(char, tmp_line, BUFSIZ);n"
  348. "txstrncpy(tmp_line, s, BUFSIZ);n"
  349. "txstrncpy(config_input_line, s, BUFSIZ);n"
  350. "tconfig_lineno++;n"
  351. "tparse_line(tmp_line);n"
  352. "}n"
  353. );
  354.     fprintf(fp,
  355. "static voidn"
  356. "default_all(void)n"
  357. "{n"
  358. "tcfg_filename = "Default Configuration";n"
  359. "tconfig_lineno = 0;n"
  360. );
  361.     for (entry = head; entry != NULL; entry = entry->next) {
  362. assert(entry->name);
  363. assert(entry != entry->next);
  365. if (!strcmp(entry->name, "comment"))
  366.     continue;
  367. if (entry->loc == NULL) {
  368.     fprintf(stderr, "NO LOCATION FOR %sn", entry->name);
  369.     rc |= 1;
  370.     continue;
  371. }
  372. if (entry->default_value == NULL) {
  373.     fprintf(stderr, "NO DEFAULT FOR %sn", entry->name);
  374.     rc |= 1;
  375.     continue;
  376. }
  377. assert(entry->default_value);
  378. if (entry->ifdef)
  379.     fprintf(fp, "#if %sn", entry->ifdef);
  380. if (strcmp(entry->default_value, "none") == 0) {
  381.     fprintf(fp, "t/* No default for %s */n", entry->name);
  382. } else {
  383.     fprintf(fp, "tdefault_line("%s %s");n",
  384. entry->name,
  385. entry->default_value);
  386. }
  387. if (entry->ifdef)
  388.     fprintf(fp, "#endifn");
  389.     }
  390.     fprintf(fp, "tcfg_filename = NULL;n");
  391.     fprintf(fp, "}nn");
  392.     return rc;
  393. }
  395. static void
  396. gen_default_if_none(Entry * head, FILE * fp)
  397. {
  398.     Entry *entry;
  399.     fprintf(fp,
  400. "static voidn"
  401. "defaults_if_none(void)n"
  402. "{n"
  403. );
  404.     for (entry = head; entry != NULL; entry = entry->next) {
  405. assert(entry->name);
  406. assert(entry->loc);
  407. if (entry->default_if_none == NULL)
  408.     continue;
  409. if (entry->ifdef)
  410.     fprintf(fp, "#if %sn", entry->ifdef);
  411. fprintf(fp,
  412.     "tif (check_null_%s(%s))n"
  413.     "ttdefault_line("%s %s");n",
  414.     entry->type,
  415.     entry->loc,
  416.     entry->name,
  417.     entry->default_if_none);
  418. if (entry->ifdef)
  419.     fprintf(fp, "#endifn");
  420.     }
  421.     fprintf(fp, "}nn");
  422. }
  424. static void
  425. gen_parse(Entry * head, FILE * fp)
  426. {
  427.     Entry *entry;
  429.     fprintf(fp,
  430. "static intn"
  431. "parse_line(char *buff)n"
  432. "{n"
  433. "tinttresult = 1;n"
  434. "tchart*token;n"
  435. "tdebug(0,10)("parse_line: %%s\n", buff);n"
  436. "tif ((token = strtok(buff, w_space)) == NULL)n"
  437. "tt(void) 0;t/* ignore empty lines */n"
  438. );
  440.     for (entry = head; entry != NULL; entry = entry->next) {
  441. if (strcmp(entry->name, "comment") == 0)
  442.     continue;
  443. if (entry->ifdef)
  444.     fprintf(fp, "#if %sn", entry->ifdef);
  445. fprintf(fp, "telse if (!strcmp(token, "%s"))n",
  446.     entry->name
  447.     );
  448. assert(entry->loc);
  449. if (strcmp(entry->loc, "none") == 0) {
  450.     fprintf(fp,
  451. "ttparse_%s();n",
  452. entry->type
  453. );
  454. } else {
  455.     fprintf(fp,
  456. "ttparse_%s(&%s);n",
  457. entry->type, entry->loc
  458. );
  459. }
  460. if (entry->ifdef)
  461.     fprintf(fp, "#endifn");
  462.     }
  464.     fprintf(fp,
  465. "telsen"
  466. "ttresult = 0; /* failure */n"
  467. "treturn(result);n"
  468. "}nn"
  469. );
  470. }
  472. static void
  473. gen_dump(Entry * head, FILE * fp)
  474. {
  475.     Entry *entry;
  476.     fprintf(fp,
  477. "static voidn"
  478. "dump_config(StoreEntry *entry)n"
  479. "{n"
  480. );
  481.     for (entry = head; entry != NULL; entry = entry->next) {
  482. assert(entry->loc);
  483. if (strcmp(entry->loc, "none") == 0)
  484.     continue;
  485. if (strcmp(entry->name, "comment") == 0)
  486.     continue;
  487. if (entry->ifdef)
  488.     fprintf(fp, "#if %sn", entry->ifdef);
  489. fprintf(fp, "tdump_%s(entry, "%s", %s);n",
  490.     entry->type,
  491.     entry->name,
  492.     entry->loc);
  493. if (entry->ifdef)
  494.     fprintf(fp, "#endifn");
  495.     }
  496.     fprintf(fp, "}nn");
  497. }
  499. static void
  500. gen_free(Entry * head, FILE * fp)
  501. {
  502.     Entry *entry;
  503.     fprintf(fp,
  504. "static voidn"
  505. "free_all(void)n"
  506. "{n"
  507. );
  508.     for (entry = head; entry != NULL; entry = entry->next) {
  509. assert(entry->loc);
  510. if (strcmp(entry->loc, "none") == 0)
  511.     continue;
  512. if (strcmp(entry->name, "comment") == 0)
  513.     continue;
  514. if (entry->ifdef)
  515.     fprintf(fp, "#if %sn", entry->ifdef);
  516. fprintf(fp, "tfree_%s(&%s);n", entry->type, entry->loc);
  517. if (entry->ifdef)
  518.     fprintf(fp, "#endifn");
  519.     }
  520.     fprintf(fp, "}nn");
  521. }
  523. static void
  524. gen_conf(Entry * head, FILE * fp)
  525. {
  526.     Entry *entry;
  528.     for (entry = head; entry != NULL; entry = entry->next) {
  529. Line *line;
  531. if (!strcmp(entry->name, "comment"))
  532.     (void) 0;
  533. else
  534.     fprintf(fp, "#  TAG: %s", entry->name);
  535. if (entry->comment)
  536.     fprintf(fp, "t%s", entry->comment);
  537. fprintf(fp, "n");
  538. for (line = entry->doc; line != NULL; line = line->next) {
  539.     fprintf(fp, "#%sn", line->data);
  540. }
  541. for (line = entry->nocomment; line != NULL; line = line->next) {
  542.     fprintf(fp, "%sn", line->data);
  543. }
  544. if (entry->doc != NULL) {
  545.     fprintf(fp, "n");
  546. }
  547.     }
  548. }