Return to xqt.c CVS log

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

Annotation of 42BSD/usr.bin/uucp/xqt.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)xqt.c      5.1 (Berkeley) 7/2/83";
                      3: #endif
                      4: 
                      5: #include "uucp.h"
                      6: #include <signal.h>
                      7: 
                      8: /*******
                      9:  *     xuucico(rmtname)                start up uucico for rmtname
                     10:  *     char *rmtname;
                     11:  *
                     12:  *     return codes:  none
                     13:  */
                     14: 
                     15: xuucico(rmtname)
                     16: char *rmtname;
                     17: {
                     18:        if (fork() == 0) {
                     19:                /*  start uucico for rmtname system  */
                     20:                char opt[100];
                     21:                close(0);
                     22:                close(1);
                     23:                close(2);
                     24:                open("/dev/null", 0);
                     25:                open("/dev/null", 1);
                     26:                open("/dev/null", 1);
                     27:                signal(SIGINT, SIG_IGN);
                     28:                signal(SIGHUP, SIG_IGN);
                     29:                signal(SIGQUIT, SIG_IGN);
                     30:                signal(SIGKILL, SIG_IGN);
                     31:                if (rmtname[0] != '\0')
                     32:                        sprintf(opt, "-s%.7s", rmtname);
                     33:                else
                     34:                        opt[0] = '\0';
                     35:                execl(UUCICO, "UUCICO", "-r1", opt, (char *)0);
                     36:                exit(100);
                     37:        }
                     38:        return;
                     39: }
                     40: 
                     41: 
                     42: /*******
                     43:  *     xuuxqt()                start up uuxqt
                     44:  *
                     45:  *     return codes:  none
                     46:  */
                     47: 
                     48: xuuxqt()
                     49: {
                     50:        if (fork() == 0) {
                     51:                /*  start uuxqt  */
                     52:                close(0);
                     53:                close(1);
                     54:                close(2);
                     55:                open("/dev/null", 2);
                     56:                open("/dev/null", 2);
                     57:                open("/dev/null", 2);
                     58:                signal(SIGINT, SIG_IGN);
                     59:                signal(SIGHUP, SIG_IGN);
                     60:                signal(SIGQUIT, SIG_IGN);
                     61:                signal(SIGKILL, SIG_IGN);
                     62:                execl(UUXQT, "UUXQT",  (char *)0);
                     63:                exit(100);
                     64:        }
                     65:        return;
                     66: }
                     67: xuucp(str)
                     68: char *str;
                     69: {
                     70:        char text[300];
                     71:        if (fork() == 0) {
                     72:                /*  start uucp  */
                     73:                close(0);
                     74:                close(1);
                     75:                close(2);
                     76:                open("/dev/null", 0);
                     77:                open("/dev/null", 1);
                     78:                open("/dev/null", 1);
                     79:                signal(SIGINT, SIG_IGN);
                     80:                signal(SIGHUP, SIG_IGN);
                     81:                signal(SIGQUIT, SIG_IGN);
                     82:                signal(SIGKILL, SIG_IGN);
                     83:                sprintf(text, "%s -r %s", UUCP, str);
                     84:                execl(SHELL, "sh", "-c", text, (char *)0);
                     85:                exit(100);
                     86:        }
                     87:        sleep(15);      /* Give uucp chance to finish */
                     88:        return;
                     89: }

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