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

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

代理服务器

开发平台：

Unix_Linux

support.c：源码内容
  1. /*                                                                           */
  2. /*  * Copyright (c) 1989, 1990, 1991 by the University of Washington         */
  3. /*  *                                                                        */
  4. /*  * For copying and distribution information, please see the file          */
  5. /*  * <copyright.h>.                                                         */
  7. /*  * Miscellaneous routines pulled from ~beta/lib/pfs and ~beta/lib/filters */
  9. #include "pmachine.h"
  10. #include <sys/file.h>
  12. #include "pfs.h"
  13. #include "pprot.h"
  14. #include "perrno.h"
  15. #include "pcompat.h"
  16. #include "pauthent.h"
  17. #include "regex.h"
  19. int pfs_enable = PMAP_ATSIGN;
  21. /*                                                                           */
  22. /*  * wcmatch - Match string s against template containing widlcards         */
  23. /*  *                                                                        */
  24. /*  * WCMATCH takes a string and a template, and returns                     */
  25. /*  * true if the string matches the template, and                           */
  26. /*  * FALSE otherwise.                                                       */
  27. /*  *                                                                        */
  28. /*  * ARGS: s - string to be tested                                          */
  29. /*  * template - Template containing optional wildcards                      */
  30. /*  *                                                                        */
  31. /*  * RETURNS: TRUE (non-zero) on match.  FALSE (0) otherwise.               */
  32. /*  *                                                                        */
  33. /*  * NOTE: If template is NULL, will return TRUE.                           */
  34. /*  *                                                                        */
  35. int
  36. wcmatch(s,template)
  37.     char *s;
  38.     char *template;
  39.     {
  40. char temp[200];
  41. char *p = temp;
  43. if(!template) return(TRUE);
  44. *p++ = '^';
  46. while(*template) {
  47.     if(*template == '*') {*(p++)='.'; *(p++) = *(template++);}
  48.     else if(*template == '?') {*(p++)='.';template++;}
  49.     else if(*template == '.') {*(p++)='\';*(p++)='.';template++;}
  50.     else if(*template == '[') {*(p++)='\';*(p++)='[';template++;}
  51.     else if(*template == '$') {*(p++)='\';*(p++)='$';template++;}
  52.     else if(*template == '^') {*(p++)='\';*(p++)='^';template++;}
  53.     else if(*template == '\') {*(p++)='\';*(p++)='\';template++;}
  54.     else *(p++) = *(template++);
  55. }
  56.     
  57. *p++ = '$';
  58. *p++ = '';
  60. if(re_comp(temp)) return(FALSE);
  62. #ifdef AUX
  63. if (re_exec(s) == (char *)NULL)
  64.   return 0;
  65. return 1;
  66. #else
  67. return(re_exec(s));
  68. #endif
  69.     }
  71. /*                                                                           */
  72. /*  * ul_insert - Insert a union link at the right location                  */
  73. /*  *                                                                        */
  74. /*  * UL_INSERT takes a directory and a union link to be added               */
  75. /*  * to a the list of union links in the directory.  It then                */
  76. /*  * inserts the union link in the right spot in the linked                 */
  77. /*  * list of union links associated with that directory.                    */
  78. /*  *                                                                        */
  79. /*  * If an identical link already exists, then the link which               */
  80. /*  * would be evaluated earlier (closer to the front of the list)           */
  81. /*  * wins and the other one is freed.  If this happens, an error            */
  82. /*  * will also be returned.                                                 */
  83. /*  *                                                                        */
  84. /*  * ARGS: ul - link to be inserted                                         */
  85. /*  * vd - directory to get link                                             */
  86. /*  * p - vl that this link will apper after                                 */
  87. /*  * NULL - This vl will go at end of list                                  */
  88. /*  * vd - This vl will go at head of list                                   */
  89. /*  *                                                                        */
  90. /*  * RETURNS: Success, or UL_INSERT_ALREADY_THERE or UL_INSERT_SUPERSEDING  */
  91. int
  92. ul_insert(ul,vd,p)
  93.     VLINK ul; /* Link to be inserted                       */
  94.     PVDIR vd; /* Directory to receive link                 */
  95.     VLINK p; /* Union link to appear prior to new one     */
  96.     {
  97. VLINK current;
  99. /* This is the first ul in the directory                             */
  100. if(vd->ulinks == NULL) {
  101.     vd->ulinks = ul;
  102.     ul->previous = NULL;
  103.     ul->next = NULL;
  104.     return(PSUCCESS);
  105. }
  107. /* This ul will go at the head of the list                           */
  108. if(p == (VLINK) vd) {
  109.     ul->next = vd->ulinks;
  110.     ul->next->previous = ul;
  111.     vd->ulinks = ul;
  112.     ul->previous = NULL;
  113. }
  114. /* Otherwise, decide if it must be inserted at all If an identical   */
  115. /* link appears before the position at which the new one is to be    */
  116. /* inserted, we can return without inserting it                      */
  117. else {
  118.     current = vd->ulinks;
  120.     while(current) {
  121. /* p == NULL means we insert after last link                 */
  122. if(!p && (current->next == NULL))
  123.     p = current;
  125. if(vl_comp(current,ul) == 0) {
  126.     vlfree(ul);
  127.     return(UL_INSERT_ALREADY_THERE);
  128. }
  130. if(current == p) break;
  131. current = current->next;
  132.     }
  134.     /* If current is null, p was not found                           */
  135.     if(current == NULL)
  136. return(UL_INSERT_POS_NOTFOUND);
  138.     /* Insert ul                                                     */
  139.     ul->next = p->next;
  140.     p->next = ul;
  141.     ul->previous = p;
  142.     if(ul->next) ul->next->previous = ul;
  143. }
  145. /* Check for identical links after ul                                */
  146. current = ul->next;
  148. while(current) {
  149.     if(vl_comp(current,ul) == 0) {
  150. current->previous->next = current->next;
  151. if(current->next)
  152.     current->next->previous = current->previous;
  153. vlfree(current);
  154. return(UL_INSERT_SUPERSEDING);
  155.     }
  156.     current = current->next;
  157. }
  159. return(PSUCCESS);
  160.     }
  162. /*                                                                           */
  163. /*  * vl_insert - Insert a directory link at the right location              */
  164. /*  *                                                                        */
  165. /*  * VL_INSERT takes a directory and a link to be added to a                */
  166. /*  * directory and inserts it in the linked list of links for               */
  167. /*  * that directory.                                                        */
  168. /*  *                                                                        */
  169. /*  * If a link already exists with the same name, and if the                */
  170. /*  * information associated with the new link matches that in               */
  171. /*  * the existing link, an error is returned.  If the information           */
  172. /*  * associated with the new link is different, but the magic numbers       */
  173. /*  * match, then the new link will be added as a replica of the             */
  174. /*  * existing link.  If the magic numbers do not match, the new             */
  175. /*  * link will only be added to the list of "replicas" if the               */
  176. /*  * allow_conflict flag has been set.                                      */
  177. /*  *                                                                        */
  178. /*  * If the link is not added, an error is returned and the link            */
  179. /*  * is freed.  Ordering for the list of links is by the link name.         */
  180. /*  *                                                                        */
  181. /*  * If vl is a union link, then VL_INSERT calls ul_insert with an          */
  182. /*  * added argument indicating the link is to be included at the            */
  183. /*  * end of the union link list.                                            */
  184. /*  *                                                                        */
  185. /*  * ARGS: vl - Link to be inserted, vd - directory to get link             */
  186. /*  * allow_conflict - insert links with conflicting names                   */
  187. /*  *                                                                        */
  188. /*  * RETURNS: Success, or VL_INSERT_ALREADY_THERE                           */
  189. int
  190. vl_insert(vl,vd,allow_conflict)
  191.     VLINK vl; /* Link to be inserted                       */
  192.     PVDIR vd; /* Directory to receive link                 */
  193.     int allow_conflict; /* Allow duplicate names                     */
  194.     {
  195. VLINK current; /* To step through list                      */
  196. VLINK crep; /* To step through list of replicas          */
  197. int retval; /* Temp for checking returned values         */
  199. /* This can also be used to insert union links at end of list        */
  200. if(vl->linktype == 'U') return(ul_insert(vl,vd,NULL));
  202. /* If this is the first link in the directory                        */
  203. if(vd->links == NULL) {
  204.     vd->links = vl;
  205.     vl->previous = NULL;
  206.     vl->next = NULL;
  207.     vd->lastlink = vl;
  208.     return(PSUCCESS);
  209. }
  211. /* If no sorting is to be done, just insert at end of list           */
  212. if(allow_conflict == VLI_NOSORT) {
  213.     vd->lastlink->next = vl;
  214.     vl->previous = vd->lastlink;
  215.     vl->next = NULL;
  216.     vd->lastlink = vl;
  217.     return(PSUCCESS);
  218. }
  220. /* If it is to be inserted at start of list                          */
  221. if(vl_comp(vl,vd->links) < 0) {
  222.     vl->next = vd->links;
  223.     vl->previous = NULL;
  224.     vl->next->previous = vl;
  225.     vd->links = vl;
  226.     return(PSUCCESS);
  227. }
  229. current = vd->links;
  231. /* Otherwise, we must find the right spot to insert it               */
  232. while((retval = vl_comp(vl,current)) > 0) {
  233.     if(!current->next) {
  234. /* insert at end */
  235. vl->previous = current;
  236. vl->next = NULL;
  237. current->next = vl;
  238. vd->lastlink = vl;
  239. return(PSUCCESS);
  240.     }
  241.     current = current->next;
  242. }
  244. /* If we found an equivilant entry already in list                   */
  245. if(!retval) {
  246.     if(vl_equal(vl,current)) {
  247. vlfree(vl);
  248. return(VL_INSERT_ALREADY_THERE);
  249.     }
  250.     if((allow_conflict == VLI_NOCONFLICT) &&
  251.        ((vl->f_magic_no != current->f_magic_no) ||
  252. (vl->f_magic_no==0)))
  253. return(VL_INSERT_CONFLICT);
  254.     /* Insert the link into the list of "replicas" If magic is 0,    */
  255.     /* then create a pseudo magic number                             */
  256.     if(vl->f_magic_no == 0) vl->f_magic_no = -1;
  257.     crep = current->replicas;
  258.     if(!crep) {
  259. current->replicas = vl;
  260. vl->next = NULL;
  261. vl->previous = NULL;
  262.     }
  263.     else {
  264. while(crep->next) {
  265.     /* If magic was 0, then we need a unique magic number    */
  266.     if((crep->f_magic_no < 0) && (vl->f_magic_no < 1))
  267. (vl->f_magic_no)--;
  268.     crep = crep->next;
  269. }
  270. /* If magic was 0, then we need a unique magic number        */
  271. if((crep->f_magic_no < 0) && (vl->f_magic_no < 1))
  272.     (vl->f_magic_no)--;
  273. crep->next = vl;
  274. vl->previous = crep;
  275. vl->next = NULL;
  276.     }
  277.     return(PSUCCESS);
  278. }
  280. /* We found the spot where vl is to be inserted                      */
  281. vl->next = current;
  282. vl->previous = current->previous;
  283. current->previous = vl;
  284. vl->previous->next = vl;
  285. return(PSUCCESS);
  286.     }
  288. /*                                                                           */
  289. /*  * nlsindex - Find first instance of string 2 in string 1 following       */
  290. /* newline                                                                   */
  291. /*  *                                                                        */
  292. /*  * NLSINDEX scans string 1 for the first instance of string               */
  293. /*  * 2 that immediately follows a newline.  If found, NLSINDEX              */
  294. /*  * returns a pointer to the first character of that instance.             */
  295. /*  * If no instance is found, NLSINDEX returns NULL (0).                    */
  296. /*  *                                                                        */
  297. /*  * NOTE: This function is only useful for searching strings that          */
  298. /*  * consist of multiple lines.  s1 is assumed to be preceeded              */
  299. /*  * by a newline.  Thus, if s2 is at the start of s1, it will              */
  300. /*  * be found.                                                              */
  301. /*  * ARGS: s1 - string to be searched                                       */
  302. /*  * s2 - string to be found                                                */
  303. /*  * RETURNS: First instance of s2 in s1, or NULL (0) if not found          */
  304. char *
  305. nlsindex(s1,s2)
  306.     char *s1; /* String to be searched                     */
  307.     char *s2; /* String to be found                        */
  308.     {
  309. register int s2len = strlen(s2);
  310. char *curline = s1; /* Pointer to start of current line          */
  312. /* In case s2 appears at start of s1                                 */
  313. if(strncmp(curline,s2,s2len) == 0)
  314.     return(curline);
  316. /* Check remaining lines of s1                                       */
  317. while((curline = (char *) index(curline,'n')) != NULL) {
  318.     curline++;
  319.     if(strncmp(curline,s2,s2len) == 0)
  320. return(curline);
  321. }
  323. /* We didn't find it                                                 */
  324. return(NULL);
  325.     }
  327. /*                                                                           */
  328. /*  * month_sname - Return a month name from it's number                     */
  329. /*  *                                                                        */
  330. /*  * MONTH_SNAME takes a number in the range 0                              */
  331. /*  * to 12 and returns a pointer to a string                                */
  332. /*  * representing the three letter abbreviation                             */
  333. /*  * for that month.  If the argument is out of                             */
  334. /*  * range, MONTH_SNAME returns a pointer to "Unk".                         */
  335. /*  *                                                                        */
  336. /*  * ARGS: n - Number of the month                                          */
  337. /*  * RETURNS: Abbreviation for selected month                               */
  338. char *month_sname(n)
  339.     int n; /* Month number */
  340. {
  341.     static char *name[] = { "Unk",
  342.         "Jan","Feb","Mar","Apr","May","Jun",
  343.         "Jul","Aug","Sep","Oct","Nov","Dec"
  344.     };
  345.     return((n < 1 || n > 12) ? name[0] : name[n]);
  346. }
  348. /*                                                                           */
  349. /*  * sindex - Find first instance of string 2 in string 1                   */
  350. /*  *                                                                        */
  351. /*  * SINDEX scans string 1 for the first instance of string                 */
  352. /*  * 2.  If found, SINDEX returns a pointer to the first                    */
  353. /*  * character of that instance.  If no instance is found,                  */
  354. /*  * SINDEX returns NULL (0).                                               */
  355. /*  *                                                                        */
  356. /*  * ARGS: s1 - string to be searched                                       */
  357. /*  * s2 - string to be found                                                */
  358. /*  * RETURNS: First instance of s2 in s1, or NULL (0) if not found          */
  359. char *
  360. sindex(s1,s2)
  361.     char *s1; /* String to be searched                     */
  362.     char *s2; /* String to be found                        */
  363.     {
  364. register int s2len = strlen(s2);
  365. char *s = s1; /* Temp pointer to string                    */
  367. /* Check for first character of s2                                   */
  368. while((s = (char *) index(s,*s2)) != NULL) {
  369.     if(strncmp(s,s2,s2len) == 0)
  370. return(s);
  371.     s++;
  372. }
  374. /* We didn't find it                                                 */
  375. return(NULL);
  376.     }
  378. int
  379. scan_error(erst)
  380.     char *erst;
  381.     {
  382. *p_err_string = '';
  384. if(strncmp(erst,"NOT-A-DIRECTORY",15) == 0) 
  385.     return(DIRSRV_NOT_DIRECTORY);
  387. if(strncmp(erst,"UNIMPLEMENTED",13) == 0) {
  388.     perrno = DIRSRV_UNIMPLEMENTED;
  389.     sscanf(erst+13,"%*[^n tr]%*[ t]%[^n]",p_err_string);
  390.     return(perrno);
  391. }
  393. if(strncmp(erst,"WARNING ",8) == 0) {
  394.     erst += 8;
  395.     *p_warn_string = '';
  396.     sscanf(erst,"%*[^n tr]%*[ t]%[^n]",p_warn_string);
  397.     /* Return values for warnings are negative */
  398.     if(strncmp(erst,"OUT-OF-DATE",11) == 0) {
  399. pwarn = PWARN_OUT_OF_DATE;
  400. return(PSUCCESS);
  401.     }
  402.     if(strncmp(erst,"MESSAGE",7) == 0) {
  403. pwarn = PWARN_MSG_FROM_SERVER;
  404. return(PSUCCESS);
  405.     }
  406.     pwarn = PWARNING;
  407.     sscanf(erst,"%[^n]",p_warn_string);
  408.     return(PSUCCESS);
  409. }
  410. else if(strncmp(erst,"ERROR",5) == 0) {
  411.     if(*(erst+5)) sscanf(erst+6,"%[^n]",p_err_string);
  412.     perrno = DIRSRV_ERROR;
  413.     return(perrno);
  414. }
  415. /* The rest start with "FAILURE" */
  416. else if(strncmp(erst,"FAILURE",7) != 0) {
  417.     /* Unrecognized - Give warning, but return PSUCCESS */
  418.     if(pwarn == 0) {
  419. *p_warn_string = '';
  420. pwarn = PWARN_UNRECOGNIZED_RESP;
  421. sscanf(erst,"%[^n]",p_warn_string);
  422.     }
  423.     return(PSUCCESS);
  424. }
  426. if(strncmp(erst,"FAILURE ",8) != 0) {
  427.     perrno = PFAILURE;
  428.     return(perrno);
  429. }
  430. erst += 8;
  432. sscanf(erst,"%*[^n tr]%*[ t]%[^n]",p_err_string);
  434. /* Still to add               */
  435. /* DIRSRV_AUTHENT_REQ     242 */
  436. /* DIRSRV_BAD_VERS        245 */
  438. if(strncmp(erst,"NOT-FOUND",9) == 0) 
  439.     perrno = DIRSRV_NOT_FOUND;
  440. else if(strncmp(erst,"NOT-AUTHORIZED",13) == 0) 
  441.     perrno = DIRSRV_NOT_AUTHORIZED;
  442. else if(strncmp(erst,"ALREADY-EXISTS",14) == 0) 
  443.     perrno = DIRSRV_ALREADY_EXISTS;
  444. else if(strncmp(erst,"NAME-CONFLICT",13) == 0) 
  445.     perrno = DIRSRV_NAME_CONFLICT;
  446. else if(strncmp(erst,"SERVER-FAILED",13) == 0) 
  447.     perrno = DIRSRV_SERVER_FAILED;
  448.   /* Use it whether it starts with FAILURE or not */
  449. else if(strncmp(erst,"NOT-A-DIRECTORY",15) == 0) 
  450.     perrno = DIRSRV_NOT_DIRECTORY;
  451. else perrno = PFAILURE;
  453. return(perrno);
  454.     }
  456. PATTRIB 
  457. parse_attribute(line)
  458.     char *line;
  459.     {
  460. char l_precedence[MAX_DIR_LINESIZE];
  461. char l_name[MAX_DIR_LINESIZE];
  462. char l_type[MAX_DIR_LINESIZE];
  463. char l_value[MAX_DIR_LINESIZE];
  464. PATTRIB at;
  465. int tmp;
  467. tmp = sscanf(line,"OBJECT-INFO %s %s %[^n]", l_name, l_type, l_value);
  469. if(tmp < 3) {
  470.     tmp = sscanf(line,"LINK-INFO %s %s %s %[^n]", l_precedence,
  471.  l_name, l_type, l_value);
  472.     if(tmp < 4) {
  473. perrno = DIRSRV_BAD_FORMAT;
  474. return(NULL);
  475.     }
  476. }
  478. at = atalloc();
  480. if(tmp == 4) {
  481.     if(strcmp(l_precedence,"CACHED") == 0) 
  482. at->precedence = ATR_PREC_CACHED;
  483.     else if(strcmp(l_precedence,"LINK") == 0) 
  484. at->precedence = ATR_PREC_LINK;
  485.     else if(strcmp(l_precedence,"REPLACEMENT") == 0) 
  486. at->precedence = ATR_PREC_REPLACE;
  487.     else if(strcmp(l_precedence,"ADDITIONAL") == 0) 
  488. at->precedence = ATR_PREC_ADD;
  489. }
  491. at->aname = stcopy(l_name);
  492. at->avtype = stcopy(l_type);
  493. if(strcmp(l_type,"ASCII") == 0) 
  494.     at->value.ascii = stcopy(l_value);
  495. else if(strcmp(l_type,"LINK") == 0) {
  496.     char ftype[MAX_DIR_LINESIZE];
  497.     char lname[MAX_DIR_LINESIZE];
  498.     char htype[MAX_DIR_LINESIZE];
  499.     char host[MAX_DIR_LINESIZE];
  500.     char ntype[MAX_DIR_LINESIZE];
  501.     char fname[MAX_DIR_LINESIZE];
  502.     VLINK al;
  504.     al = vlalloc();
  505.     at->value.link = al;
  507.     tmp = sscanf(l_value,"%c %s %s %s %s %s %s %ld %ld",
  508.  &(al->linktype),
  509.  ftype,lname,htype,host,ntype,fname,
  510.  &(al->version),
  511.  &(al->f_magic_no));
  512.     if(tmp == 9) {
  513. al->type = stcopyr(ftype,al->type);
  514. al->name = stcopyr(unquote(lname),al->name);
  515. al->hosttype = stcopyr(htype,al->hosttype);
  516. al->host = stcopyr(host,al->host);
  517. al->nametype = stcopyr(ntype,al->nametype);
  518. al->filename = stcopyr(fname,al->filename);
  519.     }
  520.     else {
  521. perrno = DIRSRV_BAD_FORMAT;
  522. return(NULL);
  523.     }
  524.     
  525. }
  527. return(at);
  528.     }
  530. /*                                                                           */
  531. /*  * nxtline - Find the next line in the string                             */
  532. /*  *                                                                        */
  533. /*  * NXTLINE takes a string and returns a pointer to                        */
  534. /*  * the character immediately following the next newline.                  */
  535. /*  *                                                                        */
  536. /*  * ARGS: s - string to be searched                                        */
  537. /*  *                                                                        */
  538. /*  * RETURNS: Next line or NULL (0) on failure                              */
  539. char *
  540. nxtline(s)
  541.     char *s; /* String to be searched */
  542.  {
  543. s = (char *) index(s,'n');
  544. if(s) return(++s);
  545. else return(NULL);
  546.     }
  549. /*                                                                           */
  550. /*  * unquote - unquote string if necessary                                  */
  551. /*  *                                                                        */
  552. /*  * UNQUOTE takes a string and unquotes it if it has been quoted.          */
  553. /*  *                                                                        */
  554. /*  * ARGS: s - string to be unquoted                                        */
  555. /*  *                                                                        */
  556. /*  * RETURNS: The original string.  If the string has been quoted, then the */
  557. /*  * result appears in static storage, and must be copied if                */
  558. /*  * it is to last beyond the next call to quote.                           */
  559. /*  *                                                                        */
  560. char *
  561. unquote(s)
  562.     char *s; /* String to be quoted */
  563.     {
  564. static char unquoted[200];
  565. char *c = unquoted;
  567. if(*s != ''') return(s);
  569. s++;
  571. /* This should really treat a quote followed by other */
  572. /* than a quote or a null as an error                 */
  573. while(*s) {
  574.     if(*s == ''') s++;
  575.     if(*s) *c++ = *s++;
  576. }
  578. *c++ = '';
  580. return(unquoted);
  581.     }
  583. #if defined(DEBUG) && !defined(HAVE_STRSPN)
  584. /* needed for -D option parsing                                              */
  585. /*                                                                           */
  586. /*  * strspn - Count initial characters from chrs in s                       */
  587. /*  *                                                                        */
  588. /*  * STRSPN counts the occurances of chacters from chrs                     */
  589. /*  * in the string s preceeding the first occurance of                      */
  590. /*  * a character not in s.                                                  */
  591. /*  *                                                                        */
  592. /*  * ARGS: s - string to be checked                                         */
  593. /*  * chrs - string of characters we are looking for                         */
  594. /*  *                                                                        */
  595. /*  * RETURNS: Count of initial characters from chrs in s                    */
  596. strspn(s,chrs)
  597.     char *s;    /* String to search                         */
  598.     char *chrs; /* String of characters we are looking for  */
  599.     {
  600. char *cp;   /* Pointer to the current character in chrs */
  601. int count; /* Count of characters seen so far          */
  603. count = 0;
  605. while(*s) {
  606.     for(cp = chrs;*cp;cp++)
  607. if(*cp == *s) {
  608.     s++;
  609.     count++;
  610.     goto done;
  611. }
  612.     return(count);
  613. done:
  614.     ;
  615. }
  616. return(count);
  617.     }
  618. #endif
  620. #ifndef HAVE_GETENV
  621. /*                                                                           */
  622. /*  * Copyright (c) 1987 Regents of the University of California.            */
  623. /*  * All rights reserved.                                                   */
  624. /*  *                                                                        */
  625. /*  * Redistribution and use in source and binary forms are permitted        */
  626. /*  * provided that: (1) source distributions retain this entire copyright   */
  627. /*  * notice and comment, and (2) distributions including binaries display   */
  628. /*  * the following acknowledgement: ``This product includes software        */
  629. /*  * developed by the University of California, Berkeley and its            */
  630. /* contributors''                                                            */
  631. /*  * in the documentation or other materials provided with the distribution */
  632. /*  * and in all advertising materials mentioning features or use of this    */
  633. /*  * software. Neither the name of the University nor the names of its      */
  634. /*  * contributors may be used to endorse or promote products derived        */
  635. /*  * from this software without specific prior written permission.          */
  636. /*  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR         */
  637. /*  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED         */
  638. /*  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.    */
  640. #if defined(LIBC_SCCS) && !defined(lint)
  641. static char sccsid[] = "@(#)getenv.c 5.7 (Berkeley) 6/1/90";
  642. #endif /* LIBC_SCCS and not lint */
  644. #include <stdlib.h>
  645. #include <stddef.h>
  647. /*                                                                           */
  648. /*  * getenv --                                                              */
  649. /*  * Returns ptr to value associated with name, if any, else NULL.          */
  650. char *
  651. getenv(name)
  652. const char *name;
  653. {
  654. int offset;
  655. char *_findenv();
  657. return(_findenv(name, &offset));
  658. }
  660. /*                                                                           */
  661. /*  * _findenv --                                                            */
  662. /*  * Returns pointer to value associated with name, if any, else NULL.      */
  663. /*  * Sets offset to be the offset of the name/value combination in the      */
  664. /*  * environmental array, for use by setenv(3) and unsetenv(3).             */
  665. /*  * Explicitly removes '=' in argument name.                               */
  666. /*  *                                                                        */
  667. /*  * This routine *should* be a static; don't use it.                       */
  668. char *
  669. _findenv(name, offset)
  670. register const char *name;
  671. int *offset;
  672. {
  673. extern char **environ;
  674. register int len;
  675. register const char *C;
  676. register char **P;
  678. for (C = name, len = 0; *C && *C != '='; ++C, ++len);
  679. for (P = environ; *P; ++P)
  680. if (!strncmp(*P, name, len))
  681. if (*(C = *P + len) == '=') {
  682. *offset = P - environ;
  683. return(++C);
  684. }
  685. return(NULL);
  686. }
  687. #endif