[unix-history] / gnu / libexec / uucp / contrib / uusnap.c

/* uusnap.c
   (c) 1992 Heiko W.Rupp hwr@pilhuhn.ka.sub.org
   uusnap is a tool to display the activities of the connected
   systems.

   Put a file uusnap.systems in NEWCONFIGDIR (see Makefile), in which
   the systems, you want to monitor are listed, one on a single line.
   The sequence of the files there determine the sequence of the
   listing.

   At the moment it only works with taylor config and taylor dirs

   compile it form the Makefile or:
   cc -c -g -pipe -O  -I. -I. -DNEWCONFIGLIB=\"/usr/local/lib/uucp\" uusnap.c
   cc  -o uusnap uusnap.o 
   For this, uusnap.[ch] must be in the same directory as uucp.h and so.

   uusnap must have read access to SPOOLDIR/.Status in order to work.
*/

#define MAXSYS 30		/* maximum number of systems */
#define WAIT_NORMAL 10		/* wait period if noone is talking */
#define WAIT_TALKING 2		/* refresh display every second if */
				/* someone is talking with us */

#include "uucp.h"
#if USE_RCS_ID
char uusnap_rcsid[] = "$Id: uusnap.c,v 1.1 1993/08/04 19:31:43 jtc Exp $";
#endif

#include <ctype.h>
#include <time.h>
#include <sys/types.h>
#include <sys/dir.h>

extern char *ctime(time_t*);

struct sysInfo  {
    char sysname[10];		/* name of the system to watch */
    char *statfile;		/* name of its status file */
    char *spooldir;		/* root of its spooldir */
    int in;			/* number of unprocessed in-files */
    int out;			/* number of files to send them */
    time_t last;		/* last poll time */
    time_t next;		/* time of next poll */
    time_t lastidir;		/* time of last in-spooldir access */
    time_t lastodir;		/* time of last outgoing spd acc */
    time_t laststat;		/* time of last status file access */
    int status;			/* status of the system */
    int num_retries;		/* number of retries */
};

struct sysInfo Systems[MAXSYS];    
\f

/*  I have extend the system status. If time for the specified system
    is Never, I say so. To get this to work, one also should extend
    uucico.c. It is not important to do this. With the normal uucico,
    one only gets no status.
*/

const char *azStatus[] =        /* Status codes as defined by uucico  */
{   			        /* listing them here instead of       */
  "Conversation complete",      /* including the appropriate file     */
  "Port unavailable",           /* reduces the size of the executable */
  "Dial failed",
  "Login failed",
  "Handshake failed",
  "Call failed",
  "Talking",
  "Wrong time to call",
  "Time to call = Never !"
};

main()
{
    int i;
    i=get_systems();
    display_info(i);
    
    exit(0);
}

int
get_systems()
{
    char filename[1024];
    char fn[1024];
    char line[80];
    FILE *fp;
    int i=0;
    int j;
    struct stat stbuf;
    struct sysInfo sys;

    strcpy(filename,NEWCONFIGLIB);
    strcat(filename,"/uusnap.systems");
    if ((fp=fopen(filename,"r"))!=NULL) {
	while (fgets(line,80,fp)!=NULL) {
	    *(rindex(line,'\n'))='\0';
	    strcpy(sys.sysname,line); /* get the name of the system */
	    strcpy(fn,SPOOLDIR); /* get the name of the statusfile */
	    strcat(fn,"/.Status/");
	    strcat(fn,line);
	    sys.statfile=malloc(strlen(fn)+1);
	    strcpy(sys.statfile,fn);
	    strcpy(fn,SPOOLDIR); /* get the name of the spooldir */
	    strcat(fn,"/");
	    strcat(fn,line);
	    sys.spooldir=malloc(strlen(fn)+1);
	    strcpy(sys.spooldir,fn);
	    sys.laststat=0;
	    sys.lastidir=sys.lastodir=0;
	    Systems[i]=sys;		/* get_stat_for_system needs it */
	    get_stat_for_system(i);    	/* now get the system status */
	    get_inq_num(i,TRUE);	/* number of unprocessed files */
	    get_outq_num(i,TRUE);       /* number of files to send */
	    i++;	
	}
	fclose(fp);
    }
    else {
	fprintf(stderr,"Can't open %s \n",filename);
	exit(1);
    }
    return i;
}

	    
display_info(int numSys)
{
    char *filename;
    int sysnum;
    FILE *fp;
    char contentline[80];
    char isTalking=FALSE;
    struct stat stbuf;
    struct sysInfo sys;
    time_t time;

    filename = (char*)malloc(1024);
    if (filename == NULL) {
	fprintf(stderr, "Can't malloc 1024 bytes");
	exit(1);
    }
	
    while(TRUE) {
	display_headline();
	for (sysnum=0;sysnum<numSys;sysnum++) {
	    sys = Systems[sysnum];
	    stat(sys.statfile,&stbuf);
	    if ((time=stbuf.st_atime) > sys.laststat) {
		get_stat_for_system(sysnum);
	    }
	    if(display_status_line(sysnum)==1)
		isTalking=TRUE;
	}
	if (isTalking) {
	    sleep(WAIT_TALKING);
	    isTalking = FALSE;
	}
	else
	    sleep(WAIT_NORMAL);            /* wait a bit */
    }
    return 0;
}

int
display_status_line(int sn)
{
    char *time_s;
    
    int sys_stat,num_retries,wait;
    int i;
    time_t last_time;
    time_t next_time;
     
    struct sysInfo sys;
    
    sys = Systems[sn];

    printf("%10s  ",sys.sysname);
    get_inq_num(sn);
    if (sys.in==0)
	printf("     ");
    else 
	printf("%3d  ",sys.in);
    get_outq_num(sn);
    if (sys.out==0)
	printf("     ");
    else
	printf("%3d  ",sys.out);
    time_s = ctime(&sys.last);
    time_s = time_s + 11;
    *(time_s+8)='\0';
    printf("%8s ",time_s);	/* time of last poll */
    time_s = ctime(&sys.next);
    time_s = time_s + 11;
    *(time_s+8)='\0';
    if (sys.last == sys.next) 
	printf("           ");
    else
	printf("%8s   ",time_s);	/* time of next poll */
    if (sys.num_retries==0) 
	printf("   ");
    else 
	printf("%2d ",sys.num_retries);
    if (sys_stat==6) 		/* system is talking */
	printf("\E[7m");	/* reverse video on */
    printf("%s",azStatus[sys.status]);
    if (sys.status==6) {
	printf("\E[m\n");	/* reverse video off */
	return 1;
    }
    else {
	printf("\n");
	return 0;
    }
}


display_headline()
{
    printf("\E[;H\E[2J");	/* clear screen */
    printf("\E[7muusnap (press CTRL-C to escape)\E[m \n\n");
    printf("  System     #in #out   last     next   #ret    Status\n");
    return 0;
}

get_inq_num(int num,char firstTime)
{
    int i=0;
    char filename[1024];
    struct stat stbuf;
    DIR *dirp;
    
    strcpy(filename,Systems[num].spooldir);
    strcat(filename,"/X./.");
    stat(filename,&stbuf);
    if ((stbuf.st_mtime > Systems[num].lastidir) || (firstTime)) {
	if ((dirp=opendir(filename))!=NULL) {
	    while(readdir(dirp))
		i++;
	    closedir(dirp);
	    stat(filename,&stbuf);
	    Systems[num].lastidir=stbuf.st_mtime;
	}
	else {
	    fprintf(stderr,"Can't open %s \n",filename);
	    exit(1);
	}
	if (i>=2)
	    i-=2;			/* correct . and .. */
	Systems[num].in=i;
    }
    return 0;
}

get_outq_num(int sys,char firstTime)
{
    int i=0;
    char filename[1024];
    struct stat stbuf;
    DIR *dirp;
    
    strcpy(filename,Systems[sys].spooldir);
    strcat(filename,"/C./.");
    stat(filename,&stbuf);
    if ((stbuf.st_mtime > Systems[sys].lastodir) || (firstTime)) {
	if ((dirp=opendir(filename))!=NULL) {
	    while(readdir(dirp))
		i++;
	    closedir(dirp);
	    stat(filename,&stbuf);
	    Systems[sys].lastodir=stbuf.st_mtime;
	}
	else {
	    fprintf(stderr,"Can't open %s \n",filename);
	    exit(1);
	}
	if (i>=2)
	    i-=2;			/* correct . and .. */
	Systems[sys].out=i;
    }
    return 0;
}

get_stat_for_system(int i)
{
    char fn[80];
    struct sysInfo sys;
    struct stat stbuf;
    FILE *fp;
    time_t wait;

    sys = Systems[i];
    stat(sys.statfile,&stbuf);
    if (stbuf.st_atime > sys.laststat) {
	if ((fp=fopen(sys.statfile,"r"))!=NULL) {
	    fgets(fn,80,fp);
	    fclose(fp);
	    sscanf(fn,"%d %d %ld %d",
		   &sys.status,
		   &sys.num_retries,
		   &sys.last,
		   &wait);
	    sys.next=sys.last+wait;
	}
	else {
	    sys.status=0;
	    sys.num_retries=0;
	    sys.last=0;
	    sys.next=0;
	}
	stat(sys.statfile,&stbuf);
	sys.laststat=stbuf.st_atime;
    }
    Systems[i] = sys;
    return 0;
}
Commit	Line	Data
78ed81a3	1	/* uusnap.c
	2	(c) 1992 Heiko W.Rupp hwr@pilhuhn.ka.sub.org
	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.1 1993/08/04 19:31:43 jtc Exp $";
	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	\f
	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	}