nss/getnssent_r.c

   1 /* Copyright (C) 2000-2016 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <errno.h>
  19 #include <netdb.h>
  20 #include "nsswitch.h"
  21
  22 /* Set up NIP to run through the services.  If ALL is zero, use NIP's
  23    current location if it's not nil.  Return nonzero if there are no
  24    services (left).  */
  25 static int
  26 setup (const char *func_name, db_lookup_function lookup_fct,
  27        void **fctp, service_user **nip, service_user **startp, int all)
  28 {
  29   int no_more;
  30   if (*startp == NULL)
  31     {
  32       no_more = lookup_fct (nip, func_name, NULL, fctp);
  33       *startp = no_more ? (service_user *) -1l : *nip;
  34     }
  35   else if (*startp == (service_user *) -1l)
  36     /* No services at all.  */
  37     return 1;
  38   else
  39     {
  40       if (all || !*nip)
  41         /* Reset to the beginning of the service list.  */
  42         *nip = *startp;
  43       /* Look up the first function.  */
  44       no_more = __nss_lookup (nip, func_name, NULL, fctp);
  45     }
  46   return no_more;
  47 }
  48 \f
  49 void
  50 __nss_setent (const char *func_name, db_lookup_function lookup_fct,
  51               service_user **nip, service_user **startp,
  52               service_user **last_nip, int stayopen, int *stayopen_tmp,
  53               int res)
  54 {
  55   union
  56   {
  57     setent_function f;
  58     void *ptr;
  59   } fct;
  60   int no_more;
  61
  62   if (res && __res_maybe_init (&_res, 0) == -1)
  63     {
  64       __set_h_errno (NETDB_INTERNAL);
  65       return;
  66     }
  67
  68   /* Cycle through the services and run their `setXXent' functions until
  69      we find an available service.  */
  70   no_more = setup (func_name, lookup_fct, &fct.ptr, nip,
  71                    startp, 1);
  72   while (! no_more)
  73     {
  74       int is_last_nip = *nip == *last_nip;
  75       enum nss_status status;
  76
  77       if (stayopen_tmp)
  78         status = DL_CALL_FCT (fct.f, (*stayopen_tmp));
  79       else
  80         status = DL_CALL_FCT (fct.f, (0));
  81
  82
  83       /* This is a special-case.  When [SUCCESS=merge] is in play,
  84          _nss_next2() will skip to the next database.  Due to the
  85          implementation of that function, we can't know whether we're
  86          in an enumeration or an individual lookup, which behaves
  87          differently with regards to merging.  We'll treat SUCCESS as
  88          an indication to start the enumeration at this database. */
  89       if (nss_next_action (*nip, status) == NSS_ACTION_MERGE)
  90         no_more = 1;
  91       else
  92         no_more = __nss_next2 (nip, func_name, NULL, &fct.ptr, status, 0);
  93
  94       if (is_last_nip)
  95         *last_nip = *nip;
  96     }
  97
  98   if (stayopen_tmp)
  99     *stayopen_tmp = stayopen;
 100 }
 101
 102
 103 void
 104 __nss_endent (const char *func_name, db_lookup_function lookup_fct,
 105               service_user **nip, service_user **startp,
 106               service_user **last_nip, int res)
 107 {
 108   union
 109   {
 110     endent_function f;
 111     void *ptr;
 112   } fct;
 113   int no_more;
 114
 115   if (res && __res_maybe_init (&_res, 0) == -1)
 116     {
 117       __set_h_errno (NETDB_INTERNAL);
 118       return;
 119     }
 120
 121   /* Cycle through all the services and run their endXXent functions.  */
 122   no_more = setup (func_name, lookup_fct, &fct.ptr, nip, startp, 1);
 123   while (! no_more)
 124     {
 125       /* Ignore status, we force check in __NSS_NEXT.  */
 126       DL_CALL_FCT (fct.f, ());
 127
 128       if (*nip == *last_nip)
 129         /* We have processed all services which were used.  */
 130         break;
 131
 132       no_more = __nss_next2 (nip, func_name, NULL, &fct.ptr, 0, 1);
 133     }
 134   *last_nip = *nip = NULL;
 135 }
 136
 137
 138 int
 139 __nss_getent_r (const char *getent_func_name,
 140                 const char *setent_func_name,
 141                 db_lookup_function lookup_fct,
 142                 service_user **nip, service_user **startp,
 143                 service_user **last_nip, int *stayopen_tmp, int res,
 144                 void *resbuf, char *buffer, size_t buflen,
 145                 void **result, int *h_errnop)
 146 {
 147   union
 148   {
 149     getent_function f;
 150     void *ptr;
 151   } fct;
 152   int no_more;
 153   enum nss_status status;
 154
 155   if (res && __res_maybe_init (&_res, 0) == -1)
 156     {
 157       *h_errnop = NETDB_INTERNAL;
 158       *result = NULL;
 159       return errno;
 160     }
 161
 162   /* Initialize status to return if no more functions are found.  */
 163   status = NSS_STATUS_NOTFOUND;
 164
 165   /* Run through available functions, starting with the same function last
 166      run.  We will repeat each function as long as it succeeds, and then go
 167      on to the next service action.  */
 168   no_more = setup (getent_func_name, lookup_fct, &fct.ptr, nip,
 169                    startp, 0);
 170   while (! no_more)
 171     {
 172       int is_last_nip = *nip == *last_nip;
 173
 174       status = DL_CALL_FCT (fct.f,
 175                             (resbuf, buffer, buflen, &errno, &h_errno));
 176
 177       /* The status is NSS_STATUS_TRYAGAIN and errno is ERANGE the
 178          provided buffer is too small.  In this case we should give
 179          the user the possibility to enlarge the buffer and we should
 180          not simply go on with the next service (even if the TRYAGAIN
 181          action tells us so).  */
 182       if (status == NSS_STATUS_TRYAGAIN
 183           && (h_errnop == NULL || *h_errnop == NETDB_INTERNAL)
 184           && errno == ERANGE)
 185         break;
 186
 187       do
 188         {
 189         /* This is a special-case.  When [SUCCESS=merge] is in play,
 190            _nss_next2() will skip to the next database.  Due to the
 191            implementation of that function, we can't know whether we're
 192            in an enumeration or an individual lookup, which behaves
 193            differently with regards to merging.  We'll treat SUCCESS as
 194            an indication to return the results here. */
 195           if (status == NSS_STATUS_SUCCESS
 196               && nss_next_action (*nip, status) == NSS_ACTION_MERGE)
 197             no_more = 1;
 198           else
 199             no_more = __nss_next2 (nip, getent_func_name, NULL, &fct.ptr,
 200                                    status, 0);
 201
 202           if (is_last_nip)
 203             *last_nip = *nip;
 204
 205           if (! no_more)
 206             {
 207               /* Call the `setXXent' function.  This wasn't done before.  */
 208               union
 209               {
 210                 setent_function f;
 211                 void *ptr;
 212               } sfct;
 213
 214               no_more = __nss_lookup (nip, setent_func_name, NULL, &sfct.ptr);
 215
 216               if (! no_more)
 217                 {
 218                   if (stayopen_tmp)
 219                     status = DL_CALL_FCT (sfct.f, (*stayopen_tmp));
 220                   else
 221                     status = DL_CALL_FCT (sfct.f, (0));
 222                 }
 223               else
 224                 status = NSS_STATUS_NOTFOUND;
 225             }
 226         }
 227       while (! no_more && status != NSS_STATUS_SUCCESS);
 228     }
 229
 230   *result = status == NSS_STATUS_SUCCESS ? resbuf : NULL;
 231   return (status == NSS_STATUS_SUCCESS ? 0
 232           : status != NSS_STATUS_TRYAGAIN ? ENOENT
 233           /* h_errno functions only set errno if h_errno is NETDB_INTERNAL.  */
 234           : (h_errnop == NULL || *h_errnop == NETDB_INTERNAL) ? errno
 235           : EAGAIN);
 236 }