![[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 [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / contrib|
Return to uusnap.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / contrib |
1.1 root 1: /* uusnap.c
2: (c) 1992 Heiko W.Rupp [email protected]
3: uusnap is a tool to display the activities of the connected
4: systems.
5:
6: Put a file uusnap.systems in NEWCONFIGDIR (see Makefile), in which
7: the systems, you want to monitor are listed, one on a single line.
8: The sequence of the files there determine the sequence of the
9: listing.
10:
11: At the moment it only works with taylor config and taylor dirs
12:
13: compile it form the Makefile or:
14: cc -c -g -pipe -O -I. -I. -DNEWCONFIGLIB=\"/usr/local/lib/uucp\" uusnap.c
15: cc -o uusnap uusnap.o
16: For this, uusnap.[ch] must be in the same directory as uucp.h and so.
17:
18: uusnap must have read access to SPOOLDIR/.Status in order to work.
19: */
20:
21: #define MAXSYS 30 /* maximum number of systems */
22: #define WAIT_NORMAL 10 /* wait period if noone is talking */
23: #define WAIT_TALKING 2 /* refresh display every second if */
24: /* someone is talking with us */
25:
26: #include "uucp.h"
27: #if USE_RCS_ID
28: char uusnap_rcsid[] = "$Id: uusnap.c,v 1.9 92/05/05 22:51:50 hwr Exp Locker: hwr $";
29: #endif
30:
31: #include <ctype.h>
32: #include <time.h>
33: #include <sys/types.h>
34: #include <sys/dir.h>
35:
36: extern char *ctime(time_t*);
37:
38: struct sysInfo {
39: char sysname[10]; /* name of the system to watch */
40: char *statfile; /* name of its status file */
41: char *spooldir; /* root of its spooldir */
42: int in; /* number of unprocessed in-files */
43: int out; /* number of files to send them */
44: time_t last; /* last poll time */
45: time_t next; /* time of next poll */
46: time_t lastidir; /* time of last in-spooldir access */
47: time_t lastodir; /* time of last outgoing spd acc */
48: time_t laststat; /* time of last status file access */
49: int status; /* status of the system */
50: int num_retries; /* number of retries */
51: };
52:
53: struct sysInfo Systems[MAXSYS];
54:
55:
56: /* I have extend the system status. If time for the specified system
57: is Never, I say so. To get this to work, one also should extend
58: uucico.c. It is not important to do this. With the normal uucico,
59: one only gets no status.
60: */
61:
62: const char *azStatus[] = /* Status codes as defined by uucico */
63: { /* listing them here instead of */
64: "Conversation complete", /* including the appropriate file */
65: "Port unavailable", /* reduces the size of the executable */
66: "Dial failed",
67: "Login failed",
68: "Handshake failed",
69: "Call failed",
70: "Talking",
71: "Wrong time to call",
72: "Time to call = Never !"
73: };
74:
75: main()
76: {
77: int i;
78: i=get_systems();
79: display_info(i);
80:
81: exit(0);
82: }
83:
84: int
85: get_systems()
86: {
87: char filename[1024];
88: char fn[1024];
89: char line[80];
90: FILE *fp;
91: int i=0;
92: int j;
93: struct stat stbuf;
94: struct sysInfo sys;
95:
96: strcpy(filename,NEWCONFIGLIB);
97: strcat(filename,"/uusnap.systems");
98: if ((fp=fopen(filename,"r"))!=NULL) {
99: while (fgets(line,80,fp)!=NULL) {
100: *(rindex(line,'\n'))='\0';
101: strcpy(sys.sysname,line); /* get the name of the system */
102: strcpy(fn,SPOOLDIR); /* get the name of the statusfile */
103: strcat(fn,"/.Status/");
104: strcat(fn,line);
105: sys.statfile=malloc(strlen(fn)+1);
106: strcpy(sys.statfile,fn);
107: strcpy(fn,SPOOLDIR); /* get the name of the spooldir */
108: strcat(fn,"/");
109: strcat(fn,line);
110: sys.spooldir=malloc(strlen(fn)+1);
111: strcpy(sys.spooldir,fn);
112: sys.laststat=0;
113: sys.lastidir=sys.lastodir=0;
114: Systems[i]=sys; /* get_stat_for_system needs it */
115: get_stat_for_system(i); /* now get the system status */
116: get_inq_num(i,TRUE); /* number of unprocessed files */
117: get_outq_num(i,TRUE); /* number of files to send */
118: i++;
119: }
120: fclose(fp);
121: }
122: else {
123: fprintf(stderr,"Can't open %s \n",filename);
124: exit(1);
125: }
126: return i;
127: }
128:
129:
130:
131: display_info(int numSys)
132: {
133: char *filename;
134: int sysnum;
135: FILE *fp;
136: char contentline[80];
137: char isTalking=FALSE;
138: struct stat stbuf;
139: struct sysInfo sys;
140: time_t time;
141:
142: filename = (char*)malloc(1024);
143: if (filename == NULL) {
144: fprintf(stderr, "Can't malloc 1024 bytes");
145: exit(1);
146: }
147:
148: while(TRUE) {
149: display_headline();
150: for (sysnum=0;sysnum<numSys;sysnum++) {
151: sys = Systems[sysnum];
152: stat(sys.statfile,&stbuf);
153: if ((time=stbuf.st_atime) > sys.laststat) {
154: get_stat_for_system(sysnum);
155: }
156: if(display_status_line(sysnum)==1)
157: isTalking=TRUE;
158: }
159: if (isTalking) {
160: sleep(WAIT_TALKING);
161: isTalking = FALSE;
162: }
163: else
164: sleep(WAIT_NORMAL); /* wait a bit */
165: }
166: return 0;
167: }
168:
169: int
170: display_status_line(int sn)
171: {
172: char *time_s;
173:
174: int sys_stat,num_retries,wait;
175: int i;
176: time_t last_time;
177: time_t next_time;
178:
179: struct sysInfo sys;
180:
181: sys = Systems[sn];
182:
183: printf("%10s ",sys.sysname);
184: get_inq_num(sn);
185: if (sys.in==0)
186: printf(" ");
187: else
188: printf("%3d ",sys.in);
189: get_outq_num(sn);
190: if (sys.out==0)
191: printf(" ");
192: else
193: printf("%3d ",sys.out);
194: time_s = ctime(&sys.last);
195: time_s = time_s + 11;
196: *(time_s+8)='\0';
197: printf("%8s ",time_s); /* time of last poll */
198: time_s = ctime(&sys.next);
199: time_s = time_s + 11;
200: *(time_s+8)='\0';
201: if (sys.last == sys.next)
202: printf(" ");
203: else
204: printf("%8s ",time_s); /* time of next poll */
205: if (sys.num_retries==0)
206: printf(" ");
207: else
208: printf("%2d ",sys.num_retries);
209: if (sys_stat==6) /* system is talking */
210: printf("\E[7m"); /* reverse video on */
211: printf("%s",azStatus[sys.status]);
212: if (sys.status==6) {
213: printf("\E[m\n"); /* reverse video off */
214: return 1;
215: }
216: else {
217: printf("\n");
218: return 0;
219: }
220: }
221:
222:
223: display_headline()
224: {
225: printf("\E[;H\E[2J"); /* clear screen */
226: printf("\E[7muusnap (press CTRL-C to escape)\E[m \n\n");
227: printf(" System #in #out last next #ret Status\n");
228: return 0;
229: }
230:
231: get_inq_num(int num,char firstTime)
232: {
233: int i=0;
234: char filename[1024];
235: struct stat stbuf;
236: DIR *dirp;
237:
238: strcpy(filename,Systems[num].spooldir);
239: strcat(filename,"/X./.");
240: stat(filename,&stbuf);
241: if ((stbuf.st_mtime > Systems[num].lastidir) || (firstTime)) {
242: if ((dirp=opendir(filename))!=NULL) {
243: while(readdir(dirp))
244: i++;
245: closedir(dirp);
246: stat(filename,&stbuf);
247: Systems[num].lastidir=stbuf.st_mtime;
248: }
249: else {
250: fprintf(stderr,"Can't open %s \n",filename);
251: exit(1);
252: }
253: if (i>=2)
254: i-=2; /* correct . and .. */
255: Systems[num].in=i;
256: }
257: return 0;
258: }
259:
260: get_outq_num(int sys,char firstTime)
261: {
262: int i=0;
263: char filename[1024];
264: struct stat stbuf;
265: DIR *dirp;
266:
267: strcpy(filename,Systems[sys].spooldir);
268: strcat(filename,"/C./.");
269: stat(filename,&stbuf);
270: if ((stbuf.st_mtime > Systems[sys].lastodir) || (firstTime)) {
271: if ((dirp=opendir(filename))!=NULL) {
272: while(readdir(dirp))
273: i++;
274: closedir(dirp);
275: stat(filename,&stbuf);
276: Systems[sys].lastodir=stbuf.st_mtime;
277: }
278: else {
279: fprintf(stderr,"Can't open %s \n",filename);
280: exit(1);
281: }
282: if (i>=2)
283: i-=2; /* correct . and .. */
284: Systems[sys].out=i;
285: }
286: return 0;
287: }
288:
289: get_stat_for_system(int i)
290: {
291: char fn[80];
292: struct sysInfo sys;
293: struct stat stbuf;
294: FILE *fp;
295: time_t wait;
296:
297: sys = Systems[i];
298: stat(sys.statfile,&stbuf);
299: if (stbuf.st_atime > sys.laststat) {
300: if ((fp=fopen(sys.statfile,"r"))!=NULL) {
301: fgets(fn,80,fp);
302: fclose(fp);
303: sscanf(fn,"%d %d %ld %d",
304: &sys.status,
305: &sys.num_retries,
306: &sys.last,
307: &wait);
308: sys.next=sys.last+wait;
309: }
310: else {
311: sys.status=0;
312: sys.num_retries=0;
313: sys.last=0;
314: sys.next=0;
315: }
316: stat(sys.statfile,&stbuf);
317: sys.laststat=stbuf.st_atime;
318: }
319: Systems[i] = sys;
320: return 0;
321: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.