nis/nss_nisplus/nisplus-grp.c

   1 /* Copyright (C) 1997, 2001, 2002, 2003, 2005, 2006
   2    Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C 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    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <atomic.h>
  21 #include <nss.h>
  22 #include <grp.h>
  23 #include <ctype.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <bits/libc-lock.h>
  27 #include <rpcsvc/nis.h>
  28
  29 #include "nss-nisplus.h"
  30 #include "nisplus-parser.h"
  31 #include <libnsl.h>
  32 #include <nis_intern.h>
  33 #include <nis_xdr.h>
  34
  35
  36 __libc_lock_define_initialized (static, lock);
  37
  38 /* Connection information.  */
  39 static ib_request *ibreq;
  40 static directory_obj *dir;
  41 static dir_binding bptr;
  42 static char *tablepath;
  43 static char *tableptr;
  44 /* Cursor.  */
  45 static netobj cursor;
  46
  47
  48 nis_name grp_tablename_val attribute_hidden;
  49 size_t grp_tablename_len attribute_hidden;
  50
  51 enum nss_status
  52 _nss_grp_create_tablename (int *errnop)
  53 {
  54   if (grp_tablename_val == NULL)
  55     {
  56       const char *local_dir = nis_local_directory ();
  57       size_t local_dir_len = strlen (local_dir);
  58       static const char prefix[] = "group.org_dir.";
  59
  60       char *p = malloc (sizeof (prefix) + local_dir_len);
  61       if (p == NULL)
  62         {
  63           *errnop = errno;
  64           return NSS_STATUS_TRYAGAIN;
  65         }
  66
  67       memcpy (__stpcpy (p, prefix), local_dir, local_dir_len + 1);
  68
  69       grp_tablename_len = sizeof (prefix) - 1 + local_dir_len;
  70
  71       atomic_write_barrier ();
  72
  73       if (atomic_compare_and_exchange_bool_acq (&grp_tablename_val, p, NULL))
  74         {
  75           /* Another thread already installed the value.  */
  76           free (p);
  77           grp_tablename_len = strlen (grp_tablename_val);
  78         }
  79     }
  80
  81   return NSS_STATUS_SUCCESS;
  82 }
  83
  84
  85 static void
  86 internal_endgrent (void)
  87 {
  88   __nisbind_destroy (&bptr);
  89   memset (&bptr, '\0', sizeof (bptr));
  90
  91   nis_free_directory (dir);
  92   dir = NULL;
  93
  94   nis_free_request (ibreq);
  95   ibreq = NULL;
  96
  97   xdr_free ((xdrproc_t) xdr_netobj, (char *) &cursor);
  98   memset (&cursor, '\0', sizeof (cursor));
  99
 100   free (tablepath);
 101   tableptr = tablepath = NULL;
 102 }
 103
 104
 105 static enum nss_status
 106 internal_setgrent (int *errnop)
 107 {
 108   enum nss_status status = NSS_STATUS_SUCCESS;
 109
 110   if (grp_tablename_val == NULL)
 111     status = _nss_grp_create_tablename (errnop);
 112
 113   if (status == NSS_STATUS_SUCCESS)
 114     {
 115       ibreq = __create_ib_request (grp_tablename_val, 0);
 116       if (ibreq == NULL)
 117         {
 118           *errnop = errno;
 119           return NSS_STATUS_TRYAGAIN;
 120         }
 121
 122       nis_error retcode = __prepare_niscall (grp_tablename_val, &dir, &bptr, 0);
 123       if (retcode != NIS_SUCCESS)
 124         {
 125           nis_free_request (ibreq);
 126           ibreq = NULL;
 127           status = niserr2nss (retcode);
 128         }
 129     }
 130
 131   return status;
 132 }
 133
 134
 135 enum nss_status
 136 _nss_nisplus_setgrent (int stayopen)
 137 {
 138   enum nss_status status;
 139
 140   __libc_lock_lock (lock);
 141
 142   internal_endgrent ();
 143
 144   // XXX We need to be able to set errno.  Pass in new parameter.
 145   int err;
 146   status = internal_setgrent (&err);
 147
 148   __libc_lock_unlock (lock);
 149
 150   return status;
 151 }
 152
 153
 154 enum nss_status
 155 _nss_nisplus_endgrent (void)
 156 {
 157   __libc_lock_lock (lock);
 158
 159   internal_endgrent ();
 160
 161   __libc_lock_unlock (lock);
 162
 163   return NSS_STATUS_SUCCESS;
 164 }
 165
 166
 167 static enum nss_status
 168 internal_nisplus_getgrent_r (struct group *gr, char *buffer, size_t buflen,
 169                              int *errnop)
 170 {
 171   int parse_res = -1;
 172   enum nss_status retval = NSS_STATUS_SUCCESS;
 173
 174   /* Get the next entry until we found a correct one. */
 175   do
 176     {
 177       nis_error status;
 178       nis_result result;
 179       memset (&result, '\0', sizeof (result));
 180
 181       if (cursor.n_bytes == NULL)
 182         {
 183           if (ibreq == NULL)
 184             {
 185               retval = internal_setgrent (errnop);
 186               if (retval != NSS_STATUS_SUCCESS)
 187                 return retval;
 188             }
 189
 190           status = __do_niscall3 (&bptr, NIS_IBFIRST,
 191                                   (xdrproc_t) _xdr_ib_request,
 192                                   (caddr_t) ibreq,
 193                                   (xdrproc_t) _xdr_nis_result,
 194                                   (caddr_t) &result,
 195                                   0, NULL);
 196         }
 197       else
 198         {
 199           ibreq->ibr_cookie.n_bytes = cursor.n_bytes;
 200           ibreq->ibr_cookie.n_len = cursor.n_len;
 201
 202           status = __do_niscall3 (&bptr, NIS_IBNEXT,
 203                                   (xdrproc_t) _xdr_ib_request,
 204                                   (caddr_t) ibreq,
 205                                   (xdrproc_t) _xdr_nis_result,
 206                                   (caddr_t) &result,
 207                                   0, NULL);
 208
 209           ibreq->ibr_cookie.n_bytes = NULL;
 210           ibreq->ibr_cookie.n_len = 0;
 211         }
 212
 213       if (status != NIS_SUCCESS)
 214         return niserr2nss (status);
 215
 216       if (NIS_RES_STATUS (&result) == NIS_NOTFOUND)
 217         {
 218           /* No more entries on this server.  This means we have to go
 219              to the next server on the path.  */
 220           status = __follow_path (&tablepath, &tableptr, ibreq, &bptr);
 221           if (status != NIS_SUCCESS)
 222             return niserr2nss (status);
 223
 224           directory_obj *newdir = NULL;
 225           dir_binding newbptr;
 226           status = __prepare_niscall (ibreq->ibr_name, &newdir, &newbptr, 0);
 227           if (status != NIS_SUCCESS)
 228             return niserr2nss (status);
 229
 230           nis_free_directory (dir);
 231           dir = newdir;
 232           __nisbind_destroy (&bptr);
 233           bptr = newbptr;
 234
 235           xdr_free ((xdrproc_t) xdr_netobj, (char *) &result.cookie);
 236           result.cookie.n_bytes = NULL;
 237           result.cookie.n_len = 0;
 238           parse_res = 0;
 239           goto next;
 240         }
 241       else if (NIS_RES_STATUS (&result) != NIS_SUCCESS)
 242         return niserr2nss (NIS_RES_STATUS (&result));
 243
 244       parse_res = _nss_nisplus_parse_grent (&result, gr,
 245                                             buffer, buflen, errnop);
 246       if (__builtin_expect (parse_res == -1, 0))
 247         {
 248           *errnop = ERANGE;
 249           retval = NSS_STATUS_TRYAGAIN;
 250           goto freeres;
 251         }
 252
 253     next:
 254       /* Free the old cursor.  */
 255       xdr_free ((xdrproc_t) xdr_netobj, (char *) &cursor);
 256       /* Remember the new one.  */
 257       cursor.n_bytes = result.cookie.n_bytes;
 258       cursor.n_len = result.cookie.n_len;
 259       /* Free the result structure.  NB: we do not remove the cookie.  */
 260       result.cookie.n_bytes = NULL;
 261       result.cookie.n_len = 0;
 262     freeres:
 263       xdr_free ((xdrproc_t) _xdr_nis_result, (char *) &result);
 264       memset (&result, '\0', sizeof (result));
 265     }
 266   while (!parse_res);
 267
 268   return retval;
 269 }
 270
 271 enum nss_status
 272 _nss_nisplus_getgrent_r (struct group *result, char *buffer, size_t buflen,
 273                          int *errnop)
 274 {
 275   int status;
 276
 277   __libc_lock_lock (lock);
 278
 279   status = internal_nisplus_getgrent_r (result, buffer, buflen, errnop);
 280
 281   __libc_lock_unlock (lock);
 282
 283   return status;
 284 }
 285
 286 enum nss_status
 287 _nss_nisplus_getgrnam_r (const char *name, struct group *gr,
 288                          char *buffer, size_t buflen, int *errnop)
 289 {
 290   int parse_res;
 291
 292   if (grp_tablename_val == NULL)
 293     {
 294       enum nss_status status = _nss_grp_create_tablename (errnop);
 295
 296       if (status != NSS_STATUS_SUCCESS)
 297         return status;
 298     }
 299
 300   if (name == NULL)
 301     {
 302       *errnop = EINVAL;
 303       return NSS_STATUS_NOTFOUND;
 304     }
 305
 306   nis_result *result;
 307   char buf[strlen (name) + 9 + grp_tablename_len];
 308   int olderr = errno;
 309
 310   snprintf (buf, sizeof (buf), "[name=%s],%s", name, grp_tablename_val);
 311
 312   result = nis_list (buf, FOLLOW_LINKS | FOLLOW_PATH, NULL, NULL);
 313
 314   if (result == NULL)
 315     {
 316       *errnop = ENOMEM;
 317       return NSS_STATUS_TRYAGAIN;
 318     }
 319
 320   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 321     {
 322       enum nss_status status = niserr2nss (result->status);
 323
 324       nis_freeresult (result);
 325       return status;
 326     }
 327
 328   parse_res = _nss_nisplus_parse_grent (result, gr, buffer, buflen, errnop);
 329   nis_freeresult (result);
 330   if (__builtin_expect (parse_res < 1, 0))
 331     {
 332       if (parse_res == -1)
 333         {
 334           *errnop = ERANGE;
 335           return NSS_STATUS_TRYAGAIN;
 336         }
 337       else
 338         {
 339           __set_errno (olderr);
 340           return NSS_STATUS_NOTFOUND;
 341         }
 342     }
 343
 344   return NSS_STATUS_SUCCESS;
 345 }
 346
 347 enum nss_status
 348 _nss_nisplus_getgrgid_r (const gid_t gid, struct group *gr,
 349                          char *buffer, size_t buflen, int *errnop)
 350 {
 351   if (grp_tablename_val == NULL)
 352     {
 353       enum nss_status status = _nss_grp_create_tablename (errnop);
 354
 355       if (status != NSS_STATUS_SUCCESS)
 356         return status;
 357     }
 358
 359   int parse_res;
 360   nis_result *result;
 361   char buf[8 + 3 * sizeof (unsigned long int) + grp_tablename_len];
 362   int olderr = errno;
 363
 364   snprintf (buf, sizeof (buf), "[gid=%lu],%s",
 365             (unsigned long int) gid, grp_tablename_val);
 366
 367   result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 368
 369   if (result == NULL)
 370     {
 371       *errnop = ENOMEM;
 372       return NSS_STATUS_TRYAGAIN;
 373     }
 374
 375   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 376     {
 377       enum nss_status status = niserr2nss (result->status);
 378
 379       __set_errno (olderr);
 380
 381       nis_freeresult (result);
 382       return status;
 383     }
 384
 385   parse_res = _nss_nisplus_parse_grent (result, gr, buffer, buflen, errnop);
 386
 387   nis_freeresult (result);
 388   if (__builtin_expect (parse_res < 1, 0))
 389     {
 390       __set_errno (olderr);
 391
 392       if (parse_res == -1)
 393         {
 394           *errnop = ERANGE;
 395           return NSS_STATUS_TRYAGAIN;
 396         }
 397       else
 398         return NSS_STATUS_NOTFOUND;
 399     }
 400
 401   return NSS_STATUS_SUCCESS;
 402 }