![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chmog.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin|
Return to chmog.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: /*
2: * chmog -- change the mode, owner, and group of files.
3: *
4: * This program was done from the 'chmod', 'chown', and 'chgrp'
5: * As result code may not be optimal, but should be pretty reliable
6: * and be backword compatible (including bugs and bad design as exit(2)).
7: *
8: * chmog should be link to chown, chmod, and chgrp. BTW it saves about
9: * 15K :-).
10: *
11: * 1-31-92 Vlad
12: */
13:
14: #include <stdio.h>
15: #include <pwd.h>
16: #include <grp.h>
17: #include <ctype.h>
18: #include <sys/stat.h>
19: #include <string.h>
20:
21: /* Masks by types of permissions */
22: #define AEXEC (S_IEXEC|(S_IEXEC>>3)|(S_IEXEC>>6))
23: #define AREAD (S_IREAD|(S_IREAD>>3)|(S_IREAD>>6))
24: #define AWRITE (S_IWRITE|(S_IWRITE>>3)|(S_IWRITE>>6))
25: #define ASUID (S_ISUID|S_ISGID)
26: #define ATEXT S_ISVTX
27:
28: /* Masks by types of users */
29: #define AOWN (S_ISUID|S_ISVTX|S_IREAD|S_IWRITE|S_IEXEC)
30: #define AGRP (S_ISGID|S_ISVTX|(S_IREAD>>3)|(S_IWRITE>>3)|(S_IEXEC>>3))
31: #define AOTH (S_ISVTX|(S_IREAD>>6)|(S_IWRITE>>6)|(S_IEXEC>>6))
32: #define AALL (AOWN|AGRP|AOTH)
33:
34: short int uid;
35:
36: char *chmod_usage = "chmod mode file ...";
37: char *chown_usage = "chown owner file ...";
38: char *chgrp_usage = "chgrp group file ...";
39: char *chmog_usage = "chmog mod owner group file ...";
40:
41: char stickwarn[] = "\
42: chmod: Warning: non-super user may not set sticky bit\n\
43: ";
44:
45: main(argc, argv)
46: int argc;
47: char *argv[];
48: {
49: char *cmdname; /* Name of the command */
50:
51: /* Strip the pathname off of the name of the executable */
52: if ((cmdname = strrchr(argv[0], '/')) != (char *) NULL)
53: cmdname++;
54: else
55: cmdname = argv[0];
56:
57: /* Who am I? */
58: if (!strcmp(cmdname, "chmod"))
59: cmd_chmod(argc, argv, 0); /* Emulate chmod */
60: else if (!strcmp(cmdname, "chown"))
61: cmd_chown(argc, argv, 0, 0); /* Emulate chown */
62: else if (!strcmp(cmdname, "chgrp"))
63: cmd_chgrp(argc, argv, 0, 0); /* Emulate chgrp */
64: else if (!strcmp(cmdname, "chmog"))
65: chmog(argc, argv); /* Be itself */
66: else /* If some entysiast will link to a different name....*/
67: usage(chmog_usage);
68: exit(0);
69: }
70:
71: /*
72: * This is main entry for chmog. Call all functions (*chmod, *chown, *chgrp)
73: * and set the proper shifts of the argv. If correspoding *argv is '-'
74: * it means that this characteristic of file should be unchanged.
75: */
76: chmog(argc, argv)
77: int argc;
78: char **argv;
79: {
80: if (argc < 5)
81: usage(chmog_usage);
82:
83: /* Change owner */
84: if (strcmp(argv[2], "-"))
85: cmd_chown(argc, argv, 1, 2);
86: /* Change group */
87: if (strcmp(argv[3], "-"))
88: cmd_chgrp(argc, argv, 2, 2);
89: /* Change mode. We want to do it at the very and, otherwise
90: * chown or chgrp will remove setuid & setgid bits
91: */
92: if (strcmp(argv[1], "-"))
93: cmd_chmod(argc, argv, 2);
94: exit(0);
95: }
96:
97: /*
98: * Change mode of the file.
99: */
100: cmd_chmod(argc, argv, shift_file)
101: int argc;
102: char **argv;
103: int shift_file; /* Shift argv to the file names */
104: {
105: register int i;
106: register char *fn;
107: int status = 0;
108:
109: if (argc < 3)
110: usage(chmod_usage);
111: uid = getuid();
112: for (i = 2 + shift_file; i < argc; i++) {
113: fn = argv[i];
114: if (chmod(fn, readmode(argv[1], fn)) < 0) {
115: perror(fn);
116: status = 2;
117: }
118: }
119: if (status)
120: exit(status);
121: }
122:
123: /*
124: * Read in the symbolic mode and
125: * set the variables `who', `op',
126: * and `mode'.
127: * Knows about the old octal modes as well.
128: */
129: readmode(s, file)
130: register char *s;
131: char *file;
132: {
133: register int c;
134: register int mode;
135: register int op;
136: register int m1, m2;
137: struct stat sb;
138:
139: mode = 0;
140: if (*s>='0' && *s<='7') {
141: while (*s != '\0') {
142: if (*s<'0' || *s>'7')
143: omusage();
144: mode = (mode<<3) | *s++-'0';
145: }
146: checkmode(mode);
147: return (mode);
148: }
149: sb.st_mode = 0;
150: stat(file, &sb);
151: mode = sb.st_mode;
152: newsym:
153: m1 = 0;
154: for (;;) {
155: switch (*s++) {
156: case 'u':
157: m1 |= AOWN;
158: continue;
159:
160: case 'g':
161: m1 |= AGRP;
162: continue;
163:
164: case 'o':
165: m1 |= AOTH;
166: continue;
167:
168: case 'a':
169: m1 |= AALL;
170: continue;
171:
172: default:
173: s--;
174: break;
175: }
176: break;
177: }
178: if (m1 == 0) {
179: m1 = AALL&~getumask();
180: }
181: newop:
182: if ((c = *s++)=='=' || c=='+' || c=='-')
183: op = c;
184: else
185: smusage();
186: m2 = 0;
187: for (;;) {
188: switch (*s++) {
189: case 'r':
190: m2 |= AREAD;
191: continue;
192:
193: case 'w':
194: m2 |= AWRITE;
195: continue;
196:
197: case 'x':
198: m2 |= AEXEC;
199: continue;
200:
201: case 's':
202: m2 |= ASUID;
203: continue;
204:
205: case 't':
206: m2 |= ATEXT;
207: continue;
208:
209: case 'u':
210: m2 |= mrepl(mode&AOWN);
211: continue;
212:
213: case 'g':
214: m2 |= mrepl((mode&AGRP)<<3);
215: continue;
216:
217: case 'o':
218: m2 |= mrepl((mode&AOTH)<<6);
219: continue;
220:
221: default:
222: s--;
223: break;
224: }
225: break;
226: }
227: switch (op) {
228: case '-':
229: mode &= ~(m1&m2);
230: break;
231:
232: case '+':
233: mode |= m1&m2;
234: break;
235:
236: case '=':
237: mode = (mode&~m1) | (m1&m2);
238: break;
239: }
240: if (*s == '\0') {
241: checkmode(mode);
242: return (mode);
243: }
244: if (*s=='+' || *s=='-' || *s=='=')
245: goto newop;
246: if (*s++ == ',')
247: goto newsym;
248: smusage();
249: }
250:
251: /*
252: * Get the value of the umask setting.
253: */
254: getumask()
255: {
256: register int omask;
257:
258: omask = umask(0);
259: umask(omask);
260: return (omask);
261: }
262:
263: /*
264: * Check the mode to see if any problem
265: * bits are on. For now, this is
266: * S_ISVTX for non-super-users.
267: */
268: checkmode(mode)
269: register int mode;
270: {
271: static int beenhere;
272:
273: if (!beenhere && uid!=0 && mode&S_ISVTX) {
274: fprintf(stderr, stickwarn);
275: beenhere++;
276: }
277: }
278:
279: /*
280: * Replicate the 3-bits of the mode from
281: * the owner position to all positions.
282: */
283: mrepl(m)
284: register int m;
285: {
286: register int m1;
287:
288: m1 = m&AOWN;
289: m = m1 | (m1>>3) | (m1>>6);
290: if (m1 & S_ISUID)
291: m |= S_ISGID;
292: return (m);
293: }
294:
295: smusage()
296: {
297: fprintf(stderr, "chmod: badly formed symbolic mode\n");
298: exit(1);
299: }
300:
301: omusage()
302: {
303: fprintf(stderr, "chmod: badly formed octal mode\n");
304: exit(1);
305: }
306:
307: /*
308: * Change owner of the file
309: */
310: cmd_chown(argc, argv, shift_cmd, shift_file)
311: int argc;
312: char **argv;
313: int shift_cmd; /* Shift argv to the owner */
314: int shift_file; /* Shift argv to the file names */
315: {
316: register struct passwd *pwp;
317: register int c;
318: register short owner, group;
319: struct stat sb;
320: register short status = 0;
321: int i_cmd;
322: int i_file;
323:
324: if (argc < 3)
325: usage(chown_usage);
326: i_cmd = 1 + shift_cmd;
327: i_file = 2 + shift_file;
328:
329: if ((c = *argv[i_cmd]) >='0' && c <= '9')
330: owner = atoi(argv[i_cmd]);
331: else {
332: if ((pwp = getpwnam(argv[i_cmd])) == NULL)
333: cherr("%s: bad username `%s'\n", argv[0], argv[i_cmd]);
334: owner = pwp->pw_uid;
335: }
336: for (c = i_file; c < argc; c++) {
337: group = 0;
338: if (stat(argv[c], &sb) >= 0)
339: group = sb.st_gid;
340: if (chown(argv[c], owner, group) < 0) {
341: perror(argv[c]);
342: status = 2;
343: }
344: }
345: if (status)
346: exit (status);
347: }
348:
349: /*
350: * Change the group owner of specified files.
351: */
352: cmd_chgrp(argc, argv, shift_cmd, shift_file)
353: int argc;
354: char **argv;
355: int shift_cmd; /* Shift argv to the group */
356: int shift_file; /* Shift argv to the file names */
357: {
358: register struct group *grp;
359: register int c;
360: register short owner, group;
361: struct stat sb;
362: register short status = 0;
363: int i_cmd;
364: int i_file;
365:
366: /* Only superuser can invoke chgrp under COHERENT. Vlad */
367: if (geteuid())
368: cherr("%s: only superuser can changed group name.\n", argv[0]);
369:
370: if (argc < 3)
371: usage(chgrp_usage);
372:
373: i_cmd = 1 + shift_cmd;
374: i_file = 2 + shift_file;
375:
376: /* You can specify group by numeric id or by name. Vlad */
377: if (isdigit((int) *argv[i_cmd])) {
378: if ((grp = getgrgid(atoi(argv[i_cmd]))) == NULL)
379: cherr("%s: bad numeric group id `%s'\n",
380: argv[0], argv[i_cmd]);
381: } else
382: if ((grp = getgrnam(argv[i_cmd])) == NULL)
383: cherr("%s: bad group name `%s'\n", argv[0],argv[i_cmd]);
384:
385: group = grp->gr_gid;
386:
387: for (c = i_file; c < argc; c++) {
388: owner = 0;
389: if (stat(argv[c], &sb) >= 0)
390: owner = sb.st_uid;
391: if (chown(argv[c], owner, group) < 0) {
392: perror(argv[c]);
393: status = 2;
394: }
395: }
396: if (status)
397: exit (status);
398: }
399:
400: usage(msg)
401: char *msg;
402: {
403: fprintf(stderr, "Usage: %s\n", msg);
404: exit(1);
405: }
406:
407: /* VARARGS */
408: cherr(x)
409: {
410: fprintf(stderr, "%r", &x);
411: exit(2);
412: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.