lib/libc/rpc/getnetpath.c

   1 /*      $NetBSD: getnetpath.c,v 1.17 2013/03/11 20:19:29 tron Exp $     */
   2
   3 /*
   4  * Copyright (c) 2010, Oracle America, Inc.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above
  13  *       copyright notice, this list of conditions and the following
  14  *       disclaimer in the documentation and/or other materials
  15  *       provided with the distribution.
  16  *     * Neither the name of the "Oracle America, Inc." nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  27  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 #if defined(LIBC_SCCS) && !defined(lint)
  36 #if 0
  37 static        char sccsid[] = "@(#)getnetpath.c 1.11 91/12/19 SMI";
  38 #else
  39 __RCSID("$NetBSD: getnetpath.c,v 1.17 2013/03/11 20:19:29 tron Exp $");
  40 #endif
  41 #endif
  42
  43 /*
  44  * Copyright (c) 1989 by Sun Microsystems, Inc.
  45  */
  46
  47 #include "namespace.h"
  48 #include <stdio.h>
  49 #include <assert.h>
  50 #include <errno.h>
  51 #include <netconfig.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <syslog.h>
  55
  56 #ifdef __weak_alias
  57 __weak_alias(getnetpath,_getnetpath)
  58 __weak_alias(setnetpath,_setnetpath)
  59 __weak_alias(endnetpath,_endnetpath)
  60 #endif
  61
  62 /*
  63  * internal structure to keep track of a netpath "session"
  64  */
  65 struct netpath_chain {
  66         struct netconfig *ncp;                  /* an nconf entry */
  67         struct netpath_chain *nchain_next;      /* next nconf entry allocated */
  68 };
  69
  70
  71 struct netpath_vars {
  72         int   valid;            /* token that indicates a valid netpath_vars */
  73         void *nc_handlep;       /* handle for current netconfig "session" */
  74         char *netpath;          /* pointer to current view-point in NETPATH */
  75         char *netpath_start;    /* pointer to start of our copy of NETPATH */
  76         struct netpath_chain *ncp_list;  /* list of nconfs allocated this session*/
  77 };
  78
  79 #define NP_VALID        0xf00d
  80 #define NP_INVALID      0
  81
  82 char *_get_next_token(char *, int);
  83
  84
  85 /*
  86  * A call to setnetpath() establishes a NETPATH "session".  setnetpath()
  87  * must be called before the first call to getnetpath().  A "handle" is
  88  * returned to distinguish the session; this handle should be passed
  89  * subsequently to getnetpath().  (Handles are used to allow for nested calls
  90  * to setnetpath()).
  91  * If setnetpath() is unable to establish a session (due to lack of memory
  92  * resources, or the absence of the /etc/netconfig file), a NULL pointer is
  93  * returned.
  94  */
  95
  96 void *
  97 setnetpath(void)
  98 {
  99         struct netpath_vars *np_sessionp;   /* this session's variables */
 100         char *npp;                              /* NETPATH env variable */
 101
 102 #ifdef MEM_CHK
 103         malloc_debug(1);
 104 #endif
 105
 106         if ((np_sessionp = malloc(sizeof(*np_sessionp))) == NULL)
 107                 return (NULL);
 108         if ((np_sessionp->nc_handlep = setnetconfig()) == NULL) {
 109                 free(np_sessionp);
 110                 syslog (LOG_ERR, "rpc: failed to open " NETCONFIG);
 111                 return (NULL);
 112         }
 113         np_sessionp->valid = NP_VALID;
 114         np_sessionp->ncp_list = NULL;
 115         if ((npp = getenv(NETPATH)) == NULL)
 116                 np_sessionp->netpath = NULL;
 117         else {
 118                 (void) endnetconfig(np_sessionp->nc_handlep);
 119                                         /* won't need nc session*/
 120                 np_sessionp->nc_handlep = NULL;
 121                 if ((np_sessionp->netpath = malloc(strlen(npp)+1)) == NULL) {
 122                         free(np_sessionp);
 123                         return (NULL);
 124                 } else
 125                         (void) strcpy(np_sessionp->netpath, npp);
 126         }
 127         np_sessionp->netpath_start = np_sessionp->netpath;
 128         return ((void *)np_sessionp);
 129 }
 130
 131 /*
 132  * When first called, getnetpath() returns a pointer to the netconfig
 133  * database entry corresponding to the first valid NETPATH component.  The
 134  * netconfig entry is formatted as a struct netconfig.
 135  * On each subsequent call, getnetpath returns a pointer to the netconfig
 136  * entry that corresponds to the next valid NETPATH component.  getnetpath
 137  * can thus be used to search the netconfig database for all networks
 138  * included in the NETPATH variable.
 139  * When NETPATH has been exhausted, getnetpath() returns NULL.  It returns
 140  * NULL and sets errno in case of an error (e.g., setnetpath was not called
 141  * previously).
 142  * getnetpath() silently ignores invalid NETPATH components.  A NETPATH
 143  * compnent is invalid if there is no corresponding entry in the netconfig
 144  * database.
 145  * If the NETPATH variable is unset, getnetpath() behaves as if NETPATH
 146  * were set to the sequence of default or visible networks in the netconfig
 147  * database, in the order in which they are listed.
 148  */
 149
 150 struct netconfig *
 151 getnetpath(void *handlep)
 152 {
 153         struct netpath_vars *np_sessionp = (struct netpath_vars *)handlep;
 154         struct netconfig *ncp = NULL;   /* temp. holds a netconfig session */
 155         struct netpath_chain *chainp;   /* holds chain of ncp's we alloc */
 156         char  *npp;             /* holds current NETPATH */
 157
 158         if (np_sessionp == NULL || np_sessionp->valid != NP_VALID) {
 159                 errno = EINVAL;
 160                 return (NULL);
 161         }
 162         if (np_sessionp->netpath_start == NULL) { /* NETPATH was not set */
 163                 do {                /* select next visible network */
 164                         if (np_sessionp->nc_handlep == NULL) {
 165                                 np_sessionp->nc_handlep = setnetconfig();
 166                                 if (np_sessionp->nc_handlep == NULL)
 167                                         syslog (LOG_ERR,
 168                                             "rpc: failed to open " NETCONFIG);
 169                         }
 170                         if ((ncp = getnetconfig(np_sessionp->nc_handlep))
 171                             == NULL)
 172                                 return(NULL);
 173                 } while ((ncp->nc_flag & NC_VISIBLE) == 0);
 174                 return (ncp);
 175         }
 176         /*
 177          * Find first valid network ID in netpath.
 178          */
 179         while ((npp = np_sessionp->netpath) != NULL && strlen(npp) != 0) {
 180                 np_sessionp->netpath = _get_next_token(npp, ':');
 181                 /*
 182                  * npp is a network identifier.
 183                  */
 184                 if ((ncp = getnetconfigent(npp)) != NULL) {
 185                                         /* cobble alloc chain entry */
 186                         chainp = malloc(sizeof (struct netpath_chain));
 187                         if (chainp == NULL) {
 188                                 freenetconfigent(ncp);
 189                                 return NULL;
 190                         }
 191                         chainp->ncp = ncp;
 192                         chainp->nchain_next = NULL;
 193                         if (np_sessionp->ncp_list == NULL)
 194                                 np_sessionp->ncp_list = chainp;
 195                         else
 196                                 np_sessionp->ncp_list->nchain_next = chainp;
 197                         return (ncp);
 198                 }
 199                 /* couldn't find this token in the database; go to next one. */
 200         }
 201         return (NULL);
 202 }
 203
 204 /*
 205  * endnetpath() may be called to unbind NETPATH when processing is complete,
 206  * releasing resources for reuse.  It returns 0 on success and -1 on failure
 207  * (e.g. if setnetpath() was not called previously.
 208  */
 209 int
 210 endnetpath(void *handlep)
 211 {
 212         struct netpath_vars *np_sessionp = (struct netpath_vars *)handlep;
 213         struct netpath_chain *chainp, *lastp;
 214
 215         if (np_sessionp == NULL || np_sessionp->valid != NP_VALID) {
 216                 errno = EINVAL;
 217                 return (-1);
 218         }
 219         if (np_sessionp->nc_handlep != NULL)
 220                 endnetconfig(np_sessionp->nc_handlep);
 221         if (np_sessionp->netpath_start != NULL)
 222                 free(np_sessionp->netpath_start);
 223         for (chainp = np_sessionp->ncp_list; chainp != NULL;
 224             lastp=chainp, chainp=chainp->nchain_next, free(lastp)) {
 225                 freenetconfigent(chainp->ncp);
 226         }
 227         free(np_sessionp);
 228 #ifdef MEM_CHK
 229         if (malloc_verify() == 0) {
 230                 fprintf(stderr, "memory heap corrupted in endnetpath\n");
 231                 exit(1);
 232         }
 233 #endif
 234         return (0);
 235 }
 236
 237
 238 /*
 239  * Returns pointer to the rest-of-the-string after the current token.
 240  * The token itself starts at arg, and we null terminate it.  We return NULL
 241  * if either the arg is empty, or if this is the last token.
 242  */
 243
 244 char *
 245 _get_next_token(
 246         char *npp,              /* string */
 247         int token               /* char to parse string for */
 248 )
 249 {
 250         char  *cp;              /* char pointer */
 251         char  *np;              /* netpath pointer */
 252         char  *ep;              /* escape pointer */
 253
 254         _DIAGASSERT(npp != NULL);
 255
 256         if ((cp = strchr(npp, token)) == NULL)
 257                 return (NULL);
 258         /*
 259          * did find a token, but it might be escaped.
 260          */
 261         if ((cp > npp) && (cp[-1] == '\\')) {
 262                 /*
 263                  * if slash was also escaped, carry on, otherwise find
 264                  * next token
 265                  */
 266                 if ((cp > npp + 1) && (cp[-2] != '\\')) {
 267                         /* shift r-o-s  onto the escaped token */
 268                         strcpy(&cp[-1], cp);  /* XXX: overlapping string copy */
 269                         /*
 270                          * Do a recursive call.
 271                          * We don't know how many escaped tokens there might be.
 272                          */
 273                         return (_get_next_token(cp, token));
 274                 }
 275         }
 276
 277         *cp++ = '\0';           /* null-terminate token */
 278         /* get rid of any backslash escapes */
 279         ep = npp;
 280         while ((np = strchr(ep, '\\')) != 0) {
 281                 if (np[1] == '\\')
 282                         np++;
 283                 strcpy(np, (ep = &np[1]));  /* XXX: overlapping string copy */
 284         }
 285         return (cp);            /* return ptr to r-o-s */
 286 }