home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / UUCP_Blars.lzh / dcp.c next >
C/C++ Source or Header  |  1992-02-02  |  8KB  |  432 lines
  1. /*
  2.  * dcp.c
  3.  *
  4.  * Revised edition of dcp
  5.  *
  6.  * Stuart Lynne May/87
  7.  *
  8.  * Copyright (c) Richard H. Lamb 1985, 1986, 1987
  9.  * Changes Copyright (c) Stuart Lynne 1987
  10.  *
  11.  * Ported to OS-9/68000:  Wolfgang Ocker    January 1988
  12.  *
  13.  */
  14.  
  15. /*
  16.  * "DCP" a uucp clone. Copyright Richard H. Lamb 1985,1986,1987
  17.  * This program implements a uucico type file transfer and remote
  18.  * execution type protocol.
  19.  */
  20.  
  21. #include "dcp.h"
  22. #include <pwd.h>
  23. #include "uucp.h"
  24.  
  25. int     pktsize;        /* packet size for pro */
  26. FILE   *logfile;        /* system log file */
  27. FILE   *syslog;            /* system log file */
  28. FILE   *fw;            /* cfile pointer */
  29. char    state;            /* system state */
  30. char    cfile[80];        /* work file pointer */
  31. int     remote = SLAVE;
  32. int     msgtime;        /* timout setting */
  33. char    fromfile[132];
  34. char    hostfile[132];        /* host version of fromfile */
  35. char    tofile[132];
  36. int     fp;            /* current disk file ptr */
  37. int     size;            /* nbytes in buff */
  38. FILE   *fsys;
  39. char    Rmtname[20];
  40. char    rmtname[20];
  41. char   *cctime;
  42. char    proto[5];
  43.  
  44. /* char loginseq[256]; */
  45. char    sysline[BUFSIZ];
  46. char    s_spooldir[100];
  47. char    s_systems[100];
  48. char    s_logfile[100];
  49. char    s_syslog[100];
  50. char    s_libdir[100];
  51. char    s_publicdir[100];
  52. char   *flds[60];
  53. int     kflds;
  54. int     debuglevel;        /* debugging flag */
  55.  
  56. char    device[40];
  57. char    speed[10];
  58. int     lock;
  59. int     uuxqtpid;
  60.  
  61. unsigned int checksum();
  62. char    nodename[15];
  63.  
  64. char   *uuxarg[] = {"uuxqt", NULL};
  65. extern char **environ;
  66. extern int os9forkc();
  67.  
  68.  
  69. /*
  70.  * new usage
  71.  *
  72.  *  dcp [-xn]               slave mode
  73.  *  dcp [-xn] -r1 -shost    call host
  74.  *
  75.  *  dcp [-xn] -r1           call any hosts as required by C. files
  76.  *
  77.  */
  78.  
  79.  
  80. static void 
  81. cant(file)
  82. char   *file;
  83. {
  84.     exit(_errmsg(errno, "Can't open/chdir: \"%s\"\n", file));
  85. }
  86.  
  87. main(argc, argv)
  88. int     argc;
  89. char   *argv[];
  90.  
  91. {
  92.     FILE   *ftmp;
  93.     char    line[132];
  94.     struct passwd *pw;
  95.  
  96.     if (gethostname(nodename, 10) < 0)
  97.     exit(_errmsg(1, "Can't get hostname\n"));
  98.  
  99.     if ((pw = getpwname("uucp")) == NULL) {
  100.     exit(_errmsg(1, "Can't get uucp's uid"));
  101.     }
  102.     setuid((pw->pw_gid << 16) | pw->pw_uid);
  103.  
  104.     strcpy(s_spooldir, SPOOLDIR);
  105.     strcpy(s_publicdir, PUBLICDIR);
  106.     strcpy(s_libdir, LIBDIR);
  107.  
  108.     if (chdir(s_spooldir) == -1)
  109.     cant(s_spooldir);
  110.  
  111.     strcpy(s_logfile, ".LOG/logfile");
  112.     strcpy(s_syslog, ".LOG/syslog");
  113.     sprintf(s_systems, "%s/systems", s_libdir);
  114.  
  115.     if ((logfile = fopen(s_logfile, "a")) == NULL)
  116.     cant(s_logfile);
  117.  
  118.     if ((syslog = fopen(s_syslog, "a")) == NULL)
  119.     cant(s_syslog);
  120.  
  121.     remote = SLAVE;
  122.     debuglevel = 0;
  123.     fp = -1;
  124.     fw = NULL;
  125.  
  126.     strcpy(Rmtname, "all");
  127.  
  128.     while (--argc) {
  129.     if (**++argv == '-') {
  130.         switch (argv[0][1]) {
  131.         case 'x':
  132.         debuglevel = atoi(&argv[0][2]);
  133.         break;
  134.         case 's':
  135.         sprintf(Rmtname, "%.7s", &argv[0][2]);
  136.         break;
  137.         case 'r':
  138.         remote = atoi(&argv[0][2]);
  139.         break;
  140.  
  141.         default:
  142.         break;
  143.         }
  144.     }
  145.     }
  146.  
  147.  
  148.     device[0] = '\0';
  149.  
  150.     if (remote == MASTER) {
  151.     printmsg(0, "Calling %s", Rmtname);
  152.     printmsg(1, "debuglevel=%d", debuglevel);
  153.  
  154.     if ((fsys = fopen(s_systems, "r")) == NULL) {
  155.         exit(_errmsg(errno, "Can't open 'systems' file\n"));
  156.     }
  157.     state = 'I';
  158.  
  159.     do {
  160.         printmsg(4, "Mstate = %c", state);
  161.  
  162.         switch (state) {
  163.         case 'I':
  164.         state = getsystem();
  165.         break;
  166.         case 'S':
  167.         state = callup();
  168.         break;
  169.         case 'P':
  170.         state = startup();
  171.         break;
  172.         case 'D':
  173.         state = master();
  174.         break;
  175.         case 'Y':
  176.         state = sysend();
  177.         break;
  178.         }
  179.     } while(state != 'A');
  180.  
  181.     fclose(fsys);
  182.     } else {
  183.     if (openline(NULL, NULL) == -1) {
  184.         printmsg(0, "Can't open line");
  185.         exit(1);
  186.     }
  187. /*    state = 'L'; */
  188.     state = 'I';
  189.  
  190.     while (TRUE) {
  191.         printmsg(4, "Sstate = %c", state);
  192.  
  193.         switch (state) {
  194. /*        case 'L':
  195.           state = login();
  196.           break; */
  197.         case 'I':
  198.         state = startup();
  199.         break;
  200.         case 'R':
  201.         state = slave();
  202.         break;
  203.         case 'Y':
  204.         state = sysend();
  205.         break;
  206.         }
  207.  
  208.         if (state == 'A')
  209.         break;
  210.     }
  211.  
  212.     closeline();
  213.     }
  214.  
  215.     /* scan and process any recieved files */
  216.  
  217.     fflush(syslog);
  218.     fflush(logfile);
  219.  
  220.     if ((uuxqtpid = os9exec(os9forkc, uuxarg[0], uuxarg, environ, 0, 10, 3)) == -1) {
  221.     int     err = errno;
  222.  
  223.     printmsg(0, "FATAL: can't exec uuxqt (%d)", errno);
  224.     fclose(syslog);
  225.     fclose(logfile);
  226.     exit(err);
  227.     }
  228.     fclose(syslog);
  229.     fclose(logfile);
  230.     exit(0);
  231. }
  232.  
  233.  
  234. /*
  235.  * master
  236.  */
  237. master()
  238. {
  239.     state = 'I';
  240.  
  241.     while (TRUE) {
  242.     printmsg(4, "Top level state (master mode) %c", state);
  243.  
  244.     switch (state) {
  245.     case 'I':
  246.         state = sinit();
  247.         break;
  248.     case 'B':
  249.         state = scandir(FALSE);
  250.         break;
  251.     case 'S':
  252.         state = send();
  253.         break;
  254.     case 'Q':
  255.         state = sbreak();
  256.         break;
  257.     case 'G':
  258.         state = receive();
  259.         break;
  260.     case 'C':
  261.         state = 'Y';
  262.         break;
  263.     case 'Y':
  264.         state = endp();
  265.         break;
  266.     case 'P':
  267.         return ('Y');
  268.     case 'A':
  269.         return ('A');
  270.     default:
  271.         return ('A');
  272.     }
  273.     }
  274. }
  275.  
  276.  
  277. /*
  278.  * slave
  279.  */
  280. slave()
  281. {
  282.     state = 'I';
  283.  
  284.     while (TRUE) {
  285.     printmsg(4, "Top level state (slave mode) %c", state);
  286.  
  287.     switch (state) {
  288.     case 'I':
  289.         state = rinit();
  290.         break;
  291.     case 'F':
  292.         state = receive();
  293.         break;
  294.     case 'C':
  295.         state = schkdir();
  296.         break;
  297.     case 'T':
  298.         state = 'B';
  299.         break;
  300.     case 'B':
  301.         state = scandir(FALSE);
  302.         break;
  303.     case 'S':
  304.         state = send();
  305.         break;
  306.     case 'Q':
  307.         state = sbreak();
  308.         break;
  309.     case 'G':
  310.         return ('Y');
  311.     case 'Y':
  312.         state = endp();
  313.         break;
  314.     case 'P':
  315.         return ('Y');
  316.     case 'A':
  317.         return ('A');
  318.     default:
  319.         return ('A');
  320.     }
  321.     }
  322. }
  323.  
  324.  
  325. /*
  326.  * r e c e i v e
  327.  *
  328.  * This is the state table switcher for receiving files.
  329.  */
  330.  
  331. receive()
  332. {
  333.     state = 'F';        /* Receive-Init is the start state */
  334.  
  335.     while (TRUE) {
  336.     printmsg(4, " receive state: %c", state);
  337.  
  338.     switch (state) {    /* Do until done */
  339.     case 'F':        /* Receive-File */
  340.         state = rfile();
  341.         break;
  342.     case 'R':        /* Receive-Data */
  343.         state = rdata();
  344.         break;
  345.     case 'D':        /* send data */
  346.         state = sdata();
  347.         break;
  348.     case 'C':
  349.         return ('C');    /* Complete state */
  350.     case 'A':
  351.         return ('Y');    /* "Abort" state */
  352.     default:
  353.         return ('Y');
  354.     }
  355.     }
  356. }
  357.  
  358.  
  359. /*
  360.  *  s e n d
  361.  *
  362.  *  Sendsw is the state table switcher for sending files.  It loops until
  363.  *  either it finishes, or an error is encountered.  The routines called
  364.  *  by sendsw are responsible for changing the state.
  365.  */
  366. send()
  367. {
  368.     fp = -1;            /* reset file getter/opener */
  369.     state = 'F';        /* Send initiate is the start state */
  370.     while (TRUE) {        /* Do this as long as necessary */
  371.     printmsg(4, "send state: %c", state);
  372.  
  373.     switch (state) {
  374.     case 'F':        /* Send-File */
  375.         state = sfile();
  376.         break;        /* Send-Data */
  377.     case 'D':
  378.         state = sdata();
  379.         break;
  380.     case 'R':        /* receive data */
  381.         state = rdata();
  382.         break;
  383.     case 'B':
  384.         return ('B');    /* Complete */
  385.     case 'A':
  386.         return ('Y');    /* "Abort" */
  387.     default:
  388.         return ('Y');    /* Unknown, fail */
  389.     }
  390.     }
  391. }
  392.  
  393.  
  394. /*
  395.  *  p r i n t m s g
  396.  *
  397.  *  Print error message on standard output if not remote.
  398.  */
  399. #include <varargs.h>
  400. printmsg(va_alist)
  401. va_dcl
  402. {
  403.     int     level;
  404.     char   *fmt;
  405.     va_list args;
  406.     char    msg[300], ltime[32];
  407.     time_t  tstamp;
  408.     int     len;
  409.  
  410.     va_start(args);
  411.     level = va_arg(args, int);
  412.     if (debuglevel >= level) {
  413.     fmt = va_arg(args, char *);
  414.     len = vsprintf(msg, fmt, args);
  415.  
  416.     msg[len++] = '\n';
  417.     msg[len] = '\0';
  418.  
  419.     time(&tstamp);
  420.     strcpy(ltime, ctime(&tstamp));
  421.     ltime[strlen(ltime) - 1] = ' ';
  422.  
  423.     if (remote == MASTER) {
  424.         fputs(ltime, stdout);
  425.         fputs(msg, stdout);
  426.     }
  427.     fputs(ltime, logfile);
  428.     fputs(msg, logfile);
  429.     }
  430.     va_end(args);
  431. }
  432.