![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to initucode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / iutil|
Return to initucode.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / iutil |
1.1 root 1: # include <stdio.h>
2: # include <ingres.h>
3: # include <aux.h>
4: # include <version.h>
5: # include <opsys.h>
6: # include <access.h>
7: # include <lock.h>
8: # include <signal.h>
9: # include <sccs.h>
10:
11: SCCSID(@(#)initucode.c 7.4 9/26/83)
12:
13: /*
14: ** INITUCODE -- initialize standalone process
15: **
16: ** This function initializes a standalone process, initializing
17: ** a lot of global variables, scanning the argument vector for
18: ** some special flags (-u and +-w), seperating flags and
19: ** parameters, and so forth.
20: **
21: ** Every standalone program should begin with the lines:
22: ** i = initucode(argc, argv, ...);
23: ** switch (i)
24: ** ...
25: **
26: ** On a return of 2, 3, or 4, essentially none of the processing
27: ** is done (particularly true with return 4). Virtually nothing
28: ** can be done in the calling program except print a "usage"
29: ** message and exit. The exception to this is that 'Pathname'
30: ** is set, so that it can be used in the error printing. For
31: ** example, ingres.c cats file .../files/usage on this sort of
32: ** error.
33: **
34: ** If it is preferable to not lock the database at this time,
35: ** the 'waitmode' parameter should be passed as -1. This still
36: ** causes the 'Wait_action' variable to be initialized, but the
37: ** database is not actually locked. It can be locked by calling:
38: ** db_lock(Dbpath, M_EXCL);
39: ** at the proper time.
40: **
41: ** For the main effects of this routine, see the "Side Effects"
42: ** section below.
43: **
44: ** Parameters:
45: ** argc -- argc from main.
46: ** argv -- argv from main.
47: ** dbflag -- TRUE -- take the first parameter as the
48: ** database name.
49: ** FALSE -- don't take the first parameter as
50: ** the database name.
51: ** paramlist -- a pointer to an array[4] of pointers
52: ** to character; set to the extra fields of
53: ** the users file entry for the real user
54: ** executing the code (not the user on the
55: ** -u flag). If NULL, this is ignored.
56: ** waitmode -- M_EXCL -- set an exclusive lock on the
57: ** database.
58: ** M_SHARE -- set a shared lock on the database.
59: ** -1 -- don't set a lock on the database.
60: ** However, other stuff (Wait_action) is
61: ** still set up so that the lock can be
62: ** placed later by calling 'db_lock'.
63: **
64: ** Returns:
65: ** 0 -- everything is ok.
66: ** 1 -- the database does not exist.
67: ** 2 -- you are not authorized to access this database.
68: ** 3 -- you are not a valid INGRES user.
69: ** 4 -- no database name was specified (only if dbflag
70: ** == TRUE).
71: ** 5 -- everything is ok, but there was an indirect
72: ** taken.
73: ** 6 -- there was an indirect taken, but there was no
74: ** database there.
75: **
76: ** If dbflag == FALSE, you can only get returns 0 and
77: ** 3.
78: **
79: ** Side Effects:
80: ** A lot of variables are set, as follows:
81: **
82: ** Dbpath -- set to the pathname of the database (only
83: ** if dbflag == TRUE). It is set even if the
84: ** database does not exist.
85: ** Parmvect -- set to the parameters from argv, that is,
86: ** anything not beginning with '+' or '-'.
87: ** Flagvect -- set to the flags from argv, that is,
88: ** everything beginning with '+' or '-'. The
89: ** flags '+w', '-w', and '-u' are stripped out,
90: ** however.
91: ** Wait_action -- set to the appropriate action (A_SLP
92: ** or A_RTN) based on the +-w flags and whether
93: ** we are running in background or not.
94: ** This is automatically used by 'db_lock()'.
95: ** Usercode -- set to the persons effective user code
96: ** (that is, after the -u processing). Only
97: ** the INGRES user or the DBA can use the -u
98: ** flag.
99: ** Pathname -- set to the pathname of the INGRES subtree.
100: ** Status -- an integer set to the user status field
101: ** of the users file for the real user.
102: ** Ing_uid -- set to the user id of the INGRES user.
103: **
104: ** The rubout signal (signal 2) is caught, and refered
105: ** to the standard rubout processor (see rub.c); thus,
106: ** a routine called 'rubproc' must be defined in the
107: ** standalone code (which will just call exit, in the
108: ** normal case).
109: **
110: ** The 'adminhdr' part of the 'Admin' struct is filled
111: ** in. This is not done with readadmin() and is not
112: ** equivalent to an 'admininit()', but it does make
113: ** the DBA and database status available.
114: **
115: ** This routine can also exit immediately with an
116: ** error message.
117: **
118: ** Defined Constants:
119: ** MAXPARGS -- the maximum number of parameter type
120: ** arguments to any standalone program.
121: ** MAXFARGS -- the maximum number of flag type arg-
122: ** uments to any standalong program (not inclu-
123: ** ding flags in the users file, and the +-w
124: ** and -u flags).
125: **
126: ** Files:
127: ** /etc/passwd -- to get the pathname for user "ingres".
128: ** .../files/users -- to get all the per-user information,
129: ** and to process the -u flag.
130: **
131: ** Compilation Flags:
132: ** xB_UNIX, xV6_UNIX -- see comments in aux.h
133: **
134: ** Trace Flags:
135: ** none
136: */
137:
138:
139: # define MAXFARGS 15 /* maximum flag-type arguments */
140: # define MAXPARGS 20 /* maximum parameter-type args */
141:
142: char *Usercode; /* the usercode of the effective user */
143: char *Pathname; /* path of INGRES subtree */
144: int Status; /* the user status of the real user */
145: int Rubignored; /* set if rubouts ignored */
146: /* (also in initproc for system processes) */
147: int Wait_action; /* the action on the db_lock */
148: char *Dbpath; /* the pathname of the database */
149: char *Flagvect[MAXFARGS+1]; /* the flags from argv */
150: char *Parmvect[MAXPARGS+1]; /* the parameters from argv */
151: int Ing_uid; /* the user id of the INGRES user */
152:
153: initucode(argc, argv, dbflag, paramlist, waitmode)
154: int argc;
155: char **argv;
156: int dbflag;
157: char *paramlist[4];
158: int waitmode;
159: {
160: register char *p;
161: char *q;
162: char c;
163: FILE *iop;
164: static char sbuf[MAXLINE * 2];
165: register char *sbufp;
166: char buf[MAXLINE+1];
167: register int i;
168: int npermit;
169: int rtval;
170: char *field[UF_NFIELDS];
171: int actualuid;
172: auto int uid;
173: auto int gid;
174: int waitflag;
175: char *userflag;
176: struct sgttyb gttydummy;
177: int fvi, pvi;
178: char **avp;
179: char usr_ovrd[3];
180: static int reenter;
181: extern rubcatch();
182: static short tvect[100];
183: bool nobuffer;
184: # ifdef xV7_UNIX
185: extern char *getenv();
186: # endif xV7_UNIX
187:
188: /*
189: ** Set up interrupts.
190: */
191:
192: reenter = 0;
193: setexit();
194: if (reenter++)
195: exit(-1);
196: if (signal(SIGINT, SIG_IGN) == SIG_DFL)
197: signal(SIGINT, rubcatch);
198: # ifdef xV6_UNIX
199: for (avp = argv; *avp != 0 && *avp != (char *) -1; avp++)
200: continue;
201: *avp = NULL;
202: # endif
203:
204: /*
205: ** Do basic initialization, such as setting trace flags.
206: */
207:
208: nobuffer = tTrace(argv, 'T', tvect, 100);
209: if (!nobuffer)
210: set_so_buf();
211: sbufp = sbuf;
212:
213: /*
214: ** Get pathname of INGRES subtree from /etc/passwd file
215: ** entry for USERINGRES (presumably "ingres") and save it
216: ** in 'Pathname'.
217: **
218: ** This algorithm suggested by Jim Popa.
219: */
220:
221: # ifdef xV7_UNIX
222: Pathname = getenv("INGPATH");
223: if (Pathname == NULL)
224: {
225: # endif xV7_UNIX
226: if ((iop = fopen("/etc/passwd", "r")) == NULL)
227: syserr("initucode: passwd");
228:
229: do
230: {
231: if (fgets(buf, MAXLINE, iop) == NULL)
232: syserr("initucode: no INGRES");
233:
234: /* decode passwd entry */
235: i = 0;
236: for (p = buf; *p != '\n' && *p != '\0'; p++)
237: {
238: if (*p == ':')
239: {
240: *p = 0;
241: i++;
242: field[i] = p + 1;
243: }
244: }
245: *p = '\0';
246:
247: /* check for enough fields for valid entry */
248: if (i < 3)
249: syserr("initucode: passwd fmt %s", buf);
250: } while (!sequal(buf, USERINGRES));
251:
252: /* we now have the INGRES passwd file entry in 'buf' */
253: fclose(iop);
254:
255: /* copy pathname entry into 'Pathname' variable */
256: Pathname = sbufp;
257: sbufp += smove(field[i - 1], sbufp) + 1;
258: # ifdef PATHEXT
259: sbufp += smove(PATHEXT, sbufp - 1);
260: # endif PATHEXT
261: # ifdef xV7_UNIX
262: }
263: # endif xV7_UNIX
264:
265: /* create the INGRES user id */
266: Ing_uid = atoi(field[2]);
267: # ifdef xV6_UNIX
268: Ing_uid &= 0377;
269: # endif
270: # ifdef xB_UNIX
271: gid = atoi(field[3]);
272: Ing_uid = (Ing_uid & 0377) | ((gid & 0377) << 8);
273: # endif
274:
275: /*
276: ** Scan the argument vector. The following flags are pulled
277: ** out of the vector (and argc and argv are adjusted so it
278: ** looks like they never existed):
279: ** +w, -w -- (don't) wait for the database to be free.
280: ** -uxxx -- run as user xxx. If first character is a
281: ** colon, the format must be '-u:xx' where 'xx' is the
282: ** internal user code.
283: */
284:
285: avp = argv;
286: fvi = 0;
287: pvi = 0;
288: waitflag = 0;
289: userflag = NULL;
290: usr_ovrd[0] = 0;
291:
292: for (i = argc; --i > 0; )
293: {
294: p = *++avp;
295: if (p[0] == '+')
296: {
297: if (p[1] == 'w')
298: waitflag = 1;
299: else
300: goto boring;
301: }
302: else if (p[0] == '-')
303: {
304: switch (p[1])
305: {
306: case 'w':
307: waitflag = -1;
308: break;
309:
310: case 'u':
311: if (p[2] == ':')
312: {
313: if (p[3] == 0 || p[4] == 0 || p[5] != 0)
314: {
315: printf("Bad flag %s\n", p);
316: exit(-1);
317: }
318: smove(&p[3], usr_ovrd);
319: }
320: else
321: userflag = &p[2];
322: break;
323:
324: default:
325: /* not an interesting flag */
326: boring:
327: if (fvi >= MAXFARGS)
328: {
329: printf("Too many flags\n");
330: exit(-1);
331: }
332: Flagvect[fvi++] = p;
333: break;
334: }
335: }
336: else
337: {
338: /* not a flag: save in Parmvect */
339: if (pvi >= MAXPARGS)
340: {
341: printf("Too many parmameters\n");
342: exit(-1);
343: }
344: Parmvect[pvi++] = p;
345: }
346: }
347:
348: if (pvi <= 0 && dbflag)
349: {
350: return (4); /* no database name specified */
351: }
352:
353: /*
354: ** Scan the "users" file.
355: */
356:
357: if ((iop = fopen(ztack(Pathname, "/files/users"), "r")) == NULL)
358: syserr("initucode: open error");
359:
360: /* get uid (out of loop) for test */
361: # ifdef xV6_UNIX
362: actualuid = getuid() & 0377;
363: # endif
364: # ifndef xV6_UNIX
365: actualuid = getuid();
366: # endif
367:
368: /* scan users file, one line at a time */
369: rtval = 3;
370: while ((Usercode == NULL || userflag != NULL) && fgets(buf, MAXLINE, iop) != NULL)
371: {
372:
373: /* decode users file entry */
374: i = 0;
375: field[0] = buf;
376: for (p = buf; *p != '\n' && *p != '\0'; p++)
377: {
378: if (*p == ':')
379: {
380: *p = 0;
381: i++;
382: field[i] = p + 1;
383: }
384: }
385: *p = '\0';
386:
387: /* check for correct number of fields */
388: if (i != UF_NFIELDS - 1)
389: syserr("initucode: users fmt %s", buf);
390:
391: /*
392: ** Check to see if this entry is the override user.
393: ** If so, save his user code in usr_ovrd.
394: */
395:
396: if (userflag != NULL && sequal(userflag, field[UF_NAME]))
397: {
398: smove(field[UF_UCODE], usr_ovrd);
399: userflag = NULL;
400: }
401:
402: /* don't bother with this shit if not needed */
403: if (Usercode != NULL)
404: continue;
405:
406: /*
407: ** Build the user id of this entry into 'uid'
408: ** and see if it is this user.
409: */
410:
411: uid = atoi(field[UF_UID]);
412:
413: # ifdef xB_UNIX
414: gid = atoi(field[UF_GID]);
415: uid = (uid & 0377) | ((gid & 0377) << 8);
416: # endif
417:
418: # ifdef xV6_UNIX
419: if ((uid & 0377) != actualuid)
420: continue;
421: # endif
422: # ifndef xV6_UNIX
423: if (uid != actualuid)
424: continue;
425: # endif
426:
427: /*
428: ** We now have the real user entry.
429: ** Fetch the usercode, the status bits, and other
430: ** fields from the users file, and save them in
431: ** a safe place (sbuf).
432: */
433:
434: Usercode = sbufp;
435: sbufp += smove(field[UF_UCODE], sbufp) + 1;
436: Status = oatoi(field[UF_STAT]);
437: if (paramlist != NULL)
438: {
439: for (i = 0; i < 4; i++)
440: {
441: paramlist[i] = sbufp;
442: sbufp += smove(field[UF_FLAGS + i], sbufp) + 1;
443: }
444: }
445:
446: /* validate access permission */
447: rtval = 0;
448: if (!dbflag || (Status & U_SUPER) != 0)
449: continue;
450: p = field[UF_DBLIST];
451: if (*p == 0)
452: continue;
453:
454: /* select permission/no-permission */
455: npermit = 0;
456: if (*p == '-')
457: {
458: p++;
459: npermit++;
460: }
461:
462: /* scan for database listed */
463: if (!npermit)
464: rtval = 2;
465: for (c = *p; c != 0; p = q + 1)
466: {
467: for (q = p; *q != ',' && *q != 0; q++)
468: continue;
469: c = *q;
470: *q = 0;
471: if (sequal(Parmvect[0], p))
472: {
473: rtval = npermit ? 2 : 0;
474: break;
475: }
476: }
477: }
478: fclose(iop);
479:
480: if (rtval != 0)
481: return (rtval);
482:
483: /*
484: ** Check for existance of the database. This is done by
485: ** first building the pathname of the database into
486: ** 'Dbpath', and then reading the admin file (just
487: ** the adhdr part).
488: */
489:
490: if (dbflag)
491: {
492: Dbpath = sbufp;
493: switch (i = initdbpath(Parmvect[0], Dbpath, TRUE))
494: {
495: case 0:
496: rtval = 0;
497: break;
498:
499: case 1:
500: rtval = 5;
501: break;
502:
503: case 2:
504: rtval = 1;
505: break;
506:
507: case 3:
508: rtval = 6;
509: break;
510:
511: default:
512: syserr("initucode: initdbpath %d", i);
513: }
514: sbufp += length(Dbpath) + 1;
515:
516: if (rtval == 0 || rtval == 5)
517: {
518: i = open(ztack(Dbpath, "/admin"), 0);
519: if (i < 0)
520: rtval += 1;
521: else
522: {
523: /* open and check admin file */
524: checkadmin(i);
525: close(i);
526: }
527: }
528: }
529:
530: /*
531: ** Check to see if the name on the -u flag is valid, and
532: ** that this user is allowed to use it.
533: */
534:
535: if (userflag != NULL)
536: {
537: printf("Invalid user name %s\n", userflag);
538: exit(-1);
539: }
540: if (usr_ovrd[0] != '\0')
541: {
542: if ((Status & U_SUPER) == 0)
543: {
544: if (!dbflag || !bequal(Admin.adhdr.adowner, Usercode, 2))
545: {
546: printf("You may not use the -u flag\n");
547: exit(-1);
548: }
549: }
550: bmove(usr_ovrd, Usercode, 2);
551: }
552:
553: /*
554: ** Process the +-w flag.
555: ** First, determine the locking mode. If +w, always
556: ** wait; if -w, never wait; if unspecified, wait if in
557: ** background, but print error and exit if running
558: ** interactive.
559: */
560:
561: if (waitflag > 0 || (waitflag == 0 && gtty(0, >tydummy) < 0))
562: Wait_action = A_SLP;
563: else
564: Wait_action = A_RTN;
565: if (dbflag && waitmode >= 0)
566: db_lock(waitmode);
567:
568: /*
569: ** Return authorization value.
570: */
571:
572: return (rtval);
573: }
574: /*
575: ** DB_LOCK -- lock database
576: **
577: ** Locks the database. Everyone should do this before using any
578: ** database.
579: **
580: ** Parameters:
581: ** database -- the pathname of the database.
582: ** mode -- M_EXCL -- get an exclusive lock.
583: ** M_SHARE -- get a shared lock.
584: **
585: ** Returns:
586: ** none
587: **
588: ** Side Effects:
589: ** Alockdes is opened.
590: */
591:
592: struct lockreq Lock; /* the database lock structure */
593:
594: db_lock(mode)
595: int mode;
596: {
597: if ((Admin.adhdr.adflags & A_DBCONCUR) == 0)
598: return;
599: if (Alockdes < 0)
600: Alockdes = start_up_lock_driver();
601: if (setdbl(Wait_action, mode) < 0)
602: {
603: printf("Database temporarily unavailable\n");
604: exit(1);
605: }
606: }
607: /*
608: ** INITDBPATH -- initialize the pathname of the database
609: **
610: ** The pathname of a specified database is created. Indirection
611: ** via a file is supported, so that if the pathname is a file,
612: ** the first line of the file is read and used as the pathname
613: ** of the real database.
614: **
615: ** Parameters:
616: ** database -- the name of the database. If NULL,
617: ** the pathname of datadir is returned.
618: ** dbbuf -- a buffer into which the pathname should
619: ** be dumped.
620: ** follow -- if set, follow the indirect chain of
621: ** database pathnames.
622: **
623: ** Returns:
624: ** 0 -- database exists in datadir
625: ** 1 -- database exists, but I followed a pointer.
626: ** 2 -- database doesn't exist in datadir.
627: ** 3 -- databae doesn't exist, but I followed a pointer.
628: **
629: ** Side Effects:
630: ** none.
631: */
632:
633: initdbpath(database, dbpath, follow)
634: char *database;
635: char *dbpath;
636: int follow;
637: {
638: struct stat ibuf;
639: register char *d;
640: register FILE *f;
641: register int phase;
642: int retval;
643: int uid;
644: extern char *index();
645:
646: d = dbpath;
647:
648: if (database == NULL)
649: {
650: # ifndef xDBPATH
651: concat(Pathname, "/data/base/", d);
652: # else
653: smove(xDBPATH, d);
654: # endif
655: return (0);
656: }
657:
658: /* get the basic pathname */
659: concat(ztack(Pathname, "/datadir/"), database, d);
660:
661: /*
662: ** Iterate looking for database.
663: ** "Phase" is what we are trying:
664: ** -1 -- looking in datadir
665: ** 0 -- looking in data/base
666: ** 1 -- following indirect.
667: */
668:
669: retval = 2;
670: for (phase = -1;;)
671: {
672: /* find out what sort of filesystem node this is */
673: if (stat(d, &ibuf) < 0)
674: {
675: if (phase < 0)
676: {
677: # ifdef xDBPATH
678: concat(xDBPATH, database, d);
679: # else
680: concat(ztack(Pathname, "/data/base/"), database, d);
681: # endif
682: phase = 0;
683: continue;
684: }
685: else
686: return (retval);
687: }
688:
689: /* set up the lock structure for future use */
690: bmove(&ibuf, Lock.dbnode, 4);
691:
692: retval -= 2;
693: if ((ibuf.st_mode & S_IFMT) == S_IFDIR)
694: return (retval);
695:
696: /* if second time through, the database must be a directory */
697: if (phase > 0)
698: syserr("initdbpath: not direc");
699:
700: /* if we shouldn't follow the chain, say it exists */
701: if (!follow)
702: return (3);
703:
704: /* it's a file -- see if we can use it */
705: uid = ibuf.st_uid;
706: # ifdef xB_UNIX
707: uid = (uid & 0377) | ((ibuf.st_gid & 0377) << 8);
708: # endif
709: # ifdef xV6_UNIX
710: uid &= 0377;
711: # endif
712: if (uid != Ing_uid || (ibuf.st_mode & 0777) != 0600)
713: return (3);
714:
715: f = fopen(d, "r");
716: if (f == NULL)
717: syserr("initdbpath: fopen");
718:
719: /* read the pathname of the database */
720: if (fgets(d, MAXLINE, f) == NULL || d[0] != '/')
721: syserr("initdbpath: bad indirect");
722: *index(d, '\n') = '\0';
723: fclose(f);
724:
725: /* prepare for next iteration */
726: retval = 3;
727: phase = 1;
728: }
729: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.