/* ** services.c /etc/services access functions ** ** This file is part of the NYS Library. ** ** The NYS Library is free software; you can redistribute it and/or ** modify it under the terms of the GNU Library General Public License as ** published by the Free Software Foundation; either version 2 of the ** License, or (at your option) any later version. ** ** The NYS Library is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ** Library General Public License for more details. ** ** You should have received a copy of the GNU Library General Public ** License along with the NYS Library; see the file COPYING.LIB. If ** not, write to the Free Software Foundation, Inc., 675 Mass Ave, ** Cambridge, MA 02139, USA. ** ** ** Copyright (c) 1983 Regents of the University of California. ** All rights reserved. ** ** Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions ** are met: ** 1. Redistributions of source code must retain the above copyright ** notice, this list of conditions and the following disclaimer. ** 2. Redistributions in binary form must reproduce the above copyright ** notice, this list of conditions and the following disclaimer in the ** documentation and/or other materials provided with the distribution. ** 3. All advertising materials mentioning features or use of this software ** must display the following acknowledgement: ** This product includes software developed by the University of ** California, Berkeley and its contributors. ** 4. Neither the name of the University nor the names of its contributors ** may be used to endorse or promote products derived from this software ** without specific prior written permission. ** ** THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ** ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ** SUCH DAMAGE. */ #define __FORCE_GLIBC #define _GNU_SOURCE #include <features.h> #include <sys/types.h> #include <sys/socket.h> #include <netdb.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <netinet/in.h> #include <arpa/inet.h> #include <errno.h> #ifdef __UCLIBC_HAS_THREADS__ #include <pthread.h> static pthread_mutex_t mylock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; # define LOCK pthread_mutex_lock(&mylock) # define UNLOCK pthread_mutex_unlock(&mylock); #else # define LOCK # define UNLOCK #endif #define MAXALIASES 35 static FILE *servf = NULL; static struct servent serv; static char buf[BUFSIZ+1 + sizeof(char *)*MAXALIASES]; static int serv_stayopen; void setservent(int f) { LOCK; if (servf == NULL) servf = fopen(_PATH_SERVICES, "r" ); else rewind(servf); serv_stayopen |= f; UNLOCK; } void endservent(void) { LOCK; if (servf) { fclose(servf); servf = NULL; } serv_stayopen = 0; UNLOCK; } struct servent * getservent(void) { struct servent *result; getservent_r(&serv, buf, sizeof(buf), &result); return result; } struct servent *getservbyname(const char *name, const char *proto) { struct servent *result; getservbyname_r(name, proto, &serv, buf, sizeof(buf), &result); return result; } struct servent * getservbyport(int port, const char *proto) { struct servent *result; getservbyport_r(port, proto, &serv, buf, sizeof(buf), &result); return result; } int getservent_r(struct servent * result_buf, char * buf, size_t buflen, struct servent ** result) { char *p; register char *cp, **q; char **serv_aliases; char *line; *result=NULL; if (buflen < sizeof(*serv_aliases)*MAXALIASES) { errno=ERANGE; return errno; } LOCK; serv_aliases=(char **)buf; buf+=sizeof(*serv_aliases)*MAXALIASES; buflen-=sizeof(*serv_aliases)*MAXALIASES; if (buflen < BUFSIZ+1) { UNLOCK; errno=ERANGE; return errno; } line=buf; buf+=BUFSIZ+1; buflen-=BUFSIZ+1; if (servf == NULL && (servf = fopen(_PATH_SERVICES, "r" )) == NULL) { UNLOCK; return errno; } again: if ((p = fgets(line, BUFSIZ, servf)) == NULL) { UNLOCK; return TRY_AGAIN; } if (*p == '#') goto again; cp = strpbrk(p, "#\n"); if (cp == NULL) goto again; *cp = '\0'; result_buf->s_name = p; p = strpbrk(p, " \t"); if (p == NULL) goto again; *p++ = '\0'; while (*p == ' ' || *p == '\t') p++; cp = strpbrk(p, ",/"); if (cp == NULL) goto again; *cp++ = '\0'; result_buf->s_port = htons((u_short)atoi(p)); result_buf->s_proto = cp; q = result_buf->s_aliases = serv_aliases; cp = strpbrk(cp, " \t"); if (cp != NULL) *cp++ = '\0'; while (cp && *cp) { if (*cp == ' ' || *cp == '\t') { cp++; continue; } if (q < &serv_aliases[MAXALIASES - 1]) *q++ = cp; cp = strpbrk(cp, " \t"); if (cp != NULL) *cp++ = '\0'; } *q = NULL; *result=result_buf; UNLOCK; return 0; } int getservbyname_r(const char *name, const char *proto, struct servent * result_buf, char * buf, size_t buflen, struct servent ** result) { register char **cp; int ret; LOCK; setservent(serv_stayopen); while (!(ret=getservent_r(result_buf, buf, buflen, result))) { if (strcmp(name, result_buf->s_name) == 0) goto gotname; for (cp = result_buf->s_aliases; *cp; cp++) if (strcmp(name, *cp) == 0) goto gotname; continue; gotname: if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0) break; } if (!serv_stayopen) endservent(); UNLOCK; return *result?0:ret; } int getservbyport_r(int port, const char *proto, struct servent * result_buf, char * buf, size_t buflen, struct servent ** result) { int ret; LOCK; setservent(serv_stayopen); while (!(ret=getservent_r(result_buf, buf, buflen, result))) { if (result_buf->s_port != port) continue; if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0) break; } if (!serv_stayopen) endservent(); UNLOCK; return *result?0:ret; }