Return to uuname.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp

Annotation of 43BSD/usr.bin/uucp/uuname.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)uuname.c   5.3 (Berkeley) 10/9/85";
                      3: #endif
                      4: 
                      5: #include "uucp.h"
                      6: #include <signal.h>
                      7: 
                      8: /*
                      9:  *      return list of all remote systems 
                     10:  *     recognized by uucp, or  (with -l) the local  uucp name.
                     11:  *
                     12:  *      return codes: 0 | 1  (can't read)
                     13:  */
                     14: 
                     15: struct timeb Now;
                     16:  
                     17: main(argc,argv)
                     18: char *argv[];
                     19: int argc;
                     20: {
                     21:        int ret;
                     22:        int i;
                     23:        int intrEXIT();
                     24:        FILE *np;
                     25: /* Increase buffers for s and prev.  cornell!pavel */
                     26:        char prev[1000];
                     27:        char s[1000];
                     28: 
                     29:        ret = chdir(Spool);
                     30:        ASSERT(ret >= 0, "CHDIR FAILED", Spool, ret);
                     31:        strcpy(Progname, "uuname");
                     32:        signal(SIGILL, intrEXIT);
                     33:        signal(SIGTRAP, intrEXIT);
                     34:        signal(SIGIOT, intrEXIT);
                     35:        signal(SIGEMT, intrEXIT);
                     36:        signal(SIGFPE, intrEXIT);
                     37:        signal(SIGBUS, intrEXIT);
                     38:        signal(SIGSEGV, intrEXIT);
                     39:        signal(SIGSYS, intrEXIT);
                     40:        signal(SIGINT, intrEXIT);
                     41:        signal(SIGHUP, intrEXIT);
                     42:        signal(SIGQUIT, intrEXIT);
                     43:        signal(SIGTERM, intrEXIT);
                     44: 
                     45:        if(argc > 1 && argv[1][0] == '-' && argv[1][1] == 'l') {
                     46:                uucpname(s);
                     47:                printf("%s\n",s);
                     48:                exit(0);
                     49:        }
                     50:         if(argc != 1) {printf("Usage: uuname [-l]\n"); exit(1);}
                     51:        if((np = fopen(SYSFILE,"r")) == NULL) {
                     52:                printf("%s (name file) protected\n",SYSFILE);
                     53:                exit(1);
                     54:        }
                     55:        while ( cfgets(s,sizeof(s),np) != NULL ) {
                     56:                for(i=0; s[i]!=' ' && s[i]!='\t'; i++)
                     57:                        ;
                     58:                s[i]='\0';
                     59:                if (strcmp(s, prev) == SAME)
                     60:                        continue;
                     61:                if(s[0]=='x' && s[1]=='x' && s[2]=='x')
                     62:                        continue;
                     63:                printf("%s\n",s);
                     64:                strcpy(prev, s);
                     65:        }
                     66:  
                     67:        exit(0);
                     68: }
                     69: intrEXIT(inter)
                     70: {
                     71:        exit(inter);
                     72: }
                     73: 
                     74: cleanup(code)
                     75: int code;
                     76: {
                     77:        exit(code);
                     78: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.