![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uusnap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp|
Return to uusnap.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)uusnap.c 5.2 (Berkeley) 7/2/83";
3: #endif
4:
5: /*
6: * Uusnap - displays a snapshot of the uucp system.
7: * RJKing WECo-MG6565 May 83
8: */
9:
10: #include "uucp.h"
11: #include <sys/types.h>
12: #include <sys/stat.h>
13: #ifdef NDIR
14: #include "ndir.h"
15: #else
16: #include <sys/dir.h>
17: #endif
18:
19: #ifndef SYSBUF
20: char SYSBUF[BUFSIZ];
21: #endif
22:
23: #define NSYSTEM 100 /* max # of systems queued */
24: #define SPOOLDR "/usr/spool/uucp" /* Where STST files are */
25: #ifdef UUDIR
26: #define CMDSDIR "/usr/spool/uucp/C." /* Name of commands dir */
27: #define DATADIR "/usr/spool/uucp/D." /* Name of data directory */
28: #define XEQTDIR "/usr/spool/uucp/X." /* Name of execute dir */
29: #else
30: #define CMDSDIR "/usr/spool/uucp" /* Name of commands dir */
31: #define DATADIR "/usr/spool/uucp" /* Name of data directory */
32: #define XEQTDIR "/usr/spool/uucp" /* Name of execute dir */
33: #endif
34:
35: #define CMDSLEN 5 /* Length of trailer */
36: #define DATALEN 5 /* Length of trailer */
37: /* rti!trt: XEQTLEN was 0, for reverse search, but that did not work. */
38: #define XEQTLEN 5 /* Length of trailer */
39: #define NUMCTRS 3 /* # file types to count */
40: #define CMDTYPE 0 /* Index into scnt.cntr */
41: #define DATTYPE 1 /* Index into scnt.cntr */
42: #define XEQTYPE 2 /* Index into scnt.cntr */
43:
44: void scandir(), getstst();
45: extern char *index(), *rindex(), *strcpy(), *strncpy();;
46: extern long atol();
47: extern time_t time();
48:
49: struct scnt { /* System count structure */
50: char name[16]; /* Name of system */
51: short cntr[NUMCTRS]; /* Count */
52: char stst[32]; /* STST Message */
53: short locked; /* If LCK..sys present */
54: int st_type; /* STST Type */
55: int st_count; /* STST Count */
56: time_t st_lastime; /* STST Last time tried */
57: time_t st_retry; /* STST Secs to retry */
58: };
59:
60: int sndx; /* Number of systems */
61: struct scnt sys[NSYSTEM]; /* Systems queued */
62:
63: main()
64: { register int i, j, nlen = 0;
65: time_t curtime, t;
66:
67: setbuf(stdout, SYSBUF);
68: scandir(CMDSDIR, "C.", CMDSLEN, NULL, CMDTYPE);
69: scandir(DATADIR, "D.", DATALEN, NULL, DATTYPE);
70: scandir(XEQTDIR, "X.", XEQTLEN, 'X', XEQTYPE);
71: getstst(SPOOLDR);
72: time(&curtime);
73: for(i=0; i<sndx; ++i)
74: if((j = strlen(sys[i].name)) > nlen)
75: nlen = j;
76: for(i=0; i<sndx; ++i)
77: { printf("%-*.*s ", nlen, nlen, sys[i].name);
78: if(sys[i].cntr[CMDTYPE])
79: printf("%3.d Cmd%s ", sys[i].cntr[CMDTYPE],
80: sys[i].cntr[CMDTYPE]>1?"s":" ");
81: else printf(" --- ");
82: if(sys[i].cntr[DATTYPE])
83: printf("%3.d Data ", sys[i].cntr[DATTYPE]);
84: else printf(" --- ");
85: if(sys[i].cntr[XEQTYPE])
86: printf("%3.d Xqt%s ", sys[i].cntr[XEQTYPE],
87: sys[i].cntr[XEQTYPE]>1?"s":" ");
88: else printf(" --- ");
89: if(*sys[i].stst == NULL)
90: { if(sys[i].locked)
91: printf("LOCKED\n");
92: else printf("\n");
93: continue;
94: }
95: printf("%s ", sys[i].stst);
96: if(sys[i].st_type == SS_INPROGRESS)
97: { printf("\n");
98: continue;
99: }
100: t = (sys[i].st_lastime +sys[i].st_retry) - curtime;
101: if(t <= 0)
102: printf("Retry time reached ");
103: else
104: { if(t < 60)
105: printf("Retry time %ld sec%s ", (long)(t%60),
106: (t%60)!=1? "s": "");
107: else printf("Retry time %ld min%s ", (long)(t/60),
108: (t/60)!=1? "s": "");
109: }
110: if(sys[i].st_count > 1)
111: printf("Count: %d\n", sys[i].st_count);
112: else printf("\n");
113: }
114: exit(0);
115: }
116: void scandir(dnam, prfx, flen, fchr, type)
117: char *dnam, *prfx, fchr;
118: { register int i, plen;
119: char fnam[MAXNAMLEN+1];
120: register struct direct *dentp;
121: register DIR *dirp;
122:
123: plen = strlen(prfx);
124: if(chdir(dnam) < 0)
125: { perror(dnam);
126: exit(1);
127: }
128: if ((dirp = opendir(".", "r")) == NULL)
129: { perror(dnam);
130: exit(1);
131: }
132: while((dentp = readdir(dirp)) != NULL)
133: { if(*dentp->d_name == '.' || dentp->d_ino == 0)
134: continue;
135: if(strncmp(dentp->d_name, prfx, plen) != SAME) {
136: #ifdef UUDIR
137: fprintf(stderr, "strange file (%s) in %s\n",
138: dentp->d_name, dnam);
139: #endif
140: continue;
141: }
142: strcpy(fnam, &dentp->d_name[plen]);
143: i = strlen(fnam);
144: if(flen > 0)
145: fnam[i -flen] = NULL;
146: else
147: for(; i>0; --i)
148: { if(fnam[i] == fchr)
149: { fnam[i] = NULL;
150: break;
151: }
152: }
153: for(i=0; i<sndx; ++i)
154: { if(strcmp(fnam, sys[i].name) == SAME)
155: { ++sys[i].cntr[type];
156: break;
157: }
158: }
159: if(i == sndx)
160: { strcpy(sys[i].name, fnam);
161: ++sys[i].cntr[type];
162: ++sndx;
163: }
164: }
165: closedir(dirp);
166: }
167: void getstst(sdir)
168: char *sdir;
169: { register int i, csys;
170: register char *tp;
171: char fnam[MAXNAMLEN+1], buff[128];
172: register struct direct *dentp;
173: register DIR *dirp;
174: register FILE *st;
175:
176: if(chdir(sdir) < 0)
177: { perror(sdir);
178: exit(1);
179: }
180: if((dirp = opendir(".", "r")) == NULL)
181: { perror(sdir);
182: exit(1);
183: }
184: while((dentp = readdir(dirp)) != NULL)
185: { if(dentp->d_ino == 0)
186: continue;
187: if(strncmp(dentp->d_name, "LCK..", 5) == SAME)
188: { if(strncmp(&dentp->d_name[5], "tty", 3) == SAME ||
189: strncmp(&dentp->d_name[5], "cul", 3) == SAME)
190: continue;
191: strcpy(fnam, dentp->d_name);
192: for(csys=0; csys<sndx; ++csys)
193: { if(strcmp(&fnam[5], sys[csys].name) == SAME)
194: break;
195: }
196: if(csys == sndx)
197: { strcpy(sys[csys].name, &fnam[5]);
198: ++sndx;
199: }
200: ++sys[csys].locked;
201: continue;
202: }
203: if(strncmp(dentp->d_name, "STST.", 5) == SAME)
204: { strcpy(fnam, dentp->d_name);
205: for(csys=0; csys<sndx; ++csys)
206: { if(strcmp(&fnam[5], sys[csys].name) == SAME)
207: break;
208: }
209: if(csys == sndx)
210: { strcpy(sys[csys].name, &fnam[5]);
211: ++sndx;
212: }
213: if((st = fopen(fnam, "r")) == NULL)
214: { strncpy(sys[csys].stst, "",
215: sizeof(sys[csys].stst));
216: continue;
217: }
218: strncpy(buff, "", sizeof(buff));
219: fgets(buff, sizeof(buff), st);
220: fclose(st);
221: if(tp = rindex(buff, ' '))
222: *tp = NULL; /* drop system name */
223: else continue;
224: for(i=0, tp=buff; i<4; ++i, ++tp)
225: if((tp = index(tp, ' ')) == NULL)
226: break;
227: if(i != 4)
228: continue;
229: strncpy(sys[csys].stst, tp, sizeof(sys[csys].stst));
230: tp = buff;
231: sys[csys].st_type = atoi(tp);
232: tp = index(tp+1, ' ');
233: sys[csys].st_count = atoi(tp+1);
234: tp = index(tp+1, ' ');
235: sys[csys].st_lastime = (time_t)atol(tp+1);
236: tp = index(tp+1, ' ');
237: sys[csys].st_retry = (time_t)atol(tp+1);
238: }
239: }
240: closedir(dirp);
241: }
242: /* @(#)index.c 4.1 (Berkeley) 12/21/80 */
243: /*
244: * Return the ptr in sp at which the character c appears;
245: * NULL if not found
246: */
247:
248:
249: char *
250: index(sp, c)
251: register char *sp, c;
252: {
253: do {
254: if (*sp == c)
255: return(sp);
256: } while (*sp++);
257: return(NULL);
258: }
259:
260: /* @(#)rindex.c 4.1 (Berkeley) 12/21/80 */
261: /*
262: * Return the ptr in sp at which the character c last
263: * appears; NULL if not found
264: */
265:
266:
267: char *
268: rindex(sp, c)
269: register char *sp, c;
270: {
271: register char *r;
272:
273: r = NULL;
274: do {
275: if (*sp == c)
276: r = sp;
277: } while (*sp++);
278: return(r);
279: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.