![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to folder.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip|
Return to folder.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip |
1.1 root 1: /* folder(s).c - report on folders */
2:
3: #include "../h/mh.h"
4: #include <errno.h>
5: #include <stdio.h>
6: #include <sys/types.h>
7: #ifndef BSD42
8: #ifndef SYS5
9: #include <ndir.h>
10: #else SYS5
11: #include <dir.h>
12: #endif SYS5
13: #else BSD42
14: #include <sys/dir.h>
15: #endif BSD42
16: #include <sys/stat.h>
17:
18: /* */
19:
20: static struct swit switches[] = {
21: #define ALLSW 0
22: "all", 0,
23:
24: #define FASTSW 1
25: "fast", 0,
26: #define NFASTSW 2
27: "nofast", 0,
28:
29: #define HDRSW 3
30: "header", 0,
31: #define NHDRSW 4
32: "noheader", 0,
33:
34: #define PACKSW 5
35: "pack", 0,
36: #define NPACKSW 6
37: "nopack", 0,
38: #define VERBSW 7
39: "verbose", 0,
40: #define NVERBSW 8
41: "noverbose", 0,
42:
43: #define RECURSW 9
44: "recurse", 0,
45: #define NRECRSW 10
46: "norecurse", 0,
47:
48: #define TOTALSW 11
49: "total", 0,
50: #define NTOTLSW 12
51: "nototal", 0,
52:
53: #define PRNTSW 13
54: "print", 0,
55: #define NPRNTSW 14
56: "noprint", 0,
57: #define LISTSW 15
58: "list", 0,
59: #define NLISTSW 16
60: "nolist", 0,
61: #define PUSHSW 17
62: "push", 0,
63: #define POPSW 18
64: "pop", 0,
65:
66: #define HELPSW 19
67: "help", 4,
68:
69: NULL, NULL
70: };
71:
72: /* */
73:
74: extern int errno;
75:
76: static int fshort = 0;
77: static int fpack = 0;
78: static int fverb = 0;
79: static int fheader = 0;
80: static int frecurse = 0;
81: static int ftotonly = 0;
82: static int msgtot = 0;
83: static int foldtot = 0;
84: static int start = 0;
85: static int foldp = 0;
86:
87: static char *mhdir;
88: static char *stack = "Folder-Stack";
89: static char folder[BUFSIZ];
90: static char *folds[NFOLDERS + 1];
91:
92: struct msgs *tfold ();
93: static int pfold(), sfold(), compare();
94: static void dodir(), addir(), addfold(), dother();
95:
96: /* */
97:
98: /* ARGSUSED */
99:
100: main(argc, argv)
101: int argc;
102: char *argv[];
103: {
104: int all = 0,
105: printsw = 0,
106: listsw = 0,
107: pushsw = 0,
108: popsw = 0;
109: char *cp,
110: *dp,
111: *msg = NULL,
112: *argfolder = NULL,
113: **ap,
114: **argp,
115: buf[100],
116: *arguments[MAXARGS];
117: struct stat st;
118:
119: invo_name = r1bindex (argv[0], '/');
120: if (argv[0][strlen (argv[0]) - 1] == 's')
121: all++;
122: if ((cp = m_find (invo_name)) != NULL) {
123: ap = brkstring (cp = getcpy (cp), " ", "\n");
124: ap = copyip (ap, arguments);
125: }
126: else
127: ap = arguments;
128: (void) copyip (argv + 1, ap);
129: argp = arguments;
130:
131: /* */
132:
133: while (cp = *argp++) {
134: if (*cp == '-')
135: switch (smatch (++cp, switches)) {
136: case AMBIGSW:
137: ambigsw (cp, switches);
138: done (1);
139: case UNKWNSW:
140: adios (NULLCP, "-%s unknown", cp);
141: case HELPSW:
142: (void) sprintf (buf, "%s [+folder] [msg] [switches]",
143: invo_name);
144: help (buf, switches);
145: done (1);
146:
147: case ALLSW:
148: all++;
149: continue;
150:
151: case FASTSW:
152: fshort++;
153: continue;
154: case NFASTSW:
155: fshort = 0;
156: continue;
157:
158: case HDRSW:
159: fheader = -1;
160: continue;
161: case NHDRSW:
162: fheader++;
163: continue;
164:
165: case PACKSW:
166: fpack++;
167: continue;
168: case NPACKSW:
169: fpack = 0;
170: continue;
171:
172: case VERBSW:
173: fverb++;
174: continue;
175: case NVERBSW:
176: fverb = 0;
177: continue;
178:
179: case RECURSW:
180: frecurse++;
181: continue;
182: case NRECRSW:
183: frecurse = 0;
184: continue;
185:
186: case TOTALSW:
187: all++;
188: ftotonly++;
189: continue;
190: case NTOTLSW:
191: if (ftotonly)
192: all = 0;
193: ftotonly = 0;
194: continue;
195:
196: case PRNTSW:
197: printsw++;
198: continue;
199: case NPRNTSW:
200: printsw = 0;
201: continue;
202:
203: case LISTSW:
204: listsw++;
205: continue;
206: case NLISTSW:
207: listsw = 0;
208: continue;
209:
210: case PUSHSW:
211: pushsw++;
212: popsw = 0;
213: continue;
214: case POPSW:
215: popsw++;
216: pushsw = 0;
217: continue;
218: }
219: if (*cp == '+' || *cp == '@')
220: if (argfolder)
221: adios (NULLCP, "only one folder at a time!");
222: else
223: argfolder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
224: else
225: if (msg)
226: adios (NULLCP, "only one (current) message at a time!");
227: else
228: msg = cp;
229: }
230:
231: /* */
232:
233: if (!m_find ("path"))
234: free (path ("./", TFOLDER));
235: mhdir = concat (m_maildir (""), "/", NULLCP);
236:
237: if (pushsw == 0 && popsw == 0 && listsw == 0)
238: printsw++;
239: if (pushsw) {
240: if (!argfolder) {
241: if ((cp = m_find (stack)) == NULL
242: || (ap = brkstring (dp = getcpy (cp), " ", "\n")) == NULL
243: || (argfolder = *ap++) == NULL)
244: adios (NULLCP, "no other folder");
245: for (cp = getcpy (m_getfolder ()); *ap; ap++)
246: cp = add (*ap, add (" ", cp));
247: free (dp);
248: m_replace (stack, cp);
249: }
250: else
251: m_replace (stack,
252: (cp = m_find (stack))
253: ? concat (m_getfolder (), " ", cp, NULLCP)
254: : getcpy (m_getfolder ()));
255: }
256: if (popsw) {
257: if (argfolder)
258: adios (NULLCP, "sorry, no folders allowed with -pop");
259: if ((cp = m_find (stack)) == NULL
260: || (ap = brkstring (dp = getcpy (cp), " ", "\n")) == NULL
261: || (argfolder = *ap++) == NULL)
262: adios (NULLCP, "folder stack empty");
263: for (cp = NULL; *ap; ap++)
264: cp = cp ? add (*ap, add (" ", cp)) : getcpy (*ap);
265: free (dp);
266: if (cp)
267: m_replace (stack, cp);
268: else
269: (void) m_delete (stack);
270: }
271: if (pushsw || popsw) {
272: if (access (cp = m_maildir (argfolder), 0) == NOTOK)
273: adios (cp, "unable to find folder");
274: m_replace (pfolder, argfolder);
275: m_update ();
276: argfolder = NULL;
277: }
278: if (pushsw || popsw || listsw) {
279: printf ("%s", argfolder ? argfolder : m_getfolder ());
280: if (cp = m_find (stack)) {
281: for (ap = brkstring (dp = getcpy (cp), " ", "\n"); *ap; ap++)
282: printf (" %s", *ap);
283: free (dp);
284: }
285: printf ("\n");
286:
287: if (!printsw)
288: done (0);
289: }
290:
291: /* */
292:
293: if (all) {
294: fheader = 0;
295: if (argfolder || msg) {
296: (void) strcpy (folder, argfolder ? argfolder : m_getfolder ());
297:
298: if (pfold (argfolder, msg) && argfolder) {
299: m_replace (pfolder, argfolder);
300: m_update ();
301: }
302: if (!frecurse) /* counter-intuitive */
303: dodir (folder);
304: }
305: else {
306: dother ();
307:
308: (void) strcpy (folder, (cp = m_find (pfolder)) ? cp : "");
309: dodir (".");
310: }
311:
312: if (!fshort) {
313: if (!ftotonly)
314: printf ("\n\t\t ");
315: printf ("TOTAL= %*d message%c in %d folder%s.\n",
316: DMAXFOLDER, msgtot, msgtot != 1 ? 's' : ' ',
317: foldtot, foldtot != 1 ? "s" : "");
318: }
319: }
320: else {
321: fheader++;
322:
323: (void) strcpy (folder, argfolder ? argfolder : m_getfolder ());
324: if (stat (strcpy (buf, m_maildir (folder)), &st) == NOTOK) {
325: if (errno != ENOENT)
326: adios (buf, "error on folder");
327: cp = concat ("Create folder \"", buf, "\"? ", NULLCP);
328: if (!getanswer (cp))
329: done (1);
330: free (cp);
331: if (!makedir (buf))
332: adios (NULLCP, "unable to create folder %s", buf);
333: }
334:
335: if (pfold (folder, msg) && argfolder)
336: m_replace (pfolder, argfolder);
337: }
338:
339: m_update ();
340:
341: done (0);
342: }
343:
344: /* */
345:
346: static void
347: dodir(dir)
348: register char *dir;
349: {
350: int i;
351: int os = start;
352: int of = foldp;
353: char buffer[BUFSIZ];
354:
355: start = foldp;
356: if (chdir (mhdir) == NOTOK)
357: adios (mhdir, "unable to change directory to");
358:
359: addir (strcpy (buffer, dir));
360: for (i = start; i < foldp; i++)
361: (void) pfold (folds[i], NULLCP), (void) fflush (stdout);
362:
363: start = os;
364: foldp = of;
365: }
366:
367: /* */
368:
369: static int
370: pfold(fold, msg)
371: register char *fold, *msg;
372: {
373: int hack,
374: others,
375: retval = 1;
376: register char *mailfile;
377: register struct msgs *mp = NULL;
378:
379: mailfile = m_maildir (fold);
380: if (chdir (mailfile) == NOTOK) {
381: if (errno != EACCES)
382: admonish (mailfile, "unable to change directory to");
383: else
384: printf ("%22s%c unreadable\n",
385: fold, strcmp (folder, fold) ? ' ' : '+');
386: return 0;
387: }
388:
389: if (fshort) {
390: printf ("%s\n", fold);
391:
392: if (!msg && !fpack) {
393: if (frecurse)
394: dodir (fold);
395: return retval;
396: }
397: }
398:
399: if (!(mp = m_gmsg (fold))) {
400: admonish (NULLCP, "unable to read folder %s", fold);
401: return 0;
402: }
403:
404: if (msg && !sfold (mp, msg))
405: retval = 0;
406: if (fpack)
407: mp = tfold (mp);
408:
409: if (fshort)
410: goto out;
411: foldtot++;
412: msgtot += mp -> nummsg;
413:
414: if (ftotonly)
415: goto out;
416:
417: if (!fheader++)
418: printf ("\t\tFolder %*s# of messages (%*srange%*s); cur%*smsg (other files)\n",
419: DMAXFOLDER, "", DMAXFOLDER - 2, "", DMAXFOLDER - 2, "",
420: DMAXFOLDER - 2, "");
421:
422: printf ("%22s%c ", fold, strcmp (folder, fold) ? ' ' : '+');
423:
424: hack = 0;
425: if (mp -> hghmsg == 0)
426: printf ("has no messages%*s",
427: mp -> msgflags & OTHERS ? DMAXFOLDER * 2 + 4 : 0, "");
428: else {
429: printf ("has %*d message%s (%*d-%*d)",
430: DMAXFOLDER, mp -> nummsg, (mp -> nummsg == 1) ? " " : "s",
431: DMAXFOLDER, mp -> lowmsg, DMAXFOLDER, mp -> hghmsg);
432: if (mp -> curmsg >= mp -> lowmsg && mp -> curmsg <= mp -> hghmsg)
433: printf ("; cur=%*d", DMAXFOLDER, hack = mp -> curmsg);
434: }
435:
436: if (mp -> msgflags & OTHERS)
437: printf (";%*s (others)", hack ? 0 : DMAXFOLDER + 6, "");
438: printf (".\n");
439:
440: out: ;
441: others = mp -> msgflags & OTHERS;
442: m_fmsg (mp);
443:
444: if (frecurse && others)
445: dodir (fold);
446:
447: return retval;
448: }
449:
450: /* */
451:
452: static int
453: sfold(mp, msg)
454: register struct msgs *mp;
455: char *msg;
456: {
457: if (!m_convert (mp, msg))
458: return 0;
459:
460: if (mp -> numsel > 1) {
461: admonish (NULLCP, "only one message at a time!");
462: return 0;
463: }
464: m_setseq (mp);
465: m_setcur (mp, mp -> lowsel);
466: m_sync (mp);
467: m_update ();
468:
469: return 1;
470: }
471:
472:
473: struct msgs *
474: tfold(mp)
475: register struct msgs *mp;
476: {
477: register int hole,
478: msgnum;
479: char newmsg[BUFSIZ],
480: oldmsg[BUFSIZ];
481:
482: if (mp -> lowmsg > 1 && (mp = m_remsg (mp, 1, mp -> hghmsg)) == NULL)
483: adios (NULLCP, "unable to allocate folder storage");
484:
485: for (msgnum = mp -> lowmsg, hole = 1; msgnum <= mp -> hghmsg; msgnum++)
486: if (mp -> msgstats[msgnum] & EXISTS) {
487: if (msgnum != hole) {
488: (void) strcpy (newmsg, m_name (hole));
489: (void) strcpy (oldmsg, m_name (msgnum));
490: if (fverb)
491: printf (" %s becomes %s\n", oldmsg, newmsg);
492: if (rename (oldmsg, newmsg) == NOTOK)
493: adios (newmsg, "unable to rename %s to", oldmsg);
494: if (msgnum == mp -> curmsg)
495: m_setcur (mp, mp -> curmsg = hole);
496: mp -> msgstats[hole] = mp -> msgstats[msgnum];
497: mp -> msgflags |= SEQMOD;
498: if (msgnum == mp -> lowsel)
499: mp -> lowsel = hole;
500: if (msgnum == mp -> hghsel)
501: mp -> hghsel = hole;
502: }
503: hole++;
504: }
505: if (mp -> nummsg > 0) {
506: mp -> lowmsg = 1;
507: mp -> hghmsg = hole - 1;
508: }
509: m_sync (mp);
510: m_update ();
511:
512: return mp;
513: }
514:
515: /* */
516:
517: static void
518: addir(name)
519: register char *name;
520: {
521: register char *base,
522: *cp;
523: struct stat st;
524: register struct direct *dp;
525: register DIR * dd;
526:
527: cp = name + strlen (name);
528: *cp++ = '/';
529: *cp = NULL;
530:
531: base = strcmp (name, "./") ? name : name + 2;/* hack */
532:
533: if ((dd = opendir (name)) == NULL) {
534: admonish (name, "unable to read directory ");
535: return;
536: }
537: while (dp = readdir (dd))
538: if (strcmp (dp -> d_name, ".") && strcmp (dp -> d_name, "..")) {
539: if (cp + dp -> d_namlen + 2 >= name + BUFSIZ)
540: continue;
541: (void) strcpy (cp, dp -> d_name);
542: if (stat (name, &st) != NOTOK && (st.st_mode & S_IFMT) == S_IFDIR)
543: addfold (base);
544: }
545: closedir (dd);
546:
547: *--cp = NULL;
548: }
549:
550: /* */
551:
552: static void
553: addfold(fold)
554: register char *fold;
555: {
556: register int i,
557: j;
558: register char *cp;
559:
560: if (foldp > NFOLDERS)
561: adios (NULLCP, "more than %d folders to report on", NFOLDERS);
562:
563: cp = getcpy (fold);
564: for (i = start; i < foldp; i++)
565: if (compare (cp, folds[i]) < 0) {
566: for (j = foldp - 1; j >= i; j--)
567: folds[j + 1] = folds[j];
568: foldp++;
569: folds[i] = cp;
570: return;
571: }
572:
573: folds[foldp++] = cp;
574: }
575:
576: /* */
577:
578: static int
579: compare(s1, s2)
580: register char *s1, *s2;
581: {
582: register int i;
583:
584: while (*s1 || *s2)
585: if (i = *s1++ - *s2++)
586: return i;
587:
588: return 0;
589: }
590:
591: /* */
592:
593: static void
594: dother()
595: {
596: int atrlen;
597: char atrcur[BUFSIZ];
598: register struct node *np;
599:
600: (void) sprintf (atrcur, "atr-%s-", current);
601: atrlen = strlen (atrcur);
602:
603: m_getdefs ();
604: for (np = m_defs; np; np = np -> n_next)
605: if (ssequal (atrcur, np -> n_name)
606: && !ssequal (mhdir, np -> n_name + atrlen))
607: (void) pfold (np -> n_name + atrlen, NULLCP);
608: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.