getservice.c 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285
  1. /*
  2. ** services.c /etc/services access functions
  3. **
  4. ** This file is part of the NYS Library.
  5. **
  6. ** The NYS Library is free software; you can redistribute it and/or
  7. ** modify it under the terms of the GNU Library General Public License as
  8. ** published by the Free Software Foundation; either version 2 of the
  9. ** License, or (at your option) any later version.
  10. **
  11. ** The NYS Library is distributed in the hope that it will be useful,
  12. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. ** Library General Public License for more details.
  15. **
  16. ** You should have received a copy of the GNU Library General Public
  17. ** License along with the NYS Library; see the file COPYING.LIB. If
  18. ** not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  19. ** Cambridge, MA 02139, USA.
  20. **
  21. **
  22. ** Copyright (c) 1983 Regents of the University of California.
  23. ** All rights reserved.
  24. **
  25. ** Redistribution and use in source and binary forms, with or without
  26. ** modification, are permitted provided that the following conditions
  27. ** are met:
  28. ** 1. Redistributions of source code must retain the above copyright
  29. ** notice, this list of conditions and the following disclaimer.
  30. ** 2. Redistributions in binary form must reproduce the above copyright
  31. ** notice, this list of conditions and the following disclaimer in the
  32. ** documentation and/or other materials provided with the distribution.
  33. ** 3. All advertising materials mentioning features or use of this software
  34. ** must display the following acknowledgement:
  35. ** This product includes software developed by the University of
  36. ** California, Berkeley and its contributors.
  37. ** 4. Neither the name of the University nor the names of its contributors
  38. ** may be used to endorse or promote products derived from this software
  39. ** without specific prior written permission.
  40. **
  41. ** THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  42. ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43. ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44. ** ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  45. ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46. ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47. ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48. ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49. ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50. ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51. ** SUCH DAMAGE.
  52. */
  53. #define __FORCE_GLIBC
  54. #include <features.h>
  55. #include <sys/types.h>
  56. #include <sys/socket.h>
  57. #include <netdb.h>
  58. #include <stdio.h>
  59. #include <string.h>
  60. #include <stdlib.h>
  61. #include <netinet/in.h>
  62. #include <arpa/inet.h>
  63. #include <errno.h>
  64. #include <unistd.h>
  65. /* Experimentally off - libc_hidden_proto(strcmp) */
  66. /* Experimentally off - libc_hidden_proto(strpbrk) */
  67. libc_hidden_proto(fopen)
  68. libc_hidden_proto(fclose)
  69. libc_hidden_proto(atoi)
  70. libc_hidden_proto(rewind)
  71. libc_hidden_proto(fgets)
  72. libc_hidden_proto(abort)
  73. #include <bits/uClibc_mutex.h>
  74. __UCLIBC_MUTEX_STATIC(mylock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
  75. #define MAXALIASES 35
  76. #define SBUFSIZE (BUFSIZ + 1 + (sizeof(char *) * MAXALIASES))
  77. static FILE *servf = NULL;
  78. static struct servent serv;
  79. static char *servbuf = NULL;
  80. static smallint serv_stayopen;
  81. static void __initbuf(void)
  82. {
  83. if (!servbuf) {
  84. servbuf = malloc(SBUFSIZE);
  85. if (!servbuf)
  86. abort();
  87. }
  88. }
  89. libc_hidden_proto(setservent)
  90. void setservent(int f)
  91. {
  92. __UCLIBC_MUTEX_LOCK(mylock);
  93. if (servf == NULL)
  94. servf = fopen(_PATH_SERVICES, "r" );
  95. else
  96. rewind(servf);
  97. if (f) serv_stayopen = 1;
  98. __UCLIBC_MUTEX_UNLOCK(mylock);
  99. }
  100. libc_hidden_def(setservent)
  101. libc_hidden_proto(endservent)
  102. void endservent(void)
  103. {
  104. __UCLIBC_MUTEX_LOCK(mylock);
  105. if (servf) {
  106. fclose(servf);
  107. servf = NULL;
  108. }
  109. serv_stayopen = 0;
  110. __UCLIBC_MUTEX_UNLOCK(mylock);
  111. }
  112. libc_hidden_def(endservent)
  113. libc_hidden_proto(getservent_r)
  114. int getservent_r(struct servent * result_buf,
  115. char * buf, size_t buflen,
  116. struct servent ** result)
  117. {
  118. char *p;
  119. register char *cp, **q;
  120. char **serv_aliases;
  121. char *line;
  122. int rv;
  123. *result=NULL;
  124. if (buflen < sizeof(*serv_aliases)*MAXALIASES) {
  125. errno=ERANGE;
  126. return errno;
  127. }
  128. __UCLIBC_MUTEX_LOCK(mylock);
  129. serv_aliases=(char **)buf;
  130. buf+=sizeof(*serv_aliases)*MAXALIASES;
  131. buflen-=sizeof(*serv_aliases)*MAXALIASES;
  132. if (buflen < BUFSIZ+1) {
  133. errno=rv=ERANGE;
  134. goto DONE;
  135. }
  136. line=buf;
  137. buf+=BUFSIZ+1;
  138. buflen-=BUFSIZ+1;
  139. if (servf == NULL && (servf = fopen(_PATH_SERVICES, "r" )) == NULL) {
  140. errno=rv=EIO;
  141. goto DONE;
  142. }
  143. again:
  144. if ((p = fgets(line, BUFSIZ, servf)) == NULL) {
  145. errno=rv=EIO;
  146. goto DONE;
  147. }
  148. if (*p == '#')
  149. goto again;
  150. cp = strpbrk(p, "#\n");
  151. if (cp == NULL)
  152. goto again;
  153. *cp = '\0';
  154. result_buf->s_name = p;
  155. p = strpbrk(p, " \t");
  156. if (p == NULL)
  157. goto again;
  158. *p++ = '\0';
  159. while (*p == ' ' || *p == '\t')
  160. p++;
  161. cp = strpbrk(p, ",/");
  162. if (cp == NULL)
  163. goto again;
  164. *cp++ = '\0';
  165. result_buf->s_port = htons((u_short)atoi(p));
  166. result_buf->s_proto = cp;
  167. q = result_buf->s_aliases = serv_aliases;
  168. cp = strpbrk(cp, " \t");
  169. if (cp != NULL)
  170. *cp++ = '\0';
  171. while (cp && *cp) {
  172. if (*cp == ' ' || *cp == '\t') {
  173. cp++;
  174. continue;
  175. }
  176. if (q < &serv_aliases[MAXALIASES - 1])
  177. *q++ = cp;
  178. cp = strpbrk(cp, " \t");
  179. if (cp != NULL)
  180. *cp++ = '\0';
  181. }
  182. *q = NULL;
  183. *result=result_buf;
  184. rv = 0;
  185. DONE:
  186. __UCLIBC_MUTEX_UNLOCK(mylock);
  187. return rv;
  188. }
  189. libc_hidden_def(getservent_r)
  190. struct servent * getservent(void)
  191. {
  192. struct servent *result;
  193. __initbuf();
  194. getservent_r(&serv, servbuf, SBUFSIZE, &result);
  195. return result;
  196. }
  197. libc_hidden_proto(getservbyname_r)
  198. int getservbyname_r(const char *name, const char *proto,
  199. struct servent * result_buf, char * buf, size_t buflen,
  200. struct servent ** result)
  201. {
  202. register char **cp;
  203. int ret;
  204. __UCLIBC_MUTEX_LOCK(mylock);
  205. setservent(serv_stayopen);
  206. while (!(ret=getservent_r(result_buf, buf, buflen, result))) {
  207. if (strcmp(name, result_buf->s_name) == 0)
  208. goto gotname;
  209. for (cp = result_buf->s_aliases; *cp; cp++)
  210. if (strcmp(name, *cp) == 0)
  211. goto gotname;
  212. continue;
  213. gotname:
  214. if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0)
  215. break;
  216. }
  217. if (!serv_stayopen)
  218. endservent();
  219. __UCLIBC_MUTEX_UNLOCK(mylock);
  220. return *result?0:ret;
  221. }
  222. libc_hidden_def(getservbyname_r)
  223. struct servent *getservbyname(const char *name, const char *proto)
  224. {
  225. struct servent *result;
  226. __initbuf();
  227. getservbyname_r(name, proto, &serv, servbuf, SBUFSIZE, &result);
  228. return result;
  229. }
  230. libc_hidden_proto(getservbyport_r)
  231. int getservbyport_r(int port, const char *proto,
  232. struct servent * result_buf, char * buf,
  233. size_t buflen, struct servent ** result)
  234. {
  235. int ret;
  236. __UCLIBC_MUTEX_LOCK(mylock);
  237. setservent(serv_stayopen);
  238. while (!(ret=getservent_r(result_buf, buf, buflen, result))) {
  239. if (result_buf->s_port != port)
  240. continue;
  241. if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0)
  242. break;
  243. }
  244. if (!serv_stayopen)
  245. endservent();
  246. __UCLIBC_MUTEX_UNLOCK(mylock);
  247. return *result?0:ret;
  248. }
  249. libc_hidden_def(getservbyport_r)
  250. libc_hidden_proto(getservbyport)
  251. struct servent * getservbyport(int port, const char *proto)
  252. {
  253. struct servent *result;
  254. __initbuf();
  255. getservbyport_r(port, proto, &serv, servbuf, SBUFSIZE, &result);
  256. return result;
  257. }
  258. libc_hidden_def(getservbyport)