nis/nis_subr.c

   1 /* Copyright (c) 1997, 1999, 2000, 2004 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 (i > buflen - 1)
  43     {
  44       __set_errno (ERANGE);
  45       return NULL;
  46     }
  47
  48   if (i > 0)
  49     {
  50       if ((size_t)i >= buflen)
  51         {
  52           __set_errno (ERANGE);
  53           return NULL;
  54         }
  55
  56       *((char *) __mempcpy (buffer, name, i)) = '\0';
  57     }
  58
  59   return buffer;
  60 }
  61 libnsl_hidden_def (nis_leaf_of_r)
  62
  63 nis_name
  64 nis_name_of (const_nis_name name)
  65 {
  66   static char result[NIS_MAXNAMELEN + 1];
  67
  68   return nis_name_of_r (name, result, NIS_MAXNAMELEN);
  69 }
  70
  71 nis_name
  72 nis_name_of_r (const_nis_name name, char *buffer, size_t buflen)
  73 {
  74   char *local_domain;
  75   int diff;
  76
  77   local_domain = nis_local_directory ();
  78
  79   diff = strlen (name) - strlen (local_domain);
  80   if (diff <= 0)
  81     return NULL;
  82
  83   if (strcmp (&name[diff], local_domain) != 0)
  84     return NULL;
  85
  86   if ((size_t) diff >= buflen)
  87     {
  88       __set_errno (ERANGE);
  89       return NULL;
  90     }
  91
  92   *((char *) __mempcpy (buffer, name, diff - 1)) = '\0';
  93
  94   if (diff - 1 == 0)
  95     return NULL;
  96
  97   return buffer;
  98 }
  99 libnsl_hidden_def (nis_name_of_r)
 100
 101 static int
 102 count_dots (const_nis_name str)
 103 {
 104   int count = 0;
 105   size_t l = strlen (str);
 106
 107   for (size_t i = 0; i < l; ++i)
 108     if (str[i] == '.')
 109       ++count;
 110
 111   return count;
 112 }
 113
 114 /* If we run out of memory, we don't give already allocated memory
 115    free. The overhead for bringing getnames back in a safe state to
 116    free it is to big. */
 117 nis_name *
 118 nis_getnames (const_nis_name name)
 119 {
 120   nis_name *getnames = NULL;
 121   char local_domain[NIS_MAXNAMELEN + 1];
 122   char *path;
 123   char *cp;
 124   int count;
 125   int pos = 0;
 126   int have_point;
 127   char *saveptr;
 128
 129   strncpy (local_domain, nis_local_directory (), NIS_MAXNAMELEN);
 130   local_domain[NIS_MAXNAMELEN] = '\0';
 131
 132   count = 1;
 133   getnames = malloc ((count + 1) * sizeof (char *));
 134   if (__builtin_expect (getnames == NULL, 0))
 135       return NULL;
 136
 137   /* Do we have a fully qualified NIS+ name ? If yes, give it back */
 138   if (name[strlen (name) - 1] == '.')
 139     {
 140       if ((getnames[0] = strdup (name)) == NULL)
 141         {
 142         free_null:
 143           while (pos-- > 0)
 144             free (getnames[pos]);
 145           free (getnames);
 146           return NULL;
 147         }
 148
 149       getnames[1] = NULL;
 150
 151       return getnames;
 152     }
 153
 154   /* Get the search path, where we have to search "name" */
 155   path = getenv ("NIS_PATH");
 156   if (path == NULL)
 157     path = strdupa ("$");
 158   else
 159     path = strdupa (path);
 160
 161   have_point = (strchr (name, '.') != NULL);
 162
 163   cp = __strtok_r (path, ":", &saveptr);
 164   while (cp)
 165     {
 166       if (strcmp (cp, "$") == 0)
 167         {
 168           char *cptr = local_domain;
 169           char *tmp;
 170
 171           while ((have_point && *cptr != '\0') || (count_dots (cptr) >= 2))
 172             {
 173               if (pos >= count)
 174                 {
 175                   count += 5;
 176                   nis_name *newp = realloc (getnames,
 177                                             (count + 1) * sizeof (char *));
 178                   if (__builtin_expect (newp == NULL, 0))
 179                     goto free_null;
 180                   getnames = newp;
 181                 }
 182               tmp = malloc (strlen (cptr) + strlen (local_domain) +
 183                             strlen (name) + 2);
 184               if (__builtin_expect (tmp == NULL, 0))
 185                 goto free_null;
 186
 187               getnames[pos] = tmp;
 188               tmp = stpcpy (tmp, name);
 189               *tmp++ = '.';
 190               if (cptr[1] != '\0')
 191                 stpcpy (tmp, cptr);
 192               else
 193                 ++cptr;
 194
 195               ++pos;
 196
 197               while (*cptr != '.' && *cptr != '\0')
 198                 ++cptr;
 199               if (cptr[0] != '\0' && cptr[1] != '\0')
 200                 /* If we have only ".", don't remove the "." */
 201                 ++cptr;
 202             }
 203         }
 204       else
 205         {
 206           char *tmp;
 207           size_t cplen = strlen (cp);
 208
 209           if (cp[cplen - 1] == '$')
 210             {
 211               char *p;
 212
 213               tmp = malloc (cplen + strlen (local_domain) + strlen (name) + 2);
 214               if (__builtin_expect (tmp == NULL, 0))
 215                 goto free_null;
 216
 217               p = __stpcpy (tmp, name);
 218               *p++ = '.';
 219               p = __mempcpy (p, cp, cplen);
 220               --p;
 221               if (p[-1] != '.')
 222                 *p++ = '.';
 223               __stpcpy (p, local_domain);
 224             }
 225           else
 226             {
 227               char *p;
 228
 229               tmp = malloc (cplen + strlen (name) + 2);
 230               if (__builtin_expect (tmp == NULL, 0))
 231                 goto free_null;
 232
 233               p = __stpcpy (tmp, name);
 234               *p++ = '.';
 235               memcpy (p, cp, cplen + 1);
 236             }
 237
 238           if (pos >= count)
 239             {
 240               count += 5;
 241               nis_name *newp = realloc (getnames,
 242                                         (count + 1) * sizeof (char *));
 243               if (__builtin_expect (newp == NULL, 0))
 244                 goto free_null;
 245               getnames = newp;
 246             }
 247           getnames[pos] = tmp;
 248           ++pos;
 249         }
 250       cp = __strtok_r (NULL, ":", &saveptr);
 251     }
 252
 253   getnames[pos] = NULL;
 254
 255   return getnames;
 256 }
 257 libnsl_hidden_def (nis_getnames)
 258
 259 void
 260 nis_freenames (nis_name *names)
 261 {
 262   int i = 0;
 263
 264   while (names[i] != NULL)
 265     {
 266       free (names[i]);
 267       ++i;
 268     }
 269
 270   free (names);
 271 }
 272 libnsl_hidden_def  (nis_freenames)
 273
 274 name_pos
 275 nis_dir_cmp (const_nis_name n1, const_nis_name n2)
 276 {
 277   int len1, len2;
 278
 279   len1 = strlen (n1);
 280   len2 = strlen (n2);
 281
 282   if (len1 == len2)
 283     {
 284       if (strcmp (n1, n2) == 0)
 285         return SAME_NAME;
 286       else
 287         return NOT_SEQUENTIAL;
 288     }
 289
 290   if (len1 < len2)
 291     {
 292       if (n2[len2 - len1 - 1] != '.')
 293         return NOT_SEQUENTIAL;
 294       else if (strcmp (&n2[len2 - len1], n1) == 0)
 295         return HIGHER_NAME;
 296       else
 297         return NOT_SEQUENTIAL;
 298     }
 299   else
 300     {
 301       if (n1[len1 - len2 - 1] != '.')
 302         return NOT_SEQUENTIAL;
 303       else if (strcmp (&n1[len1 - len2], n2) == 0)
 304         return LOWER_NAME;
 305       else
 306         return NOT_SEQUENTIAL;
 307
 308     }
 309 }
 310 libnsl_hidden_def (nis_dir_cmp)
 311
 312 void
 313 nis_destroy_object (nis_object *obj)
 314 {
 315   nis_free_object (obj);
 316 }
 317 libnsl_hidden_def (nis_destroy_object)