nis/nis_subr.c

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