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