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

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

代理服务器

开发平台：

Unix_Linux

validate.c：源码内容
  1. /* Copyright (c) 1995,1996,1997 NEC Corporation.  All rights reserved.       */
  2. /*                                                                           */
  3. /* The redistribution, use and modification in source or binary forms of     */
  4. /* this software is subject to the conditions set forth in the copyright     */
  5. /* document ("Copyright") included with this distribution.                   */
  7. /*
  8.  * $Id: validate.c,v 1.74.2.1.2.6 1998/09/22 20:34:39 wlu Exp $
  9.  */
  11. /* This file contains all of the stuff associated with parsing the config    */
  12. /* file, except for some utility routines which appear in valutil.c.  The    */
  13. /* routines for checking the parsed config file appear in check.c.           */
  14. #include "socks5p.h"
  15. #include "threads.h"
  16. #include "daemon.h"
  17. #include "confutil.h"
  18. #include "validate.h"
  19. #include "protocol.h"
  20. #include "msgids.h"
  21. #include "info.h"
  22. #include "log.h"
  24. #define INVALID_TYPE (char)-1   /* some kind of config error...               */
  26. IFTHREADED(static MUTEX_T confid_mutex = MUTEX_INITIALIZER;)
  27. static struct intfc *intfcs = NULL;
  28. static int ifcnt = 0;
  30. struct sroute {
  31.     char type;
  32.     int calloced;
  33.     struct in_addr ifaddr;
  34.     struct intfc *ifp;
  35. };
  37. struct authtuple {
  38.     int realline;
  39.     struct host source;
  40.     struct port sport;
  41.     list *authlist;
  42.     u_char banned;
  43. };
  44. typedef struct authtuple AuthTuple;
  45. static AuthTuple *authList = NULL; /* An array of auth list entries          */
  46. static int nalines = 0, na = 0;    /* how many auth lines, and current index */
  48. /* A configuration tuple, used in the access control portion of the config   */
  49. /* file...It tells us the permission as well as matching information...      */
  50. struct conftuple {
  51.     int realline;
  52.     char permit;
  53.     list *command;
  54.     list *userlist;
  55.     list *authlist;
  57.     struct host source, dest;
  58.     struct port sport, dport;
  59. };
  60. typedef struct conftuple ConfTuple;
  61. static ConfTuple *accessList  = NULL; /* An array of access list entries     */
  62. static int nplines = 0, np = 0;       /* how many access lines, & index      */
  64. /* A routing tuple...used in the routing portion of the config file to tell  */
  65. /* the server how it should be connecting (and being connected) to hosts...  */
  66. struct routetuple {
  67.     int realline;
  68.     struct host source;
  69.     struct port sport;
  70.     struct sroute nexthop;
  71. };
  72. typedef struct routetuple RouteTuple;
  73. static RouteTuple *routeList = NULL; /* An array of route list entries       */
  74. static int nrlines = 0, nr = 0;      /* how many route lines, & index        */
  76. /* A proxy tuple...used in the proxy portion of the config file to tell the  */
  77. /* server how it should get to a destination (what the next step is...)      */
  78. struct proxytuple {
  79.     int realline;
  80.     struct host source;
  81.     struct port sport;
  82.     
  83.     u_char  nextver;
  84.     S5NetAddr nextaddr[S5_SERVER_NUM];
  85.     int nnextaddr;
  86. };
  87. typedef struct proxytuple ProxyTuple;
  88. static ProxyTuple *proxyList = NULL; /* An array of socks list entries       */
  89. static int nslines = 0, ns = 0;      /* how many proxy lines & index         */
  91. /* A filter tuple, used in the filter portion of the config file...It tells  */
  92. /* us the what filter to use for a given connection...                       */
  93. struct filtertuple {
  94.     int realline;
  95.     char name[S5_NAME_SIZE];
  97.     list *command;
  98.     list *userlist;
  99.     list *authlist;
  101.     struct host source, dest;
  102.     struct port sport, dport;
  103. };
  104. typedef struct filtertuple FilterTuple;
  105. static FilterTuple *filterList = NULL; /* An array of socks list entries     */
  106. static int nflines = 0, nf = 0;        /* how many filter lines & index      */
  108. static char **varList = NULL;    /* A list of variables allocated            */
  109. static int nvlines = 0, nv = 0;  /* how many variable lines and cur index    */
  111. extern void AuthsHandler  P((void **, int, int, char *)); /* Auth line       */
  112. extern void PermsHandler  P((void **, int, int, char *)); /* permission line */
  113. extern void HowtoHandler  P((void **, int, int, char *)); /* proxy line...   */
  114. extern void RouteHandler  P((void **, int, int, char *)); /* route line...   */
  115. extern void EvarsHandler  P((void **, int, int, char *)); /* evar line..     */
  116. extern void FilterHandler P((void **, int, int, char *)); /* filter line...  */
  118. confid confids[] = {
  119.     { "permit",  "p",   PermsHandler, (void **)&accessList, &nplines, &np, sizeof(ConfTuple)    },
  120. #define PERMIT_IND  0 /* An indentifier that this line is "permit"            */
  121.     { "deny",    "d",   PermsHandler, (void **)&accessList, &nplines, &np, 0                    },
  122. #define DENY_IND    1 /* An indentifier that this line is "deny"              */
  123.     { "route",   "r",   RouteHandler, (void **)&routeList,  &nrlines, &nr, sizeof(RouteTuple)   },
  124. #define ROUTE_IND   2 /* An indentifier that this line is "route"             */
  125.     { "interface",   "i",   RouteHandler, (void **)&routeList,  &nrlines, &nr, 0 },
  126. #define INTFC_IND   3 /* An indentifier that this line is "interface"         */
  127.     { "socks4",  "4",   HowtoHandler, (void **)&proxyList,  &nslines, &ns, 0                    },
  128. #define SOCKS4_IND  4 /* An indentifier that this line is "socks"             */
  129.     { "socks5",  "5",   HowtoHandler, (void **)&proxyList,  &nslines, &ns, sizeof(ProxyTuple)   },
  130. #define SOCKS5_IND  5 /* An indentifier that this line is "socks5"            */
  131.     { "noproxy", "n",   HowtoHandler, (void **)&proxyList,  &nslines, &ns, 0                    },
  132. #define DIRECT_IND  6 /* An indentifier that this line is "direct"            */
  133.     { "auth",    "a",   AuthsHandler, (void **)&authList,   &nalines, &na, sizeof(AuthTuple)    },
  134. #define AUTH_IND    7 /* An indentifier that this line is "auth"              */
  135.     { "ban",     "b",   AuthsHandler, (void **)&authList,   &nalines, &na, 0                    },
  136. #define BAN_IND     8 /* An indentifier that this line is "ban"               */
  137.     { "set",     "s",   EvarsHandler, (void **)&varList,     &nvlines, &nv, sizeof(char *)      },
  138. #define SET_IND     9 /* An indentifier that this line is "set"               */
  139.     { "filter",  "f",   FilterHandler,(void **)&filterList,  &nflines, &nf, sizeof(FilterTuple) },
  140. #define FILTER_IND  10 /* An indentifier that this line is "filter"            */
  141. };
  142. #define NCONFIDS (sizeof(confids)/sizeof(struct confid))
  144. /* Look at the buffer that ptr points to, and read either a net address of a */
  145. /* valid interface or the name (e.g. ef0, ef1, le0) of a valid int address.  */
  146. /*                                                                           */
  147. /* Arguments: ptr  -- a ptr to the buffer we are working with...(in/out)     */
  148. /*            val  -- a ptr to the address we are looking up...(out)         */
  149. static int lsGetHostOrIntfc(char **ptr, struct sroute *val) {
  150.     struct in_addr guess;
  151.     char *tmp, tc;
  152.     int i, j;
  154.     /* XXX ipv6 support here may get messy...                                */
  155.     memset((char *)val, 0, sizeof(struct sroute));
  156.     val->type = INVALID_TYPE;
  158.     SKIPSPACE(*ptr);
  159.     tmp = *ptr;
  161.     SKIPNONSPACE(tmp);
  162.     tc = *tmp; *tmp = '';
  164.     if ((guess.s_addr = inet_addr(*ptr)) == INVALIDADDR) {
  165. val->type = NAME;
  166. val->ifp = NULL;
  168. for (i = 0; i < ifcnt; i++) {
  169.     if (strcmp(*ptr, intfcs[i].name)) continue;
  171.     val->ifp  = &intfcs[i];
  172.     break;
  173. }
  175. if (val->ifp == NULL && (val->ifp = (struct intfc *)calloc(1, sizeof(struct intfc)))) {
  176.     strncpy(val->ifp->name, *ptr, 16);
  177.     val->ifp->name[15] = '';
  178.     val->calloced = 1;
  179. }
  180.     } else {
  181. val->type = IN_ADDR;
  182. val->ifaddr.s_addr = guess.s_addr;
  183. val->ifp = NULL;
  185. for (i = 0; i < ifcnt; i++) {
  186.     for (j = 0; j < intfcs[i].addrcnt; j++) {
  187.         if (intfcs[i].addrlist[j].ip.s_addr == guess.s_addr) break;
  188.     }
  190.     if (j < intfcs[i].addrcnt) {
  191. val->ifp = &intfcs[i];
  192.      break;
  193.     }
  194. }
  195.     }
  197.     *(*ptr = tmp) = tc;
  198.     return (val->type == INVALID_TYPE)?-1:0;
  199. }
  201. /* myunsetenv goes through and finds a variable=value pair which is the same */
  202. /* as (char *)n.  Once it finds it, it switches it with the last variable in */
  203. /* the environment, and returns...                                           */
  204. /*                                                                           */
  205. /* Arguments: n -- the name=value pair we are looking for (just name)        */
  206. /*                                                                           */
  207. /* Globals affected: environ -- no longer contians n.                        */
  208. static void myunsetenv(void *n) {
  209. #ifdef HAVE_UNSETENV
  210.     unsetenv((char *)n);
  211.     free(n);
  212. #else
  213.     char *name = (char *)n, **tmp, **end;
  214.     extern char **environ;
  216.     for (tmp = environ; *tmp; tmp++) 
  217. if (!strncmp(name, *tmp, strlen(name))) break; /* find a match...    */
  219.     if (!*tmp) return;                /* no match, so give up...             */
  220.     for (end = tmp; *(end+1); end++); /* find last set variable...           */
  222.     *tmp = *end;                      /* switch with the last set var...     */
  223.     *end = NULL;                      /* zero out the last set var...        */
  224.     free(name);
  225. #endif
  226. }
  228. #ifndef HAVE_SETENV
  229. static int myputenv(char *name) {
  230. #ifdef HAVE_PUTENV
  231.     return putenv(name);
  232. #else
  233.     char **tmp, *end = strchr(name, '='), c;
  234.     extern char **environ;
  235.     static int done;
  236.     int nenv;
  237.     
  238.     if (end == NULL) return 0;
  240.     /* Find a match or count the number of variables in the environment...   */
  241.     for (nenv = 0, tmp = environ; *tmp; tmp++, nenv++) {
  242. if (strncmp(name, *tmp, end-name)) continue;
  243. if ((*tmp)[end - name] != '=') continue;
  244. *tmp = name;
  245. return 1;
  246.     }
  248.     if (!done) {
  249. if ((tmp = (char **)malloc((nenv + 2) * sizeof(char *))) == NULL) {
  250.     return 0;
  251. }
  253. memcpy(environ, tmp, nenv+1 * sizeof(char *));
  254. done = 1;
  255.     } else {
  256. if ((tmp = (char **)realloc(environ, (nenv + 2) * sizeof(char *))) == NULL) {
  257.     return 0;
  258. }
  259.     }
  261.     tmp[nenv+1] = name;
  262.     tmp[nenv+2] = NULL;
  263.     environ = tmp;
  265.     return 1;
  266. #endif
  267. }
  268. #endif
  270. /* A function that clears up a given EntryList, for reading or rereading     */
  271. /* the configuration file.   It deallocates any memory used in allocating    */
  272. /* the list to begin with, and memset's the array of entries to be 0...      */
  273. /*                                                                           */
  274. /* Arguments: index -- which index in the confids array to clear up...       */
  275. static void ClearEntryList(confid *confids, int nconfids) {
  276.     int i;
  278. #define CLEANUPIND(ind) do { if(*confids[(ind)].array) free(*confids[(ind)].array); *confids[(ind)].array = NULL, *confids[(ind)].number = 0; *confids[(ind)].cnum = 0; } while (0);
  280.     for (i = 0; i < *confids[AUTH_IND].number; i++) {
  281. lsDeleteLinkedList(&((AuthTuple *)*confids[AUTH_IND].array)[i].authlist);
  282.     }
  284.     for (i = 0; i < *confids[ROUTE_IND].number; i++) {
  285.         if (((RouteTuple *)*confids[ROUTE_IND].array)[i].nexthop.calloced)
  286. free(((RouteTuple *)*confids[ROUTE_IND].array)[i].nexthop.ifp);
  287.     }
  289.     for (i = 0; i < *confids[PERMIT_IND].number; i++) {
  290. lsDeleteLinkedList(&((ConfTuple *)*confids[PERMIT_IND].array)[i].command);
  291. lsDeleteLinkedList(&((ConfTuple *)*confids[PERMIT_IND].array)[i].userlist);
  292. lsDeleteLinkedList(&((ConfTuple *)*confids[PERMIT_IND].array)[i].authlist);
  293.     }
  295.     for (i = 0; i < *confids[SET_IND].number; i++) {
  296. if (((char **)*confids[SET_IND].array)[i]) {
  297.     MUTEX_LOCK(env_mutex);
  298.     myunsetenv(((char **)*confids[SET_IND].array)[i]);
  299.     MUTEX_UNLOCK(env_mutex);
  300. }
  301.     }
  303.     CLEANUPIND(AUTH_IND);
  304.     CLEANUPIND(PERMIT_IND);
  305.     CLEANUPIND(SOCKS5_IND);
  306.     CLEANUPIND(ROUTE_IND);
  307.     CLEANUPIND(SET_IND);
  308. }
  310. static void badline(int ln, char *msg) {
  311.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_WARNING, MSGID_SERVER_CONF_BADLINE, "Conf: Bad line (line number %d) in configuration file: %s", ln, msg);
  312. }
  313.     
  314. /* Examine the current line for an entry setting an environment variable...  */
  315. /*                                                                           */
  316. /* Arguments: indx -- index into the array we are dealing with...(in)        */
  317. /*            i    -- index of the array we came from...(in)                 */
  318. /*            tmp  -- postion in the buffer...(in)                           */
  319. void EvarsHandler(void **array, int indx, int i, char *ptr) {
  320.     /* set up the "environment variables", only from file... */  
  321.     char *tmp, *end1, *new, **vlist = (*(char ***)array), buf[1024];
  322.     int len;
  324.     if (indx >= nvlines) {
  325. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(1), 0, "Config: Not enough environment variable lines allocated");
  326. return;
  327.     }
  329.     SKIPNONSPACE(ptr);
  330.     SKIPSPACE(ptr);
  332.     if ((end1 = strstr(ptr, "n"))) len = MIN(sizeof(buf)-1, end1-ptr);
  333.     else len = MIN(sizeof(buf)-1, strlen(ptr));
  335.     memset(buf, 0, sizeof(buf));
  336.     strncpy(buf, ptr, len);
  337.     buf[len] = '';
  339.     for (tmp = buf ; !isspace(*tmp) && *tmp != ''; tmp++)
  340. if (islower(*tmp)) *tmp = toupper(*tmp); 
  342.     end1 = tmp;
  343.     SKIPSPACE(tmp);
  344.     
  345. #ifndef HAVE_SETENV
  346.     /* mush "variable    value" into "variable=value", and find the end     */
  347.     if (end1 != tmp) for (*end1++ = '='; !isspace(*tmp) && *tmp != ''; tmp++, end1++) *end1 = *tmp;
  348.     else *end1++ = '=';
  349.     *end1 = '';
  350. #endif
  352.     new = strdup(buf);
  353.     MUTEX_LOCK(env_mutex);
  355. #ifdef HAVE_SETENV
  356.     new[end1 - buf] = '';
  357.     setenv(new, new + (tmp-buf), 1);
  358. #else
  359.     myputenv(new);        /* replace it in actual environ                    */
  360. #endif
  362.     MUTEX_UNLOCK(env_mutex);
  363.     vlist[indx] = new;    /* put it in varList for future frees...           */
  364. }
  366. /* Examine the current line for an entry setting a filter to use...          */
  367. /*                                                                           */
  368. /* Arguments: indx -- index into the array we are dealing with...(in)        */
  369. /*            i    -- index of the array we came from...(in)                 */
  370. /*            tmp  -- postion in the buffer...(in)                           */
  371. void FilterHandler(void **array, int indx, int i, char *tmp) {
  372.     FilterTuple *entry = &(*(FilterTuple **)array)[indx];
  373.     char *start;
  374.     
  375.     if (indx >= nflines) {
  376. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(1), 0, "Config: Not enough filter entries allocated");
  377. return;
  378.     }
  380.     SKIPNONSPACE(tmp);
  381.     entry->realline = lsLineNo;
  383.     SKIPSPACE(tmp);
  384.     start = tmp;
  385.     SKIPNONSPACE(tmp);
  387.     strncpy(entry->name, start, MIN(tmp-start, S5_NAME_SIZE-1));
  388.     entry->name[MIN(tmp-start, S5_NAME_SIZE-1)] = '';
  390.     if (lsGetAuthMethods   (&tmp, &entry->authlist) < 0) badline(entry->realline, "auth methods");
  391.     if (lsGetPermCommand   (&tmp, &entry->command)  < 0) badline(entry->realline, "command");
  392.     if (lsGetHostAndMask   (&tmp, &entry->source)   < 0) badline(entry->realline, "source host");
  393.     if (lsGetHostAndMask   (&tmp, &entry->dest)     < 0) badline(entry->realline, "destination host");
  394.     if (lsGetPortOrService (&tmp, &entry->sport)    < 0) badline(entry->realline, "source port");
  395.     if (lsGetPortOrService (&tmp, &entry->dport)    < 0) badline(entry->realline, "destination port");
  396.     if (lsGetPermUsers     (&tmp, &entry->userlist) < 0) badline(entry->realline, "userlist");
  397. }
  398. /* Examine the current line for an entry setting a route to use...           */
  399. /*                                                                           */
  400. /* Arguments: indx -- index into the array we are dealing with...(in)        */
  401. /*            i    -- index of the array we came from...(in)                 */
  402. /*            tmp  -- postion in the buffer...(in)                           */
  403. void RouteHandler(void **array, int indx, int i, char *tmp) {
  404.     RouteTuple *entry = &(*(RouteTuple **)array)[indx];
  405.     
  406.     if (indx >= nrlines) {
  407. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(1), 0, "Config: Not enough route entries allocated");
  408. return;
  409.     }
  411.     SKIPNONSPACE(tmp);
  412.     entry->realline = lsLineNo;
  413.     if (lsGetHostAndMask   (&tmp, &entry->source)  < 0) badline(entry->realline, "source host");
  414.     if (lsGetPortOrService (&tmp, &entry->sport)   < 0) badline(entry->realline, "source port");
  415.     if (lsGetHostOrIntfc   (&tmp, &entry->nexthop) < 0) badline(entry->realline, "interface");
  416. }
  418. /* Examine the current line for an entry telling us how to get someplace...  */
  419. /*                                                                           */
  420. /* Arguments: indx -- index into the array we are dealing with...(in)        */
  421. /*            i    -- index of the array we came from...(in)                 */
  422. /*            tmp  -- postion in the buffer...(in)                           */
  423. void HowtoHandler(void **array, int indx, int i, char *tmp) {
  424.     static u_short socksport;
  425.     u_short port;
  426.     
  427.     ProxyTuple *entry = &(*(ProxyTuple **)array)[indx];
  428.     SKIPNONSPACE(tmp);
  429.     
  430.     if (indx >= nslines) {
  431. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(1), 0, "Config: Not enough proxy entries allocated");
  432. return;
  433.     }
  435.     entry->realline = lsLineNo;
  436.     if (lsGetHostAndMask   (&tmp, &entry->source) < 0) badline(entry->realline, "source host");
  437.     if (lsGetPortOrService (&tmp, &entry->sport)  < 0) badline(entry->realline, "source port");
  439.     if (i == DIRECT_IND) {
  440. entry->nextver   = 0;
  441. entry->nnextaddr = 0;
  442. memset((char *)entry->nextaddr, 0, sizeof(S5NetAddr));
  443. return;
  444.     } 
  446.     entry->nextver = (i == SOCKS5_IND)?SOCKS5_VERSION:SOCKS4_VERSION;
  448.     for (i = 0; i < S5_SERVER_NUM && *tmp && *tmp != 'n'; i++, tmp++) {
  449. if (lsGetHostAddressAndPort(&tmp, &entry->nextaddr[i]) < 0) badline(entry->realline, "server address");
  451. if ((port = lsAddr2Port(&entry->nextaddr[i])) == INVALIDPORT || port == (u_short)0) {
  452.     if (!socksport && lsName2Port("socks", "tcp", &socksport) < 0) socksport = htons(SOCKS_DEFAULT_PORT);
  453.     lsAddrSetPort(&entry->nextaddr[i], socksport);
  454. }
  456. SKIPSPACE(tmp);
  458. if (*tmp != ',') {
  459.     i++;
  460.     break;
  461. }
  462.     }
  464.     entry->nnextaddr = i;
  465. }
  467. /* Examine the current line for an entry telling us what is allowed...       */
  468. /*                                                                           */
  469. /* Arguments: indx -- index into the array we are dealing with...(in)        */
  470. /*            i    -- index of the array we came from...(in)                 */
  471. /*            tmp  -- postion in the buffer...(in)                           */
  472. void PermsHandler(void **array, int indx, int i, char *tmp) {
  473.     ConfTuple *entry = &(*(ConfTuple **)array)[indx];
  475.     if (indx >= nplines) {
  476. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(1), 0, "Config: Not enough permission entries allocated");
  477. return;
  478.     }
  480.     SKIPNONSPACE(tmp);
  481.     entry->realline = lsLineNo;
  482.     entry->permit = (i == PERMIT_IND)?AUTH_OK:AUTH_FAIL;
  484.     if (lsGetAuthMethods   (&tmp, &entry->authlist) < 0) badline(entry->realline, "auth methods");
  485.     if (lsGetPermCommand   (&tmp, &entry->command)  < 0) badline(entry->realline, "command");
  486.     if (lsGetHostAndMask   (&tmp, &entry->source)   < 0) badline(entry->realline, "source host");
  487.     if (lsGetHostAndMask   (&tmp, &entry->dest)     < 0) badline(entry->realline, "destination host");
  488.     if (lsGetPortOrService (&tmp, &entry->sport)    < 0) badline(entry->realline, "source port");
  489.     if (lsGetPortOrService (&tmp, &entry->dport)    < 0) badline(entry->realline, "destination port");
  490.     if (lsGetPermUsers     (&tmp, &entry->userlist) < 0) badline(entry->realline, "userlist");
  491. }
  493. void AuthsHandler(void **array, int indx, int i, char *tmp) {
  494.     AuthTuple *entry = &(*(AuthTuple **)array)[indx];
  496.     if (indx >= nalines) {
  497. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(1), 0, "Config: Not enough authentication entries allocated");
  498. return;
  499.     }
  501.     SKIPNONSPACE(tmp);
  502.     entry->realline = lsLineNo;
  504.     if (lsGetHostAndMask   (&tmp, &entry->source)   < 0) badline(entry->realline, "source host");
  505.     if (lsGetPortOrService (&tmp, &entry->sport)    < 0) badline(entry->realline, "source port");
  507.     if (i != BAN_IND) {
  508. if (lsGetAuthMethods   (&tmp, &entry->authlist) < 0) badline(entry->realline, "auth methods");
  509. entry->banned = 0;
  510.     } else {
  511. entry->banned = 1;
  512.     }
  514. }
  516. void ReadConfig(void) {
  517.     char *file;
  518.     static int mi = 0;
  520.     if (mi == 0) {
  521.         mi++;
  522.         IFTHREADED(MUTEX_SETUP(confid_mutex);)
  523.     }
  524.     MUTEX_LOCK(env_mutex);
  525.     file = getenv("SOCKS5_CONFFILE");
  526.     if (file) file = strdup(file);
  527.     MUTEX_UNLOCK(env_mutex);
  529.     if (!file) file = strdup(SRVCONF_FILE);
  530.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Config: Reading config file: %s", file);
  532.     lsSetupIntfcs(&intfcs, &ifcnt);
  534.     MUTEX_LOCK(confid_mutex);
  535.     ClearEntryList(confids, NCONFIDS);
  536.     lsReadConfig(file, confids, NCONFIDS);
  537.     MUTEX_UNLOCK(confid_mutex);
  539.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Config: Config file read");
  540.     if (file) free(file);
  541. /*
  542.     S5LogStart(&S5LogDefaultHandle, -1, -1,"Socks5");
  543. */
  544. }
  546. /* See what kind of auths we will have to use...If the client can't do one   */
  547. /* of them, then we'll probably quit.  Otherwise, we'll use this list to     */
  548. /* decide which one we do do...                                              */
  549. int GetAuths(S5LinkInfo *pri, list **authlist) {
  550.     int i;
  551.     
  552.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Checking Authentication");
  553.     *authlist = NULL;
  555.     if (nalines == 0) {
  556. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Auth: No auth line specified");
  557. return 0;
  558.     }
  560.     MUTEX_LOCK(confid_mutex);
  561.     for (i = 0; i < nalines; i++) {
  562. if (!lsCheckHost(&authList[i].source, &pri->srcAddr, pri->srcName)) {
  563.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Auth: Line %d: Source host didn't match", authList[i].realline);
  564.     continue;
  565. }
  567. if (pri->peerCommand != SOCKS_PING && pri->peerCommand != SOCKS_TRACER
  568. && !lsCheckPort(&authList[i].sport, &pri->srcAddr, NULL, (pri->peerCommand == SOCKS_UDP)?"udp":"tcp")) {
  569.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Auth: Line %d: Source port didn't match", authList[i].realline);
  570.     continue;
  571. }
  573. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Auth: Line %d: Matched", authList[i].realline);
  575. if (authList[i].banned) {
  576.     MUTEX_UNLOCK(confid_mutex);
  577.     return -1;
  578. } else {
  579.     *authlist = authList[i].authlist;
  580.     MUTEX_UNLOCK(confid_mutex);
  581.     return 0;
  582. }
  583.     }
  585.     MUTEX_UNLOCK(confid_mutex);
  586.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Auth: No line matched");
  587.     return -1;
  588. }
  590. /* Check to see if the current set of global variables is allowed to proceed */
  591. /* by the current state of the configuration file.  If we are accepting, we  */
  592. /* don't need to necessariy match the destinaion host and port since they    */
  593. /* are not specified yet...                                                  */
  594. int Authorize(S5LinkInfo *pri, int accepting) {
  595.     int rval, i;
  596.     
  597.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Checking Authorization");
  599.     /* Before check with ACL, following address checking is performed:       */
  600.     /*                                                                       */
  601.     /* if src == dst => AUTH_FAIL...                                         */ 
  602.     /* if dst == LOOPBACK => AUTH_FAIL...                                    */ 
  603.     /* if src is one of the next proxy => AUTH_FAIL (avoid looping)...       */ 
  604.     if (pri->peerCommand != SOCKS_UDP && !lsAddrComp(&pri->srcAddr, &pri->dstAddr)) return AUTH_FAIL;
  605.     if (pri->dstAddr.sin.sin_addr.s_addr == htonl(INADDR_LOOPBACK)) return AUTH_FAIL;
  607.     for (i = 0; i < pri->nAltSckAddrs; i++) {
  608.      if (!lsAddrComp(&pri->srcAddr, &pri->altSckAddrs[i])) return AUTH_FAIL;
  609.     }
  611.     MUTEX_LOCK(confid_mutex);
  612.     for (i = 0; i < nplines; i++) {
  613. if (!lsCheckByte(accessList[i].command, pri->peerCommand, "commands")) {
  614.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d: Command didn't match", accessList[i].realline);
  615.     continue;
  616. }
  618. if (!lsCheckByte(accessList[i].authlist, pri->peerAuth, "auths")) {
  619.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d: Authentication didn't match", accessList[i].realline);
  620.     continue;
  621. }
  623. if (!lsCheckHost(&accessList[i].source, &pri->srcAddr, pri->srcName)) {
  624.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d: Source host didn't match", accessList[i].realline);
  625.     continue;
  626. }
  628. if (pri->peerCommand != SOCKS_PING && pri->peerCommand != SOCKS_TRACER &&
  629. !lsCheckPort(&accessList[i].sport, &pri->srcAddr, NULL, (pri->peerCommand == SOCKS_UDP)?"udp":"tcp")) {
  630.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d: Source port didn't match", accessList[i].realline);
  631.     continue;
  632. }
  634. /* if it is a UDP request, source address matches destination        */
  635.         /* address, and permission is OK, we are done...                     */
  636. if (pri->peerCommand == SOCKS_UDP && !lsAddrComp(&pri->srcAddr, &pri->dstAddr)) {
  637.     if (accessList[i].permit != AUTH_OK) continue;
  639.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d:matched", accessList[i].realline);
  640.     MUTEX_UNLOCK(confid_mutex);
  641.     return AUTH_OK;
  642. }
  644.         /* If we are accepting, we don't know the port. Therefore we should  */
  645. /* only care about permit lines. If we know the destination address  */
  646.    /* we will check the address.                                        */
  647.         if (accepting) {
  648.     if (accessList[i].permit != AUTH_OK) continue;
  649.     if (lsAddrIsNull(&pri->dstAddr) != 0) {
  650.              if (!lsCheckHost(&accessList[i].dest, &pri->dstAddr, pri->dstName)) {
  651.                     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d: Destination host didn't match", accessList[i].realline);
  652.                     continue;
  653.                 }
  654.     }
  655. } else {
  656.     if (!lsCheckHost(&accessList[i].dest, &pri->dstAddr, pri->dstName)) {
  657.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d: Destination host didn't match", accessList[i].realline);
  658.         continue;
  659.     }
  661.     if (!lsCheckPort(&accessList[i].dport, &pri->dstAddr, pri->dstServ, (pri->peerCommand == SOCKS_UDP)?"udp":"tcp")) {
  662.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d: Destination port didn't match", accessList[i].realline);
  663.         continue;
  664.     }
  665. }
  667. if (!lsCheckUser(accessList[i].userlist, pri->srcUser)) {
  668.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d: Username didn't match", accessList[i].realline);
  669.     continue;
  670. }
  672. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: Line %d:matched", accessList[i].realline);
  673. rval = accessList[i].permit;
  674. MUTEX_UNLOCK(confid_mutex);
  675. return rval;
  676.     }
  677.     
  678.     MUTEX_UNLOCK(confid_mutex);
  679.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Perm: No line matched");
  680.     return AUTH_FAIL;
  681. }
  683. /* Check the destination is on the same subnet. returns cwnumber of matching */
  684. /* interfaces...                                                             */
  685. static int lsCheckIntfc(const S5NetAddr *dst, S5NetAddr *addr) {
  686.     struct intaddr tmpaddr;
  687.     struct ifreq ifr;
  688.     int i, j, k = 0;
  690.     memset((char *)&ifr, 0, sizeof(struct ifreq));
  692.     for (i = 0; i < ifcnt; i++) {
  693. if (intfcs[i].addrcnt == 0 || intfcs[i].up != 1 || intfcs[i].type == 1) {
  694.     /* not an IP interface...                                    */
  695.             if (intfcs[i].up == 1 && intfcs[i].type != 1) continue;
  697.     /* the interface is still down...                            */
  698.     strcpy(ifr.ifr_name, intfcs[i].name);
  699.     if (lsLookupIntfc(S5InvalidIOHandle, NET_STAT, &ifr) <= 0) continue;
  701.     /* the interface is up now. Find the address and mask, and   */
  702.     /* check if the dst is on the same subnet ...                */
  703.     if (lsLookupIntfc(S5InvalidIOHandle, NET_ADDR, &ifr) < 0) continue;
  704.     if (ifssi(ifr)->sin_family != AF_INET) continue;
  705.     tmpaddr.ip = ifssi(ifr)->sin_addr;
  707.     if (lsLookupIntfc(S5InvalidIOHandle, NET_MASK, &ifr) < 0) continue;
  708.             tmpaddr.net = ifssi(ifr)->sin_addr;
  710.             if (checkifc(tmpaddr, dst->sin.sin_addr)) {
  711.         addr->sin.sin_addr = tmpaddr.ip;
  712.         k++;
  713.             }
  715.     continue; 
  716. }
  718. /* loopback interface ...                                        */
  719. if (intfcs[i].addrlist[0].ip.s_addr == htonl(INADDR_LOOPBACK)) continue;
  720.     
  721. for (j = 0; j < intfcs[i].addrcnt; j++) {
  722.     /* null address and null mask doesn't count ...              */
  723.     if (!(intfcs[i].addrlist[j].ip.s_addr & intfcs[i].addrlist[j].net.s_addr)) continue;
  725.     /* on the same subnet...                                     */
  726.             if (checkifc(intfcs[i].addrlist[j], dst->sin.sin_addr)) {
  727. addr->sin.sin_addr = intfcs[i].addrlist[j].ip;
  728. k++;
  729.     }
  730. }
  731.     }
  733.     return k;
  734. }
  736. /* GetProxy takes the destination and the type of the destination and picks  */
  737. /* how it should and a demand for what kind of server is needed, and finds a */
  738. /* server of that type, or returns -1 if there is no such server.            */
  739. /*                                                                           */
  740. /* Globals used: proxyList, the array of proxy entries....                   */
  741. int GetProxy(const S5NetAddr *dst, const char *name, char *proto, S5NetAddr *sckAddrs, int *nsckAddrs, u_char *verp) {
  742.     int i;
  743.     S5NetAddr tmpaddr;
  745.     *verp = 0;
  746.     *nsckAddrs = 0;
  748.     if (!lsAddrIsNull(dst)) return 0;
  750.     /* Before check the proxy lines, check if the dst is on the same subnet  */
  751.     /* as the server is on.                                                  */
  752.     if (getenv("SOCKS5_NONETMASKCHECK") == NULL) {
  753. if (lsCheckIntfc(dst, &tmpaddr) > 0) {
  754.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Proxy: dst on the same subnet");
  755.             return 0;
  756.         }
  757.     }
  759.     MUTEX_LOCK(confid_mutex);
  760.     for (i = 0; i < nslines; i++) {
  761. if (!lsCheckHost(&proxyList[i].source, dst, name)) {
  762.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Proxy: Line %d: Destination host didn't match", proxyList[i].realline);
  763.     continue;
  764. }
  766. if (!lsCheckPort(&proxyList[i].sport, dst, NULL, proto)) {
  767.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Proxy: Line %d: Destination port didn't match", proxyList[i].realline);
  768.     continue;
  769. }
  771. #define REALDEST(x) ((x)->sa.sa_family == AF_INET && (x)->sin.sin_addr.s_addr != INVALIDADDR && (x)->sin.sin_addr.s_addr != INADDR_ANY)
  773. if (proxyList[i].nextver && !REALDEST(&proxyList[i].nextaddr[0])) {
  774.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Proxy: Line %d: Invalid server address", proxyList[i].realline);
  775.     continue;
  776. }
  778. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Proxy: Line %d: Matched", proxyList[i].realline);
  779. if (!proxyList[i].nextver) break;
  781. *verp      = proxyList[i].nextver;
  782. memcpy((char *)sckAddrs, (char *)proxyList[i].nextaddr, sizeof(proxyList[i].nextaddr));
  783. *nsckAddrs = proxyList[i].nnextaddr;
  785. MUTEX_UNLOCK(confid_mutex);
  786. return 0;
  787.     }
  789.     MUTEX_UNLOCK(confid_mutex);
  790.     return -1;
  791. }
  793. /* Determine the outbound address for a given destination           */
  794. /* If not route does match, default will by any interface           */
  795. int GetRoute(const S5NetAddr *dst, const char *name, char *proto, S5NetAddr *addr) {
  796.     struct ifreq ifr;
  797.     int i;
  799.     memset((char *)&ifr, 0, sizeof(struct ifreq));
  801.     /* If we return before we change this, there was an error...             */
  802.     memset((char *)addr, 0, sizeof(S5NetAddr));
  803.     addr->sin.sin_family = AF_INET;
  805.     /* If dst is loopback, the route will be loopback....                    */
  806.     if (dst->sin.sin_family == AF_INET && !lsAddrIsNull(dst)) {
  807.         lsAddrCopy(addr, dst, lsAddrSize(dst));
  808.         return 0;
  809.     }
  811.     MUTEX_LOCK(confid_mutex);
  813.     for (i = 0; i < nrlines; i++) {
  814. if (!lsCheckHost(&routeList[i].source, dst, name)) {
  815.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Route: Line %d: Destination host didn't match", routeList[i].realline);     
  816.     continue;
  817. }
  819. if (!lsCheckPort(&routeList[i].sport, dst, NULL, proto)) {
  820.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Route: Line %d: Destination port didn't match", routeList[i].realline);     
  821.     continue;
  822. }
  824. if (routeList[i].nexthop.type == INVALID_TYPE) {
  825.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Route: Line %d: Invalid interface type", routeList[i].realline);     
  826.     continue;
  827. }
  829. if (routeList[i].nexthop.type == NAME) {
  830.     /* If the interface is not up when the daemon started or the interface */
  831.     /* has multiple addresses, get the current active address... otherwise */
  832.     /* we are done...                                                      */
  833.             if (routeList[i].nexthop.ifp->type == 1 || routeList[i].nexthop.ifp->up <= 0 || routeList[i].nexthop.ifp->addrcnt != 1) {
  834. strcpy(ifr.ifr_name, routeList[i].nexthop.ifp->name);
  836.      if (lsLookupIntfc(S5InvalidIOHandle, NET_STAT, &ifr) <= 0) {
  837.                  S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Route: Line %d: Interface is down", routeList[i].realline);
  838.          continue;
  839. }
  841.      if (lsLookupIntfc(S5InvalidIOHandle, NET_ADDR, &ifr) < 0 || ifssi(ifr)->sin_family != AF_INET) {
  842.                  S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Route: Line %d: Invalid interface address", routeList[i].realline);
  843.          continue;
  844. }
  846. addr->sin.sin_addr = ifssi(ifr)->sin_addr;
  847. break;
  848.     } else if (routeList[i].nexthop.ifp->addrcnt == 0) continue;
  849.     else {
  850. addr->sin.sin_addr = routeList[i].nexthop.ifp->addrlist[0].ip;
  851. break;
  852.     }
  853. } else {
  854.     addr->sin.sin_addr = routeList[i].nexthop.ifaddr;
  855.     break;
  856. }
  857.     }
  859.     if (i < nrlines) {
  860. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Route: Line %d: Matched", routeList[i].realline);     
  861. MUTEX_UNLOCK(confid_mutex);
  862. return 0;
  863.     }
  865.     /* No match...                                                           */
  866.     MUTEX_UNLOCK(confid_mutex);
  868.     /* Before check the route lines, check if the server is single-homed or  */
  869.     /* if the dst is on the same subnet as the server is on. If the server   */
  870.     /* is single-homed, route line is useless. If the dst is on the same     */
  871.     /* subnet, use that interface IP...                                      */
  872.     if (getenv("SOCKS5_NONETMASKCHECK") == NULL) {
  873. if (lsCheckIntfc(dst, addr) == 1) {
  874.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Route: dst on the same subnet");
  875.             return 0;
  876. }
  877.     }
  879.     return -1;
  880. }
  882. int GetFilter(S5LinkInfo *pri, char *name) {
  883.     int i;
  884.     
  885.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Checking Filter");
  887.     MUTEX_LOCK(confid_mutex);
  888.     for (i = 0; i < nflines; i++) {
  889. if (!lsCheckByte(filterList[i].command,  pri->peerCommand, "commands")) {
  890.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: Line %d: Command didn't match", filterList[i].realline);
  891.     continue;
  892. }
  894. if (!lsCheckByte(filterList[i].authlist, pri->peerAuth, "auths")) {
  895.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: Line %d: Authentication didn't match", filterList[i].realline);
  896.     continue;
  897. }
  899. if (!lsCheckHost(&filterList[i].source,  &pri->srcAddr, pri->srcName)) {
  900.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: Line %d: Source host didn't match", filterList[i].realline);
  901.     continue;
  902. }
  904. if (!lsCheckPort(&filterList[i].sport,   &pri->srcAddr, NULL, (pri->peerCommand == SOCKS_UDP)?"udp":"tcp")) {
  905.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: Line %d: Source port didn't match", filterList[i].realline);
  906.     continue;
  907. }
  909. if (!lsCheckHost(&filterList[i].dest,    &pri->dstAddr, pri->dstName)) {
  910.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: Line %d: Destination host didn't match", filterList[i].realline);
  911.     continue;
  912. }
  914. if (!lsCheckPort(&filterList[i].dport, &pri->dstAddr, pri->dstServ, (pri->peerCommand == SOCKS_UDP)?"udp":"tcp")) {
  915.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: Line %d: Destination port didn't match", filterList[i].realline);
  916.     continue;
  917. }
  919. if (!lsCheckUser(filterList[i].userlist, pri->srcUser)) {
  920.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: Line %d: Username didn't match", filterList[i].realline);
  921.     continue;
  922. }
  924. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: Line %d:matched", filterList[i].realline);
  925. strcpy(name, filterList[i].name);
  926. MUTEX_UNLOCK(confid_mutex);
  927. return 0;
  928.     }
  929.     
  930.     MUTEX_UNLOCK(confid_mutex);
  931.     memset(name, 0, S5_NAME_SIZE);
  932.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Filter: No line matched");
  933.     return -1;
  934. }