48e0318dd8c5876c24b331f96ad725a2422bbd01
[rsync.git] / uidlist.c
1 /*
2  * Handle the mapping of uid/gid and user/group names between systems.
3  *
4  * Copyright (C) 1996 Andrew Tridgell
5  * Copyright (C) 1996 Paul Mackerras
6  * Copyright (C) 2004-2007 Wayne Davison
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, visit the http://fsf.org website.
20  */
21
22 /* If the source username/group does not exist on the target then use
23  * the numeric IDs.  Never do any mapping for uid=0 or gid=0 as these
24  * are special. */
25
26 #include "rsync.h"
27 #include "io.h"
28
29 extern int verbose;
30 extern int am_root;
31 extern int preserve_uid;
32 extern int preserve_gid;
33 extern int preserve_acls;
34 extern int numeric_ids;
35
36 #ifdef HAVE_GETGROUPS
37 # ifndef GETGROUPS_T
38 #  define GETGROUPS_T gid_t
39 # endif
40 #endif
41
42 #define GID_NONE ((gid_t)-1)
43
44 struct idlist {
45         struct idlist *next;
46         const char *name;
47         id_t id, id2;
48         uint16 flags;
49 };
50
51 static struct idlist *uidlist;
52 static struct idlist *gidlist;
53
54 static struct idlist *add_to_list(struct idlist **root, id_t id, const char *name,
55                                   id_t id2, uint16 flags)
56 {
57         struct idlist *node = new(struct idlist);
58         if (!node)
59                 out_of_memory("add_to_list");
60         node->next = *root;
61         node->name = name;
62         node->id = id;
63         node->id2 = id2;
64         node->flags = flags;
65         *root = node;
66         return node;
67 }
68
69 /* turn a uid into a user name */
70 static const char *uid_to_name(uid_t uid)
71 {
72         struct passwd *pass = getpwuid(uid);
73         if (pass)
74                 return strdup(pass->pw_name);
75         return NULL;
76 }
77
78 /* turn a gid into a group name */
79 static const char *gid_to_name(gid_t gid)
80 {
81         struct group *grp = getgrgid(gid);
82         if (grp)
83                 return strdup(grp->gr_name);
84         return NULL;
85 }
86
87 static uid_t map_uid(uid_t id, char *name)
88 {
89         uid_t uid;
90         if (id != 0 && name_to_uid(name, &uid))
91                 return uid;
92         return id;
93 }
94
95 static gid_t map_gid(gid_t id, char *name)
96 {
97         gid_t gid;
98         if (id != 0 && name_to_gid(name, &gid))
99                 return gid;
100         return id;
101 }
102
103 static int is_in_group(gid_t gid)
104 {
105 #ifdef HAVE_GETGROUPS
106         static gid_t last_in = GID_NONE, last_out;
107         static int ngroups = -2;
108         static GETGROUPS_T *gidset;
109         int n;
110
111         if (gid == last_in)
112                 return last_out;
113         if (ngroups < -1) {
114                 gid_t mygid = MY_GID();
115                 if ((ngroups = getgroups(0, NULL)) < 0)
116                         ngroups = 0;
117                 gidset = new_array(GETGROUPS_T, ngroups+1);
118                 if (!gidset)
119                         out_of_memory("is_in_group");
120                 if (ngroups > 0)
121                         ngroups = getgroups(ngroups, gidset);
122                 /* The default gid might not be in the list on some systems. */
123                 for (n = 0; n < ngroups; n++) {
124                         if (gidset[n] == mygid)
125                                 break;
126                 }
127                 if (n == ngroups)
128                         gidset[ngroups++] = mygid;
129                 if (verbose > 3) {
130                         int pos;
131                         char *gidbuf = new_array(char, ngroups*21+32);
132                         if (!gidbuf)
133                                 out_of_memory("is_in_group");
134                         pos = snprintf(gidbuf, 32, "process has %d gid%s: ",
135                                        ngroups, ngroups == 1? "" : "s");
136                         for (n = 0; n < ngroups; n++) {
137                                 pos += snprintf(gidbuf+pos, 21, " %d", (int)gidset[n]);
138                         }
139                         rprintf(FINFO, "%s\n", gidbuf);
140                         free(gidbuf);
141                 }
142         }
143
144         last_in = gid;
145         for (n = 0; n < ngroups; n++) {
146                 if (gidset[n] == gid)
147                         return last_out = 1;
148         }
149         return last_out = 0;
150
151 #else
152         static gid_t mygid = GID_NONE;
153         if (mygid == GID_NONE) {
154                 mygid = MY_GID();
155                 if (verbose > 3)
156                         rprintf(FINFO, "process has gid %u\n", (unsigned)mygid);
157         }
158         return gid == mygid;
159 #endif
160 }
161
162 /* Add a uid to the list of uids.  Only called on receiving side. */
163 static struct idlist *recv_add_uid(uid_t id, char *name)
164 {
165         uid_t id2 = name ? map_uid(id, name) : id;
166         struct idlist *node;
167
168         node = add_to_list(&uidlist, id, name, id2, 0);
169
170         if (verbose > 3) {
171                 rprintf(FINFO, "uid %u(%s) maps to %u\n",
172                         (unsigned)id, name ? name : "", (unsigned)id2);
173         }
174
175         return node;
176 }
177
178 /* Add a gid to the list of gids.  Only called on receiving side. */
179 static struct idlist *recv_add_gid(gid_t id, char *name)
180 {
181         gid_t id2 = name ? map_gid(id, name) : id;
182         struct idlist *node;
183
184         node = add_to_list(&gidlist, id, name, id2,
185                 !am_root && !is_in_group(id2) ? FLAG_SKIP_GROUP : 0);
186
187         if (verbose > 3) {
188                 rprintf(FINFO, "gid %u(%s) maps to %u\n",
189                         (unsigned)id, name ? name : "", (unsigned)id2);
190         }
191
192         return node;
193 }
194
195 /* this function is a definate candidate for a faster algorithm */
196 uid_t match_uid(uid_t uid)
197 {
198         static uid_t last_in, last_out;
199         struct idlist *list;
200
201         if (uid == 0)
202                 return 0;
203
204         if (uid == last_in)
205                 return last_out;
206
207         last_in = uid;
208
209         for (list = uidlist; list; list = list->next) {
210                 if (list->id == uid)
211                         return last_out = list->id2;
212         }
213
214         return last_out = uid;
215 }
216
217 gid_t match_gid(gid_t gid, uint16 *flags_ptr)
218 {
219         static struct idlist *last = NULL;
220         struct idlist *list;
221
222         if (last && gid == last->id)
223                 list = last;
224         else {
225                 for (list = gidlist; list; list = list->next) {
226                         if (list->id == gid)
227                                 break;
228                 }
229                 if (!list)
230                         list = recv_add_gid(gid, NULL);
231                 last = list;
232         }
233
234         if (flags_ptr && list->flags & FLAG_SKIP_GROUP)
235                 *flags_ptr |= FLAG_SKIP_GROUP;
236         return list->id2;
237 }
238
239 /* Add a uid to the list of uids.  Only called on sending side. */
240 const char *add_uid(uid_t uid)
241 {
242         struct idlist *list;
243         struct idlist *node;
244
245         if (uid == 0)   /* don't map root */
246                 return NULL;
247
248         for (list = uidlist; list; list = list->next) {
249                 if (list->id == uid)
250                         return NULL;
251         }
252
253         node = add_to_list(&uidlist, uid, uid_to_name(uid), 0, 0);
254         return node->name;
255 }
256
257 /* Add a gid to the list of gids.  Only called on sending side. */
258 const char *add_gid(gid_t gid)
259 {
260         struct idlist *list;
261         struct idlist *node;
262
263         if (gid == 0)   /* don't map root */
264                 return NULL;
265
266         for (list = gidlist; list; list = list->next) {
267                 if (list->id == gid)
268                         return NULL;
269         }
270
271         node = add_to_list(&gidlist, gid, gid_to_name(gid), 0, 0);
272         return node->name;
273 }
274
275 /* send a complete uid/gid mapping to the peer */
276 void send_id_list(int f)
277 {
278         struct idlist *list;
279
280         if (preserve_uid || preserve_acls) {
281                 int len;
282                 /* we send sequences of uid/byte-length/name */
283                 for (list = uidlist; list; list = list->next) {
284                         if (!list->name)
285                                 continue;
286                         len = strlen(list->name);
287                         write_varint30(f, list->id);
288                         write_byte(f, len);
289                         write_buf(f, list->name, len);
290                 }
291
292                 /* terminate the uid list with a 0 uid. We explicitly exclude
293                  * 0 from the list */
294                 write_varint30(f, 0);
295         }
296
297         if (preserve_gid || preserve_acls) {
298                 int len;
299                 for (list = gidlist; list; list = list->next) {
300                         if (!list->name)
301                                 continue;
302                         len = strlen(list->name);
303                         write_varint30(f, list->id);
304                         write_byte(f, len);
305                         write_buf(f, list->name, len);
306                 }
307                 write_varint30(f, 0);
308         }
309 }
310
311 uid_t recv_user_name(int f, uid_t uid)
312 {
313         struct idlist *node;
314         int len = read_byte(f);
315         char *name = new_array(char, len+1);
316         if (!name)
317                 out_of_memory("recv_user_name");
318         read_sbuf(f, name, len);
319         node = recv_add_uid(uid, name); /* node keeps name's memory */
320         return node->id2;
321 }
322
323 gid_t recv_group_name(int f, gid_t gid, uint16 *flags_ptr)
324 {
325         struct idlist *node;
326         int len = read_byte(f);
327         char *name = new_array(char, len+1);
328         if (!name)
329                 out_of_memory("recv_group_name");
330         read_sbuf(f, name, len);
331         node = recv_add_gid(gid, name); /* node keeps name's memory */
332         if (flags_ptr && node->flags & FLAG_SKIP_GROUP)
333                 *flags_ptr |= FLAG_SKIP_GROUP;
334         return node->id2;
335 }
336
337 /* recv a complete uid/gid mapping from the peer and map the uid/gid
338  * in the file list to local names */
339 void recv_id_list(int f, struct file_list *flist)
340 {
341         id_t id;
342         int i;
343
344         if ((preserve_uid || preserve_acls) && !numeric_ids) {
345                 /* read the uid list */
346                 while ((id = read_varint30(f)) != 0)
347                         recv_user_name(f, id);
348         }
349
350         if ((preserve_gid || preserve_acls) && !numeric_ids) {
351                 /* read the gid list */
352                 while ((id = read_varint30(f)) != 0)
353                         recv_group_name(f, id, NULL);
354         }
355
356         /* Now convert all the uids/gids from sender values to our values. */
357 #ifdef SUPPORT_ACLS
358         if (preserve_acls && !numeric_ids)
359                 match_acl_ids();
360 #endif
361         if (am_root && preserve_uid && !numeric_ids) {
362                 for (i = 0; i < flist->used; i++)
363                         F_OWNER(flist->files[i]) = match_uid(F_OWNER(flist->files[i]));
364         }
365         if (preserve_gid && (!am_root || !numeric_ids)) {
366                 for (i = 0; i < flist->used; i++) {
367                         F_GROUP(flist->files[i]) = match_gid(F_GROUP(flist->files[i]),
368                                                              &flist->files[i]->flags);
369                 }
370         }
371 }