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

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

代理服务器

开发平台：

Unix_Linux

serverconfig.c：源码内容
  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. #include "common.h"
  45. #include "config_parse.h"
  47. static const char rcsid[] =
  48. "$Id: serverconfig.c,v 1.92 1999/12/22 09:29:25 karls Exp $";
  50. __BEGIN_DECLS
  52. static void
  53. showuser __P((const struct linkedname_t *user));
  54. /*
  55.  * shows usernames in "user".
  56.  */
  58. static void
  59. showlog __P((const struct log_t *log));
  60. /*
  61.  * shows what type of logging is specified in "log".
  62.  */
  64. #if HAVE_LIBWRAP
  65. extern jmp_buf tcpd_buf;
  67. static void
  68. libwrapinit __P((int s, struct request_info *request));
  69. /*
  70.  * Initializes "request" for later usage via libwrap.
  71.  */
  73. static int
  74. connectisok __P((struct request_info *request, const struct rule_t *rule,
  75.   struct connectionstate_t *state));
  76. #else /* !HAVE_LIBWRAP */
  77. static int
  78. connectisok __P((void *request, const struct rule_t *rule,
  79.   struct connectionstate_t *state));
  80. #endif /* !HAVE_LIBWRAP */
  81. /*
  82.  * Checks the connection on "s".
  83.  * "rule" is the rule that matched the connection and "state" is the current
  84.  * state.
  85.  * This function should be called after each rulecheck for a new
  86.  * connection/packet.
  87.  *
  88.  * Returns:
  89.  * If connection is acceptable: true
  90.  * If connection is not acceptable: false
  91.  */
  93. static struct rule_t *
  94. addrule __P((const struct rule_t *newrule, struct rule_t **rulebase));
  95. /*
  96.  * Appends a copy of "newrule" to "rulebase".
  97.  * Returns a pointer to the added rule (not "newrule").
  98.  */
  100. static void
  101. checkrule __P((const struct rule_t *rule));
  102. /*
  103.  * Check that the rule "rule" makes sense.
  104.  */
  106. __END_DECLS
  108. struct config_t config;
  109. const int configtype = CONFIGTYPE_SERVER;
  111. #if HAVE_LIBWRAP
  112. int allow_severity, deny_severity;
  113. #endif  /* HAVE_LIBWRAP */
  115. struct rule_t *
  116. addclientrule(newrule)
  117. const struct rule_t *newrule;
  118. {
  119. struct rule_t *rule;
  121. rule = addrule(newrule, &config.crule);
  123. /*
  124.  * there are a few things that need to be changed versus the generic
  125.  * init done by addrule().
  126.  */
  128. if (rule->user != NULL) {
  129. /*
  130.  * this is a clientrule so strip away any methods that
  131.  * can not provide a username without socks negotiation.
  132.  */
  133. int i;
  135. for (i = 0; i < rule->state.methodc; ++i)
  136. switch (rule->state.methodv[i]) {
  137. case AUTHMETHOD_RFC931:
  138. break;
  140. default:
  141. rule->state.methodv[i--]
  142. = rule->state.methodv[--rule->state.methodc];
  143. }
  144. }
  146. checkrule(rule);
  148. /* LINTED cast discards 'const' from pointer target type */
  149. return (struct rule_t *)rule;
  150. }
  152. struct rule_t *
  153. addsocksrule(newrule)
  154. const struct rule_t *newrule;
  155. {
  157. struct rule_t *rule;
  159. rule = addrule(newrule, &config.srule);
  161. if (rule->user == NULL) {
  162. /*
  163.  * For each method taking a username, default to
  164.  * allowing everybody that's in the passwordfile.
  165.  */
  166. int i;
  168. for (i = 0; i < rule->state.methodc; ++i)
  169. switch (rule->state.methodv[i]) {
  170. case AUTHMETHOD_UNAME:
  171. case AUTHMETHOD_RFC931:
  172. if (adduser(&rule->user, method2string(rule->state.methodv[i]))
  173. == NULL)
  174. serrx(EXIT_FAILURE, NOMEM);
  175. break;
  176. }
  177. }
  179. checkrule(rule);
  181. /* LINTED cast discards 'const' from pointer target type */
  182. return (struct rule_t *)rule;
  183. }
  185. struct linkedname_t *
  186. adduser(ruleuser, name)
  187. struct linkedname_t **ruleuser;
  188. const char *name;
  189. {
  190. struct linkedname_t *user, *last;
  192. for (user = *ruleuser, last = NULL; user != NULL; user = user->next)
  193. last = user;
  195. if ((user = (struct linkedname_t *)malloc(sizeof(*user))) == NULL)
  196. return NULL;
  198. if ((user->name = strdup(name)) == NULL)
  199. return NULL;
  200. user->next = NULL;
  202. if (*ruleuser == NULL)
  203. *ruleuser = user;
  204. else
  205. last->next = user;
  207. return *ruleuser;
  208. }
  211. void
  212. showrule(rule)
  213. const struct rule_t *rule;
  214. {
  215. char addr[MAXRULEADDRSTRING];
  217. slog(LOG_INFO, "socks-rule #%d",
  218. rule->number);
  220. slog(LOG_INFO, "verdict: %s",
  221. rule->verdict == VERDICT_PASS ? VERDICT_PASSs : VERDICT_BLOCKs);
  223. slog(LOG_INFO, "src: %s",
  224. ruleaddress2string(&rule->src, addr, sizeof(addr)));
  226. slog(LOG_INFO, "dst: %s",
  227. ruleaddress2string(&rule->dst, addr, sizeof(addr)));
  229. showuser(rule->user);
  231. showstate(&rule->state);
  233. showlog(&rule->log);
  235. #if HAVE_LIBWRAP
  236. if (*rule->libwrap != NUL)
  237. slog(LOG_INFO, "libwrap: %s", rule->libwrap);
  238. #endif  /* HAVE_LIBWRAP */
  239. }
  241. void
  242. showclient(rule)
  243. const struct rule_t *rule;
  244. {
  245. char addr[MAXRULEADDRSTRING];
  247. slog(LOG_INFO, "client-rule #%d", rule->number);
  249. slog(LOG_INFO, "verdict: %s",
  250. rule->verdict == VERDICT_PASS ? VERDICT_PASSs : VERDICT_BLOCKs);
  252. slog(LOG_INFO, "from: %s",
  253. ruleaddress2string(&rule->src, addr, sizeof(addr)));
  255. slog(LOG_INFO, "to: %s",
  256. ruleaddress2string(&rule->dst, addr, sizeof(addr)));
  258. showuser(rule->user);
  260. showlog(&rule->log);
  262. #if HAVE_LIBWRAP
  263. if (*rule->libwrap != NUL)
  264. slog(LOG_INFO, "libwrap: %s", rule->libwrap);
  265. #endif  /* HAVE_LIBWRAP */
  266. }
  268. void
  269. showconfig(config)
  270. const struct config_t *config;
  271. {
  272. int i;
  273. char address[MAXSOCKADDRSTRING], buf[1024];
  274. size_t bufused;
  276. slog(LOG_INFO, "internal addresses (%d):", config->internalc);
  277. for (i = 0; i < config->internalc; ++i)
  278. slog(LOG_INFO, "%s",
  279. /* LINTED pointer casts may be troublesome */
  280. sockaddr2string((struct sockaddr *)&config->internalv[i], address,
  281. sizeof(address)));
  283. slog(LOG_INFO, "external addresses (%d):", config->externalc);
  284. for (i = 0; i < config->externalc; ++i)
  285. slog(LOG_INFO, "%s",
  286. /* LINTED pointer casts may be troublesome */
  287. sockaddr2string((struct sockaddr *)&config->externalv[i], address,
  288. sizeof(address)));
  290. bufused = snprintf(buf, sizeof(buf), "compatibility options: ");
  291. if (config->compat.reuseaddr)
  292. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "reuseaddr, ");
  293. if (config->compat.sameport)
  294. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "sameport, ");
  295. slog(LOG_INFO, buf);
  297. bufused = snprintf(buf, sizeof(buf), "extensions enabled: ");
  298. if (config->extension.bind)
  299. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "bind, ");
  300. slog(LOG_INFO, buf);
  302. bufused = snprintf(buf, sizeof(buf), "logoutput goes to: ");
  303. if (config->log.type & LOGTYPE_SYSLOG)
  304. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "syslog, ");
  305. if (config->log.type & LOGTYPE_FILE)
  306. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "files (%d)",
  307. config->log.fpc);
  308. slog(LOG_INFO, buf);
  310. slog(LOG_INFO, "debug level: %d",
  311. config->option.debug);
  313. bufused = snprintf(buf, sizeof(buf), "resolveprotocol: ");
  314. switch (config->resolveprotocol) {
  315. case RESOLVEPROTOCOL_TCP:
  316. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused,
  317. PROTOCOL_TCPs);
  318. break;
  320. case RESOLVEPROTOCOL_UDP:
  321. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused,
  322. PROTOCOL_UDPs);
  323. break;
  325. case RESOLVEPROTOCOL_FAKE:
  326. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused,
  327. "fake");
  328. break;
  330. default:
  331. SERRX(config->resolveprotocol);
  332. }
  333. slog(LOG_INFO, buf);
  335. slog(LOG_INFO, "address/host mismatch tolerated: %s",
  336. config->srchost.nomismatch ? "no" : "yes");
  337. slog(LOG_INFO, "unresolvable addresses tolerated: %s",
  338. config->srchost.nounknown ? "no" : "yes");
  340. slog(LOG_INFO, "negotiate timeout: %lds",
  341. (long)config->timeout.negotiate);
  342. slog(LOG_INFO, "I/O timeout: %lds",
  343. (long)config->timeout.io);
  345. slog(LOG_INFO, "euid: %d", config->state.euid);
  347. slog(LOG_INFO, "userid.privileged: %lu",
  348. (unsigned long)config->uid.privileged);
  349. slog(LOG_INFO, "userid.unprivileged: %lu",
  350. (unsigned long)config->uid.unprivileged);
  351. slog(LOG_INFO, "userid.libwrap: %lu",
  352. (unsigned long)config->uid.libwrap);
  354. bufused = snprintf(buf, sizeof(buf), "method(s): ");
  355. for (i = 0; i < config->methodc; ++i)
  356. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s%s",
  357. i > 0 ? ", " : "", method2string(config->methodv[i]));
  358. slog(LOG_INFO, buf);
  360. if (config->option.debug) {
  361. struct rule_t *rule;
  362. int count;
  364. for (count = 0, rule = config->crule; rule != NULL; rule = rule->next)
  365. ++count;
  366. slog(LOG_INFO, "client-rules (%d): ", count);
  367. for (rule = config->crule; rule != NULL; rule = rule->next)
  368. showclient(rule);
  370. for (count = 0, rule = config->srule; rule != NULL; rule = rule->next)
  371. ++count;
  372. slog(LOG_INFO, "socks-rules (%d): ", count);
  373. for (rule = config->srule; rule != NULL; rule = rule->next)
  374. showrule(rule);
  375. }
  376. }
  379. void
  380. resetconfig(void)
  381. {
  382. struct rule_t *rule;
  384. /*
  385.  * internal; don't touch, only settable at start.
  386.  */
  388. /* external addresses can be changed. */
  389. free(config.externalv);
  390. config.externalv = NULL;
  391. config.externalc = 0;
  393. /* delete all old rules */
  394. rule = config.srule;
  395. while (rule != NULL) {
  396. struct rule_t *next = rule->next;
  397. struct linkedname_t *user, *nextuser;
  399. user = rule->user;
  400. while (user != NULL) {
  401. nextuser = user->next;
  402. free(user);
  403. user = nextuser;
  404. }
  406. free(rule);
  407. rule = next;
  408. }
  409. config.srule = NULL;
  411. /* clientrules too. */
  412. rule = config.crule;
  413. while (rule != NULL) {
  414. struct rule_t *next = rule->next;
  415. struct linkedname_t *user, *nextuser;
  417. user = rule->user;
  418. while (user != NULL) {
  419. nextuser = user->next;
  420. free(user);
  421. user = nextuser;
  422. }
  424. free(rule);
  425. rule = next;
  426. }
  427. config.crule = NULL;
  429. /* route; currently not supported in server. */
  431. /* compat, read from configfile. */
  432. bzero(&config.compat, sizeof(config.compat));
  434. /* extensions, read from configfile. */
  435. bzero(&config.extension, sizeof(config.extension));
  437. /* log; only settable at start. */
  439. /* option; only settable at commandline. */
  441. /* resolveprotocol, read from configfile. */
  442. bzero(&config.resolveprotocol, sizeof(config.resolveprotocol));
  444. /* srchost, read from configfile. */
  445. bzero(&config.srchost, sizeof(config.srchost));
  447. /* stat: keep it. */
  449. /* state; keep it. */
  451. /* methods, read from configfile. */
  452. bzero(config.methodv, sizeof(config.methodv));
  453. config.methodc = 0;
  455. /* timeout, read from configfile. */
  456. bzero(&config.timeout, sizeof(config.timeout));
  458. /* uid, read from configfile. */
  459. bzero(&config.uid, sizeof(config.uid));
  461. /*
  462.  * initialize misc options to sensible default.
  463.  */
  465. config.resolveprotocol = RESOLVEPROTOCOL_UDP;
  466. config.option.keepalive = 1;
  467. config.timeout.negotiate = SOCKD_NEGOTIATETIMEOUT;
  468. config.timeout.io = SOCKD_IOTIMEOUT;
  469. }
  471. void
  472. iolog(rule, state, operation, src, dst, data, count)
  473. struct rule_t *rule;
  474. const struct connectionstate_t *state;
  475. int operation;
  476. const struct sockshost_t *src, *dst;
  477. const char *data;
  478. size_t count;
  479. {
  480. char srcstring[MAXSOCKSHOSTSTRING + MAXNAMELEN + sizeof("@") - 1];
  481. char dststring[MAXSOCKSHOSTSTRING];
  482. const char *name;
  483. int p;
  485. name = NULL;
  486. switch (state->auth.method) {
  487. case AUTHMETHOD_NONE:
  488. case AUTHMETHOD_NOACCEPT: /* closing connection. */
  489. /*
  490.  * doesn't take any space so it's possible it has a name, even
  491.  * if method doesn't indicate it.
  492.  */
  493. name = state->auth.mdata.rfc931.name;
  494. break;
  496. case AUTHMETHOD_UNAME:
  497. name = state->auth.mdata.uname.name;
  498. break;
  500. case AUTHMETHOD_RFC931:
  501. name = state->auth.mdata.rfc931.name;
  502. break;
  504. default:
  505. SERRX(state->auth.method);
  506. }
  508. if (name != NULL && *name != NUL)
  509. p = snprintf(srcstring, sizeof(srcstring), "%s@", name);
  510. else
  511. p = 0;
  513. sockshost2string(src, &srcstring[p], sizeof(srcstring) - p);
  514. sockshost2string(dst, dststring, sizeof(dststring));
  516. /* XXX should probably include authinfo somewhere here too. */
  517. switch (operation) {
  518. case OPERATION_ACCEPT:
  519. case OPERATION_DISCONNECT:
  520. case OPERATION_CONNECT:
  521. if (rule->log.connect || rule->log.disconnect)
  522. slog(LOG_INFO, "%s(%d): %s: %s -> %s",
  523. rule->verdict == VERDICT_PASS ? VERDICT_PASSs : VERDICT_BLOCKs,
  524. rule->number, command2string(state->command),
  525. srcstring, dststring);
  526. break;
  528. case OPERATION_ABORT:
  529. if (rule->log.disconnect || rule->log.error)
  530. slog(LOG_INFO, "%s(%d): %s abort: %s -> %s: %s",
  531. rule->verdict == VERDICT_PASS ? VERDICT_PASSs : VERDICT_BLOCKs,
  532. rule->number, command2string(state->command), srcstring, dststring,
  533. data == NULL ? strerror(errno) : data);
  534. break;
  536. case OPERATION_ERROR:
  537. if (rule->log.error)
  538. slog(LOG_INFO, "%s(%d): %s error: %s -> %s: %s",
  539. rule->verdict == VERDICT_PASS ? VERDICT_PASSs : VERDICT_BLOCKs,
  540. rule->number, protocol2string(state->protocol), srcstring,
  541. dststring, data == NULL ? strerror(errno) : data);
  542. break;
  544. case OPERATION_IO:
  545. if (rule->log.data) {
  546. char *visdata;
  548. SASSERTX(data != NULL);
  550. slog(LOG_INFO, "%s(%d): %s: %s -> %s (%lu): %s",
  551. rule->verdict == VERDICT_BLOCK ? VERDICT_BLOCKs : VERDICT_PASSs,
  552. rule->number, protocol2string(state->protocol),
  553. srcstring, dststring, (unsigned long)count,
  554. strcheck(visdata = str2vis(data, count)));
  556. free(visdata);
  557. }
  558. else if (rule->log.iooperation)
  559. slog(LOG_INFO, "%s(%d): %s: %s -> %s (%lu)",
  560. rule->verdict == VERDICT_BLOCK ? VERDICT_BLOCKs : VERDICT_PASSs,
  561. rule->number, protocol2string(state->protocol),
  562. srcstring, dststring, (unsigned long)count);
  563. break;
  565. default:
  566. SERRX(operation);
  567. }
  568. }
  570. int
  571. rulespermit(s, match, state, src, dst)
  572. int s;
  573. struct rule_t *match;
  574. struct connectionstate_t *state;
  575. const struct sockshost_t *src;
  576. const struct sockshost_t *dst;
  577. {
  578. const char *function = "rulespermit()";
  579. static int init;
  580. static struct rule_t defrule;
  581. struct rule_t *rule;
  582. struct connectionstate_t ostate;
  583. #if HAVE_LIBWRAP
  584. struct request_info libwraprequest;
  586. libwrapinit(s, &libwraprequest);
  587. #else /* !HAVE_LIBWRAP */
  588. void *libwraprequest = NULL;
  589. #endif
  591. /* make a somewhat sensible default rule for entries with no match. */
  592. if (!init) {
  593. defrule.verdict = VERDICT_BLOCK;
  594. defrule.number = 0;
  596. defrule.src.atype = SOCKS_ADDR_IPV4;
  597. defrule.src.addr.ipv4.ip.s_addr = htonl(INADDR_ANY);
  598. defrule.src.addr.ipv4.mask.s_addr = htonl(0);
  599. defrule.src.port.tcp = htons(0);
  600. defrule.src.port.udp = htons(0);
  601. defrule.src.portend = htons(0);
  602. defrule.src.operator = none;
  604. defrule.dst = defrule.src;
  606. if (config.option.debug) {
  607. defrule.log.connect = 1;
  608. defrule.log.disconnect = 1;
  609. defrule.log.error = 1;
  610. defrule.log.iooperation = 1;
  611. }
  612. else {
  613. memset(&defrule.log, 0, sizeof(defrule.log));
  614. defrule.log.connect = 1;
  615. }
  617. memset(&defrule.state.command, UCHAR_MAX, sizeof(defrule.state.command));
  619. defrule.state.methodc = 0;
  621. memset(&defrule.state.protocol, UCHAR_MAX,
  622. sizeof(defrule.state.protocol));
  624. memset(&defrule.state.proxyprotocol, UCHAR_MAX,
  625. sizeof(defrule.state.proxyprotocol));
  627. #if HAVE_LIBWRAP
  628. *defrule.libwrap = NUL;
  629. #endif  /* HAVE_LIBWRAP */
  631. init = 1;
  632. }
  634. /* what rulebase to use.  XXX nicer way to do this. */
  635. switch (state->command) {
  636. case SOCKS_ACCEPT:
  637. /* only set by negotiate children so must be clientrule. */
  638. rule = config.crule;
  639. break;
  641. default:
  642. /* everyone else, socksrules. */
  643. rule = config.srule;
  644. break;
  645. }
  647. /* let "state" be unchanged from original unless we actually get a match. */
  648. for (ostate = *state; rule != NULL; rule = rule->next, *state = ostate) {
  649. char *name, *password;
  651. /* current rule covers desired command? */
  652. switch (state->command) {
  653. case SOCKS_BIND:
  654. if (!rule->state.command.bind)
  655. continue;
  656. break;
  658. case SOCKS_CONNECT:
  659. if (!rule->state.command.connect)
  660. continue;
  661. break;
  663. case SOCKS_UDPASSOCIATE:
  664. if (!rule->state.command.udpassociate)
  665. continue;
  666. break;
  668. /* pseudo commands. */
  670. case SOCKS_BINDREPLY:
  671. if (!rule->state.command.bindreply)
  672. continue;
  673. break;
  675. case SOCKS_UDPREPLY:
  676. if (!rule->state.command.udpreply)
  677. continue;
  678. break;
  680. /* client-rule commands. */
  681. case SOCKS_ACCEPT:
  682. break;
  684. default:
  685. SERRX(state->command);
  686. }
  688. /* current rule covers desired protocol? */
  689. switch (state->protocol) {
  690. case SOCKS_TCP:
  691. if (!rule->state.protocol.tcp)
  692. continue;
  693. break;
  695. case SOCKS_UDP:
  696. if (!rule->state.protocol.udp)
  697. continue;
  698. break;
  700. default:
  701. SERRX(state->protocol);
  702. }
  704. /* current rule covers desired version? */
  705. switch (state->version) {
  706. case SOCKS_V4:
  707. if (!rule->state.proxyprotocol.socks_v4)
  708. continue;
  709. break;
  711. case SOCKS_V5:
  712. if (!rule->state.proxyprotocol.socks_v5)
  713. continue;
  714. break;
  716. default:
  717. SERRX(state->version);
  718. }
  720. /* current rule allows for selected authentication? */
  721. if (!methodisset(state->auth.method, rule->state.methodv,
  722. (size_t)rule->state.methodc))
  723. /*
  724.  * There are some "extra" methods that are independent of
  725.  * socks protocol negotiation and it's thus possible
  726.  * to get a match on them even if above check failed.
  727.  * Currently it's only rfc931.
  728.  */
  730. #if HAVE_LIBWRAP
  731. if (methodisset(AUTHMETHOD_RFC931, rule->state.methodv,
  732. (size_t)rule->state.methodc)) {
  733. strncpy(state->auth.mdata.rfc931.name, eval_user(&libwraprequest),
  734. sizeof(state->auth.mdata.rfc931.name) - 1);
  736. if (state->auth.mdata.rfc931.name[
  737. sizeof(state->auth.mdata.rfc931.name) - 1] != NUL) {
  738. slog(LOG_INFO, "%s: rfc931 name truncated", function);
  739. state->auth.mdata.rfc931.name[
  740. sizeof(state->auth.mdata.rfc931.name) - 1] = NUL;
  741. }
  743. state->auth.method = AUTHMETHOD_RFC931;
  744. }
  745. else
  746. #endif /* HAVE_LIBWRAP */
  747. continue;
  749. SASSERTX(methodisset(state->auth.method, rule->state.methodv,
  750. (size_t)rule->state.methodc));
  752. switch (state->auth.method) {
  753. case AUTHMETHOD_UNAME:
  754. name = state->auth.mdata.uname.name;
  755. password = state->auth.mdata.uname.password;
  756. break;
  758. case AUTHMETHOD_RFC931:
  759. name = state->auth.mdata.rfc931.name;
  760. password = NULL;
  761. break;
  763. default:
  764. name = password = NULL;
  765. }
  767. if (name != NULL && rule->user != NULL) {
  768. const char *methodname;
  769. char srcstring[MAXSOCKSHOSTSTRING];
  770. struct linkedname_t *ruleuser;
  772. /*
  773.  * The rule->user names restricts access further, only names
  774.  * appearing there and in the passwordfile are matched.
  775.  * An alias for "everyone" is a name that is the same as the
  776.  * name of the selected method.
  777.  */
  779. methodname = method2string(state->auth.method);
  780. ruleuser = rule->user;
  781. do {
  782. if (strcmp(methodname, ruleuser->name) == 0)
  783. break; /* all usernames "match" here. */
  784. else if (string2method(name) >= 0)
  785. slog(LOG_INFO, "%s: suspicious username from %s: %s",
  786. function, sockshost2string(src, srcstring, sizeof(srcstring)),
  787. name);
  788. else if (strcmp(name, ruleuser->name) == 0)
  789. break;
  790. } while ((ruleuser = ruleuser->next) != NULL);
  792. if (ruleuser == NULL)
  793. continue; /* no match. */
  795. if (!state->auth.matched) { /* may have been checked at lower level. */
  796. /* all users must also be in passwordfile. */
  797. if (passwordcheck(name, password) != 0)
  798. continue;
  799. state->auth.matched = 1;
  800. }
  801. }
  803. /*
  804.  * This is a little tricky, but for some commands we may not
  805.  * have all info at time of (preliminary) rulechecks.
  806.  * What we want to do if there is no (complete) address given is
  807.  * to see if there's any chance at all the rules will permit this
  808.  * request when the address (later) becomes available.
  809.  * We therefore continue to scan the rules until we either get
  810.  * a pass (ignoring peer with missing info), or the default block
  811.  * is triggered.
  812.  */
  814. if (src != NULL) {
  815. if (!addressmatch(&rule->src, src, state->protocol, 0))
  816. continue;
  817. }
  818. else
  819. if (rule->verdict == VERDICT_BLOCK)
  820. continue; /* continue scan. */
  822. if (dst != NULL) {
  823. if (!addressmatch(&rule->dst, dst, state->protocol, 0))
  824. continue;
  825. }
  826. else
  827. if (rule->verdict == VERDICT_BLOCK)
  828. continue; /* continue scan. */
  830. break;
  831. }
  833. if (rule == NULL) /* no rules matched; match default rule. */
  834. rule = &defrule;
  835. *match = *rule;
  837. /*
  838.  * got our rule, now check connection.  Connectioncheck
  839.  * requires the rule matched so needs to be delayed til here.
  840.  */
  842. if (!connectisok(&libwraprequest, match, state))
  843. match->verdict = VERDICT_BLOCK;
  845. /*
  846.  * specialcases that we delay til here to get correct addr/rule match,
  847.  * even if we could have decided on the final answer before.
  848.  */
  849. switch (state->command) {
  850. case SOCKS_BIND:
  851. if (dst->atype == SOCKS_ADDR_IPV4 && dst->addr.ipv4.s_addr == htonl(0))
  852. if (!config.extension.bind) {
  853. slog(LOG_DEBUG, "%s: client requested disabled extension: bind",
  854. function);
  855. match->verdict = VERDICT_BLOCK;
  856. }
  857. break;
  858. }
  860. return match->verdict == VERDICT_PASS;
  861. }
  863. static struct rule_t *
  864. addrule(newrule, rulebase)
  865. const struct rule_t *newrule;
  866. struct rule_t **rulebase;
  867. {
  868. static const struct serverstate_t state;
  869. const char *function = "addrule()";
  870. struct rule_t *rule;
  872. if ((rule = malloc(sizeof(*rule))) == NULL)
  873. serrx(1, "%s: %s", function, NOMEM);
  874. *rule = *newrule;
  876. /* try to set values not set to a sensible default. */
  878. if (config.option.debug) {
  879. rule->log.connect = 1;
  880. rule->log.disconnect = 1;
  881. rule->log.error = 1;
  882. rule->log.iooperation = 1;
  883. }
  884. /* else; don't touch logging, no logging is ok. */
  886. /* if no command set, set all. */
  887. if (memcmp(&state.command, &rule->state.command, sizeof(state.command)) == 0)
  888. memset(&rule->state.command, UCHAR_MAX, sizeof(rule->state.command));
  890. /*
  891.  * If no method set, set all we support.  This in practice
  892.  * limits the methods we accept here to the globally set methods
  893.  * (config.methodv), since they are checked before we get to
  894.  * rulespesific checks.  We can't just copy config.methodv
  895.  * since it may not be set yet.
  896.  */
  897. if (rule->state.methodc == 0) {
  898. int *methodv = rule->state.methodv;
  899. int *methodc = &rule->state.methodc;
  901. if (rule->user == NULL)
  902. methodv[(*methodc)++] = AUTHMETHOD_NONE;
  904. methodv[(*methodc)++] = AUTHMETHOD_UNAME;
  905. #if HAVE_LIBWRAP
  906. methodv[(*methodc)++] = AUTHMETHOD_RFC931;
  907. #endif
  908. }
  910. /* if no protocol set, set all. */
  911. if (memcmp(&state.protocol, &rule->state.protocol, sizeof(state.protocol))
  912. == 0)
  913. memset(&rule->state.protocol, UCHAR_MAX, sizeof(rule->state.protocol));
  915. /* if no proxyprotocol set, set all except msproxy. */
  916. if (memcmp(&state.proxyprotocol, &rule->state.proxyprotocol,
  917. sizeof(state.proxyprotocol)) == 0) {
  918. memset(&rule->state.proxyprotocol, UCHAR_MAX,
  919. sizeof(rule->state.proxyprotocol));
  921. rule->state.proxyprotocol.msproxy_v2 = 0;
  922. }
  924. if (*rulebase == NULL) {
  925. *rulebase = rule;
  926. (*rulebase)->number = 1;
  927. }
  928. else {
  929. struct rule_t *lastrule;
  931. /* append this rule to the end of our list. */
  933. lastrule = *rulebase;
  934. while (lastrule->next != NULL)
  935. lastrule = lastrule->next;
  937. rule->number = lastrule->number + 1;
  938. lastrule->next = rule;
  939. }
  941. rule->next = NULL;
  943. return rule;
  944. }
  946. static void
  947. checkrule(rule)
  948. const struct rule_t *rule;
  949. {
  951. if (rule->user != NULL)
  952. if (rule->state.methodc == 0)
  953. yyerror("rule restricts by name, but no username-based method given");
  954. }
  956. static void
  957. showuser(user)
  958. const struct linkedname_t *user;
  959. {
  960. char buf[10240];
  961. size_t bufused;
  963. bufused = snprintf(buf, sizeof(buf), "user: ");
  964. for (; user != NULL; user = user->next)
  965. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  966. user->name);
  968. if (bufused > sizeof("user: "))
  969. slog(LOG_INFO, buf);
  970. }
  972. static void
  973. showlog(log)
  974. const struct log_t *log;
  975. {
  976. char buf[1024];
  977. size_t bufused;
  979. bufused = snprintf(buf, sizeof(buf), "log: ");
  981. if (log->connect)
  982. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  983. LOG_CONNECTs);
  985. if (log->disconnect)
  986. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  987. LOG_DISCONNECTs);
  989. if (log->data)
  990. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  991. LOG_DATAs);
  993. if (log->error)
  994. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  995. LOG_ERRORs);
  997. if (log->iooperation)
  998. bufused += snprintf(&buf[bufused], sizeof(buf) - bufused, "%s, ",
  999. LOG_IOOPERATIONs);
  1001. slog(LOG_INFO, buf);
  1002. }
  1005. #if HAVE_LIBWRAP
  1006. static void
  1007. libwrapinit(s, request)
  1008. int s;
  1009. struct request_info *request;
  1010. {
  1012. request_init(request, RQ_FILE, s, RQ_DAEMON, __progname, 0);
  1013. fromhost(request);
  1014. }
  1015. #endif /* HAVE_LIBWRAP */
  1017. static int
  1018. connectisok(request, rule, state)
  1019. #if HAVE_LIBWRAP
  1020. struct request_info *request;
  1021. #else
  1022. void *request;
  1023. #endif
  1024. const struct rule_t *rule;
  1025. struct connectionstate_t *state;
  1026. {
  1028. #if HAVE_LIBWRAP
  1030. /* do we need to involve libwrap for this rule? */
  1031. if (*rule->libwrap != NUL
  1032. ||  config.srchost.nomismatch
  1033. ||  config.srchost.nounknown) {
  1034. const char *function = "connectisok()";
  1035. char libwrap[LIBWRAPBUF];
  1036. uid_t euid;
  1037. int checkforname;
  1039. socks_seteuid(&euid, config.uid.libwrap);
  1041. /* libwrap modifies the passed buffer. */
  1042. SASSERTX(strlen(rule->libwrap) < sizeof(libwrap));
  1043. strcpy(libwrap, rule->libwrap);
  1045. /* Wietse Venema says something along the lines of: */
  1046. if (setjmp(tcpd_buf) != 0) {
  1047. socks_reseteuid(config.uid.libwrap, euid);
  1048. swarnx("%s: failed libwrap line: %s", function, libwrap);
  1049. return 0; /* something got screwed up. */
  1050. }
  1051. process_options(libwrap, request);
  1053. /*
  1054.  * check if we got a username and won't clobber anything by saving it.
  1055.  */
  1056. switch (state->auth.method) {
  1057. case AUTHMETHOD_NONE: /* doesn't take any memory from rfc931. */
  1058. checkforname = 1;
  1059. break;
  1061. default:
  1062. checkforname = 0; /* can't take it or should already have it. */
  1063. }
  1065. if (checkforname) {
  1066. /* XXX can't use eval_user() since it always does rfc931 lookup. */
  1067. if (*request->user != NUL) {
  1068. strncpy(state->auth.mdata.rfc931.name, request->user,
  1069. sizeof(state->auth.mdata.rfc931.name) - 1);
  1071. if (state->auth.mdata.rfc931.name
  1072. [sizeof(state->auth.mdata.rfc931.name) - 1] != NUL) {
  1073. slog(LOG_DEBUG, "%s: rfc931 name too long, truncated", function);
  1074. state->auth.mdata.rfc931.name
  1075. [sizeof(state->auth.mdata.rfc931.name)
  1076. - 1] = NUL;
  1077. }
  1078. }
  1079. }
  1081. if (config.srchost.nounknown)
  1082. if (strcmp(eval_hostname(request->client), STRING_UNKNOWN) == 0) {
  1083. slog(LOG_INFO, "%s: srchost unknown",
  1084. eval_hostaddr(request->client));
  1085. socks_reseteuid(config.uid.libwrap, euid);
  1086. return 0;
  1087. }
  1089. if (config.srchost.nomismatch)
  1090. if (strcmp(eval_hostname(request->client), STRING_PARANOID) == 0) {
  1091. slog(LOG_INFO, "%s: srchost ip/host mismatch",
  1092. eval_hostaddr(request->client));
  1093. socks_reseteuid(config.uid.libwrap, euid);
  1094. return 0;
  1095. }
  1097. socks_reseteuid(config.uid.libwrap, euid);
  1098. }
  1100. #else /* !HAVE_LIBWRAP */
  1102. #endif  /* !HAVE_LIBWRAP */
  1104. return 1;
  1105. }