lib/userspec.c

   1 /* userspec.c -- Parse a user and group string.
   2    Copyright (C) 1989-1992, 1997-1998, 2000, 2002-2003 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program 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
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Written by David MacKenzie <djm@gnu.ai.mit.edu>.  */
  19
  20 #if HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include <alloca.h>
  25
  26 #include <stdio.h>
  27 #include <sys/types.h>
  28 #include <pwd.h>
  29 #include <grp.h>
  30
  31 #if HAVE_SYS_PARAM_H
  32 # include <sys/param.h>
  33 #endif
  34
  35 #include <limits.h>
  36
  37 #if HAVE_STRING_H
  38 # include <string.h>
  39 #else
  40 # include <strings.h>
  41 # ifndef strchr
  42 #  define strchr index
  43 # endif
  44 #endif
  45
  46 #if STDC_HEADERS
  47 # include <stdlib.h>
  48 #endif
  49
  50 #if HAVE_UNISTD_H
  51 # include <unistd.h>
  52 #endif
  53
  54 #include "posixver.h"
  55 #include "xalloc.h"
  56 #include "xstrtol.h"
  57
  58 #include "gettext.h"
  59 #define _(msgid) gettext (msgid)
  60 #define N_(msgid) msgid
  61
  62 #ifndef _POSIX_VERSION
  63 struct passwd *getpwnam ();
  64 struct group *getgrnam ();
  65 struct group *getgrgid ();
  66 #endif
  67
  68 #ifndef HAVE_ENDGRENT
  69 # define endgrent() ((void) 0)
  70 #endif
  71
  72 #ifndef HAVE_ENDPWENT
  73 # define endpwent() ((void) 0)
  74 #endif
  75
  76 /* The extra casts work around common compiler bugs.  */
  77 #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
  78 /* The outer cast is needed to work around a bug in Cray C 5.0.3.0.
  79    It is necessary at least when t == time_t.  */
  80 #define TYPE_MINIMUM(t) ((t) (TYPE_SIGNED (t) \
  81                               ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) : (t) 0))
  82 #define TYPE_MAXIMUM(t) ((t) (~ (t) 0 - TYPE_MINIMUM (t)))
  83
  84 #ifndef UID_T_MAX
  85 # define UID_T_MAX TYPE_MAXIMUM (uid_t)
  86 #endif
  87
  88 #ifndef GID_T_MAX
  89 # define GID_T_MAX TYPE_MAXIMUM (gid_t)
  90 #endif
  91
  92 /* MAXUID may come from limits.h or sys/params.h.  */
  93 #ifndef MAXUID
  94 # define MAXUID UID_T_MAX
  95 #endif
  96 #ifndef MAXGID
  97 # define MAXGID GID_T_MAX
  98 #endif
  99
 100 /* Perform the equivalent of the statement `dest = strdup (src);',
 101    but obtaining storage via alloca instead of from the heap.  */
 102
 103 #define V_STRDUP(dest, src)                                             \
 104   do                                                                    \
 105     {                                                                   \
 106       int _len = strlen ((src));                                        \
 107       (dest) = (char *) alloca (_len + 1);                              \
 108       strcpy (dest, src);                                               \
 109     }                                                                   \
 110   while (0)
 111
 112 /* ISDIGIT differs from isdigit, as follows:
 113    - Its arg may be any int or unsigned int; it need not be an unsigned char.
 114    - It's guaranteed to evaluate its argument exactly once.
 115    - It's typically faster.
 116    POSIX says that only '0' through '9' are digits.  Prefer ISDIGIT to
 117    ISDIGIT_LOCALE unless it's important to use the locale's definition
 118    of `digit' even when the host does not conform to POSIX.  */
 119 #define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
 120
 121 #ifndef strdup
 122 char *strdup ();
 123 #endif
 124
 125 /* Return nonzero if STR represents an unsigned decimal integer,
 126    otherwise return 0. */
 127
 128 static int
 129 is_number (const char *str)
 130 {
 131   for (; *str; str++)
 132     if (!ISDIGIT (*str))
 133       return 0;
 134   return 1;
 135 }
 136
 137 /* Extract from NAME, which has the form "[user][:.][group]",
 138    a USERNAME, UID U, GROUPNAME, and GID G.
 139    Either user or group, or both, must be present.
 140    If the group is omitted but the ":" separator is given,
 141    use the given user's login group.
 142    If SPEC_ARG contains a `:', then use that as the separator, ignoring
 143    any `.'s.  If there is no `:', but there is a `.', then first look
 144    up the entire SPEC_ARG as a login name.  If that look-up fails, then
 145    try again interpreting the `.'  as a separator.
 146
 147    USERNAME and GROUPNAME will be in newly malloc'd memory.
 148    Either one might be NULL instead, indicating that it was not
 149    given and the corresponding numeric ID was left unchanged.
 150
 151    Return NULL if successful, a static error message string if not.  */
 152
 153 const char *
 154 parse_user_spec (const char *spec_arg, uid_t *uid, gid_t *gid,
 155                  char **username_arg, char **groupname_arg)
 156 {
 157   static const char *E_invalid_user = N_("invalid user");
 158   static const char *E_invalid_group = N_("invalid group");
 159   static const char *E_bad_spec =
 160     N_("cannot get the login group of a numeric UID");
 161   static const char *E_cannot_omit_both =
 162     N_("cannot omit both user and group");
 163
 164   const char *error_msg;
 165   char *spec;                   /* A copy we can write on.  */
 166   struct passwd *pwd;
 167   struct group *grp;
 168   char *g, *u, *separator;
 169   char *groupname;
 170   int maybe_retry = 0;
 171   char *dot = NULL;
 172
 173   error_msg = NULL;
 174   *username_arg = *groupname_arg = NULL;
 175   groupname = NULL;
 176
 177   V_STRDUP (spec, spec_arg);
 178
 179   /* Find the POSIX `:' separator if there is one.  */
 180   separator = strchr (spec, ':');
 181
 182   /* If there is no colon, then see if there's a `.'.  */
 183   if (separator == NULL && posix2_version () < 200112)
 184     {
 185       dot = strchr (spec, '.');
 186       /* If there's no colon but there is a `.', then first look up the
 187          whole spec, in case it's an OWNER name that includes a dot.
 188          If that fails, then we'll try again, but interpreting the `.'
 189          as a separator.  */
 190       /* FIXME: accepting `.' as the separator is contrary to POSIX.
 191          someday we should drop support for this.  */
 192       if (dot)
 193         maybe_retry = 1;
 194     }
 195
 196  retry:
 197
 198   /* Replace separator with a NUL.  */
 199   if (separator != NULL)
 200     *separator = '\0';
 201
 202   /* Set U and G to non-zero length strings corresponding to user and
 203      group specifiers or to NULL.  */
 204   u = (*spec == '\0' ? NULL : spec);
 205
 206   g = (separator == NULL || *(separator + 1) == '\0'
 207        ? NULL
 208        : separator + 1);
 209
 210   if (u == NULL && g == NULL)
 211     return _(E_cannot_omit_both);
 212
 213 #ifdef __DJGPP__
 214   /* Pretend that we are the user U whose group is G.  This makes
 215      pwd and grp functions ``know'' about the UID and GID of these.  */
 216   if (u && !is_number (u))
 217     setenv ("USER", u, 1);
 218   if (g && !is_number (g))
 219     setenv ("GROUP", g, 1);
 220 #endif
 221
 222   if (u != NULL)
 223     {
 224       pwd = getpwnam (u);
 225       if (pwd == NULL)
 226         {
 227
 228           if (!is_number (u))
 229             error_msg = E_invalid_user;
 230           else
 231             {
 232               int use_login_group;
 233               use_login_group = (separator != NULL && g == NULL);
 234               if (use_login_group)
 235                 error_msg = E_bad_spec;
 236               else
 237                 {
 238                   unsigned long int tmp_long;
 239                   if (xstrtoul (u, NULL, 0, &tmp_long, NULL) != LONGINT_OK
 240                       || tmp_long > MAXUID)
 241                     return _(E_invalid_user);
 242                   *uid = tmp_long;
 243                 }
 244             }
 245         }
 246       else
 247         {
 248           *uid = pwd->pw_uid;
 249           if (g == NULL && separator != NULL)
 250             {
 251               /* A separator was given, but a group was not specified,
 252                  so get the login group.  */
 253               *gid = pwd->pw_gid;
 254               grp = getgrgid (pwd->pw_gid);
 255               if (grp == NULL)
 256                 {
 257                   /* This is enough room to hold the unsigned decimal
 258                      representation of any 32-bit quantity and the trailing
 259                      zero byte.  */
 260                   char uint_buf[21];
 261                   sprintf (uint_buf, "%u", (unsigned) (pwd->pw_gid));
 262                   V_STRDUP (groupname, uint_buf);
 263                 }
 264               else
 265                 {
 266                   V_STRDUP (groupname, grp->gr_name);
 267                 }
 268               endgrent ();
 269             }
 270         }
 271       endpwent ();
 272     }
 273
 274   if (g != NULL && error_msg == NULL)
 275     {
 276       /* Explicit group.  */
 277       grp = getgrnam (g);
 278       if (grp == NULL)
 279         {
 280           if (!is_number (g))
 281             error_msg = E_invalid_group;
 282           else
 283             {
 284               unsigned long int tmp_long;
 285               if (xstrtoul (g, NULL, 0, &tmp_long, NULL) != LONGINT_OK
 286                   || tmp_long > MAXGID)
 287                 return _(E_invalid_group);
 288               *gid = tmp_long;
 289             }
 290         }
 291       else
 292         *gid = grp->gr_gid;
 293       endgrent ();              /* Save a file descriptor.  */
 294
 295       if (error_msg == NULL)
 296         V_STRDUP (groupname, g);
 297     }
 298
 299   if (error_msg == NULL)
 300     {
 301       if (u != NULL)
 302         {
 303           *username_arg = strdup (u);
 304           if (*username_arg == NULL)
 305             error_msg = xalloc_msg_memory_exhausted;
 306         }
 307
 308       if (groupname != NULL && error_msg == NULL)
 309         {
 310           *groupname_arg = strdup (groupname);
 311           if (*groupname_arg == NULL)
 312             {
 313               if (*username_arg != NULL)
 314                 {
 315                   free (*username_arg);
 316                   *username_arg = NULL;
 317                 }
 318               error_msg = xalloc_msg_memory_exhausted;
 319             }
 320         }
 321     }
 322
 323   if (error_msg && maybe_retry)
 324     {
 325       maybe_retry = 0;
 326       separator = dot;
 327       error_msg = NULL;
 328       goto retry;
 329     }
 330
 331   return _(error_msg);
 332 }
 333
 334 #ifdef TEST
 335
 336 # define NULL_CHECK(s) ((s) == NULL ? "(null)" : (s))
 337
 338 int
 339 main (int argc, char **argv)
 340 {
 341   int i;
 342
 343   for (i = 1; i < argc; i++)
 344     {
 345       const char *e;
 346       char *username, *groupname;
 347       uid_t uid;
 348       gid_t gid;
 349       char *tmp;
 350
 351       tmp = strdup (argv[i]);
 352       e = parse_user_spec (tmp, &uid, &gid, &username, &groupname);
 353       free (tmp);
 354       printf ("%s: %u %u %s %s %s\n",
 355               argv[i],
 356               (unsigned int) uid,
 357               (unsigned int) gid,
 358               NULL_CHECK (username),
 359               NULL_CHECK (groupname),
 360               NULL_CHECK (e));
 361     }
 362
 363   exit (0);
 364 }
 365
 366 #endif