libc/inet/getnet.c

   1 /*
   2  * Copyright (C) 2010 Bernhard Reutner-Fischer <uclibc@uclibc.org>
   3  *
   4  * Licensed under LGPL v2.1 or later, see the file COPYING.LIB in this tarball.
   5  */
   6
   7 /* /etc/networks
   8 #   network-name  number     [aliases ...]
   9 loopback          127.0.0.0  # optional aliases
  10
  11 network-name: symbolic name of the netwkork
  12 number: official number of the network in dotted quad
  13 aliases: case sensitive optional space or tab separated list of other names
  14 */
  15
  16 #include <features.h>
  17 #include <netdb.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <netinet/in.h>
  21 #include <arpa/inet.h>
  22 #include <errno.h>
  23 #include <unistd.h>
  24 #include "internal/parse_config.h"
  25
  26 #include <bits/uClibc_mutex.h>
  27 __UCLIBC_MUTEX_STATIC(mylock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
  28
  29 #define MINTOKENS       2
  30 #define MAXALIASES      8
  31 #define MAXTOKENS       (MINTOKENS + MAXALIASES + 1)
  32 #define BUFSZ           (255) /* one line */
  33 #define SBUFSIZE        (BUFSZ + 1 + (sizeof(char *) * MAXTOKENS))
  34
  35 static parser_t *netp = NULL;
  36 static struct netent nete;
  37 static char *netbuf = NULL;
  38 static smallint net_stayopen;
  39
  40 void setnetent(int stayopen)
  41 {
  42         __UCLIBC_MUTEX_LOCK(mylock);
  43         if (netp)
  44                 config_close(netp);
  45         netp = config_open(_PATH_NETWORKS);
  46         if (stayopen)
  47                 net_stayopen = 1;
  48         __UCLIBC_MUTEX_UNLOCK(mylock);
  49 }
  50 libc_hidden_def(setnetent)
  51
  52 void endnetent(void)
  53 {
  54         __UCLIBC_MUTEX_LOCK(mylock);
  55         if (netp) {
  56                 config_close(netp);
  57                 netp = NULL;
  58         }
  59         net_stayopen = 0;
  60         __UCLIBC_MUTEX_UNLOCK(mylock);
  61 }
  62 libc_hidden_def(endnetent)
  63
  64 int getnetent_r(struct netent *result_buf,
  65                                 char *buf, size_t buflen, struct netent **result,
  66                                 int *h_errnop
  67                                  )
  68 {
  69         char **tok = NULL;
  70         const size_t aliaslen = sizeof(char *) * MAXTOKENS;
  71         int ret = ERANGE;
  72         (void)h_errnop;
  73
  74         *result = NULL;
  75         if (buflen < aliaslen
  76                 || (buflen - aliaslen) < BUFSZ + 1)
  77                 goto DONE_NOUNLOCK;
  78
  79         __UCLIBC_MUTEX_LOCK(mylock);
  80         ret = ENOENT;
  81         if (netp == NULL)
  82                 setnetent(net_stayopen);
  83         if (netp == NULL)
  84                 goto DONE;
  85         netp->data = buf;
  86         netp->data_len = aliaslen;
  87         netp->line_len = buflen - aliaslen;
  88         /* <name>[[:space:]]<netnumber>[[:space:]][<aliases>] */
  89         if (!config_read(netp, &tok, MAXTOKENS-1, MINTOKENS, "# \t/", PARSE_NORMAL)) {
  90                 goto DONE;
  91         }
  92         result_buf->n_name = *(tok++);
  93         {
  94                 struct addrinfo hints, *addri;
  95 # define sa4_to_uint32(sa) \
  96         (ntohl(((struct sockaddr_in*)sa)->sin_addr.s_addr))
  97 #ifdef __UCLIBC_HAS_IPV6__
  98 # define sa6_to_uint8(sa) \
  99         (ntohl(((struct sockaddr_in6*)sa)->sin6_addr.s6_addr))
 100 #endif
 101                 memset(&hints, 0, sizeof(struct addrinfo));
 102                 hints.ai_family = AF_UNSPEC;
 103                 hints.ai_flags = AI_NUMERICHOST;
 104                 getaddrinfo(*(tok++), NULL, &hints, &addri);
 105                 result_buf->n_addrtype = addri->ai_family;
 106                 result_buf->n_net =
 107 #if 0 /*FIXME: implement me! def __UCLIBC_HAS_IPV6__ */
 108                         addri->ai_family == AF_INET6 ? sa6_to_uint8(addri->ai_addr) :
 109 #endif
 110                         sa4_to_uint32(addri->ai_addr);
 111                 freeaddrinfo(addri);
 112         }
 113         result_buf->n_aliases = tok;
 114         *result = result_buf;
 115         ret = 0;
 116  DONE:
 117         __UCLIBC_MUTEX_UNLOCK(mylock);
 118  DONE_NOUNLOCK:
 119         errno = ret;
 120         return errno;
 121 }
 122 libc_hidden_def(getnetent_r)
 123
 124 static void __initbuf(void)
 125 {
 126         if (!netbuf) {
 127                 netbuf = malloc(SBUFSIZE);
 128                 if (!netbuf)
 129                         abort();
 130         }
 131 }
 132
 133 struct netent *getnetent(void)
 134 {
 135         struct netent *result;
 136         int herrnop;
 137
 138         __initbuf();
 139         getnetent_r(&nete, netbuf, SBUFSIZE, &result, &herrnop);
 140         return result;
 141 }
 142
 143 int getnetbyname_r(const char *name,
 144                                         struct netent *result_buf, char *buf, size_t buflen,
 145                                         struct netent **result,
 146                                         int *h_errnop
 147                                         )
 148 {
 149         register char **cp;
 150         int ret, herrnop;
 151         (void)h_errnop;
 152
 153         __UCLIBC_MUTEX_LOCK(mylock);
 154         setnetent(net_stayopen);
 155         while (!(ret = getnetent_r(result_buf, buf, buflen, result, &herrnop))) {
 156                 if (strcmp(name, result_buf->n_name) == 0)
 157                         break;
 158                 for (cp = result_buf->n_aliases; *cp; cp++)
 159                         if (strcmp(name, *cp) == 0)
 160                                 goto gotname;
 161         }
 162  gotname:
 163         if (!net_stayopen)
 164                 endnetent();
 165         __UCLIBC_MUTEX_UNLOCK(mylock);
 166         return *result ? 0 : ret;
 167 }
 168 libc_hidden_def(getnetbyname_r)
 169
 170 struct netent *getnetbyname(const char *name)
 171 {
 172         struct netent *result;
 173         int herrnop;
 174
 175         __initbuf();
 176         getnetbyname_r(name, &nete, netbuf, SBUFSIZE, &result, &herrnop);
 177         return result;
 178 }
 179
 180 int getnetbyaddr_r(uint32_t net, int type,
 181                                         struct netent *result_buf, char *buf,
 182                                         size_t buflen, struct netent **result,
 183                                         int *h_errnop)
 184 {
 185         int ret, herrnop;
 186         (void)h_errnop;
 187
 188         __UCLIBC_MUTEX_LOCK(mylock);
 189         setnetent(net_stayopen);
 190         while (!(ret = getnetent_r(result_buf, buf, buflen, result, &herrnop))) {
 191                 if (net == result_buf->n_net && type == result_buf->n_addrtype)
 192                         break;
 193         }
 194         if (!net_stayopen)
 195                 endnetent();
 196         __UCLIBC_MUTEX_UNLOCK(mylock);
 197         return *result ? 0 : ret;
 198 }
 199 libc_hidden_def(getnetbyaddr_r)
 200
 201 struct netent *getnetbyaddr(uint32_t net, int type)
 202 {
 203         struct netent *result;
 204         int herrnop;
 205
 206         __initbuf();
 207         getnetbyaddr_r(net, type, &nete, netbuf, SBUFSIZE, &result, &herrnop);
 208         return result;
 209 }
 210