nis/nss_nisplus/nisplus-grp.c

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