![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rmproject.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / spms / src / bin / rmproject|
Return to rmproject.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / spms / src / bin / rmproject |
1.1 root 1: static char *rcsid = "$Header$";
2: /*
3: * rmproject - remove a project root directory
4: *
5: * Author: Peter J. Nicklin
6: */
7: #include <sys/param.h>
8: #include <signal.h>
9: #include <stdio.h>
10: #include "getarg.h"
11: #include "macro.h"
12: #include "null.h"
13: #include "path.h"
14: #include "pdb.h"
15: #include "pld.h"
16: #include "slist.h"
17: #include "spms.h"
18: #include "system.h"
19: #include "yesno.h"
20:
21: char CWD[PATHSIZE]; /* current working directory */
22: char *CWP; /* current working project */
23: char *PGN = "rmproject"; /* program name */
24: char *RMFLAG = ""; /* rm "-f" flag */
25: int FORCE = 0; /* brute force remove or undefine */
26: int RECURSIVE = 0; /* remove project dirs recursively */
27: int UNDEFINE = 0; /* remove proj dir definitions only */
28: int WANT_TO_EXIT = 0; /* advisory exit flag */
29:
30: main(argc, argv)
31: int argc;
32: char **argv;
33: {
34: extern int PPDEBUG; /* project pathname debug flag */
35: char *getcwp(); /* get current working project */
36: char *getwd(); /* get current working directory */
37: int isfg(); /* is process in foreground? */
38: int onintr(); /* process signals */
39: int rmproject(); /* remove a project root directory */
40: int rmtyp(); /* remove project dir type labels */
41: int status = 0; /* exit status */
42: int unproject(); /* undefine project root directory */
43: int xppath(); /* expand project pathname */
44: PATH pathbuf; /* pathname struct buffer */
45: SLIST *pdirtyp; /* project directory type labels list */
46: SLIST *slinit(); /* initialize singly-linked list */
47: void typargtolist(); /* type labels -> pdirtyp list */
48:
49: pdirtyp = slinit();
50: {
51: register char *s; /* option pointer */
52: while (--argc > 0 && **++argv == '-')
53: {
54: for (s = argv[0]+1; *s != '\0'; s++)
55: switch (*s)
56: {
57: case 'D':
58: PPDEBUG = YES;
59: break;
60: case 'F':
61: /*
62: * 'F' option is mentioned in
63: * rmproject() and unproject()
64: */
65: FORCE++;
66: break;
67: case 'T':
68: typargtolist(GETARG(s), pdirtyp);
69: if (*s == '\0')
70: status = 1;
71: goto endfor;
72: case 'f':
73: RMFLAG = "-f";
74: break;
75: case 'r':
76: RECURSIVE++;
77: break;
78: case 'u':
79: UNDEFINE++;
80: break;
81: default:
82: warn("bad option -%c", *s);
83: status = 1;
84: goto endfor;
85: }
86: endfor: continue;
87: }
88: }
89: if (status == 1 || argc < 1)
90: fatal("usage: rmproject [-fru] [-T type[,type...]] projectname ...");
91:
92: if ((CWP = getcwp()) == NULL)
93: fatal("no project environment");
94: if (getwd(CWD) == NULL)
95: fatal("can't find current working directory");
96: if (isfg() == YES)
97: {
98: signal(SIGINT, onintr);
99: signal(SIGQUIT, onintr);
100: signal(SIGHUP, onintr);
101: }
102:
103: for (; argc > 0; ++argv, --argc)
104: {
105: if (xppath(*argv, &pathbuf) == -1)
106: {
107: patherr(*argv);
108: status = 1;
109: continue;
110: }
111: switch (pathbuf.p_mode & P_IFMT)
112: {
113: case P_IFHOME:
114: case P_IFPROOT:
115: if (SLNUM(pdirtyp) > 0)
116: status |= rmtyp(*argv, pdirtyp, &pathbuf);
117: else if (UNDEFINE)
118: status |= unproject(*argv, &pathbuf);
119: else
120: status |= rmproject(*argv, &pathbuf);
121: break;
122: case P_IFPDIR:
123: warn("%s is a project directory", *argv);
124: status = 1;
125: break;
126: case P_IFNEW:
127: case P_IFREG:
128: warn("%s: no such project", *argv);
129: status = 1;
130: break;
131: }
132: if (WANT_TO_EXIT)
133: exit(1);
134: }
135: exit(status);
136: }
137:
138:
139:
140: /*
141: * onintr() resets interrupt, quit, and hangup signals, and sets a flag
142: * which advises the process to exit at the first opportunity.
143: */
144: onintr()
145: {
146: signal(SIGINT, onintr);
147: signal(SIGQUIT, onintr);
148: signal(SIGHUP, onintr);
149:
150: WANT_TO_EXIT = 1;
151: }
152:
153:
154:
155: /*
156: * pbrmtyp() removes type labels from database buffer.
157: */
158: void
159: pbrmtyp(ppathname, typlist)
160: char *ppathname; /* project pathname */
161: SLIST *typlist; /* type labels list */
162: {
163: char *pbgetstring(); /* get specified string field */
164: char *pdtfind(); /* find type label in buffer */
165: char *slget(); /* get next key from list */
166: char *tp; /* pointer to type label */
167: char typbuf[TYPBUFSIZE]; /* project directory types buffer */
168: int pbaddstring(); /* add string field */
169: int strlen(); /* string length */
170: void slrewind(); /* rewind list */
171: void pdtrm(); /* remove type label */
172:
173: pbgetstring(PDIRTYPE, typbuf);
174: slrewind(typlist);
175: while ((tp = slget(typlist)) != NULL)
176: {
177: if (pdtfind(tp, typbuf) != NULL)
178: pdtrm(tp, typbuf);
179: else
180: warn("%s: \"%s\" type label not found", ppathname, tp);
181: }
182: pbaddstring(PDIRTYPE, typbuf);
183: }
184:
185:
186:
187: /*
188: * rmd() removes a project directory. rmd() returns the status of the rm
189: * command or 1 if the user decides not to remove a project directory.
190: * Before removing a directory the project link directory is moved to
191: * safe place. If the directory is removed successfully, the project link
192: * directory is removed.
193: */
194: rmd(pathname)
195: char *pathname; /* full pathname of directory */
196: {
197: char cmdbuf[PATHSIZE+9]; /* command buffer */
198: int rmpld(); /* remove project link directory */
199: int savepld(); /* save project link directory */
200: int status; /* return status */
201: int yes(); /* is reply yes? */
202: void restorpld(); /* restore project link directory */
203: void unsavepld(); /* remove saved project link dir */
204:
205: if (RECURSIVE)
206: {
207: sprintf(cmdbuf, "rm %s -r %s", RMFLAG, pathname);
208: printf("%s? [yn](n): ", cmdbuf);
209: if (!yes())
210: return(1);
211: status = system(cmdbuf);
212: status >>= NBBY;
213: status &= 0xff;
214: }
215: else {
216: if ((status = savepld(pathname)) == 0)
217: if ((status = rmpld(pathname)) == 0)
218: if ((status = RM_DIR(pathname)) != 0)
219: restorpld(pathname);
220: else
221: unsavepld();
222: }
223: return(status);
224: }
225:
226:
227:
228: /*
229: * rmpld() removes a project link directory. Returns 1 if file not
230: * removed, otherwise zero.
231: */
232: rmpld(pathname)
233: char *pathname; /* project root directory pathname */
234: {
235: char *pathcat(); /* pathname concatenation */
236: char pldpathname[PATHSIZE]; /* project link directory pathname */
237:
238: if (unlink(pathcat(pldpathname, pathname, PLDNAME)) != 0)
239: if (!FORCE)
240: {
241: pperror(pldpathname);
242: return(1);
243: }
244: return(0);
245: }
246:
247:
248:
249: /*
250: * rmproject() removes a project root directory. Returns 0 is successful,
251: * otherwise 1.
252: */
253: rmproject(ppathname, pb)
254: char *ppathname; /* project root directory pathname */
255: PATH *pb; /* pathname struct buffer */
256: {
257: char *ppathcat(); /* project pathname concatenation */
258: char *ppathhead(); /* remove tail of project pathname */
259: char pppathname[PPATHSIZE]; /* parent project pathname */
260: char *strcpy(); /* string copy */
261: int _closepdb(); /* close database without updating */
262: int closepdb(); /* close database */
263: int errpdb(); /* print database error */
264: int plen; /* length of regular pathname */
265: int pputent(); /* write buffer to database */
266: int pstatus = 0; /* project status */
267: int strlen(); /* string length */
268: int strncmp(); /* compare n characters */
269: int subprojects(); /* check for subprojects */
270: int xppath(); /* expand project pathname */
271: PATH *pd; /* pathname struct pointer */
272: PATH ppathbuf; /* parent project pathname struct buf */
273: PATH *readpld(); /* read project link directory entry */
274: PDB *openpdb(); /* open database */
275: PDB *pldp; /* project link directory stream */
276: void resetpdb(); /* reset current database pointer */
277:
278: if (EQUAL(ppathname, CURPROJECT))
279: {
280: warn("%s: can't remove current project", ppathname);
281: return(1);
282: }
283: plen = strlen(pb->p_path);
284: if (strncmp(pb->p_path, CWD, plen) == 0)
285: {
286: warn("can't remove %s from current directory", ppathname);
287: return(1);
288: }
289: if (FORCE)
290: {
291: if (*ppathname != _PDIRC && *ppathname != _HDIRC)
292: {
293: warn("%s must an absolute project pathname", ppathname);
294: return(1);
295: }
296: ppathhead(strcpy(pppathname, ppathname));
297: }
298: else {
299: ppathcat(pppathname, ppathname, PARENTPROJECT);
300: }
301: if (xppath(pppathname, &ppathbuf) == -1)
302: {
303: patherr("");
304: warn("force removal by typing `rmproject -F projectname'");
305: return(1);
306: }
307: if ((pldp = openpdb(PLDNAME, ppathbuf.p_path, "rw")) == NULL)
308: return(errpdb((PDB *) NULL));
309: while ((pd = readpld(pldp)) != NULL)
310: if (EQUAL(pb->p_alias, pd->p_alias))
311: {
312: pstatus = subprojects(pb->p_path);
313: if (pstatus == 1)
314: {
315: warn("%s: project not empty", ppathname);
316: resetpdb(pldp);
317: break;
318: }
319: else if (pstatus == 2)
320: {
321: warn("can't remove %s because subprojects exist",
322: ppathname);
323: resetpdb(pldp);
324: break;
325: }
326: else if (pstatus == 3)
327: {
328: resetpdb(pldp);
329: break;
330: }
331: resetpdb(pldp);
332: }
333: else if (strncmp(pb->p_path, pd->p_path, plen) == 0)
334: { /* don't clobber nested projects */
335: if (pd->p_mode == P_IFPROOT)
336: {
337: warnexist(ppathname, pd->p_alias);
338: pstatus = 4;
339: break;
340: }
341: }
342: else {
343: pputent(pldp);
344: }
345: if (pstatus != 0)
346: _closepdb(pldp);
347: else if ((pstatus = rmd(pb->p_path)) != 0)
348: _closepdb(pldp);
349: else
350: pstatus = closepdb(pldp);
351: return(pstatus != 0);
352: }
353:
354:
355:
356: /*
357: * rmtyp() removes type labels from an existing project directory.
358: */
359: rmtyp(ppathname, pdirtyp, pb)
360: char *ppathname; /* project directory pathname */
361: SLIST *pdirtyp; /* project directory type labels list */
362: PATH *pb; /* pathname struct buffer */
363: {
364: char *pbfndkey(); /* find key */
365: int closepdb(); /* close database */
366: int errpdb(); /* print database error */
367: int pgetent(); /* load next entry into buffer */
368: int pputent(); /* write buffer to database */
369: int status = 0; /* return status */
370: PDB *openpdb(); /* open database */
371: PDB *pldp; /* project link directory stream */
372: void pbrmtyp(); /* remove type labels from buffer */
373:
374: if ((pldp = openpdb(PLDNAME, pb->p_project, "rw")) == NULL)
375: return(errpdb((PDB *) NULL));
376: while (pgetent(pldp) != EOF)
377: {
378: if (pbfndkey(CURPROJECT) != NULL)
379: pbrmtyp(ppathname, pdirtyp);
380: pputent(pldp);
381: }
382: status = closepdb(pldp);
383: return(status);
384: }
385:
386:
387:
388: /*
389: * subprojects() returns 1 if a project has project directories, 2 if any
390: * of these are subprojects, and zero otherwise.
391: */
392: subprojects(pathname)
393: char *pathname; /* project root directory pathname */
394: {
395: char *pbfndkey(); /* find key */
396: int closepdb(); /* close database */
397: int errpdb(); /* print database error */
398: int pbfndflag(); /* find flag field */
399: int pgetent(); /* load next entry into buffer */
400: int status = 0; /* return status */
401: PDB *openpdb(); /* open database */
402: PDB *pldp; /* project link directory stream */
403:
404: if ((pldp = openpdb(PLDNAME, pathname, "r")) == NULL)
405: {
406: if (!FORCE) return(errpdb((PDB *) NULL));
407: return(status);
408: }
409: while (pgetent(pldp) != EOF)
410: if (pbfndkey(CURPROJECT) == NULL &&
411: pbfndkey(PARENTPROJECT) == NULL)
412: {
413: if (!RECURSIVE) status = 1;
414: if (pbfndflag(PROOTDIR) == YES)
415: {
416: status = 2;
417: break;
418: }
419: }
420: closepdb(pldp);
421: return(status);
422: }
423:
424:
425:
426: /*
427: * typargtolist() prepends comma-separated type labels specified in typarg
428: * to typlist.
429: */
430: void
431: typargtolist(typarg, typlist)
432: register char *typarg; /* type labels argument */
433: SLIST *typlist; /* type labels list */
434: {
435: register char *t; /* type label argument pointer */
436: char *slprepend(); /* prepend singly-linked list key */
437:
438: for (t = typarg; *t != '\0'; t++)
439: continue;
440: for (; t >= typarg; t--)
441: if (t[0] == ',')
442: {
443: if (t[1] != '\0')
444: slprepend(t+1, typlist);
445: t[0] = '\0';
446: }
447: slprepend(typarg, typlist);
448: }
449:
450:
451:
452: /*
453: * unproject() undefines a project root directory. Returns 0 is successful,
454: * otherwise 1.
455: */
456: unproject(ppathname, pb)
457: char *ppathname; /* project root directory pathname */
458: PATH *pb; /* pathname struct buffer */
459: {
460: char *ppathcat(); /* project pathname concatenation */
461: char *ppathhead(); /* remove tail of project pathname */
462: char pppathname[PPATHSIZE]; /* parent project pathname */
463: char *strcpy(); /* string copy */
464: int _closepdb(); /* close database without updating */
465: int closepdb(); /* close database */
466: int errpdb(); /* print database error */
467: int pputent(); /* write buffer to database */
468: int pstatus = 0; /* project status */
469: int rmpld(); /* remove project link directory */
470: int subprojects(); /* check for subprojects */
471: int xppath(); /* expand project pathname */
472: PATH *pd; /* pathname struct pointer */
473: PATH ppathbuf; /* parent project pathname struct buf */
474: PATH *readpld(); /* read project link directory entry */
475: PDB *openpdb(); /* open database */
476: PDB *pldp; /* project link directory stream */
477: void resetpdb(); /* reset current database pointer */
478:
479: if (EQUAL(ppathname, CURPROJECT))
480: {
481: warn("%s: can't undefine current project", ppathname);
482: return(1);
483: }
484: if (FORCE)
485: {
486: if (*ppathname != _PDIRC && *ppathname != _HDIRC)
487: {
488: warn("%s must an absolute project pathname", ppathname);
489: return(1);
490: }
491: ppathhead(strcpy(pppathname, ppathname));
492: }
493: else {
494: ppathcat(pppathname, ppathname, PARENTPROJECT);
495: }
496: if (xppath(pppathname, &ppathbuf) == -1)
497: {
498: patherr("");
499: warn("force conversion by typing `rmproject -uF projectname'");
500: return(1);
501: }
502: if ((pldp = openpdb(PLDNAME, ppathbuf.p_path, "rw")) == NULL)
503: return(errpdb((PDB *) NULL));
504: while ((pd = readpld(pldp)) != NULL)
505: if (EQUAL(pb->p_alias, pd->p_alias))
506: {
507: pstatus = subprojects(pb->p_path);
508: if (pstatus == 1)
509: {
510: warn("can't undefine %s: project not empty",
511: ppathname);
512: resetpdb(pldp);
513: break;
514: }
515: else if (pstatus == 2)
516: {
517: warn("can't undefine %s because subprojects exist",
518: ppathname);
519: resetpdb(pldp);
520: break;
521: }
522: else if (pstatus == 3)
523: {
524: resetpdb(pldp);
525: break;
526: }
527: resetpdb(pldp);
528: }
529: else {
530: pputent(pldp);
531: }
532: if (pstatus != 0)
533: _closepdb(pldp);
534: else if ((pstatus = rmpld(pb->p_path)) != 0)
535: _closepdb(pldp);
536: else
537: pstatus = closepdb(pldp);
538: return(pstatus != 0);
539: }
540:
541:
542:
543: /*
544: * warnexist() warns of nested or duplicate projects.
545: */
546: warnexist(ppathname, alias)
547: char *ppathname; /* project to be removed */
548: char *alias; /* nested or duplicate project alias */
549: {
550: char npathname[PPATHSIZE]; /* nested project pathname */
551: char *p; /* nested project pathname pointer */
552: char *strpcpy(); /* string copy and update pointer */
553:
554: p = strpcpy(npathname, ppathname);
555: while (p > npathname && p[-1] != _PPSC)
556: p--;
557: *p = '\0';
558: warn("can't remove %s because project %s%s exists", ppathname,
559: npathname, alias);
560: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.