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

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

代理服务器

开发平台：

Unix_Linux

confutil.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: confutil.c,v 1.74.4.9 1998/11/13 21:36:36 wlu Exp $
  9.  */
  11. #include "socks5p.h"
  12. #include "threads.h"
  13. #include "buffer.h"
  14. #include "addr.h"
  15. #include "confutil.h"
  16. #include "log.h"
  18. #ifdef HAVE_IFADDRS_H
  19. #include <ifaddrs.h>
  20. #define ifassi(x) (((ssi *)(x))->sin_addr.s_addr)
  21. #endif
  23. #ifdef OSIOCGIFCONF
  24. #define RSIOCGIFCONF OSIOCGIFCONF
  25. #else
  26. #define RSIOCGIFCONF SIOCGIFCONF
  27. #endif
  29. #ifdef SIOCGIFADDR
  30. #define RSIOCGIFADDR SIOCGIFADDR
  31. #else
  32. #define RSIOCGIFADDR OSIOCGIFADDR
  33. #endif
  35. #ifdef SIOCGIFNETMASK
  36. #define RSIOCGIFNETMASK SIOCGIFNETMASK
  37. #else
  38. #define RSIOCGIFNETMASK OSIOCGIFNETMASK
  39. #endif
  41. IFTHREADED(extern MUTEX_T gh_mutex;)
  42. IFTHREADED(extern MUTEX_T gs_mutex;)
  43. int lsLineNo = 0;
  47. /* A function that checks if s1 is the first string in s1, and is followed   */
  48. /* by whitespace.  Used for configuration file entries.                      */
  49. static int CheckString(char *s1, char *s2) {
  50.     if (s2 == NULL) return 1;
  51.     if (strncmp(s1, s2, strlen(s2))) return 0;
  52.     if (!isspace(s1[strlen(s2)]))    return 0;
  53.     return 1;
  54. }
  56. /* A function that checks if c's string or abbreviation member is the first  */
  57. /* string in s1, and is followed by whitespace...                            */
  58. /*                                                                           */
  59. /* Arguments: s1 -- the string which we are examining                        */
  60. /* Arguments: c  -- a structure containing the string and abbreviation we    */
  61. /*                  are checking for.                                        */
  62. static int CheckStringOrAbbrev(char *s1, struct confid *c) {
  63.     char *tmp;
  65.     for (tmp = s1; *tmp && !isspace(*tmp); tmp++) if (isupper(*tmp)) *tmp = tolower(*tmp);
  66.     if (CheckString(s1, c->string)) return 1;
  67.     return CheckString(s1, c->abbrev);
  68. }
  70. /* This a malloc/realloc'ish function which takes orig, mallocs it if its    */
  71. /* Null, or reallocs it if it is non-null...pretty simple...oh, if the size  */
  72. /* is 0, and the pointer was allocated, it frees the memory, otherwise rets. */
  73. static void *remalloc(void *orig, size_t size) {
  74.     if (size == 0) {
  75. if (orig) free(orig);
  76. return NULL;
  77.     }
  78.     
  79.     if (orig == NULL) return (void *)malloc(size);
  80.     else              return (void *)realloc(orig, size);
  81. }
  83. int lsLinkedListInsertUnaligned(list **l, size_t s) {
  84.     list *templ = remalloc(NULL, s+sizeof(list));
  86.     if (templ == NULL) return -1;
  88.     templ->dataptr     = (void *)(templ+1);
  89.     templ->ptrmalloced = 0;
  90.     templ->next        = *l;
  91.     *l = templ;
  93.     return 0;
  94. }
  96. int lsLinkedListInsertAligned(list **l, size_t s) {
  97.     list *templ = remalloc(NULL, sizeof(list));
  98.     void *vptr  = remalloc(NULL, s);
  100.     if (templ == NULL || vptr == NULL) return -1;
  102.     templ->dataptr     = vptr;
  103.     templ->ptrmalloced = 1;
  104.     templ->next        = *l;
  105.     *l = templ;
  107.     return 0;
  108. }
  110. /* Delete a linked list...nothing to it really, except not freeing some ptrs */
  111. /*                                                                           */
  112. /* Arguments: l -- a ptr to the list we need to free...will be set to null.  */
  113. void lsDeleteLinkedList(list **l) {
  114.     list *tmp, *cur;
  115.     
  116.     for (tmp = *l, *l = NULL; tmp;) {
  117. cur = tmp; tmp = tmp->next;
  118. if (cur->ptrmalloced) free(cur->dataptr);
  119. free(cur);
  120.     }
  121. }
  123. /* Look at the buffer that ptr points to, and read an address...             */
  124. /*                                                                           */
  125. /* Arguments: ptr  -- a ptr to the buffer we are working with...(in/out)     */
  126. /*             na  -- a ptr to the address we are looking up...(out)         */
  127. int lsGetHostAddress(char **ptr, S5NetAddr *na) {
  128.     char *tmp, tc;
  129.     int rval;
  131.     SKIPSPACE(*ptr);
  132.     tmp = *ptr;
  134.     SKIPNSPNCOMMA(tmp);
  135.     tc = *tmp; *tmp = '';
  137.     rval = lsName2Addr(*ptr, na);
  139.     *(*ptr = tmp) = tc;
  140.     return rval;
  141. }
  143. /* Look at the buffer that ptr points to, and read a port... check ,'s       */
  144. /*                                                                           */
  145. /* Arguments: ptr  -- a ptr to the buffer we are working with...(in/out)     */
  146. /*            val  -- a ptr to the address we are looking up...(out)         */
  147. static int lsGetPort(char **ptr, u_short *val) {
  148.     char *tmp, tc;
  149.     int retval = 0;
  151.     SKIPSPACE(*ptr);
  152.     tmp = *ptr;
  154.     SKIPNSPNCOMMA(tmp);
  155.     tc = *tmp; *tmp = '';
  157.     if (tmp != *ptr) retval = lsName2Port(*ptr, NULL /* XXX OK? */, val);
  158.     else             *val = INVALIDPORT;
  159.     *(*ptr = tmp) = tc;
  161.     return retval;
  162. }
  164. /* Look at the buffer that ptr points to, and read a port... no commas       */
  165. /* Stuff the answer into an S5NetAddr...                                     */
  166. /*                                                                           */
  167. /* Arguments: ptr -- a ptr to the buffer we are working with...(in/out)      */
  168. /*             na -- a ptr to the address we are looking up...(out)          */
  169. int lsGetHostPort(char **ptr, S5NetAddr *na) {
  170.     u_short port = INVALIDPORT;
  171.     int rval;
  173.     rval = lsGetPort(ptr, &port);
  174.     lsAddrSetPort(na, port);
  176.     return rval;
  177. }
  179. /* Look at the buffer that ptr points to, and read an address and a port...  */
  180. /* The address and port are separated by ':' ...                             */
  181. /*                                                                           */
  182. /* Arguments: ptr -- a ptr to the buffer we are working with...(in/out)      */
  183. /*             na -- a ptr to the address we are looking up...(out)          */
  184. int lsGetHostAddressAndPort(char **ptr, S5NetAddr *na) {
  185.     int rval;
  186.     char *tmp, tc;
  188.     SKIPSPACE(*ptr);
  189.     tmp = *ptr;
  191.     SKIPNSPNCOLNCOM(tmp);
  193.     if (tmp == *ptr) return 0;
  195.     tc = *tmp; *tmp = '';
  197.     rval = lsName2Addr(*ptr, na);
  198.     *(*ptr = tmp) = tc;
  200.     if (rval < 0) return rval;
  202.     if (tc == ':') {
  203. (*ptr)++;
  204. return lsGetHostPort(ptr, na);
  205.     }
  207.     return 0;
  208. }
  210. /* Given ip (address in net order) return the standard subnet mask for it.   */ 
  211. static void StandardSubnetMaskForClass(struct in_addr ip, struct in_addr *mask) {
  212.     if      ((ip.s_addr & htonl(0x80000000)) == 0) mask->s_addr = htonl(0xffff0000); /* class A  */
  213.     else if ((ip.s_addr & htonl(0x40000000)) == 0) mask->s_addr = htonl(0xffffff00); /* class B  */
  214.     else if ((ip.s_addr & htonl(0x20000000)) == 0) mask->s_addr = htonl(0xfffffff0); /* class C  */
  215.     else mask->s_addr = htonl(0xffffffff);                                           /* class D  */
  216. }
  218. /* Given ip (address in net order) return the standard net mask for it.      */ 
  219. static void StandardNetMaskForClass(struct in_addr ip, struct in_addr *mask) {
  220.     if      ((ip.s_addr & htonl(0x80000000)) == 0) mask->s_addr = htonl(0xff000000); /* class A  */
  221.     else if ((ip.s_addr & htonl(0x40000000)) == 0) mask->s_addr = htonl(0xffff0000); /* class B  */
  222.     else if ((ip.s_addr & htonl(0x20000000)) == 0) mask->s_addr = htonl(0xffffff00); /* class C  */
  223.     else mask->s_addr = htonl(0xffffffff);                                           /* class D  */
  224. }
  226. /* Look at the buffer that ptr points to, and read either a net address of a */
  227. /* host and a netmask (n.n.n.n/m.m.m.m) or a abbreviated portion of that     */
  228. /* (n.n.n. n.n. or n.) or the name of a valid machine (idaho.syl.dl.nec.com) */
  229. /* or a portion of that name which must match (.syl.dl.nec.com)...           */
  230. /*                                                                           */
  231. /* Arguments: ptr  -- a ptr to the buffer we are working with...(in/out)     */
  232. /*            host -- a ptr to the address/mask we are looking up...(out)    */
  233. int lsGetHostAndMask(char **ptr, struct host *h) {
  234.     int i, nd = 0, rval = 0;
  235.     struct hostent *hp;
  236.     char *tmp, *st, c;
  238.     if (!h) return -1;
  239.     memset((char *)h, 0, sizeof(struct host));
  241.     SKIPSPACE(*ptr);
  242.     tmp = *ptr;
  244.     if (*tmp == 'n') {
  245. h->type        = IN_ADDR;
  246. h->mask.s_addr = 0xffffffff;
  247. h->ip.s_addr   = INVALIDADDR;
  249. return -1;
  250.     }
  252.     for (st = tmp; !isspace(*tmp) && *tmp != '' && *tmp != '/'; tmp++) if (*tmp == '.') nd++;
  253.     c  = *tmp; *tmp = '';
  255.     if (*st == '-') {
  256. /* - */
  258. /* This is obviously the easiest case...its a -, so any body matches */
  259. h->type        = IN_ADDR;
  260. h->mask.s_addr = htonl(0x00000000);
  261. h->ip.s_addr   = htonl(0x00000000);
  262.     } else if (c == '/') {
  263. /* n.n.n.n/[m.m.m.m|h|s|n|a] */
  264. char *end, c2;
  266. for (end = tmp+1; !isspace(*end) && *end != ''; end++);
  267. c2 = *end; *end = '';
  269. /* There was a /, so there has to have been an IP address before it. */
  270. /* Read the address, then read the mask... Pretty straight forward.  */
  271. if ((h->ip.s_addr = inet_addr(st)) == INVALIDADDR) {
  272.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_WARNING, 0, "Conf: Invalid address in address/mask host pair");
  273.     rval = -1;
  274. } 
  276. switch (*(tmp + 1)) {
  277.     case 'h': h->mask.s_addr = htonl(0xffffffff); break;
  278.     case 's': StandardSubnetMaskForClass(h->ip, &h->mask); break;
  279.     case 'n': StandardNetMaskForClass   (h->ip, &h->mask); break;
  280.     case 'a': h->mask.s_addr = htonl(0x00000000); break;
  281.     default:  h->mask.s_addr = inet_addr(tmp+1); break;
  282. }
  284. h->type       = IN_ADDR;
  285. h->ip.s_addr &= h->mask.s_addr;
  287. if (h->mask.s_addr == htonl(0xffffffff) && getenv("SOCKS5_REVERSEMAP") != NULL) {
  288.     /* Map the IP, since the name we will be comparing it to         */
  289.     /* will already have been resolved and mapped (hopefully).       */
  290.     MUTEX_LOCK(gh_mutex);
  291.     if ((hp = gethostbyaddr((char *)&h->ip, sizeof(struct in_addr), AF_INET)) != NULL) {
  292. /* Store all the aliases and the ip addresses                */
  293. h->resolve = 1;
  294.         strncpy(h->name, hp->h_name, MIN(strlen(hp->h_name), S5_HOSTNAME_SIZE-1));
  295.         h->name[MIN(strlen(hp->h_name), S5_HOSTNAME_SIZE-1)] = '';
  297. for (i = 0; hp->h_aliases[i] && i < S5_HOSTALIASES_NUM; i++) {
  298.             strncpy(h->aliases[i], hp->h_aliases[i], MIN(strlen(hp->h_aliases[i]), S5_HOSTNAME_SIZE-1));
  299.             h->aliases[i][MIN(strlen(hp->h_aliases[i]), S5_HOSTNAME_SIZE-1)] = '';
  300. }
  301. h->aliascnt = i;
  303. for (i = 0; hp->h_addr_list[i] && i < S5_HOSTIP_NUM; i++) {
  304.             memcpy((char *)&h->back[i], hp->h_addr_list[i], sizeof(struct in_addr));
  305. }
  306. h->ipcnt = i;
  307.     }
  308.     MUTEX_UNLOCK(gh_mutex);
  309. }
  311. *tmp = c;
  312. tmp  = end;
  313. c    = c2;
  315.     } else if (*(tmp-1) == '.') {
  316. /* n.n.n. or n.n. or n. */
  318. /* Put a 0 on the end just for inet_addr's sake, even though it      */
  319. /* seems to work without it...its not documented so it probably      */
  320. /* won't work on some OS...restore it at the end...                  */
  321. char c2 = tmp[1];
  322. tmp[0] = '0';
  323. tmp[1] = '';
  325. if ((h->ip.s_addr = inet_addr(st)) == INVALIDADDR) {
  326.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_WARNING, 0, "Conf: Invalid address in truncated address");
  327.     rval = -1;
  328. }
  330. h->type        = IN_ADDR;
  331. h->mask.s_addr = htonl(((u_int)0xffffffff) << (8*(4-nd)));
  332. h->ip.s_addr  &= h->mask.s_addr;
  334. tmp[1] = c2;
  335. tmp[0] = '';
  337.     } else if ((h->ip.s_addr = inet_addr(st)) != INVALIDADDR) {
  338. /* n.n.n.n or n.n.n or n.n or n */
  340. /* This one's really simple, inet_addr worked, and the mask          */
  341. /* should be exact, so just do it...                                 */
  342. h->type        = IN_ADDR;
  343. h->mask.s_addr = htonl(0xffffffff);
  344. h->ip.s_addr  &= h->mask.s_addr;
  346. /* Map the IP, since the name we will be comparing it to             */
  347. /* will already have been resolved and mapped (hopefully).           */
  348. if (getenv("SOCKS5_REVERSEMAP") != NULL) {
  349.     MUTEX_LOCK(gh_mutex);
  350.     if ((hp = gethostbyaddr((char *)&h->ip, sizeof(struct in_addr), AF_INET)) != NULL) {
  351. /* Store all the aliases and the ip addresses                */
  352. h->resolve = 1;
  353. strncpy(h->name, hp->h_name, MIN(strlen(hp->h_name), S5_HOSTNAME_SIZE-1));
  354. h->name[MIN(strlen(hp->h_name), S5_HOSTNAME_SIZE-1)] = '';
  356. for (i = 0; hp->h_aliases[i] && i < S5_HOSTALIASES_NUM; i++) {
  357.     strncpy(h->aliases[i], hp->h_aliases[i], MIN(strlen(hp->h_aliases[i]), S5_HOSTNAME_SIZE-1));
  358.     h->aliases[i][MIN(strlen(hp->h_aliases[i]), S5_HOSTNAME_SIZE-1)] = '';
  359. }
  360. h->aliascnt = i;
  362. for (i = 0; hp->h_addr_list[i] && i < S5_HOSTIP_NUM; i++) {
  363.     memcpy((char *)&h->back[i], hp->h_addr_list[i], sizeof(struct in_addr));
  364. }
  365. h->ipcnt = i;
  366.     }
  367.     MUTEX_UNLOCK(gh_mutex);
  368. }
  369.     } else {
  370. /* name */
  371. h->type    = NAME;
  372. h->resolve = (*st == '.')?0:1;
  374. /* Make this string lower case so we don't have to call (non-POSIX)  */
  375. /* strncasecmp, but instead strncmp.                                 */
  376. for (tmp = st; *tmp != ''; tmp++) if (isupper(*tmp)) *tmp = tolower(*tmp);
  378. strncpy(h->name, st, MIN(strlen(st), S5_HOSTNAME_SIZE-1));
  379. h->name[MIN(strlen(st), S5_HOSTNAME_SIZE-1)] = '';
  381. if (h->resolve) {
  382.     /* Reverse map the name, since the name we will be comparing it to   */
  383.     /* will already have been reverse and mapped (hopefully).            */
  384.     MUTEX_LOCK(gh_mutex);
  385.     if ((hp = REAL(gethostbyname)(st)) != NULL) {
  386. /* Store all the aliases and the ip addresses                */
  387.         strncpy(h->name, hp->h_name, MIN(strlen(hp->h_name), S5_HOSTNAME_SIZE-1));
  388.         h->name[MIN(strlen(hp->h_name), S5_HOSTNAME_SIZE-1)] = '';
  390. for (i = 0; hp->h_aliases[i] && i < S5_HOSTALIASES_NUM; i++) {
  391.             strncpy(h->aliases[i], hp->h_aliases[i], MIN(strlen(hp->h_aliases[i]), S5_HOSTNAME_SIZE-1));
  392.             h->aliases[i][MIN(strlen(hp->h_aliases[i]), S5_HOSTNAME_SIZE-1)] = '';
  393. }
  394. h->aliascnt = i;
  396. for (i = 0; hp->h_addr_list[i] && i < S5_HOSTIP_NUM; i++) {
  397.             memcpy((char *)&h->back[i], hp->h_addr_list[i], sizeof(struct in_addr));
  398. }
  399. h->ipcnt = i;
  400.     }
  401.     MUTEX_UNLOCK(gh_mutex);
  402. }
  404. h->length = strlen(h->name);
  405.     } 
  407.     *tmp = c;
  408.     SKIPNONSPACE(*ptr);
  409.     return rval;
  410. }
  412. /* Look at the buffer that ptr points to, and read either a port number or   */
  413. /* the name of a service...the name may be used in service name proxying.    */
  414. /*                                                                           */
  415. /* Arguments: ptr -- a ptr to the buffer we are working with...(in/out)      */
  416. /*            p -- a ptr to the port/service we are looking up...(out)       */
  417. int lsGetPortOrService(char **ptr, struct port *p) {
  418.     char *tmp, c, *end, ec;
  419.     int retval = 0;
  420.     u_short tmpport;
  422.     SKIPSPACE(*ptr);
  423.     tmp = *ptr;
  424.     
  425.     p->lport = htons(INVALIDPORT);
  426.     p->hport = htons(INVALIDPORT);
  428.     if (*tmp == 'n') {
  429. p->lport = htons(0);
  430. return 0;
  431.     }
  433.     if ((c = *tmp) == '-') {
  434. /* anything goes */
  435. p->lport = htons(0);
  436.     } else if (*tmp != '[' && *tmp != '(') {
  437. retval = lsGetPort(&tmp, &p->lport);
  438. p->hport = p->lport;
  439.     } else {
  440. for (end = tmp; !isspace(*end) && *end != ',' && *end != ''; end++);
  441. ec = *end; *end = '';
  442. tmp++;
  444. retval = lsName2Port(tmp, NULL /* XXX OK? */, &p->lport);
  445. *(tmp = end) = ec;
  447. if (retval) goto done;
  448. if (c == '(') {
  449.     tmpport = ntohs(p->lport) + 1;
  450.     p->lport = htons(tmpport);
  451. }
  453. if (*tmp != ',') {
  454.     p->lport = INVALIDPORT;
  455.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_WARNING, 0, "Conf: Expected a ',' between ports in a range");
  456.     retval = -1;
  457.     goto done;
  458. } 
  460. for (end = tmp; !isspace(*end) && *end != ')' && *end != ']' && *end != ''; end++);
  461. ec = *end; *end = '';
  462. tmp++;
  464. retval = lsName2Port(tmp, NULL /* XXX OK? */, &p->hport);
  465. *end = ec;
  467. if (retval) goto done;
  468. if (ec == ')') {
  469.     tmpport = ntohs(p->hport) - 1;
  470.     p->hport = htons(tmpport);
  471. }
  472.     }
  474.   done:
  475.     SKIPNONSPACE(*ptr);
  476.     return retval;
  477. }
  479. /* Look at the buffer that ptr points to, and read the string representing   */
  480. /* valid authentication methods.                                             */
  481. /*                                                                           */
  482. /* Arguments: ptr -- a ptr to the buffer we are working with...(in/out)      */
  483. /*            val -- a ptr to the char which will hold valid auths...(out)   */
  484. int lsGetAuthMethods(char **ptr, list **val) {
  485.     char *tmp, c, tmpn[S5_NAME_SIZE];
  486.     int len, rval = 0;
  488.     SKIPSPACE(*ptr);
  490.     for (*val = NULL; **ptr != ''; (*ptr)++) {
  491. for (tmp = *ptr; *tmp != '' && *tmp != ',' && !isspace(*tmp); tmp++);
  492. c = *tmp; *tmp = '';
  494. if (tmp == *ptr) {
  495.     *tmp = c;
  496.     break;
  497. }
  499. if (!strcmp(*ptr, "-")) {
  500.     if (*val) lsDeleteLinkedList(val);
  501.     *tmp = c;
  502.     break;
  503. }
  505. if (lsLinkedListInsertUnaligned(val, 0) < 0) {
  506.     *tmp = c;
  507.     break;
  508. }
  510. len = MIN(strlen(*ptr), S5_NAME_SIZE-1);
  511. strncpy(tmpn, *ptr, len);
  512. tmpn[len] = '';
  513. *(*ptr = tmp) = c;
  515. /* Somehow, they know the auth number, so let them use it...      */
  516. if (isdigit(*tmpn)) {
  517.     if (((*val)->dataint = atoi(tmpn)) >= 0xff) {
  518.      (*val)->dataint = 0xff;
  519. rval = -1;
  520.      break;
  521.     } else if (isspace(c) || c == '') break;
  522.     continue;
  523. }
  525. /* See if the long (word) or short (letter) names match...           */
  526. if (!strcmp(tmpn, "null")           || !strcmp(tmpn, "n")) {
  527.     (*val)->dataint = AUTH_NONE;           /* null                   */
  528.     if (isspace(c) || c == '') break;
  529.     continue;
  530. } else if (!strcmp(tmpn, "krb5gss") || !strcmp(tmpn, "k")) {
  531.     (*val)->dataint = AUTH_GSSAPI;         /* kerberos               */
  532.     if (isspace(c) || c == '') break;
  533.     continue;
  534. } else if (!strcmp(tmpn, "upwd")    || !strcmp(tmpn, "u")) {
  535.     (*val)->dataint = AUTH_PASSWD;         /* passwd                 */
  536.     if (isspace(c) || c == '') break;
  537.     continue;
  538. }
  540. /* Nothing matched, so mark this as a bad entry and return -1...     */
  541. (*val)->dataint = 0xff;
  542. lsDeleteLinkedList(&(*val)->next);
  543. rval = -1;
  544. break;
  545.     }
  546.     
  547.     SKIPNONSPACE(*ptr);
  548.     return rval;
  549. }
  551. /* Look at the buffer that ptr points to, and read the string representing   */
  552. /* valid protocols...                                                        */
  553. /*                                                                           */
  554. /* Arguments: ptr -- a ptr to the buffer we are working with...(in/out)      */
  555. /*            val -- a ptr to the char which will hold valid protos...(out)  */
  556. int lsGetPermCommand(char **ptr, list **val) {
  557.     char tmpn[S5_NAME_SIZE], *tmp, c;
  558.     int len, rval = 0;
  560.     SKIPSPACE(*ptr);
  562.     for (*val = NULL; **ptr != ''; (*ptr)++) {
  563. for (tmp = *ptr; *tmp != '' && *tmp != ',' && !isspace(*tmp); tmp++);
  564. c = *tmp; *tmp = '';
  566. if (tmp == *ptr) {
  567.     *tmp = c;
  568.     break;
  569. }
  571. if (!strcmp(*ptr, "-")) {
  572.     if (*val) lsDeleteLinkedList(val);
  573.     *tmp = c;
  574.     break;
  575. }
  577. if (lsLinkedListInsertUnaligned(val, 0) < 0) {
  578.     *tmp = c;
  579.     break;
  580. }
  582. len = MIN(strlen(*ptr), S5_NAME_SIZE-1);
  583. strncpy(tmpn, *ptr, len);
  584. tmpn[len] = '';
  585. *(*ptr = tmp) = c;
  587. /* Somehow, they know the command number, so let them use it...      */
  588. if (isdigit(*tmpn)) {
  589.     if (((*val)->dataint = atoi(tmpn)) >= 0xff) {
  590.      (*val)->dataint = 0xff;
  591. rval = -1;
  592.      break;
  593.     } else if (isspace(c) || c == '') break;
  594.     continue;
  595. }
  598. /* See if the long (word) or short (letter) names match...           */
  599. if (!strcmp(tmpn, "bind")              || !strcmp(tmpn, "b")) {
  600.     (*val)->dataint = SOCKS_BIND;
  601.     if (isspace(c) || c == '') break;
  602.     continue;
  603. } else if (!strcmp(tmpn, "connect")    || !strcmp(tmpn, "c")) {
  604.     (*val)->dataint = SOCKS_CONNECT;
  605.     if (isspace(c) || c == '') break;
  606.     continue;
  607. } else if (!strcmp(tmpn, "udp")        || !strcmp(tmpn, "u")) {
  608.     (*val)->dataint = SOCKS_UDP;
  609.     if (isspace(c) || c == '') break;
  610.     continue;
  611. } else if (!strcmp(tmpn, "ping")       || !strcmp(tmpn, "p")) {
  612.     (*val)->dataint = SOCKS_PING;
  613.     if (isspace(c) || c == '') break;
  614.     continue;
  615. } else if (!strcmp(tmpn, "traceroute") || !strcmp(tmpn, "t")) {
  616.     (*val)->dataint = SOCKS_TRACER;
  617.     if (isspace(c) || c == '') break;
  618.     continue;
  619. }
  621. /* Nothing matched, so mark this as a bad entry and return -1...     */
  622. (*val)->dataint = 0xff;
  623. lsDeleteLinkedList(&(*val)->next);
  624. rval = -1;
  625. break;
  626.     }
  627.     
  628.     SKIPNONSPACE(*ptr);
  629.     return rval;
  630. }
  632. /* Look at the buffer that ptr points to, and read the string representing   */
  633. /* a list of users.  The list is comma separated with no whitespce between   */
  634. /* usernames.   "-" is a special string meaning any user is ok...            */
  635. /*                                                                           */
  636. /* Arguments: ptr  -- a ptr to the buffer we are working with...(in/out)     */
  637. /*            l    -- a ptr to the list of users which are ok...(out)        */
  638. int lsGetPermUsers(char **ptr, list **l) {
  639.     char *tmp, c;
  641.     SKIPSPACE(*ptr);
  643.     for (*l = NULL; **ptr != ''; (*ptr)++) {
  644. for (tmp = *ptr; *tmp != '' && *tmp != ',' && !isspace(*tmp); tmp++);
  645. c = *tmp; *tmp = '';
  647. if (tmp == *ptr) {
  648.     *tmp = c;
  649.     break;
  650. }
  652. if (!strcmp(*ptr, "-")) {
  653.     if (*l) lsDeleteLinkedList(l);
  654.     *tmp = c;
  655.     break;
  656. }
  658. if (lsLinkedListInsertUnaligned(l, strlen(*ptr)+1) < 0) {
  659.     *tmp = c;
  660.     break;
  661. }
  663. strcpy((*l)->dataptr, *ptr);
  664. *(*ptr = tmp) = c;
  665. if (isspace(c) || c == '') break;
  666.     }
  668.     SKIPNONSPACE(*ptr);
  669.     return 0;
  670. }
  672. /* Check to see if username appears in userlist or if userlist is NULL.      */
  673. /* If username is NULL, and the list is not, it obviously does not.          */
  674. /* Returns 1 on success 0 on failure.                                        */
  675. int lsCheckUser(list *userlist, const char *username) {
  676.     list *tmp;
  678.     if (!userlist) {
  679. /* Authentication is ok for anybody.                                 */
  680. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking username, %s is in -", username?username:"(null)");
  681. return 1; 
  682.     }
  683.     
  684.     if (!username) {
  685. /* Authentication is ok for nobody..                                 */
  686. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking username, username is (null)");
  687. return 0;
  688.     }
  690.     for (tmp = userlist; tmp != NULL; tmp = tmp->next) {
  691. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking if %s is %s", username, tmp->dataptr);
  692. if (!strcmp(tmp->dataptr, username)) return 1;
  693.     }
  694.       
  695.     return 0;
  696. }
  698. /* Check to see if s or name match the host pattern specified in h.  If so   */
  699. /* return 1, if not return 0.                                                */
  700. int lsCheckHost(struct host *h, const S5NetAddr *s, const char *name) {
  701.     char tmp[S5_HOSTNAME_SIZE], nbuf[MAXHOSTNAMELEN];
  702.     int offset, i;
  703.     struct in_addr addr;
  705.     /* Make sure the input address is valid                                  */
  706.     if (!s && !name) return 0;
  707.     if (s && s->sa.sa_family == AF_INET && s->sin.sin_addr.s_addr == INVALIDADDR) return 0;
  709.     /* The address was stored, not the name => compare addresses.            */
  710.     if (h->type == IN_ADDR) {
  711.   if (h->ip.s_addr == INVALIDADDR) return 0;
  712. /* It is all....                                                     */
  713. if (h->ip.s_addr == htonl(0x00000000) && h->mask.s_addr == htonl(0x00000000)) return 1;
  715. /* s is S5NAME but IP is not mapped...                               */
  716. if ((!s || s->sa.sa_family == AF_S5NAME) && !h->resolve) return 0;
  718. /* only name is available...                                         */
  719. if (!s) {
  720.     if (!strcmp(h->name, name)) return 1;
  722.     for (i = 0; i < h->aliascnt; i++) {
  723.      if (!strcmp(h->aliases[i], name)) return 1;
  724.     }
  726.     return 0;
  727. }
  729. if (s->sa.sa_family == AF_S5NAME) {
  730.     if (!strcmp(h->name, s->sn.sn_name)) return 1;
  732.     for (i = 0; i < h->aliascnt; i++) {
  733.      if (!strcmp(h->aliases[i], s->sn.sn_name)) return 1;
  734.     }
  736.     return 0;
  737. }
  739. /* s is AF_INET...                                                   */
  740. if (s->sin.sin_addr.s_addr != INADDR_ANY) addr = s->sin.sin_addr;
  741. else addr.s_addr = (name)?inet_addr((char *)name):INVALIDADDR;
  743. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking host address (%08x == %08x)?", addr.s_addr & h->mask.s_addr, h->ip.s_addr);
  744. if ((addr.s_addr & h->mask.s_addr) == h->ip.s_addr) return 1;
  746. for (i = 0; i < h->ipcnt; i++) {
  747.     if (h->back[i].s_addr == addr.s_addr) return 1;
  748. }
  750. /* last possibility, the name maches...                               */
  751. if (name && h->resolve) {
  752.     if (!strcmp(h->name, name)) return 1;
  754.     for (i = 0; i < h->aliascnt; i++) {
  755.      if (!strcmp(h->aliases[i], name)) return 1;
  756.     }
  757. }
  759. return 0;
  760.     }
  762.     /* The name was stored, not the address => compare names.                */
  763.     /* If we stored a backup address, check and see if it matches...         */
  764.     if (h->resolve) {
  765.      if (s && s->sa.sa_family == AF_INET && s->sin.sin_addr.s_addr != INADDR_ANY) addr = s->sin.sin_addr;
  766. else addr.s_addr = (name)?inet_addr((char *)name):INVALIDADDR;
  768. for (i = 0; i < h->ipcnt; i++) {
  769.     if (h->back[i].s_addr == addr.s_addr) return 1;
  770. }
  771.     }
  773.     if (s && s->sa.sa_family == AF_S5NAME) strcpy(tmp, s->sn.sn_name);
  774.     else if (name) strcpy(tmp, name);
  775.     else if (s && s->sa.sa_family == AF_INET) { 
  776.      struct hostent *hp = NULL;
  778.         MUTEX_LOCK(gh_mutex);
  779.         if (!(hp = gethostbyaddr((char *)&s->sin.sin_addr.s_addr, sizeof(struct in_addr), AF_INET))) {
  780.             MUTEX_UNLOCK(gh_mutex);
  781.             return 0;
  782.         }
  784.      strcpy(tmp, hp->h_name);
  785.         MUTEX_UNLOCK(gh_mutex);
  786.     } else return 0;
  788.     for (i = 0; tmp[i] != ''; i++) nbuf[i] = (isupper(tmp[i]))?tolower(tmp[i]):tmp[i];
  789.     nbuf[i] = '';
  790.     
  791.     if (h->resolve) {
  792. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking host name  (%s is %s)?",nbuf, h->name);
  794. if (!strcmp(h->name, nbuf)) return 1;
  796. for (i = 0; i < h->aliascnt; i++) {
  797.     if (!strcmp(h->aliases[i], nbuf)) return 1;
  798. }
  800. return 0;
  801.     } else {
  802.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking host domain (%s is in %s)?", nbuf, h->name);
  804.      /* How much longer is name than the stored one?  If its too short, well  */
  805.      /* its not a match...If it has to be exact and its too long, ditto.  If  */
  806.      /* h->name isn't the last part of name, ditto...otherwise, a match.   */
  807.      if ((offset = i - h->length) < 0) return 0;
  808.      if (strncmp(nbuf+offset, h->name, h->length)) return 0;
  809.      return 1;
  810.     }
  811. }
  813. /* Check to see if s or name match the port specified by p.                  */
  814. int lsCheckPort(struct port *p, const S5NetAddr *s, const char *name, char *proto) {
  815.     u_short port = s?s->sin.sin_port:0;
  816.     struct servent *sp;
  818.     MUTEX_LOCK(gs_mutex);
  819.     if (port == 0 && name && (sp = getservbyname((char *)name, proto))) port = sp->s_port;
  820.     MUTEX_UNLOCK(gs_mutex);
  822.     /* compare the port number to the range of numbers we stored....     */
  823.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking port range   (%d <= %d <= %d)?", ntohs(p->lport), ntohs(port), ntohs(p->hport));
  824.     return ((ntohs(port) < ntohs(p->lport)) || (ntohs(port) > ntohs(p->hport)))?0:1;
  825. }
  827. /* Check to see if byte appears in bytes, a list of bytes.                   */
  828. /*                                                                           */
  829. /* Arguments: bytes - the list of bytes we're checking                       */
  830. /*            byte  - the byte we're looking for in bytes                    */
  831. /*            name  - a name for the logs describing what this check is      */
  832. int lsCheckByte(list *bytes, u_char byte, const char *name) {
  833.     list *tl;
  834.     
  835.     if (!bytes) {
  836. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking %s: Anything is ok ", name);
  837. return 1;
  838.     }
  840.     for (tl = bytes; tl; tl = tl->next) {
  841. if (tl->dataint == (int)byte && tl->dataint != 0xff) {
  842.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking %s: %d matched ", name, (int)byte);
  843.     return 1;
  844. } else {
  845.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking %s: %d didn't match %d", name, tl->dataint, (int)byte);
  846. }
  847.     }
  849.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(5), 0, "Check: Checking %s: No match for %d", name, (int)byte);
  850.     return 0;
  851. }
  853. /* A function for use in LoopThroughFile which increments the number of      */
  854. /* entries of this line type that need to be allocated...                    */
  855. static void ClassifyLine(confid *confids, int nids, int indx, char *tmp) {
  856.     if (indx >= 0 && indx < nids) {
  857. if (confids[indx].number) (*confids[indx].number)++;
  858. return;
  859.     }
  861.     SKIPSPACE(tmp);
  862.     if (*tmp == 'n' || *tmp =='') return;
  863.     
  864.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Bad line in configuration file: %d", lsLineNo);
  865. }
  867. /* A function for use in LoopThroughFile which actually reads the line into  */
  868. /* the appropriate structure, by calling the right line handler...           */
  869. static void ProcessLine(confid *confids, int nids, int indx, char *tmp) {
  870.     char *end, c;
  872.     for (end = tmp; *end != 'n' && *end != ''; end++);
  873.     c = *end; *end = '';
  874.     
  875.     if (indx < nids)
  876. confids[indx].handler(confids[indx].array, confids[indx].cnum?(*confids[indx].cnum)++:0, indx, tmp);
  877.     *end = c;
  878. }
  880. /* LoopTroughFile() reads through (line by line) the file (read into buf)    */
  881. /* and performs func on each line of the file...telling func what kind of    */
  882. /* line it seems to be...                                                    */
  883. static void LoopThroughFile(char *buf, int fsize, confid *confids, int nids, void (*func)(confid *, int, int, char *)) {
  884.     char *tmp, *nl;
  885.     int i;
  886.     
  887.     for (lsLineNo = 1, tmp = buf; tmp && tmp < buf+fsize; tmp = nl+1, lsLineNo++) {
  888. if ((nl = strchr(tmp, 'n')) != NULL) *nl = '';
  890.         SKIPSPACE(tmp);
  891. if (*tmp != '#' && *tmp != '') {
  892.     /* Do this even if "i" is too big (so we only warn once)         */
  893.     for (i = 0; i < nids; i++) if (CheckStringOrAbbrev(tmp, &confids[i])) break;
  894.     func(confids, nids, i, tmp); 
  895. }
  897. if (!nl) break; else *nl = 'n';
  898.     }
  899. }
  901. /* A function that reads teh configuration file SRVCONF_FILE int buf and     */
  902. /* sets *size to be the size of the new buffer...if something goes wrong, it */
  903. /* returns NULL indicating there is no valid configuration (for now)...      */
  904. static char *ReadConfigFile(const char *filename, int *sizep) {
  905.     int size = 1024 * 1024;
  906.     char *buf = NULL;
  907.     S5IOHandle fd;
  908.     struct stat sb;
  910.     *sizep = 0;
  912.     while ((fd = open(filename, O_RDONLY)) < 0 && errno == EINTR);
  914.     if (fd < 0) {
  915. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Config: Error opening config file (%s): %m", filename);
  916. return NULL;
  917.     }
  919.     if (fstat(fd, &sb) < 0) {
  920. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Config: Error stating open config file (%s): %m", filename);
  921. goto end;
  922.     }
  924.     size = sb.st_size;
  925.     
  926.     if ((buf = (char *)malloc((size+1)*sizeof(char))) == NULL) {
  927. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Config: Error allocating space for config file (%s): %m", filename);
  928. goto end;
  929.     }
  930.     
  931.     if ((size = READFILE(fd, buf, size)) < 0) {
  932. S5LogUpdate(S5LogDefaultHandle, S5_LOG_ERROR, 0, "Config: Error reading open config file (%s): %m", filename);
  933. free(buf);
  934. buf = NULL;
  935.     } else {
  936. buf[size] = '';
  937. *sizep = size;
  938.     }
  940.   end:
  941.     REAL(close)(fd);
  942.     return buf;
  943. }
  945. /* ReadConfig() reads the configuration file specified by SRVCONF_FILE.  It  */
  946. /* first figures out how much memory it will need, allocates the memory,     */
  947. /* reads in the array, counts the number of entries of each type, and        */
  948. /* allocates (or reallocates) the appropriate arrays those entries are kept  */
  949. /* in.  After all that, it actually reads in the entries themselves (from    */
  950. /* memory) and rstarts the logging in case its variables may have changed.   */
  951. /*                                                                           */
  952. /* Globals Affected: -- too many to list... big ones are...                  */
  953. /*                   -- confids, where the entries are stored.               */
  954. /*                   -- environ, which may have new entries in it...         */
  955. void lsReadConfig(const char *filename, confid *confids, int nids) {
  956.     int i, fsize;
  957.     char *buf;
  959.     if ((buf = ReadConfigFile(filename, &fsize)) == NULL) return; /* read in */
  960.     LoopThroughFile(buf, fsize, confids, nids, ClassifyLine);     /* count   */
  962.     for (i = 0; i < nids; i++) if (confids[i].size > 0) {
  963. *confids[i].array = (void *)remalloc(*confids[i].array, *confids[i].number * confids[i].size);
  964. memset(*confids[i].array, 0, *confids[i].number * confids[i].size);
  965.     }
  967.     LoopThroughFile(buf, fsize, confids, nids, ProcessLine);      /* process */
  968.     free(buf);
  969. }
  971. /* check out interface's condition                                           */
  972. int lsLookupIntfc(S5IOHandle sd, int query, struct ifreq *ifr) {
  973.     int rval = -1;
  974.     S5IOHandle osd = (sd != S5InvalidIOHandle)?sd:socket(AF_INET, SOCK_DGRAM, 0);
  975.     if (osd == S5InvalidIOHandle) return rval;
  977.     memset((char *)&ifr->ifr_ifru, 0, sizeof(ifr->ifr_ifru));
  979.     switch (query) {
  980.     case NET_STAT:
  981.         if (ioctl(osd, SIOCGIFFLAGS, (char *)ifr) == 0) {
  982.          if (!(ifr->ifr_flags & (IFF_UP | IFF_RUNNING))) {
  983.         rval = 0;
  984.     } else rval = 1;
  985. }
  986. break;
  987.     case NET_TYPE:
  988.         if (ioctl(osd, SIOCGIFFLAGS, (char *)ifr) == 0) {
  989.             if ((ifr->ifr_flags & IFF_POINTOPOINT)) rval = 1;
  990.             else rval = 0;
  991.         }
  992.         break;
  993.     case NET_ADDR:
  994. #ifdef linux
  995.         ((struct sockaddr *)&ifr->ifr_addr)->sa_family = AF_INET;
  996. #endif
  997.      if (ioctl(osd, RSIOCGIFADDR, (char *)ifr) == 0) rval = 0;
  998. break;
  999.     case NET_MASK:
  1000.      if (ioctl(osd, RSIOCGIFNETMASK, (char *)ifr) == 0) rval = 0;
  1001. break;
  1002.     default:
  1003. break;
  1004.     }
  1006.     if (sd == S5InvalidIOHandle && osd != S5InvalidIOHandle) CLOSESOCKET(osd);
  1007.     return rval;
  1008. }
  1010. /* Get a list of valid interfaces...                                         */
  1011. void lsSetupIntfcs(struct intfc **intfc, int *cnt) { 
  1012. #ifdef HAVE_GETIFADDRS
  1013.     struct ifaddrs *ifp, *ibuf = NULL;
  1014. #else
  1015.     struct ifreq ibuf[1024];
  1016.     struct ifconf ifc;
  1017.     S5IOHandle s;
  1018. #endif
  1019.     struct intfc *pintfc;
  1020.     struct intaddr *pintaddr;
  1021.     struct in_addr tmpaddr;
  1022.     char tmpname[16];
  1023.     int i, j, k, m, n;
  1025.     if (*intfc) {
  1026. if (intfc[0]->addrlist) free(intfc[0]->addrlist);
  1027.         free(*intfc);
  1028.         *intfc = NULL;
  1029.     }
  1030.     *cnt = 0;
  1032. #ifdef HAVE_GETIFADDRS
  1033.     if (getifaddrs(&ibuf) < 0 || !ibuf) {
  1034.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(0), 0, "Interface Query: Error looking up interface names");
  1035.         return;
  1036.     }
  1037.     n = 0;
  1038.     strcpy(tmpname, ibuf->ifa_name);
  1039. #else
  1040.     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == S5InvalidIOHandle) {
  1041.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(0), 0, "Interface Query: socket: %m");
  1042.         return;
  1043.     }
  1045.     ifc.ifc_len = sizeof(ibuf);
  1046.     ifc.ifc_buf = (caddr_t)ibuf;
  1048.     memset((char *)ibuf, 0, sizeof(ibuf));
  1050.     /* Get the list of all the interfaces...                                */
  1051.     if (ioctl(s, RSIOCGIFCONF, (char *)&ifc) < 0 || ifc.ifc_len < sizeof(struct ifreq)) {
  1052. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(0), 0, "Interface Query: Error looking up interface names");
  1053. CLOSESOCKET(s);
  1054. return;
  1055.     }
  1057.     n = ifc.ifc_len/sizeof(struct ifreq);
  1058.     if (n > 0) strcpy(tmpname, ibuf[0].ifr_name);
  1059. #endif
  1061.     /* Walk through the list and count the interfaces that are configured   */
  1062.     /* with IP...                                                           */
  1063.     i = 0; j = 0; k = 0;
  1064.     tmpaddr.s_addr = 0L;
  1066. #ifdef HAVE_GETIFADDRS
  1067.     for (ifp = ibuf; ifp; ifp = ifp->ifa_next) {
  1068.         if (strcmp(tmpname, ifp->ifa_name)) {
  1069.             if (n) j++;
  1070.             n = 0;
  1071.             strcpy(tmpname, ifp->ifa_name);
  1072.         }
  1074.         i = (ifp->ifa_flags & (IFF_UP | IFF_RUNNING))?1:0;
  1075.         if (i && ifp->ifa_addr->sa_family != AF_INET) continue;
  1076.         if (!i && !(ifp->ifa_flags & IFF_POINTOPOINT)) continue;
  1077.         n = 1;
  1078.         if (!i || ifassi(ifp->ifa_addr) == 0L) continue;
  1079.         if (k > 0 && ifassi(ifp->ifa_addr) == tmpaddr.s_addr) continue;
  1081.         tmpaddr.s_addr = ifassi(ifp->ifa_addr);
  1082.         k++;
  1083.     }
  1084.     if (n) j++;
  1085. #else
  1086.     for (; i < n; i++) {
  1087. if (strcmp(tmpname, ibuf[i].ifr_name)) {
  1088.     j++;
  1089.     strcpy(tmpname, ibuf[i].ifr_name);
  1090. }
  1092. if (lsLookupIntfc(s, NET_ADDR, &ibuf[i]) < 0) continue;
  1093. if (ifssi(ibuf[i])->sin_family != AF_INET) continue;
  1094. if (k > 0 && tmpaddr.s_addr == ifssi(ibuf[i])->sin_addr.s_addr) continue;
  1096. tmpaddr.s_addr = ifssi(ibuf[i])->sin_addr.s_addr;
  1097. k++;
  1098.     }
  1099.     j++;
  1100. #endif
  1102.     if ((pintfc = (struct intfc *)calloc(j, sizeof(struct intfc))) == NULL) {
  1103. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(0), 0, "Interface Query: no space");
  1104. return;
  1105.     }
  1107.     if ((pintaddr = (struct intaddr *)calloc(k, sizeof(struct intaddr))) == NULL) {
  1108. S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(0), 0, "Interface Query: no space");
  1109. free(pintfc);
  1110. return;
  1111.     }
  1113.     /* Store IP-configured interfaces information...                        */
  1114.     i = 0; j = 0; k = 0;
  1115. #ifdef HAVE_GETIFADDRS
  1116.     strcpy(pintfc[j].name, ibuf->ifa_name);
  1117.     pintfc[j].up = (ibuf->ifa_flags & (IFF_UP | IFF_RUNNING))?1:0;
  1118.     pintfc[j].type = (ibuf->ifa_flags & IFF_POINTOPOINT)?1:0;
  1119.     pintfc[j].addrlist = &pintaddr[k];
  1120.     pintfc[j].addrcnt = 0;
  1121.     n = 0;
  1122.     m = 0;
  1124.     for (ifp = ibuf; ifp; ifp = ifp->ifa_next) {
  1125.         if (strcmp(pintfc[j].name, ifp->ifa_name)) {
  1126.             pintfc[j].addrcnt = m;
  1127.             S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Interface Query: if%d is %s(%d) with %d IPs", j, pintfc[j].name, pintfc[j].up, m);
  1128.             if (n) j++;
  1129.             strcpy(pintfc[j].name, ifp->ifa_name);
  1130.             pintfc[j].up = (ifp->ifa_flags & (IFF_UP | IFF_RUNNING))?1:0;
  1131.             pintfc[j].type = (ifp->ifa_flags & IFF_POINTOPOINT)?1:0;
  1132.             pintfc[j].addrlist = &pintaddr[k];
  1133.             pintfc[j].addrcnt = 0;
  1134.             n = 0;
  1135.             m = 0;
  1136.         }
  1138.         if (pintfc[j].up && ifp->ifa_addr->sa_family != AF_INET) continue;
  1139.         if (!pintfc[j].up && !pintfc[j].type) continue;
  1140.         n = 1;
  1141.         if (!pintfc[j].up || ifassi(ifp->ifa_addr) == 0L) continue;
  1142.         if (k > 0 && ifassi(ifp->ifa_addr) == pintaddr[k-1].ip.s_addr) continue;
  1144.         pintaddr[k].ip.s_addr = ifassi(ifp->ifa_addr);
  1145.         pintaddr[k].net.s_addr = ifassi(ifp->ifa_netmask);
  1147.         m++; k++;
  1149.         S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Interface Query: if%d addr/mask is %08x:%08x", j, pintaddr[k-1].ip.s_addr, pintaddr[k-1].net.s_addr);
  1150.     }
  1152.     pintfc[j].addrcnt = m;
  1153.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Interface Query: if%d is %s(%d) with %d IPs", j, pintfc[j].name, pintfc[j].up, m);
  1155.     if (n) j++;
  1156.     *cnt = j;
  1157.     *intfc = pintfc;
  1159.     free(ibuf);
  1160. #else
  1161.     strcpy(pintfc[j].name, ibuf[i].ifr_name);
  1162.     pintfc[j].up = lsLookupIntfc(s, NET_STAT, &ibuf[i]);
  1163.     pintfc[j].type = lsLookupIntfc(s, NET_TYPE, &ibuf[i]);
  1164.     pintfc[j].addrlist = &pintaddr[k];
  1165.     pintfc[j].addrcnt = 0;
  1166.     m = 0;
  1168.     for (; i < n; i++) {
  1169. if (strcmp(pintfc[j].name, ibuf[i].ifr_name)) {
  1170.     pintfc[j].addrcnt = m;
  1171.          S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Interface Query: if%d is %s(%d) with %d IPs", j, pintfc[j].name, pintfc[j].up, m);
  1172.     j++;
  1173.     strcpy(pintfc[j].name, ibuf[i].ifr_name);
  1174.     pintfc[j].up = lsLookupIntfc(s, NET_STAT, &ibuf[i]);
  1175.             pintfc[j].type = lsLookupIntfc(s, NET_TYPE, &ibuf[i]);
  1176.     pintfc[j].addrlist = &pintaddr[k];
  1177.     pintfc[j].addrcnt = 0;
  1178.     m = 0;
  1179. }
  1181. if (lsLookupIntfc(s, NET_ADDR, &ibuf[i]) < 0) continue;
  1182. if (ifssi(ibuf[i])->sin_family != AF_INET) continue;
  1183. if (k > 0 && pintaddr[k-1].ip.s_addr == ifssi(ibuf[i])->sin_addr.s_addr) continue;
  1185. pintaddr[k].ip.s_addr = ifssi(ibuf[i])->sin_addr.s_addr;
  1186. if (lsLookupIntfc(s, NET_MASK, &ibuf[i]) >= 0) {
  1187.     pintaddr[k].net.s_addr = ifssi(ibuf[i])->sin_addr.s_addr;
  1188. } else pintaddr[k].net.s_addr = 0xffffffff;
  1190. m++; k++;
  1192.      S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Interface Query: if%d addr/mask is %08x:%08x", j, pintaddr[k-1].ip.s_addr, pintaddr[k-1].net.s_addr);
  1193.     }
  1195.     pintfc[j].addrcnt = m;
  1196.     S5LogUpdate(S5LogDefaultHandle, S5_LOG_DEBUG(10), 0, "Interface Query: if%d is %s(%d) with %d IPs", j, pintfc[j].name, pintfc[j].up, m);
  1198.     *cnt = ++j;
  1199.     *intfc = pintfc;
  1201.     CLOSESOCKET(s);
  1202. #endif
  1203. }