nfsidmap: Stack variable not being initialized.
[nfs-utils.git] / utils / nfsidmap / nfsidmap.c
1
2 #include <stdarg.h>
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <string.h>
6
7 #include <pwd.h>
8 #include <grp.h>
9 #include <keyutils.h>
10 #include <nfsidmap.h>
11
12 #include <unistd.h>
13 #include "xlog.h"
14
15 int verbose = 0;
16 char *usage="Usage: %s [-v] [-c || [-u|-g|-r key] || [-t timeout] key desc]";
17
18 #define MAX_ID_LEN   11
19 #define IDMAP_NAMESZ 128
20 #define USER  1
21 #define GROUP 0
22
23 #define PROCKEYS "/proc/keys"
24 #ifndef DEFAULT_KEYRING
25 #define DEFAULT_KEYRING "id_resolver"
26 #endif
27
28
29 #define UIDKEYS 0x1
30 #define GIDKEYS 0x2
31
32 /*
33  * Find either a user or group id based on the name@domain string
34  */
35 int id_lookup(char *name_at_domain, key_serial_t key, int type)
36 {
37         char id[MAX_ID_LEN];
38         uid_t uid = 0;
39         gid_t gid = 0;
40         int rc;
41
42         if (type == USER) {
43                 rc = nfs4_owner_to_uid(name_at_domain, &uid);
44                 sprintf(id, "%u", uid);
45         } else {
46                 rc = nfs4_group_owner_to_gid(name_at_domain, &gid);
47                 sprintf(id, "%u", gid);
48         }
49         if (rc < 0)
50                 xlog_err("id_lookup: %s: failed: %m",
51                         (type == USER ? "nfs4_owner_to_uid" : "nfs4_group_owner_to_gid"));
52
53         if (rc == 0) {
54                 rc = keyctl_instantiate(key, id, strlen(id) + 1, 0);
55                 if (rc < 0)
56                         xlog_err("id_lookup: keyctl_instantiate failed: %m");
57         }
58
59         return rc;
60 }
61
62 /*
63  * Find the name@domain string from either a user or group id
64  */
65 int name_lookup(char *id, key_serial_t key, int type)
66 {
67         char name[IDMAP_NAMESZ];
68         char domain[NFS4_MAX_DOMAIN_LEN];
69         uid_t uid;
70         gid_t gid;
71         int rc;
72
73         rc = nfs4_get_default_domain(NULL, domain, NFS4_MAX_DOMAIN_LEN);
74         if (rc != 0) {
75                 rc = -1;
76                 xlog_err("name_lookup: nfs4_get_default_domain failed: %m");
77                 goto out;
78         }
79
80         if (type == USER) {
81                 uid = atoi(id);
82                 rc = nfs4_uid_to_name(uid, domain, name, IDMAP_NAMESZ);
83         } else {
84                 gid = atoi(id);
85                 rc = nfs4_gid_to_name(gid, domain, name, IDMAP_NAMESZ);
86         }
87         if (rc < 0)
88                 xlog_err("name_lookup: %s: failed: %m",
89                         (type == USER ? "nfs4_uid_to_name" : "nfs4_gid_to_name"));
90
91         if (rc == 0) {
92                 rc = keyctl_instantiate(key, &name, strlen(name), 0);
93                 if (rc < 0)
94                         xlog_err("name_lookup: keyctl_instantiate failed: %m");
95         }
96 out:
97         return rc;
98 }
99 /*
100  * Clear all the keys on the given keyring
101  */
102 static int keyring_clear(char *keyring)
103 {
104         FILE *fp;
105         char buf[BUFSIZ];
106         key_serial_t key;
107
108         xlog_syslog(0);
109         if (keyring == NULL)
110                 keyring = DEFAULT_KEYRING;
111
112         if ((fp = fopen(PROCKEYS, "r")) == NULL) {
113                 xlog_err("fopen(%s) failed: %m", PROCKEYS);
114                 return 1;
115         }
116
117         while(fgets(buf, BUFSIZ, fp) != NULL) {
118                 if (strstr(buf, "keyring") == NULL)
119                         continue;
120                 if (strstr(buf, keyring) == NULL)
121                         continue;
122                 if (verbose) {
123                         *(strchr(buf, '\n')) = '\0';
124                         xlog_warn("clearing '%s'", buf);
125                 }
126                 /*
127                  * The key is the first arugment in the string
128                  */
129                 *(strchr(buf, ' ')) = '\0';
130                 sscanf(buf, "%x", &key);
131                 if (keyctl_clear(key) < 0) {
132                         xlog_err("keyctl_clear(0x%x) failed: %m", key);
133                         fclose(fp);
134                         return 1;
135                 }
136                 fclose(fp);
137                 return 0;
138         }
139         xlog_err("'%s' keyring was not found.", keyring);
140         fclose(fp);
141         return 1;
142 }
143 /*
144  * Revoke a key 
145  */
146 static int key_revoke(char *keystr, int keymask)
147 {
148         FILE *fp;
149         char buf[BUFSIZ], *ptr;
150         key_serial_t key;
151         int mask;
152
153         xlog_syslog(0);
154
155         if ((fp = fopen(PROCKEYS, "r")) == NULL) {
156                 xlog_err("fopen(%s) failed: %m", PROCKEYS);
157                 return 1;
158         }
159
160         while(fgets(buf, BUFSIZ, fp) != NULL) {
161                 if (strstr(buf, "keyring") != NULL)
162                         continue;
163
164                 mask = 0;
165                 if ((ptr = strstr(buf, "uid:")) != NULL)
166                         mask = UIDKEYS;
167                 else if ((ptr = strstr(buf, "gid:")) != NULL)
168                         mask = GIDKEYS;
169                 else 
170                         continue;
171
172                 if ((keymask & mask) == 0)
173                         continue;
174
175                 if (strncmp(ptr+4, keystr, strlen(keystr)) != NULL)
176                         continue;
177
178                 if (verbose) {
179                         *(strchr(buf, '\n')) = '\0';
180                         xlog_warn("revoking '%s'", buf);
181                 }
182                 /*
183                  * The key is the first arugment in the string
184                  */
185                 *(strchr(buf, ' ')) = '\0';
186                 sscanf(buf, "%x", &key);
187
188                 if (keyctl_revoke(key) < 0) {
189                         xlog_err("keyctl_revoke(0x%x) failed: %m", key);
190                         fclose(fp);
191                         return 1;
192                 }
193
194                 keymask &= ~mask;
195                 if (keymask == 0) {
196                         fclose(fp);
197                         return 0;
198                 }
199         }
200         xlog_err("'%s' key was not found.", keystr);
201         fclose(fp);
202         return 1;
203 }
204
205 int main(int argc, char **argv)
206 {
207         char *arg;
208         char *value;
209         char *type;
210         int rc = 1, opt;
211         int timeout = 600;
212         key_serial_t key;
213         char *progname, *keystr = NULL;
214         int clearing = 0, keymask = 0;
215
216         /* Set the basename */
217         if ((progname = strrchr(argv[0], '/')) != NULL)
218                 progname++;
219         else
220                 progname = argv[0];
221
222         xlog_open(progname);
223
224         while ((opt = getopt(argc, argv, "u:g:r:ct:v")) != -1) {
225                 switch (opt) {
226                 case 'u':
227                         keymask = UIDKEYS;
228                         keystr = strdup(optarg);
229                         break;
230                 case 'g':
231                         keymask = GIDKEYS;
232                         keystr = strdup(optarg);
233                         break;
234                 case 'r':
235                         keymask = GIDKEYS|UIDKEYS;
236                         keystr = strdup(optarg);
237                         break;
238                 case 'c':
239                         clearing++;
240                         break;
241                 case 'v':
242                         verbose++;
243                         break;
244                 case 't':
245                         timeout = atoi(optarg);
246                         break;
247                 default:
248                         xlog_warn(usage, progname);
249                         break;
250                 }
251         }
252
253         if (keystr) {
254                 rc = key_revoke(keystr, keymask);
255                 return rc;              
256         }
257         if (clearing) {
258                 rc = keyring_clear(DEFAULT_KEYRING);
259                 return rc;              
260         }
261
262         xlog_stderr(0);
263         if ((argc - optind) != 2) {
264                 xlog_err("Bad arg count. Check /etc/request-key.conf");
265                 xlog_warn(usage, progname);
266                 return 1;
267         }
268
269         if (verbose)
270                 nfs4_set_debug(verbose, NULL);
271
272         key = strtol(argv[optind++], NULL, 10);
273
274         arg = strdup(argv[optind]);
275         if (arg == NULL) {
276                 xlog_err("strdup failed: %m");
277                 return 1;
278         }
279         type = strtok(arg, ":");
280         value = strtok(NULL, ":");
281
282         if (verbose) {
283                 xlog_warn("key: %ld type: %s value: %s timeout %ld",
284                         key, type, value, timeout);
285         }
286
287         if (strcmp(type, "uid") == 0)
288                 rc = id_lookup(value, key, USER);
289         else if (strcmp(type, "gid") == 0)
290                 rc = id_lookup(value, key, GROUP);
291         else if (strcmp(type, "user") == 0)
292                 rc = name_lookup(value, key, USER);
293         else if (strcmp(type, "group") == 0)
294                 rc = name_lookup(value, key, GROUP);
295
296         /* Set timeout to 10 (600 seconds) minutes */
297         if (rc == 0)
298                 keyctl_set_timeout(key, timeout);
299
300         free(arg);
301         return rc;
302 }