getproto.c 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279
  1. /*
  2. ** protocols.c /etc/protocols 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 <stdlib.h>
  60. #include <string.h>
  61. #include <errno.h>
  62. #include <unistd.h>
  63. libc_hidden_proto(fopen)
  64. /* Experimentally off - libc_hidden_proto(strcmp) */
  65. /* Experimentally off - libc_hidden_proto(strpbrk) */
  66. libc_hidden_proto(atoi)
  67. libc_hidden_proto(rewind)
  68. libc_hidden_proto(fgets)
  69. libc_hidden_proto(fclose)
  70. /* libc_hidden_proto(abort) */
  71. #include <bits/uClibc_mutex.h>
  72. __UCLIBC_MUTEX_STATIC(mylock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
  73. #define MAXALIASES 35
  74. #define SBUFSIZE (BUFSIZ + 1 + (sizeof(char *) * MAXALIASES))
  75. static FILE *protof = NULL;
  76. static struct protoent proto;
  77. static char *static_aliases = NULL;
  78. static smallint proto_stayopen;
  79. static void __initbuf(void)
  80. {
  81. if (!static_aliases) {
  82. static_aliases = malloc(SBUFSIZE);
  83. if (!static_aliases)
  84. abort();
  85. }
  86. }
  87. libc_hidden_proto(setprotoent)
  88. void setprotoent(int f)
  89. {
  90. __UCLIBC_MUTEX_LOCK(mylock);
  91. if (protof == NULL)
  92. protof = fopen(_PATH_PROTOCOLS, "r" );
  93. else
  94. rewind(protof);
  95. if (f) proto_stayopen = 1;
  96. __UCLIBC_MUTEX_UNLOCK(mylock);
  97. }
  98. libc_hidden_def(setprotoent)
  99. libc_hidden_proto(endprotoent)
  100. void endprotoent(void)
  101. {
  102. __UCLIBC_MUTEX_LOCK(mylock);
  103. if (protof) {
  104. fclose(protof);
  105. protof = NULL;
  106. }
  107. proto_stayopen = 0;
  108. __UCLIBC_MUTEX_UNLOCK(mylock);
  109. }
  110. libc_hidden_def(endprotoent)
  111. libc_hidden_proto(getprotoent_r)
  112. int getprotoent_r(struct protoent *result_buf,
  113. char *buf, size_t buflen,
  114. struct protoent **result)
  115. {
  116. char *p;
  117. register char *cp, **q;
  118. char **proto_aliases;
  119. char *line;
  120. int rv;
  121. *result = NULL;
  122. if (buflen < sizeof(*proto_aliases)*MAXALIASES) {
  123. errno=ERANGE;
  124. return errno;
  125. }
  126. __UCLIBC_MUTEX_LOCK(mylock);
  127. proto_aliases=(char **)buf;
  128. buf+=sizeof(*proto_aliases)*MAXALIASES;
  129. buflen-=sizeof(*proto_aliases)*MAXALIASES;
  130. if (buflen < BUFSIZ+1) {
  131. errno=rv=ERANGE;
  132. goto DONE;
  133. }
  134. line=buf;
  135. buf+=BUFSIZ+1;
  136. buflen-=BUFSIZ+1;
  137. if (protof == NULL && (protof = fopen(_PATH_PROTOCOLS, "r" )) == NULL) {
  138. rv=errno;
  139. goto DONE;
  140. }
  141. again:
  142. if ((p = fgets(line, BUFSIZ, protof)) == NULL) {
  143. rv=TRY_AGAIN;
  144. goto DONE;
  145. }
  146. if (*p == '#')
  147. goto again;
  148. cp = strpbrk(p, "#\n");
  149. if (cp == NULL)
  150. goto again;
  151. *cp = '\0';
  152. result_buf->p_name = p;
  153. cp = strpbrk(p, " \t");
  154. if (cp == NULL)
  155. goto again;
  156. *cp++ = '\0';
  157. while (*cp == ' ' || *cp == '\t')
  158. cp++;
  159. p = strpbrk(cp, " \t");
  160. if (p != NULL)
  161. *p++ = '\0';
  162. result_buf->p_proto = atoi(cp);
  163. q = result_buf->p_aliases = proto_aliases;
  164. if (p != NULL) {
  165. cp = p;
  166. while (cp && *cp) {
  167. if (*cp == ' ' || *cp == '\t') {
  168. cp++;
  169. continue;
  170. }
  171. if (q < &proto_aliases[MAXALIASES - 1])
  172. *q++ = cp;
  173. cp = strpbrk(cp, " \t");
  174. if (cp != NULL)
  175. *cp++ = '\0';
  176. }
  177. }
  178. *q = NULL;
  179. *result=result_buf;
  180. rv = 0;
  181. DONE:
  182. __UCLIBC_MUTEX_UNLOCK(mylock);
  183. return rv;
  184. }
  185. libc_hidden_def(getprotoent_r)
  186. struct protoent * getprotoent(void)
  187. {
  188. struct protoent *result;
  189. __initbuf();
  190. getprotoent_r(&proto, static_aliases, SBUFSIZE, &result);
  191. return result;
  192. }
  193. libc_hidden_proto(getprotobyname_r)
  194. int getprotobyname_r(const char *name,
  195. struct protoent *result_buf,
  196. char *buf, size_t buflen,
  197. struct protoent **result)
  198. {
  199. register char **cp;
  200. int ret;
  201. __UCLIBC_MUTEX_LOCK(mylock);
  202. setprotoent(proto_stayopen);
  203. while (!(ret=getprotoent_r(result_buf, buf, buflen, result))) {
  204. if (strcmp(result_buf->p_name, name) == 0)
  205. break;
  206. for (cp = result_buf->p_aliases; *cp != 0; cp++)
  207. if (strcmp(*cp, name) == 0)
  208. goto found;
  209. }
  210. found:
  211. if (!proto_stayopen)
  212. endprotoent();
  213. __UCLIBC_MUTEX_UNLOCK(mylock);
  214. return *result?0:ret;
  215. }
  216. libc_hidden_def(getprotobyname_r)
  217. struct protoent * getprotobyname(const char *name)
  218. {
  219. struct protoent *result;
  220. __initbuf();
  221. getprotobyname_r(name, &proto, static_aliases, SBUFSIZE, &result);
  222. return result;
  223. }
  224. libc_hidden_proto(getprotobynumber_r)
  225. int getprotobynumber_r (int proto_num,
  226. struct protoent *result_buf,
  227. char *buf, size_t buflen,
  228. struct protoent **result)
  229. {
  230. int ret;
  231. __UCLIBC_MUTEX_LOCK(mylock);
  232. setprotoent(proto_stayopen);
  233. while (!(ret=getprotoent_r(result_buf, buf, buflen, result)))
  234. if (result_buf->p_proto == proto_num)
  235. break;
  236. if (!proto_stayopen)
  237. endprotoent();
  238. __UCLIBC_MUTEX_UNLOCK(mylock);
  239. return *result?0:ret;
  240. }
  241. libc_hidden_def(getprotobynumber_r)
  242. struct protoent * getprotobynumber(int proto_num)
  243. {
  244. struct protoent *result;
  245. __initbuf();
  246. getprotobynumber_r(proto_num, &proto, static_aliases,
  247. SBUFSIZE, &result);
  248. return result;
  249. }