![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chfn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb|
Return to chfn.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@@(#)chfn.c 4.6 (Berkeley) 7/10/83";
3: #endif lint
4:
5: /*
6: * changefinger - change finger entries
7: */
8: #include <stdio.h>
9: #include <signal.h>
10: #include <pwd.h>
11: #include <sys/time.h>
12: #include <sys/resource.h>
13: #include <sys/file.h>
14: #include <ctype.h>
15:
16: struct default_values {
17: char *name;
18: char *office_num;
19: char *office_phone;
20: char *home_phone;
21: };
22:
23: char passwd[] = "/etc/passwd";
24: char temp[] = "/etc/ptmp";
25: struct passwd *pwd;
26: struct passwd *getpwent(), *getpwnam(), *getpwuid();
27: int endpwent();
28: char *crypt();
29: char *getpass();
30: int hadQ = 0, hadZ = 0;
31:
32: main(argc, argv)
33: int argc;
34: char *argv[];
35: {
36: int user_uid;
37: char replacement[4*BUFSIZ];
38: int fd;
39: FILE *tf;
40:
41: if (argc > 2) {
42: printf("Usage: changefinger [user]\n");
43: exit(1);
44: }
45: /*
46: * Error check to make sure the user (foolishly) typed their own name.
47: */
48: user_uid = getuid();
49: if ((argc == 2) && (user_uid != 0)) {
50: pwd = getpwnam(argv[1]);
51: if (pwd == NULL) {
52: printf("%s%s%s%s%s%s%s%s",
53: "There is no account for ", argv[1],
54: " on this machine.\n",
55: "You probably mispelled your login name;\n",
56: "only root is allowed to change another",
57: " person's finger entry.\n",
58: "Note: you do not need to type your login",
59: " name as an argument.\n");
60: exit(1);
61: }
62: if (pwd->pw_uid != user_uid) {
63: printf("%s%s",
64: "You are not allowed to change another",
65: " person's finger entry.\n");
66: exit(1);
67: }
68: }
69: /*
70: * If root is changing a finger entry, then find the uid that
71: * corresponds to the user's login name.
72: */
73: if ((argc == 2) && (user_uid == 0)) {
74: pwd = getpwnam(argv[1]);
75: if (pwd == NULL) {
76: printf("There is no account for %s on this machine\n",
77: pwd->pw_name);
78: exit(1);
79: }
80: user_uid = pwd->pw_uid;
81: }
82: if (argc == 1) {
83: pwd = getpwuid(user_uid);
84: if (pwd == NULL) {
85: fprintf(stderr, "No passwd file entry!?\n");
86: exit(1);
87: }
88: }
89: /*
90: * Collect name, office number, office phone, and home phone.
91: */
92: get_info(pwd->pw_gecos, replacement);
93:
94: (void) signal(SIGHUP, SIG_IGN);
95: (void) signal(SIGINT, SIG_IGN);
96: (void) signal(SIGQUIT, SIG_IGN);
97: (void) signal(SIGTSTP, SIG_IGN);
98: (void) umask(0);
99: if ((fd = open(temp, O_CREAT|O_EXCL|O_RDWR, 0644)) < 0) {
100: printf("Temporary file busy -- try again\n");
101: exit(1);
102: }
103: if ((tf = fdopen(fd, "w")) == NULL) {
104: printf("Absurd fdopen failure - seek help\n");
105: goto out;
106: }
107: unlimit(RLIMIT_CPU);
108: unlimit(RLIMIT_FSIZE);
109: /*
110: * Copy passwd to temp, replacing matching lines
111: * with new gecos field.
112: */
113: while ((pwd = getpwent()) != NULL) {
114: if (pwd->pw_uid == user_uid)
115: pwd->pw_gecos = replacement;
116: fprintf(tf,"%s:%s:%d:%d:%s:%s:%s\n",
117: pwd->pw_name,
118: pwd->pw_passwd,
119: pwd->pw_uid,
120: pwd->pw_gid,
121: pwd->pw_gecos,
122: pwd->pw_dir,
123: pwd->pw_shell);
124: }
125: (void) endpwent();
126: if (rename(temp, passwd) < 0) {
127: fprintf(stderr, "chfn: "); perror("rename");
128: out:
129: (void) unlink(temp);
130: exit(1);
131: }
132: (void) fclose(tf);
133: exit(0);
134: }
135:
136: unlimit(lim)
137: {
138: struct rlimit rlim;
139:
140: rlim.rlim_cur = rlim.rlim_max = RLIM_INFINITY;
141: (void) setrlimit(lim, &rlim);
142: }
143:
144: /*
145: * Get name, office number, office phone, and home phone.
146: */
147: get_info(gecos_field, answer)
148: char *gecos_field;
149: char *answer;
150: {
151: char *strcpy(), *strcat();
152: char in_str[BUFSIZ];
153: struct default_values *defaults, *get_defaults();
154: int phflag;
155:
156: answer[0] = '\0';
157: defaults = get_defaults(gecos_field);
158: printf("Default values are printed inside of '[]'.\n");
159: printf("Examples are printed inside of '()'.\n");
160: printf("To accept the default, type <return>.\n");
161: printf("To have a blank entry, type the word 'none'.\n");
162: /*
163: * Get name.
164: */
165: do {
166: printf("\nName [%s]: ", defaults->name);
167: (void) fgets(in_str, BUFSIZ, stdin);
168: if (special_case(in_str, defaults->name))
169: break;
170: } while (illegal_input(in_str));
171: (void) strcpy(answer, in_str);
172: /*
173: * Get office number.
174: */
175: again:
176: do {
177: printf("Office number (Exs: 597E or 197C) [%s]: ",
178: defaults->office_num);
179: (void) fgets(in_str, BUFSIZ, stdin);
180: if (special_case(in_str, defaults->office_num)) {
181: if (hadQ)
182: if (*in_str != '\0')
183: strcat(in_str, "Q");
184: break;
185: }
186: } while (illegal_input(in_str));
187: if (illegal_building(in_str))
188: strcat(in_str, "Q");
189: if (strlen(in_str) > 10) {
190: printf("office number must be no more than 9 characters\n");
191: goto again;
192: }
193: (void) strcat(strcat(answer, ","), in_str);
194: /*
195: * Get office phone number.
196: * Remove hyphens and 642, x2, or 2 prefixes if present.
197: */
198: do {
199: printf("Office Phone (Ex: 1632) [%s]: ",
200: defaults->office_phone);
201: (void) fgets(in_str, BUFSIZ, stdin);
202: phflag = 0;
203: if (special_case(in_str, defaults->office_phone)) {
204: phflag = 1;
205: if (hadZ)
206: if (*in_str != '\0')
207: strcat(in_str, "Z");
208: break;
209: }
210: remove_hyphens(in_str);
211: if ((strlen(in_str) == 8) && (strcmpn(in_str, "642", 3) == 0)) {
212: (void) strcpy(in_str, in_str+3);
213: phflag = 1;
214: }
215: if ((strlen(in_str) == 7) && (strcmpn(in_str, "x2", 2) == 0)) {
216: (void) strcpy(in_str, in_str+2);
217: phflag = 1;
218: }
219: if ((strlen(in_str) == 6) && (in_str[0] == '2')) {
220: (void) strcpy(in_str, in_str+1);
221: phflag = 1;
222: }
223: } while (illegal_input(in_str) || wrong_length(in_str, 7));
224: if (!phflag)
225: strcat(in_str, "Z");
226: (void) strcat(strcat(answer, ","), in_str);
227: /*
228: * Get home phone number.
229: * Remove hyphens if present.
230: */
231: do {
232: printf("Home Phone (Ex: 9875432) [%s]: ", defaults->home_phone);
233: (void) fgets(in_str, BUFSIZ, stdin);
234: if (special_case(in_str, defaults->home_phone))
235: break;
236: remove_hyphens(in_str);
237: } while (illegal_input(in_str));
238: (void) strcat(strcat(answer, ","), in_str);
239: }
240:
241: /*
242: * Prints an error message if a ':' or a newline is found in the string.
243: * A message is also printed if the input string is too long.
244: * The password file uses :'s as seperators, and are not allowed in the "gcos"
245: * field. Newlines serve as delimiters between users in the password file,
246: * and so, those too, are checked for. (I don't think that it is possible to
247: * type them in, but better safe than sorry)
248: *
249: * Returns '1' if a colon or newline is found or the input line is too long.
250: */
251: illegal_input(input_str)
252: char *input_str;
253: {
254: char *index();
255: char *ptr;
256: int error_flag = 0;
257: int length = strlen(input_str);
258:
259: if (index(input_str, ':')) {
260: printf("':' is not allowed.\n");
261: error_flag = 1;
262: }
263: if (input_str[length-1] != '\n') {
264: /* the newline and the '\0' eat up two characters */
265: printf("Maximum number of characters allowed is %d\n",
266: BUFSIZ-2);
267: /* flush the rest of the input line */
268: while (getchar() != '\n')
269: /* void */;
270: error_flag = 1;
271: }
272: /*
273: * Delete newline by shortening string by 1.
274: */
275: input_str[length-1] = '\0';
276: /*
277: * Don't allow control characters, etc in input string.
278: */
279: for (ptr=input_str; *ptr != '\0'; ptr++) {
280: if ((int) *ptr < 040) {
281: printf("Control characters are not allowed.\n");
282: error_flag = 1;
283: break;
284: }
285: }
286: return(error_flag);
287: }
288:
289: /*
290: * Removes '-'s from the input string.
291: */
292: remove_hyphens(str)
293: char *str;
294: {
295: char *hyphen, *index(), *strcpy();
296:
297: while ((hyphen=index(str, '-')) != NULL) {
298: (void) strcpy(hyphen, hyphen+1);
299: }
300: }
301:
302: /*
303: * Returns 1 when the length of the input string is not zero and
304: * greater than n.
305: * Prints an error message in this case.
306: */
307: wrong_length(str, n)
308: char *str;
309: int n;
310: {
311:
312: if ((strlen(str) != 0) && (strlen(str) >= n)) {
313: printf("The phone number should be less than %d digits long.\n",
314: n);
315: return(1);
316: }
317: return(0);
318: }
319:
320: /*
321: * Make sure that building is 'E', 'C' or 'L'.
322: * Error correction is done if building is 'e', 'c', 'l',
323: * "evans", "cory" or "lbl".
324: * Correction changes "str".
325: * The finger program determines the building by looking at the last
326: * character. Currently, finger only allows that character to be 'E', 'C'
327: * or 'L'.
328: *
329: * Returns 1 if incorrect office format.
330: *
331: * Note: this function assumes that the newline has been removed from str.
332: */
333: illegal_building(str)
334: char *str;
335: {
336: int length = strlen(str);
337: char *last_ch, *ptr;
338:
339: /*
340: * Zero length strings are acceptable input.
341: */
342: if (length == 0)
343: return(0);
344: /*
345: * Delete "vans", "ory" and "bl".
346: */
347: if (strcmpn(str+length-4, "vans", 4) == 0) {
348: length -= 4;
349: str[length] = '\0';
350: }
351: if (strcmpn(str+length-3, "ory", 3) == 0) {
352: length -= 3;
353: str[length] = '\0';
354: }
355: if (strcmpn(str+length-2, "bl", 2) == 0) {
356: length -= 2;
357: str[length] = '\0';
358: }
359: last_ch = str+length-1;
360: /*
361: * Now change e to E or c to C or l to L.
362: */
363: if (*last_ch == 'e')
364: *last_ch = 'E';
365: if (*last_ch == 'c')
366: *last_ch = 'C';
367: if (*last_ch == 'l')
368: *last_ch = 'L';
369: /*
370: * Delete any spaces before the E, C or L.
371: */
372: for (ptr=last_ch-1; ptr>str; ptr--) {
373: if (*ptr != ' ')
374: break;
375: }
376: (void) strcpy(ptr+1, last_ch);
377: /*
378: * Make sure building is evans, cory or lbl.
379: */
380: if ((*last_ch != 'E') && (*last_ch != 'C') && (*last_ch != 'L'))
381: return(1);
382: return(0);
383: }
384:
385: /* get_defaults picks apart "str" and returns a structure points.
386: * "str" contains up to 4 fields separated by commas.
387: * Any field that is missing is set to blank.
388: */
389: struct default_values
390: *get_defaults(str)
391: char *str;
392: {
393: struct default_values *answer;
394: char *malloc(), *index();
395: int len;
396:
397: answer = (struct default_values *)
398: malloc((unsigned)sizeof(struct default_values));
399: if (answer == (struct default_values *) NULL) {
400: fprintf(stderr,
401: "\nUnable to allocate storage in get_defaults!\n");
402: exit(1);
403: }
404: /*
405: * Values if no corresponding string in "str".
406: */
407: answer->name = str;
408: answer->office_num = "";
409: answer->office_phone = "";
410: answer->home_phone = "";
411: str = index(answer->name, ',');
412: if (str == 0)
413: return(answer);
414: *str = '\0';
415: answer->office_num = str + 1;
416: str = index(answer->office_num, ',');
417: if (str == 0) {
418: len = strlen(answer->office_num);
419: if (answer->office_num[len - 1] == 'Q') {
420: answer->office_num[len - 1] = '\0';
421: hadQ = 1;
422: }
423: return(answer);
424: }
425: *str = '\0';
426: len = strlen(answer->office_num);
427: if (answer->office_num[len - 1] == 'Q') {
428: answer->office_num[len - 1] = '\0';
429: hadQ = 1;
430: }
431: answer->office_phone = str + 1;
432: str = index(answer->office_phone, ',');
433: if (str == 0) {
434: len = strlen(answer->office_phone);
435: if (answer->office_phone[len - 1] == 'Z') {
436: answer->office_phone[len - 1] = '\0';
437: hadZ = 1;
438: }
439: return(answer);
440: }
441: *str = '\0';
442: len = strlen(answer->office_phone);
443: if (answer->office_phone[len - 1] == 'Z') {
444: answer->office_phone[len - 1] = '\0';
445: hadZ = 1;
446: }
447: answer->home_phone = str + 1;
448: return(answer);
449: }
450:
451: /*
452: * special_case returns true when either the default is accepted
453: * (str = '\n'), or when 'none' is typed. 'none' is accepted in
454: * either upper or lower case (or any combination). 'str' is modified
455: * in these two cases.
456: */
457: int special_case(str,default_str)
458: char *str;
459: char *default_str;
460: {
461: static char word[] = "none\n";
462: char *ptr, *wordptr;
463:
464: /*
465: * If the default is accepted, then change the old string do the
466: * default string.
467: */
468: if (*str == '\n') {
469: (void) strcpy(str, default_str);
470: return(1);
471: }
472: /*
473: * Check to see if str is 'none'. (It is questionable if case
474: * insensitivity is worth the hair).
475: */
476: wordptr = word-1;
477: for (ptr=str; *ptr != '\0'; ++ptr) {
478: ++wordptr;
479: if (*wordptr == '\0') /* then words are different sizes */
480: return(0);
481: if (*ptr == *wordptr)
482: continue;
483: if (isupper(*ptr) && (tolower(*ptr) == *wordptr))
484: continue;
485: /*
486: * At this point we have a mismatch, so we return
487: */
488: return(0);
489: }
490: /*
491: * Make sure that words are the same length.
492: */
493: if (*(wordptr+1) != '\0')
494: return(0);
495: /*
496: * Change 'str' to be the null string
497: */
498: *str = '\0';
499: return(1);
500: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.