nis/nis_subr.c

   1 /* Copyright (c) 1997,1999,2000,2004,2005,2006 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <errno.h>
  21 #include <string.h>
  22 #include <rpcsvc/nis.h>
  23
  24 nis_name
  25 nis_leaf_of (const_nis_name name)
  26 {
  27   static char result[NIS_MAXNAMELEN + 1];
  28
  29   return nis_leaf_of_r (name, result, NIS_MAXNAMELEN);
  30 }
  31
  32 nis_name
  33 nis_leaf_of_r (const_nis_name name, char *buffer, size_t buflen)
  34 {
  35   size_t i = 0;
  36
  37   buffer[0] = '\0';
  38
  39   while (name[i] != '.' && name[i] != '\0')
  40     i++;
  41
  42   if (__builtin_expect (i >= buflen, 0))
  43     {
  44       __set_errno (ERANGE);
  45       return NULL;
  46     }
  47
  48   *((char *) __mempcpy (buffer, name, i)) = '\0';
  49
  50   return buffer;
  51 }
  52 libnsl_hidden_def (nis_leaf_of_r)
  53
  54 nis_name
  55 nis_name_of (const_nis_name name)
  56 {
  57   static char result[NIS_MAXNAMELEN + 1];
  58
  59   return nis_name_of_r (name, result, NIS_MAXNAMELEN);
  60 }
  61
  62 nis_name
  63 nis_name_of_r (const_nis_name name, char *buffer, size_t buflen)
  64 {
  65   char *local_domain;
  66   int diff;
  67
  68   local_domain = nis_local_directory ();
  69
  70   diff = strlen (name) - strlen (local_domain);
  71   if (diff <= 0)
  72     return NULL;
  73
  74   if (strcmp (&name[diff], local_domain) != 0)
  75     return NULL;
  76
  77   if ((size_t) diff >= buflen)
  78     {
  79       __set_errno (ERANGE);
  80       return NULL;
  81     }
  82
  83   *((char *) __mempcpy (buffer, name, diff - 1)) = '\0';
  84
  85   if (diff - 1 == 0)
  86     return NULL;
  87
  88   return buffer;
  89 }
  90 libnsl_hidden_def (nis_name_of_r)
  91
  92 static int __always_inline
  93 count_dots (const_nis_name str)
  94 {
  95   int count = 0;
  96
  97   for (size_t i = 0; str[i] != '\0'; ++i)
  98     if (str[i] == '.')
  99       ++count;
 100
 101   return count;
 102 }
 103
 104 /* If we run out of memory, we don't give already allocated memory
 105    free. The overhead for bringing getnames back in a safe state to
 106    free it is to big. */
 107 nis_name *
 108 nis_getnames (const_nis_name name)
 109 {
 110   const char *local_domain = nis_local_directory ();
 111   size_t local_domain_len = strlen (local_domain);
 112   size_t name_len = strlen (name);
 113   char *path;
 114   int pos = 0;
 115   char *saveptr;
 116   int have_point;
 117   const char *cp;
 118   const char *cp2;
 119
 120   int count = 2;
 121   nis_name *getnames = malloc ((count + 1) * sizeof (char *));
 122   if (__builtin_expect (getnames == NULL, 0))
 123       return NULL;
 124
 125   /* Do we have a fully qualified NIS+ name ? If yes, give it back */
 126   if (name[name_len - 1] == '.')
 127     {
 128       if ((getnames[0] = strdup (name)) == NULL)
 129         {
 130         free_null:
 131           while (pos-- > 0)
 132             free (getnames[pos]);
 133           free (getnames);
 134           return NULL;
 135         }
 136
 137       getnames[1] = NULL;
 138
 139       return getnames;
 140     }
 141
 142   /* If the passed NAME is shared a suffix (the latter of course with
 143      a final dot) with each other we pass back NAME with a final
 144      dot.  */
 145   if (local_domain_len > 2)
 146     {
 147       have_point = 0;
 148       cp = &local_domain[local_domain_len - 2];
 149       cp2 = &name[name_len - 1];
 150
 151       while (*cp == *cp2)
 152         {
 153           if (*cp == '.')
 154             have_point = 1;
 155           --cp;
 156           --cp2;
 157           if (cp < local_domain)
 158             {
 159               have_point = cp2 < name || *cp2 == '.';
 160               break;
 161             }
 162           if (cp2 < name)
 163             {
 164               have_point = *cp == '.';
 165               break;
 166             }
 167         }
 168
 169       if (have_point)
 170         {
 171           getnames[0] = malloc (name_len + 2);
 172           if (getnames[0] == NULL)
 173             goto free_null;
 174
 175           strcpy (stpcpy (getnames[0], name), ".");
 176           ++pos;
 177         }
 178     }
 179
 180   /* Get the search path, where we have to search "name" */
 181   path = getenv ("NIS_PATH");
 182   if (path == NULL)
 183     path = strdupa ("$");
 184   else
 185     path = strdupa (path);
 186
 187   have_point = strchr (name, '.') != NULL;
 188
 189   cp = __strtok_r (path, ":", &saveptr);
 190   while (cp)
 191     {
 192       if (strcmp (cp, "$") == 0)
 193         {
 194           const char *cptr = local_domain;
 195           char *tmp;
 196
 197           while (*cptr != '\0' && count_dots (cptr) >= 2)
 198             {
 199               if (pos >= count)
 200                 {
 201                   count += 5;
 202                   nis_name *newp = realloc (getnames,
 203                                             (count + 1) * sizeof (char *));
 204                   if (__builtin_expect (newp == NULL, 0))
 205                     goto free_null;
 206                   getnames = newp;
 207                 }
 208               tmp = malloc (strlen (cptr) + local_domain_len + name_len + 2);
 209               if (__builtin_expect (tmp == NULL, 0))
 210                 goto free_null;
 211
 212               getnames[pos] = tmp;
 213               tmp = stpcpy (tmp, name);
 214               *tmp++ = '.';
 215               if (cptr[1] != '\0')
 216                 stpcpy (tmp, cptr);
 217               else
 218                 ++cptr;
 219
 220               ++pos;
 221
 222               while (*cptr != '.' && *cptr != '\0')
 223                 ++cptr;
 224               if (cptr[0] != '\0' && cptr[1] != '\0')
 225                 /* If we have only ".", don't remove the "." */
 226                 ++cptr;
 227             }
 228         }
 229       else
 230         {
 231           char *tmp;
 232           size_t cplen = strlen (cp);
 233
 234           if (cp[cplen - 1] == '$')
 235             {
 236               char *p;
 237
 238               tmp = malloc (cplen + local_domain_len + name_len + 2);
 239               if (__builtin_expect (tmp == NULL, 0))
 240                 goto free_null;
 241
 242               p = __stpcpy (tmp, name);
 243               *p++ = '.';
 244               p = __mempcpy (p, cp, cplen);
 245               --p;
 246               if (p[-1] != '.')
 247                 *p++ = '.';
 248               __stpcpy (p, local_domain);
 249             }
 250           else
 251             {
 252               char *p;
 253
 254               tmp = malloc (cplen + name_len + 3);
 255               if (__builtin_expect (tmp == NULL, 0))
 256                 goto free_null;
 257
 258               p = __mempcpy (tmp, name, name_len);
 259               *p++ = '.';
 260               p = __mempcpy (p, cp, cplen);
 261               if (p[-1] != '.')
 262                 *p++ = '.';
 263               *p = '\0';
 264             }
 265
 266           if (pos >= count)
 267             {
 268               count += 5;
 269               nis_name *newp = realloc (getnames,
 270                                         (count + 1) * sizeof (char *));
 271               if (__builtin_expect (newp == NULL, 0))
 272                 goto free_null;
 273               getnames = newp;
 274             }
 275           getnames[pos] = tmp;
 276           ++pos;
 277         }
 278       cp = __strtok_r (NULL, ":", &saveptr);
 279     }
 280
 281   if (pos == 0
 282       && __asprintf (&getnames[pos++], "%s%s%s%s",
 283                      name, name[name_len - 1] == '.' ? "" : ".",
 284                      local_domain,
 285                      local_domain[local_domain_len - 1] == '.' ? "" : ".") < 0)
 286     goto free_null;
 287
 288   getnames[pos] = NULL;
 289
 290   return getnames;
 291 }
 292 libnsl_hidden_def (nis_getnames)
 293
 294 void
 295 nis_freenames (nis_name *names)
 296 {
 297   int i = 0;
 298
 299   while (names[i] != NULL)
 300     {
 301       free (names[i]);
 302       ++i;
 303     }
 304
 305   free (names);
 306 }
 307 libnsl_hidden_def  (nis_freenames)
 308
 309 name_pos
 310 nis_dir_cmp (const_nis_name n1, const_nis_name n2)
 311 {
 312   int len1, len2;
 313
 314   len1 = strlen (n1);
 315   len2 = strlen (n2);
 316
 317   if (len1 == len2)
 318     {
 319       if (strcmp (n1, n2) == 0)
 320         return SAME_NAME;
 321       else
 322         return NOT_SEQUENTIAL;
 323     }
 324
 325   if (len1 < len2)
 326     {
 327       if (n2[len2 - len1 - 1] != '.')
 328         return NOT_SEQUENTIAL;
 329       else if (strcmp (&n2[len2 - len1], n1) == 0)
 330         return HIGHER_NAME;
 331       else
 332         return NOT_SEQUENTIAL;
 333     }
 334   else
 335     {
 336       if (n1[len1 - len2 - 1] != '.')
 337         return NOT_SEQUENTIAL;
 338       else if (strcmp (&n1[len1 - len2], n2) == 0)
 339         return LOWER_NAME;
 340       else
 341         return NOT_SEQUENTIAL;
 342
 343     }
 344 }
 345 libnsl_hidden_def (nis_dir_cmp)
 346
 347 void
 348 nis_destroy_object (nis_object *obj)
 349 {
 350   nis_free_object (obj);
 351 }
 352 libnsl_hidden_def (nis_destroy_object)