Some uid/gid fixes for (id_t)-1 and other large ID values.

[rsync/rsync.git] / uidlist.c

diff --git a/uidlist.c b/uidlist.c
index 5d3d1f3..c6639ad 100644 (file)
--- a/uidlist.c
+++ b/uidlist.c
@@ -43,8 +43,6 @@ extern char *groupmap;
 # endif
 #endif
 
-#define GID_NONE ((gid_t)-1)
-
 #define NFLAGS_WILD_NAME_MATCH (1<<0)
 #define NFLAGS_NAME_MATCH (1<<1)
 
@@ -58,6 +56,26 @@ struct idlist {
 static struct idlist *uidlist, *uidmap;
 static struct idlist *gidlist, *gidmap;
 
+static id_t id_parse(const char *num_str)
+{
+       id_t tmp, num = 0;
+       const char *cp = num_str;
+
+       while (*cp) {
+               if (!isDigit(cp)) {
+                 invalid_num:
+                       rprintf(FERROR, "Invalid ID number: %s\n", num_str);
+                       exit_cleanup(RERR_SYNTAX);
+               }
+               tmp = num * 10 + *cp++ - '0';
+               if (tmp < num)
+                       goto invalid_num;
+               num = tmp;
+       }
+
+       return num;
+}
+
 static struct idlist *add_to_list(struct idlist **root, id_t id, const char *name,
                                  id_t id2, uint16 flags)
 {
@@ -74,7 +92,7 @@ static struct idlist *add_to_list(struct idlist **root, id_t id, const char *nam
 }
 
 /* turn a uid into a user name */
-static const char *uid_to_name(uid_t uid)
+char *uid_to_user(uid_t uid)
 {
        struct passwd *pass = getpwuid(uid);
        if (pass)
@@ -83,7 +101,7 @@ static const char *uid_to_name(uid_t uid)
 }
 
 /* turn a gid into a group name */
-static const char *gid_to_name(gid_t gid)
+char *gid_to_group(gid_t gid)
 {
        struct group *grp = getgrgid(gid);
        if (grp)
@@ -91,15 +109,47 @@ static const char *gid_to_name(gid_t gid)
        return NULL;
 }
 
+/* Parse a user name or (optionally) a number into a uid */
+int user_to_uid(const char *name, uid_t *uid_p, BOOL num_ok)
+{
+       struct passwd *pass;
+       if (!name || !*name)
+               return 0;
+       if (num_ok && name[strspn(name, "0123456789")] == '\0') {
+               *uid_p = id_parse(name);
+               return 1;
+       }
+       if (!(pass = getpwnam(name)))
+               return 0;
+       *uid_p = pass->pw_uid;
+       return 1;
+}
+
+/* Parse a group name or (optionally) a number into a gid */
+int group_to_gid(const char *name, gid_t *gid_p, BOOL num_ok)
+{
+       struct group *grp;
+       if (!name || !*name)
+               return 0;
+       if (num_ok && name[strspn(name, "0123456789")] == '\0') {
+               *gid_p = id_parse(name);
+               return 1;
+       }
+       if (!(grp = getgrnam(name)))
+               return 0;
+       *gid_p = grp->gr_gid;
+       return 1;
+}
+
 static int is_in_group(gid_t gid)
 {
 #ifdef HAVE_GETGROUPS
-       static gid_t last_in = GID_NONE, last_out;
-       static int ngroups = -2;
+       static gid_t last_in;
+       static int ngroups = -2, last_out = -1;
        static GETGROUPS_T *gidset;
        int n;
 
-       if (gid == last_in)
+       if (gid == last_in && last_out >= 0)
                return last_out;
        if (ngroups < -1) {
                if ((ngroups = getgroups(0, NULL)) < 0)
@@ -162,7 +212,7 @@ static struct idlist *recv_add_id(struct idlist **idlist_ptr, struct idlist *idm
                        if (strcmp(node->name, name) != 0)
                                continue;
                } else if (node->name) {
-                       if (id < node->id || id > (unsigned long)node->name)
+                       if (id < node->id || (unsigned long)id > (unsigned long)node->name)
                                continue;
                } else {
                        if (node->id != id)
@@ -198,13 +248,11 @@ static struct idlist *recv_add_id(struct idlist **idlist_ptr, struct idlist *idm
 /* this function is a definate candidate for a faster algorithm */
 uid_t match_uid(uid_t uid)
 {
-       static uid_t last_in = -1, last_out = -1;
+       static struct idlist *last = NULL;
        struct idlist *list;
 
-       if (uid == last_in)
-               return last_out;
-
-       last_in = uid;
+       if (last && uid == last->id)
+               return last->id2;
 
        for (list = uidlist; list; list = list->next) {
                if (list->id == uid)
@@ -213,8 +261,9 @@ uid_t match_uid(uid_t uid)
 
        if (!list)
                list = recv_add_id(&uidlist, uidmap, uid, NULL);
+       last = list;
 
-       return last_out = list->id2;
+       return list->id2;
 }
 
 gid_t match_gid(gid_t gid, uint16 *flags_ptr)
@@ -253,7 +302,7 @@ const char *add_uid(uid_t uid)
                        return NULL;
        }
 
-       node = add_to_list(&uidlist, uid, uid_to_name(uid), 0, 0);
+       node = add_to_list(&uidlist, uid, uid_to_user(uid), 0, 0);
        return node->name;
 }
 
@@ -271,7 +320,7 @@ const char *add_gid(gid_t gid)
                        return NULL;
        }
 
-       node = add_to_list(&gidlist, gid, gid_to_name(gid), 0, 0);
+       node = add_to_list(&gidlist, gid, gid_to_group(gid), 0, 0);
        return node->name;
 }
 
@@ -414,11 +463,11 @@ void parse_name_map(char *map, BOOL usernames)
                                exit_cleanup(RERR_SYNTAX);
                        }
                        if (dash)
-                               name = (char *)atol(dash+1);
+                               name = (char *)id_parse(dash+1);
                        else
                                name = (char *)0;
                        flags = 0;
-                       id1 = atol(cp);
+                       id1 = id_parse(cp);
                } else if (strpbrk(cp, "*[?")) {
                        flags = NFLAGS_WILD_NAME_MATCH;
                        name = cp;
@@ -457,5 +506,29 @@ void parse_name_map(char *map, BOOL usernames)
 
        /* The 0 user/group doesn't get its name sent, so add it explicitly. */
        recv_add_id(idlist_ptr, *idmap_ptr, 0,
-                   numeric_ids ? NULL : usernames ? uid_to_name(0) : gid_to_name(0));
+                   numeric_ids ? NULL : usernames ? uid_to_user(0) : gid_to_group(0));
 }
+
+#ifdef HAVE_GETGROUPLIST
+const char *getallgroups(uid_t uid, gid_t *gid_list, int *size_ptr)
+{
+       struct passwd *pw;
+       if ((pw = getpwuid(uid)) == NULL)
+               return "getpwuid failed";
+       /* Get all the process's groups, with the pw_gid group first. */
+       if (getgrouplist(pw->pw_name, pw->pw_gid, gid_list, size_ptr) < 0)
+               return "getgrouplist failed";
+       /* Paranoia: is the default group not first in the list? */
+       if (gid_list[0] != pw->pw_gid) {
+               int j;
+               for (j = 0; j < *size_ptr; j++) {
+                       if (gid_list[j] == pw->pw_gid) {
+                               gid_list[j] = gid_list[0];
+                               gid_list[0] = pw->pw_gid;
+                               break;
+                       }
+               }
+       }
+       return NULL;
+}
+#endif