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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
config_parse.y
资源名称：dante-1.1.1.tar.gz　[点击查看]
上传用户：zm130024
上传日期：2007-01-04
资源大小：432k
文件大小：23k
源码类别：

代理服务器

开发平台：

Unix_Linux

config_parse.y：源码内容
  1. /*
  2.  * Copyright (c) 1997, 1998, 1999
  3.  *      Inferno Nettverk A/S, Norway.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. The above copyright notice, this list of conditions and the following
  9.  *    disclaimer must appear in all copies of the software, derivative works
  10.  *    or modified versions, and any portions thereof, aswell as in all
  11.  *    supporting documentation.
  12.  * 2. All advertising materials mentioning features or use of this software
  13.  *    must display the following acknowledgement:
  14.  *      This product includes software developed by
  15.  *      Inferno Nettverk A/S, Norway.
  16.  * 3. The name of the author may not be used to endorse or promote products
  17.  *    derived from this software without specific prior written permission.
  18.  *
  19.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29.  *
  30.  * Inferno Nettverk A/S requests users of this software to return to
  31.  *
  32.  *  Software Distribution Coordinator  or  sdc@inet.no
  33.  *  Inferno Nettverk A/S
  34.  *  Oslo Research Park
  35.  *  Gaustadal閑n 21
  36.  *  N-0349 Oslo
  37.  *  Norway
  38.  *
  39.  * any improvements or extensions that they make and grant Inferno Nettverk A/S
  40.  * the rights to redistribute these changes.
  41.  *
  42.  */
  44. %{
  46. #include "common.h"
  48. #include "yacconfig.h"
  50. static const char rcsid[] =
  51. "$Id: config_parse.y,v 1.121 1999/12/22 09:29:23 karls Exp $";
  53. __BEGIN_DECLS
  55. #if HAVE_LIBWRAP && SOCKS_SERVER
  56. extern jmp_buf tcpd_buf;
  57. #endif /* HAVE_LIBWRAP && SOCKS_SERVER */
  59. static void
  60. addressinit __P((struct ruleaddress_t *address));
  62. __END_DECLS
  64. extern int yylineno;
  65. extern char *yytext;
  67. #if SOCKS_SERVER
  68. static struct rule_t ruleinit;
  69. static struct rule_t rule; /* new rule. */
  70. static struct protocol_t protocolmem; /* new protocolmem. */
  71. struct linkedname_t **userbase; /* users rule applies to. */
  72. #endif
  74. #if SOCKS_CLIENT
  75. static struct serverstate_t state;
  76. static struct route_t route; /* new route. */
  77. static struct ruleaddress_t gw; /* new gateway. */
  78. #endif
  81. static struct ruleaddress_t src; /* new src. */
  82. static struct ruleaddress_t dst; /* new dst. */
  83. static struct ruleaddress_t *ruleaddress; /* current ruleaddress */
  84. static struct extension_t *extension; /* new extensions */
  85. static struct proxyprotocol_t *proxyprotocol;/* proxy protocol. */
  87. static char *atype; /* atype of new address. */
  88. static struct in_addr *ipaddr; /* new ipaddress */
  89. static struct in_addr *netmask; /* new netmask */
  90. static char *domain; /* new domain. */
  92. static in_port_t *port_tcp; /* new tcp portnumber. */
  93. static in_port_t *port_udp; /* new udp portnumber. */
  94. static int *methodv; /* new authmethods. */
  95. static int *methodc; /* number of them. */
  96. static struct protocol_t *protocol; /* new protocol. */
  97. static struct command_t *command; /* new command. */
  98. static enum operator_t *operator; /* new operator. */
  100. static const struct {
  101. const char *name;
  102. const int value;
  103. } syslogfacility[] = {
  104. #ifdef LOG_AUTH
  105. { "auth", LOG_AUTH },
  106. #endif /* LOG_AUTH */
  107. #ifdef LOG_AUTHPRIV
  108. { "authpriv", LOG_AUTHPRIV },
  109. #endif /* LOG_AUTHPRIV */
  110. #ifdef LOG_DAEMON
  111. { "daemon", LOG_DAEMON },
  112. #endif /* LOG_DAEMON */
  113. #ifdef LOG_USER
  114. { "user", LOG_USER },
  115. #endif /* LOG_USER */
  116. #ifdef LOG_LOCAL0
  117. { "local0", LOG_LOCAL0 },
  118. #endif /* LOG_LOCAL0 */
  119. #ifdef LOG_LOCAL1
  120. { "local1", LOG_LOCAL1 },
  121. #endif /* LOG_LOCAL1 */
  122. #ifdef LOG_LOCAL2
  123. { "local2", LOG_LOCAL2 },
  124. #endif /* LOG_LOCAL2 */
  125. #ifdef LOG_LOCAL3
  126. { "local3", LOG_LOCAL3 },
  127. #endif /* LOG_LOCAL3 */
  128. #ifdef LOG_LOCAL4
  129. { "local4", LOG_LOCAL4 },
  130. #endif /* LOG_LOCAL4 */
  131. #ifdef LOG_LOCAL5
  132. { "local5", LOG_LOCAL5 },
  133. #endif /* LOG_LOCAL5 */
  134. #ifdef LOG_LOCAL6
  135. { "local6", LOG_LOCAL6 },
  136. #endif /* LOG_LOCAL6 */
  137. #ifdef LOG_LOCAL7
  138. { "local7", LOG_LOCAL7 }
  139. #endif /* LOG_LOCAL7 */
  140. };
  143. #define YYDEBUG 1
  145. #define ADDMETHOD(method) 
  146. do { 
  147. if (*methodc >= AUTHMETHOD_MAX)
  148. yyerror("internal error or duplicate methods given");
  149. methodv[(*methodc)++] = method; 
  150. } while (0)
  153. %}
  155. %union {
  156. char *string;
  157. uid_t uid;
  158. }
  161. %type <string> configtype serverline clientline deprecated
  162. %token <string> SERVERCONFIG CLIENTCONFIG DEPRECATED
  164. %type <string> protocol protocols protocolname
  165. %type <string> proxyprotocol proxyprotocolname proxyprotocols
  166. %type <string> user username usernames
  167. %type <string> resolveprotocol resolveprotocolname
  168. %type <string> srchost srchostoption srchostoptions
  169. %type <string> command commands commandname
  170. %type <string> routeinit
  172. /* clientconfig exclusive. */
  173. %type <string> clientinit clientconfig
  174. %type <string> clientoption
  175. %type <string> debuging
  178. /* serverconfig exclusive */
  179. %type <string> iotimeout connecttimeout
  180. %type <string> extension extensionname extensions
  181. %type <string> internal internalinit external externalinit
  182. %type <string> logoutput logoutputdevice logoutputdevices
  183. %type <string> compatibility compatibilityname compatibilitys
  184. %type <string> authmethod authmethods authmethodname
  185. %type <string> serveroption
  186. %type <string> serverinit serverconfig
  187. %type <string> userids user_privileged user_unprivileged user_libwrap
  188. %type <uid> userid
  190. %token <string> CLIENTRULE
  191. %token <string> INTERNAL EXTERNAL
  192. %token <string> DEBUGING RESOLVEPROTOCOL
  193. %token <string> SRCHOST NOMISMATCH NOUNKNOWN
  194. %token <string> EXTENSION BIND PRIVILEGED
  195. %token <string> IOTIMEOUT CONNECTTIMEOUT
  196. %token <string> METHOD NONE GSSAPI UNAME RFC931
  197. %token <string> COMPATIBILITY REUSEADDR SAMEPORT
  198. %token <string> USERNAME
  199. %token <string> USER_PRIVILEGED USER_UNPRIVILEGED USER_LIBWRAP
  200. %token <string> LOGOUTPUT LOGFILE
  202. /* route */
  203. %type <string> route
  204. %type <string> via gateway routeoption routeoptions
  206. %token <string> ROUTE VIA
  208. /* rulelines */
  209. %type <string> rule ruleoption ruleoptions
  210. %type <string> clientrule clientruleoption clientruleoptions
  211. %type <string> verdict
  212. %type <string> fromto
  213. %type <string> log logs logname
  214. %type <string> libwrap
  215. %type <string> srcaddress dstaddress
  216. %type <string> address ipaddress gwaddress domain direct
  217. %type <string> from to
  218. %type <string> netmask
  219. %type <string> port portrange portstart portoperator portnumber portservice
  221. %token <string> VERDICT_BLOCK VERDICT_PASS
  222. %token <string> PROTOCOL PROTOCOL_TCP PROTOCOL_UDP PROTOCOL_FAKE
  223. %token <string> PROXYPROTOCOL PROXYPROTOCOL_SOCKS_V4 PROXYPROTOCOL_SOCKS_V5
  224.  PROXYPROTOCOL_MSPROXY_V2
  225. %token <string> USER
  226. %token <string> COMMAND COMMAND_BIND COMMAND_CONNECT COMMAND_UDPASSOCIATE  COMMAND_BINDREPLY COMMAND_UDPREPLY
  227. %token <string> ACTION
  228. %token <string> LINE
  229. %token <string> LIBWRAPSTART
  230. %token <string> OPERATOR
  231. %token <string> LOG LOG_CONNECT  LOG_DATA LOG_DISCONNECT LOG_ERROR     LOG_IOOPERATION
  232. %token <string> IPADDRESS DOMAIN DIRECT
  233. %token <string> PORT PORTNUMBER SERVICENAME
  234. %token <string> NUMBER
  235. %token <string> FROM TO
  237. %%
  240. /*
  241.  * first token we get should say whether we are parsing for client
  242.  * or server.  Init as appropriate.
  243.  */
  245. configtype: serverinit serverline
  246. | clientinit clientline
  247. ;
  250. serverinit: SERVERCONFIG {
  251. #if SOCKS_SERVER
  252. protocol = &protocolmem;
  253. extension = &config.extension;
  254. methodv = config.methodv;
  255. methodc = &config.methodc;
  256. #endif
  257. }
  258. ;
  261. serverline: { $$ = NULL; }
  262. | serverline 'n'
  263. | serverline serverconfig
  264. | serverline clientrule
  265. | serverline rule
  266. ;
  268. clientline: { $$ = NULL; }
  269. | clientline 'n'
  270. | clientline clientconfig
  271. | clientline route
  272. ;
  275. clientinit: CLIENTCONFIG {
  276. }
  277. ;
  279. clientconfig: clientoption
  280. |  deprecated
  281. ;
  283. serverconfig: authmethod
  284. |  deprecated
  285. | internal
  286. | external
  287. | logoutput
  288. | serveroption
  289. | userids
  290. ;
  292. serveroption: compatibility
  293. | connecttimeout
  294. | extension
  295. | iotimeout
  296. | resolveprotocol
  297. | srchost
  298. ;
  301. deprecated: DEPRECATED {
  302. yyerror("given keyword is deprecated");
  303. }
  305. route: ROUTE routeinit '{' routeoptions fromto gateway routeoptions '}' {
  306. #if SOCKS_CLIENT
  307. route.src = src;
  308. route.dst = dst;
  309. ruleaddress2sockshost(&gw, &route.gw.host, SOCKS_TCP);
  310. route.gw.state = state;
  312. addroute(&route);
  313. #endif
  314. }
  315. ;
  317. routeinit: {
  318. #if SOCKS_CLIENT
  319. command = &state.command;
  320. extension = &state.extension;
  321. methodv = state.methodv;
  322. methodc = &state.methodc;
  323. protocol = &state.protocol;
  324. proxyprotocol = &state.proxyprotocol;
  326. bzero(&state, sizeof(state));
  327. bzero(&route, sizeof(route));
  328. bzero(&gw, sizeof(gw));
  329. bzero(&src, sizeof(src));
  330. bzero(&dst, sizeof(dst));
  331. src.atype = SOCKS_ADDR_IPV4;
  332. dst.atype = SOCKS_ADDR_IPV4;
  333. #endif
  334. }
  335. ;
  338. proxyprotocol: PROXYPROTOCOL ':' proxyprotocols
  339. ;
  341. proxyprotocolname: PROXYPROTOCOL_SOCKS_V4 {
  342. proxyprotocol->socks_v4 = 1;
  343. }
  344. | PROXYPROTOCOL_SOCKS_V5 {
  345. proxyprotocol->socks_v5 = 1;
  346. }
  347. |  PROXYPROTOCOL_MSPROXY_V2 {
  348. proxyprotocol->msproxy_v2 = 1;
  349. }
  350. ;
  352. proxyprotocols: proxyprotocolname
  353. | proxyprotocolname proxyprotocols
  354. ;
  356. user: USER ':' usernames
  357. ;
  359. username: USERNAME {
  360. #if SOCKS_SERVER
  361. #if !HAVE_LIBWRAP
  362. if (strcmp($1, method2string(AUTHMETHOD_RFC931)) == 0)
  363. yyerror("method rfc931 requires libwrap");
  364. #endif /* !HAVE_LIBWRAP */
  365. if (adduser(userbase, $1) == NULL)
  366. yyerror(NOMEM);
  367. #endif /* SOCKS_SERVER */
  368. }
  369. ;
  371. usernames: username
  372. | username usernames
  373. ;
  375. extension: EXTENSION ':' extensions
  376. ;
  378. extensionname: BIND {
  379. extension->bind = 1;
  380. }
  381. ;
  383. extensions: extensionname
  384. | extensionname extensions
  385. ;
  388. internal: INTERNAL internalinit ':' ipaddress port {
  389. #if SOCKS_SERVER
  390. if (config.state.init) {
  391. int i;
  393. for (i = 0; i < config.internalc; ++i)
  394. if (config.internalv[i].addr.sin_addr.s_addr == ipaddr->s_addr
  395. &&  config.internalv[i].addr.sin_port == *port_tcp)
  396. break;
  398. if (i == config.internalc)
  399. swarnx("can not change internal addresses once running");
  400. }
  401. #endif /* SOCKS_SERVER */
  402. }
  403. ;
  405. internalinit: {
  406. #if SOCKS_SERVER
  407. static struct ruleaddress_t mem;
  408. struct servent *service;
  410. addressinit(&mem);
  412. if (!config.state.init) {
  413. if ((config.internalv = (struct listenaddress_t *)
  414. realloc(config.internalv, sizeof(*config.internalv) * ++config.internalc))
  415. == NULL)
  416. yyerror(NOMEM);
  418. bzero(&config.internalv[config.internalc - 1].addr,
  419. sizeof((*config.internalv).addr));
  420. config.internalv[config.internalc - 1].addr.sin_family = AF_INET;
  422. ipaddr = &config.internalv[config.internalc - 1].addr.sin_addr;
  423. port_tcp = &config.internalv[config.internalc - 1].addr.sin_port;
  424. }
  425. else { /* can only set internal addresses once. */
  426. static struct in_addr inaddrmem;
  427. static in_port_t portmem;
  429. ipaddr = &inaddrmem;
  430. port_tcp = &portmem;
  431. }
  433. /* set default port. */
  434. if ((service = getservbyname("socks", "tcp")) == NULL)
  435. *port_tcp = htons(SOCKD_PORT);
  436. else
  437. *port_tcp = service->s_port;
  438. #endif
  439. }
  440. ;
  442. external: EXTERNAL externalinit ':' ipaddress {
  443. #if SOCKS_SERVER
  444. if (config.externalv[config.externalc - 1].sin_addr.s_addr
  445. == htonl(INADDR_ANY))
  446. yyerror("external address can't be a wildcard address");
  447. #endif
  448. }
  449. ;
  451. externalinit: {
  452. #if SOCKS_SERVER
  453. static struct ruleaddress_t mem;
  455. if ((config.externalv = (struct sockaddr_in *)realloc(config.externalv,
  456. sizeof(*config.externalv) * ++config.externalc)) == NULL)
  457. yyerror(NOMEM);
  459. bzero(&config.externalv[config.externalc - 1], sizeof(*config.externalv));
  460. config.externalv[config.externalc - 1].sin_family = AF_INET;
  462. addressinit(&mem);
  464. ipaddr = &config.externalv[config.externalc - 1].sin_addr;
  465. #endif
  466. }
  467. ;
  469. clientoption: logoutput
  470. | debuging
  471. | resolveprotocol
  472. ;
  474. logoutput: LOGOUTPUT ':' logoutputdevices
  475. ;
  477. logoutputdevice: LOGFILE {
  478. if (!config.state.init) {
  479. const char *syslogname = "syslog";
  481. if (strncmp($1, syslogname, strlen(syslogname)) == 0
  482. && ($1[strlen(syslogname)] == NUL || $1[strlen(syslogname)] == '/')) {
  483. char *sl;
  485. config.log.type |= LOGTYPE_SYSLOG;
  487. if (*(sl = &($1[strlen(syslogname)])) == '/') { /* facility. */
  488. size_t i;
  490. for (i = 0, ++sl; i < ELEMENTS(syslogfacility); ++i)
  491. if (strcmp(sl, syslogfacility[i].name) == 0)
  492. break;
  494. if (i == ELEMENTS(syslogfacility))
  495. serrx(EXIT_FAILURE, "unknown syslog facility "%s"", sl);
  496. config.log.facility = syslogfacility[i].value;
  497. }
  498. else
  499. config.log.facility = LOG_DAEMON; /* default. */
  500. }
  501. else {
  502. config.log.type |= LOGTYPE_FILE;
  504. if ((config.log.fpv = (FILE **)realloc(config.log.fpv,
  505. sizeof(*config.log.fpv) * (config.log.fpc + 1))) == NULL
  506. || (config.log.fplockv = (int *)realloc(config.log.fplockv,
  507. sizeof(*config.log.fplockv) * (config.log.fpc + 1))) == NULL)
  508. serrx(EXIT_FAILURE, NOMEM);
  510. if ((config.log.fplockv[config.log.fpc]
  511. = socks_mklock(SOCKS_LOCKFILE)) == -1)
  512. serr(EXIT_FAILURE, "socks_mklock()");
  514. if (strcmp($1, "stdout") == 0)
  515. config.log.fpv[config.log.fpc] = stdout;
  516. else if (strcmp($1, "stderr") == 0)
  517. config.log.fpv[config.log.fpc] = stderr;
  518. else {
  519. int flag;
  521. if ((config.log.fpv[config.log.fpc] = fopen($1, "a"))
  522. == NULL)
  523. serr(EXIT_FAILURE, "fopen(%s)", $1);
  525. if ((flag = fcntl(fileno(config.log.fpv[config.log.fpc]),
  526. F_GETFD, 0)) == -1
  527. ||  fcntl(fileno(config.log.fpv[config.log.fpc]), F_SETFD,
  528. flag | FD_CLOEXEC) == -1)
  529. serr(EXIT_FAILURE, "fcntl(F_GETFD/F_SETFD)");
  530. }
  531. ++config.log.fpc;
  532. }
  533. }
  534. else
  535. ; /* XXX warn/exit if output changed. */
  536. }
  537. ;
  539. logoutputdevices: logoutputdevice
  540. | logoutputdevice logoutputdevices
  541. ;
  543. userids: user_privileged
  544. | user_unprivileged
  545. | user_libwrap
  546. ;
  548. user_privileged: USER_PRIVILEGED ':' userid {
  549. #if SOCKS_SERVER
  550. config.uid.privileged = $3;
  551. config.uid.privileged_isset = 1;
  552. #endif
  553. }
  554. ;
  556. user_unprivileged: USER_UNPRIVILEGED ':' userid {
  557. #if SOCKS_SERVER
  558. config.uid.unprivileged = $3;
  559. config.uid.unprivileged_isset = 1;
  560. #endif
  561. }
  562. ;
  564. user_libwrap: USER_LIBWRAP ':' userid {
  565. #if HAVE_LIBWRAP && SOCKS_SERVER
  566. config.uid.libwrap = $3;
  567. config.uid.libwrap_isset = 1;
  568. #else  /* HAVE_LIBWRAP */
  569. yyerror("libwrap support not compiled in");
  570. #endif /* !HAVE_LIBWRAP */
  571. }
  572. ;
  575. userid: USERNAME {
  576. struct passwd *pw;
  578. if ((pw = getpwnam($1)) == NULL)
  579. serrx(EXIT_FAILURE, "no such user "%s"", $1);
  580. else
  581. $$ = pw->pw_uid;
  582. }
  583. ;
  585. iotimeout: IOTIMEOUT ':' NUMBER {
  586. #if SOCKS_SERVER
  587. config.timeout.io = atol($3);
  588. #endif
  589. }
  590. ;
  592. connecttimeout: CONNECTTIMEOUT ':' NUMBER {
  593. #if SOCKS_SERVER
  594. config.timeout.negotiate = atol($3);
  595. #endif
  596. }
  597. ;
  599. debuging: DEBUGING ':' NUMBER {
  600. config.option.debug = atoi($3);
  601. }
  602. ;
  604. compatibility: COMPATIBILITY ':' compatibilitys
  605. ;
  607. compatibilityname: REUSEADDR {
  608. #if SOCKS_SERVER
  609. config.compat.reuseaddr = 1;
  610. }
  611. | SAMEPORT {
  612. config.compat.sameport = 1;
  613. #endif
  614. }
  615. ;
  617. compatibilitys: compatibilityname
  618. | compatibilityname compatibilitys
  619. ;
  621. resolveprotocol: RESOLVEPROTOCOL ':' resolveprotocolname
  622. ;
  624. resolveprotocolname: PROTOCOL_FAKE {
  625. config.resolveprotocol = RESOLVEPROTOCOL_FAKE;
  626. }
  627. |  PROTOCOL_TCP {
  628. #if HAVE_NO_RESOLVESTUFF
  629. yyerror("resolveprotocol keyword not supported on this installation");
  630. #else /* HAVE_NO_RESOLVESTUFF */
  631. config.resolveprotocol = RESOLVEPROTOCOL_TCP;
  632. #endif /* !HAVE_NO_RESOLVESTUFF */
  633. }
  634. | PROTOCOL_UDP {
  635. config.resolveprotocol = RESOLVEPROTOCOL_UDP;
  636. }
  637. ;
  639. srchost: SRCHOST ':' srchostoptions
  640. ;
  642. srchostoption: NOMISMATCH {
  643. #if HAVE_LIBWRAP && SOCKS_SERVER
  644. config.srchost.nomismatch = 1;
  645. }
  646. |  NOUNKNOWN {
  647. config.srchost.nounknown = 1;
  648. #else
  649. yyerror("srchostoption requires libwrap");
  650. #endif
  651. }
  652. ;
  654. srchostoptions: srchostoption
  655. | srchostoption srchostoptions
  656. ;
  659. authmethod: METHOD ':' authmethods
  660. ;
  662. authmethodname: NONE {
  663. ADDMETHOD(AUTHMETHOD_NONE);
  664. };
  665. | GSSAPI {
  666. yyerror("GSSAPI not supported");
  667. }
  668. | UNAME {
  669. ADDMETHOD(AUTHMETHOD_UNAME);
  670. }
  671. | RFC931 {
  672. #if HAVE_LIBWRAP && SOCKS_SERVER
  673. ADDMETHOD(AUTHMETHOD_RFC931);
  674. #else /* !HAVE_LIBWRAP */
  675. yyerror("method rfc931 requires libwrap");
  676. #endif /* !HAVE_LIBWRAP */
  677. }
  678. ;
  680. authmethods: authmethodname
  681. | authmethodname authmethods
  682. ;
  685. /* filterrules */
  687. clientrule: CLIENTRULE verdict '{' clientruleoptions fromto clientruleoptions '}' {
  688. #if SOCKS_SERVER
  689. rule.src = src;
  690. rule.dst = dst;
  692. addclientrule(&rule);
  694. bzero(&src, sizeof(src));
  695. bzero(&dst, sizeof(dst));
  696. rule = ruleinit;
  698. src.atype = SOCKS_ADDR_IPV4;
  699. dst.atype = SOCKS_ADDR_IPV4;
  700. #endif
  701. }
  702. ;
  704. clientruleoption: libwrap
  705. | log
  706. | user
  707. ;
  709. clientruleoptions: { $$ = NULL; }
  710. | clientruleoption clientruleoptions
  711. ;
  713. rule: verdict '{' ruleoptions fromto ruleoptions '}' {
  714. #if SOCKS_SERVER
  715. rule.src = src;
  716. rule.dst = dst;
  718. addsocksrule(&rule);
  720. bzero(&src, sizeof(src));
  721. bzero(&dst, sizeof(dst));
  722. rule = ruleinit;
  724. src.atype = SOCKS_ADDR_IPV4;
  725. dst.atype = SOCKS_ADDR_IPV4;
  726. #endif
  727. }
  728. ;
  731. ruleoption: authmethod
  732. | command
  733. | libwrap
  734. | log
  735. | protocol
  736. | proxyprotocol
  737. | user
  738. ;
  740. ruleoptions: { $$ = NULL; }
  741. | ruleoption ruleoptions
  742. ;
  744. verdict: VERDICT_BLOCK {
  745. #if SOCKS_SERVER
  746. rule.verdict = VERDICT_BLOCK;
  747. command = &rule.state.command;
  748. methodv = rule.state.methodv;
  749. methodc = &rule.state.methodc;
  750. protocol = &rule.state.protocol;
  751. proxyprotocol = &rule.state.proxyprotocol;
  752. userbase = &rule.user;
  753. }
  754. | VERDICT_PASS {
  755. rule.verdict = VERDICT_PASS;
  756. command = &rule.state.command;
  757. methodv = rule.state.methodv;
  758. methodc = &rule.state.methodc;
  759. protocol = &rule.state.protocol;
  760. proxyprotocol = &rule.state.proxyprotocol;
  761. userbase = &rule.user;
  762. #endif
  763. }
  764. ;
  766. command: COMMAND ':' commands
  767. ;
  769. commandname: COMMAND_BIND {
  770. command->bind = 1;
  771. }
  772. | COMMAND_CONNECT {
  773. command->connect = 1;
  774. }
  775. | COMMAND_UDPASSOCIATE {
  776. command->udpassociate = 1;
  777. }
  779. /* pseudocommands */
  781. | COMMAND_BINDREPLY {
  782. command->bindreply = 1;
  783. }
  785. | COMMAND_UDPREPLY {
  786. command->udpreply = 1;
  787. }
  788. ;
  790. commands: commandname
  791. | commandname commands
  792. ;
  794. protocol: PROTOCOL ':'  protocols
  795. ;
  797. protocolname: PROTOCOL_TCP {
  798. protocol->tcp = 1;
  799. }
  800. | PROTOCOL_UDP {
  801. protocol->udp = 1;
  802. }
  803. ;
  805. protocols: protocolname
  806. | protocolname protocols
  807. ;
  810. fromto: srcaddress dstaddress
  811. ;
  813. log: LOG ':' logs
  814. ;
  816. logname:  LOG_CONNECT {
  817. #if SOCKS_SERVER
  818. rule.log.connect = 1;
  819. }
  820. | LOG_DATA {
  821. rule.log.data = 1;
  822. }
  823. | LOG_DISCONNECT {
  824. rule.log.disconnect = 1;
  825. }
  826. | LOG_ERROR {
  827. rule.log.error = 1;
  828. }
  829. | LOG_IOOPERATION {
  830. rule.log.iooperation = 1;
  831. #endif
  832. }
  833. ;
  835. logs: logname
  836. |  logname logs
  837. ;
  840. libwrap: LIBWRAPSTART ':' LINE {
  841. #if HAVE_LIBWRAP && SOCKS_SERVER
  842. struct request_info request;
  843. char libwrap[LIBWRAPBUF];
  845. if (strlen($3) >= sizeof(rule.libwrap))
  846. yyerror("libwrap line too long, make LIBWRAPBUF bigger");
  847. strcpy(rule.libwrap, $3);
  849. /* libwrap modifies the passed buffer. */
  850. SASSERTX(strlen(rule.libwrap) < sizeof(libwrap));
  851. strcpy(libwrap, rule.libwrap);
  853. ++dry_run;
  854. request_init(&request, RQ_FILE, -1, RQ_DAEMON, __progname, 0);
  855. if (setjmp(tcpd_buf) != 0)
  856. yyerror("bad libwrap line");
  857. process_options(libwrap, &request);
  858. --dry_run;
  860. #else /* !HAVE_LIBWRAP */
  861. yyerror("libwrap support not compiled in");
  862. #endif
  863. }
  864. ;
  867. srcaddress: from ':' address
  868. ;
  871. dstaddress: to ':' address
  872. ;
  875. gateway: via ':' gwaddress
  876. ;
  878. routeoption: command
  879. | extension
  880. | protocol
  881. | proxyprotocol
  882. | authmethod
  883. ;
  885. routeoptions: { $$ = NULL; }
  886. | routeoption routeoptions
  887. ;
  889. from: FROM {
  890. addressinit(&src);
  891. }
  892. ;
  895. to: TO {
  896. addressinit(&dst);
  897. }
  898. ;
  901. via: VIA {
  902. #if SOCKS_CLIENT
  903. addressinit(&gw);
  904. #endif
  905. }
  906. ;
  909. address: ipaddress '/' netmask port
  910. | domain port
  911. ;
  914. gwaddress: ipaddress port
  915. | domain port
  916. | direct
  917. ;
  920. ipaddress: IPADDRESS {
  921. *atype = SOCKS_ADDR_IPV4;
  923. if (inet_aton($1, ipaddr) != 1)
  924. yyerror("bad address");
  925. }
  926. ;
  929. netmask: NUMBER {
  930. if (atoi($1) < 0 || atoi($1) > 32)
  931. yyerror("bad netmask");
  933. netmask->s_addr
  934. = atoi($1) == 0 ? 0 : htonl(0xffffffff << (32 - atoi($1)));
  935. }
  936. | IPADDRESS {
  937. if (!inet_aton($1, netmask))
  938. yyerror("bad netmask");
  939. }
  940. ;
  942. domain: DOMAIN {
  943. *atype = SOCKS_ADDR_DOMAIN;
  945. if (strlen($1) >= MAXHOSTNAMELEN)
  946. yyerror("domain too long");
  947. strcpy(domain, $1);
  948. }
  949. ;
  951. direct: DIRECT {
  952. *atype = SOCKS_ADDR_DOMAIN;
  954. if (strlen($1) >= MAXHOSTNAMELEN)
  955. yyerror("domain too long");
  956. strcpy(domain, $1);
  958. #if SOCKS_CLIENT
  959. route.state.direct = 1;
  960. #endif
  961. }
  962. ;
  964. port: { $$ = NULL; }
  965. | PORT portoperator portnumber
  966. | PORT portrange
  967. ;
  969. portnumber: portservice
  970. | portstart
  971. ;
  973. portrange: portstart '-' portend
  974. ;
  977. portstart: PORTNUMBER {
  978. *port_tcp = htons((in_port_t)atoi($1));
  979. *port_udp = htons((in_port_t)atoi($1));
  980. }
  981. ;
  983. portservice: SERVICENAME {
  984. struct servent *service;
  985. struct protocol_t protocolunset;
  986. int set;
  988. bzero(&protocolunset, sizeof(protocolunset));
  990. /* set all protocols if none set, default. */
  991. if (memcmp(protocol, &protocolunset, sizeof(*protocol)) == 0) {
  992. memset(protocol, UCHAR_MAX, sizeof(*protocol));
  993. set = 0;
  994. }
  995. else
  996. set = 1;
  998. if (protocol->tcp) {
  999. if ((service = getservbyname($1, "tcp")) == NULL) {
  1000. if (set)
  1001. yyerror("bad servicename for tcp");
  1002. else
  1003. *port_tcp = htons(0);
  1004. }
  1005. else
  1006. *port_tcp = (in_port_t)service->s_port;
  1007. }
  1009. if (protocol->udp) {
  1010. if ((service = getservbyname($1, "udp")) == NULL) {
  1011. if (set)
  1012. yyerror("bad servicename for udp");
  1013. else
  1014. *port_udp = htons(0);
  1015. }
  1016. else
  1017. *port_udp = (in_port_t)service->s_port;
  1018. }
  1020. /* check we got both protocol ports set right. */
  1021. if (*port_tcp == htons(0) && *port_udp == htons(0))
  1022. yyerror("bad service name for tcp/udp");
  1023. if (*port_tcp == htons(0))
  1024. *port_tcp = *port_udp;
  1025. else if (*port_udp == htons(0))
  1026. *port_udp = *port_tcp;
  1027. }
  1028. ;
  1031. portend: PORTNUMBER {
  1032. ruleaddress->portend = htons((in_port_t)atoi($1));
  1033. ruleaddress->operator = range;
  1034. }
  1035. ;
  1037. portoperator: OPERATOR {
  1038. *operator = string2operator($1);
  1039. }
  1040. ;
  1042. %%
  1044. #define INTERACTIVE 0
  1046. #if SOCKS_SERVER
  1047. #define ELECTRICFENCE 0
  1048. #else
  1049. #define ELECTRICFENCE 0
  1050. #endif
  1053. #if ELECTRICFENCE
  1054. extern int EF_PROTECT_FREE;
  1055. extern int EF_ALLOW_MALLOC_0;
  1056. extern int EF_ALIGNMENT;
  1057. extern int EF_PROTECT_BELOW;
  1058. #endif /* ELECTRICFENCE */
  1060. extern FILE *yyin;
  1062. int parseinit;
  1064. int
  1065. readconfig(filename)
  1066. const char *filename;
  1067. {
  1068. const char *function = "readconfig()";
  1070. #if ELECTRICFENCE
  1071. EF_PROTECT_FREE         = 1;
  1072. EF_ALLOW_MALLOC_0       = 1;
  1073. EF_ALIGNMENT            = 0;
  1074. EF_PROTECT_BELOW = 0;
  1075. #endif /* ELECTRICFENCE */
  1077. /* yydebug = 0; */
  1078. yylineno = 1;
  1079. parseinit = 0;
  1081. if ((yyin = fopen(filename, "r")) == NULL) {
  1082. swarn("%s: %s", function, filename);
  1083. return -1;
  1084. }
  1086. yyparse();
  1087. fclose(yyin);
  1089. errno = 0; /* yacc for some reason alters errno sometimes. */
  1091. return 0;
  1092. }
  1095. void
  1096. yyerror(s)
  1097. const char *s;
  1098. {
  1100. serrx(1, "%s: error on line %d, near '%.10s': %s",
  1101. config.option.configfile, yylineno,
  1102. (yytext == NULL || *yytext == NUL) ? "'start of line'" : yytext, s);
  1103. }
  1106. static void
  1107. addressinit(address)
  1108. struct ruleaddress_t *address;
  1109. {
  1110. ruleaddress = address;
  1112. atype = &ruleaddress->atype;
  1113. ipaddr = &ruleaddress->addr.ipv4.ip;
  1114. netmask = &ruleaddress->addr.ipv4.mask;
  1115. domain = ruleaddress->addr.domain;
  1116. port_tcp = &ruleaddress->port.tcp;
  1117. port_udp = &ruleaddress->port.udp;
  1118. operator = &ruleaddress->operator;
  1119. }