home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume1 / 8708 / 18 / dcp.c next >
Encoding:
C/C++ Source or Header  |  1990-07-13  |  7.7 KB  |  452 lines
  1. /*            dcp.c
  2.  
  3.             Revised edition of dcp
  4.  
  5.             Stuart Lynne May/87
  6.  
  7.             Copyright (c) Richard H. Lamb 1985, 1986, 1987
  8.             Changes Copyright (c) Stuart Lynne 1987
  9.  
  10. */
  11. /* "DCP" a uucp clone. Copyright Richard H. Lamb 1985,1986,1987 */
  12. /* This program implements a uucico type file transfer and remote
  13. execution type protocol.
  14. */
  15. #include "dcp.h"
  16. /**/
  17. int    pktsize;                    /* packet size for pro */
  18. FILE    *logfile;                /* system log file */
  19. FILE    *syslog;                /* system log file */
  20. FILE    *fw;                     /* cfile pointer */
  21. char    state;                    /* system state*/
  22. char    cfile[80];              /* work file pointer */
  23. int        remote;                 /* -1 means we're remote ..7*/
  24. int        msgtime;                /* timout setting */
  25. char    fromfile[132];
  26. char    hostfile[132];        /* host version of fromfile */
  27. char    tofile[132];
  28. int        fp;                     /* current disk file ptr */
  29. int        size;                   /* nbytes in buff */
  30. FILE    *fsys;
  31. char    Rmtname[20];
  32. char    rmtname[20];
  33. char    * cctime;
  34. char    proto[5];
  35. /* char    loginseq[256]; */
  36. char     sysline[BUFSIZ];
  37. char    s_systems[64];
  38. char    s_logfile[64];
  39. char    s_syslog[64];
  40. char     *flds[60];
  41. int     kflds;
  42. int        debuglevel;        /* debugging flag */
  43.  
  44. unsigned int    checksum();
  45.  
  46.  
  47. /**/
  48. /* new usage
  49.  
  50.     dcp    [-xn] -r0        slave mode
  51.     dcp    [-xn] -shost         call host
  52.     dcp    [-xn] -sall        call all hosts
  53.  
  54.     dcp    [-xn]         call any hosts as required by C. files
  55.  
  56. */
  57.  
  58. complain( s )
  59. char *s;
  60. {
  61.     fprintf( stderr, "Please set your %s environment variable.", s );
  62. }
  63.  
  64. static void cant( file )
  65. char *file;
  66. {
  67.     fprintf( stderr, "Can't open: \"%s\"\n", file );
  68.     exit( NULL );
  69. }
  70.  
  71. dcpmain( argc, argv )
  72. int    argc;
  73. char*argv[];
  74. {
  75.     FILE    *ftmp;
  76.     char    line[132];
  77.  
  78.     if ( name == NULL || *name == '\0' ) {
  79.         complain( NAME );
  80.         exit( -1 );
  81.     }
  82.     if ( nodename == NULL || *nodename == '\0' ) {
  83.         complain( NODENAME );
  84.         exit( -1 );
  85.     }
  86.  
  87.  
  88.     mkfilename( s_logfile, spooldir, LOGFILE );
  89.     mkfilename( s_syslog,  spooldir, SYSLOG  );
  90.     mkfilename( s_systems, confdir,  SYSTEMS );
  91.  
  92.     if ( (logfile = FOPEN( s_logfile, "a", 't' )) == NULL )
  93.        cant( s_logfile );
  94.     if ( (syslog  = FOPEN( s_syslog,  "a", 't' )) == NULL )
  95.        cant( s_syslog );
  96.  
  97.     remote = MASTER;
  98.     debuglevel = 1;
  99.     fp = -1;
  100.     fw = (char *)NULL;
  101.  
  102.  
  103.     remote = MASTER;
  104.     strcpy( Rmtname, "any" );
  105.  
  106.     while ( --argc ) {
  107.         if ( **++argv == '-') {
  108.             switch(argv[0][1]) {
  109.             case 'x':
  110.                 debuglevel = atoi( &argv[0][2] );
  111.                 break;
  112.             case 's':
  113.                 sprintf( Rmtname, "%.7s", &argv[0][2] );
  114.                 break;
  115.             case 'r':
  116.                 remote = atoi( &argv[0][2] );
  117.                 break;
  118.  
  119.             default:
  120.                 break;
  121.             }
  122.         }
  123.     }
  124.  
  125.  
  126.     if ( remote == MASTER ) {
  127.          printmsg( 0, "Calling %s, debuglevel=%d", Rmtname, debuglevel );
  128.         if (( fsys = FOPEN( s_systems, "r", 't' )) == (char *)NULL )
  129.             exit( FAILED );
  130.         state = 'I';
  131.  
  132.  
  133.         while (TRUE) {
  134.             printmsg( 4, "Mstate = %c", state );
  135.             switch (state) {
  136.             case 'I':
  137.                 state = getsystem();
  138.                 break;
  139.             case 'S':
  140.                 state = callup();
  141.                 break;
  142.             case 'P':
  143.                 state = startup();
  144.                 break;
  145.             case 'D':
  146.                 state = master();
  147.                 break;
  148.             case 'Y':
  149.                 state = sysend();
  150.                 break;
  151.             case 'G':
  152.                 if ( strcmp( Rmtname, "any" ) != SAME )
  153.                     state = 'Y';
  154.                 else
  155.                     state = 'I';
  156.                 break;
  157.             }
  158.             if (state == 'A')
  159.                 break;
  160.         }
  161.         fclose( fsys );
  162.     } else
  163.      {
  164.         if (openline( device, speed ) == -1)
  165.             return(FALSE);
  166.         state = 'L';
  167.         while (TRUE) {
  168.             printmsg( 4, "Sstate = %c", state );
  169.             switch (state) {
  170.             case 'L':
  171.                 state = login();
  172.                 break;
  173.             case 'I':
  174.                 state = startup();
  175.                 break;
  176.             case 'R':
  177.                 state = slave();
  178.                 break;
  179.             case 'Y':
  180.                 state = sysend();
  181.                 break;
  182.             }
  183.             if (state == 'A')
  184.                 break;
  185.         }
  186.         closeline();
  187.     }
  188.  
  189.     /* fprintf( stderr, "calling dcxqt\n" ); */
  190.     if (dcxqt())
  191.         printmsg( 0, "ERROR in DCXQT" );
  192.  
  193.     /* scan and process any recieved files */
  194.  
  195.     fclose( syslog );
  196.     fclose( logfile );
  197.     return 0;
  198. }
  199.  
  200.  
  201. /**/
  202. /*
  203. **
  204. **
  205. **master
  206. **
  207. **
  208. */
  209. master()
  210. {
  211.     state = 'I';
  212.     while (TRUE) {
  213.         printmsg( 4, "Top level state (master mode) %c", state );
  214.         switch (state) {
  215.         case 'I':
  216.             state = sinit();
  217.             break;
  218.         case 'B':
  219.             state = scandir();
  220.             break;
  221.         case 'S':
  222.             state = send();
  223.             break;
  224.         case 'Q':
  225.             state = sbreak();
  226.             break;
  227.         case 'G':
  228.             state = receive();
  229.             break;
  230.         case 'C':
  231.             state = 'Y';
  232.             break;
  233.         case 'Y':
  234.             state = endp();
  235.             break;
  236.         case 'P':
  237.             return('Y');
  238.         case 'A':
  239.             return('A');
  240.         default:
  241.             return('A');
  242.         }
  243.     }
  244. }
  245.  
  246.  
  247. /**/
  248. /*
  249. **
  250. **
  251. **slave
  252. **
  253. **
  254. */
  255. slave()
  256. {
  257.     state = 'I';
  258.     while (TRUE) {
  259.         printmsg( 4, "Top level state (slave mode) %c", state );
  260.         switch (state) {
  261.         case 'I':
  262.             state = rinit();
  263.             break;
  264.         case 'F':
  265.             state = receive();
  266.             break;
  267.         case 'C':
  268.             state = schkdir();
  269.             break;
  270.         case 'T':
  271.             state = 'B';
  272.             break;
  273.         case 'B':
  274.             state = scandir();
  275.             break;
  276.         case 'S':
  277.             state = send();
  278.             break;
  279.         case 'Q':
  280.             state = sbreak();
  281.             break;
  282.         case 'G':
  283.             return('Y');
  284.         case 'Y':
  285.             state = endp();
  286.             break;
  287.         case 'P':
  288.             return('Y');
  289.         case 'A':
  290.             return('A');
  291.         default:
  292.             return('A');
  293.         }
  294.     }
  295. }
  296.  
  297.  
  298. /**/
  299. /*
  300.  *  r e c e i v e
  301.  *
  302.  *  This is the state table switcher for receiving files.
  303.  */
  304.  
  305. receive()
  306. {
  307.  
  308.     state = 'F';/* Receive-Init is the start state */
  309.  
  310.     while (TRUE) {
  311.         printmsg( 4, " receive state: %c", state );
  312.         switch (state)/* Do until done */ {
  313.         case 'F':
  314.             state = rfile();
  315.             break; /* Receive-File */
  316.         case 'D':
  317.             state = rdata();
  318.             break; /* Receive-Data */
  319.         case 'C':
  320.             return('C');/* Complete state */
  321.         case 'A':
  322.             return('Y');/* "Abort" state */
  323.         default:
  324.             return('Y');
  325.         }
  326.     }
  327. }
  328.  
  329.  
  330. /**/
  331. /*
  332.  *  s e n d
  333.  *
  334.  *  Sendsw is the state table switcher for sending files.  It loops until
  335.  *  either it finishes, or an error is encountered.  The routines called
  336.  *  by sendsw are responsible for changing the state.
  337.  *
  338.  */
  339. send()
  340. {
  341.     fp = -1;                /* reset file getter/opener */
  342.     state = 'F';/* Send initiate is the start state */
  343.     while (TRUE)/* Do this as long as necessary */ {
  344.         printmsg( 4, "send state: %c", state );
  345.         switch (state) {
  346.         case 'F':
  347.             state = sfile();
  348.             break; /* Send-File */
  349.         case 'D':
  350.             state = sdata();
  351.             break; /* Send-Data */
  352.         case 'Z':
  353.             state = seof();
  354.             break; /* Send-End-of-File */
  355.         case 'B':
  356.             return ('B'); /* Complete */
  357.         case 'A':
  358.             return ('Y'); /* "Abort" */
  359.         default:
  360.             return ('Y'); /* Unknown, fail */
  361.         }
  362.     }
  363. }
  364.  
  365.  
  366. /**/
  367. /* A command formatter for DCP. RH Lamb */
  368. /* sets up stdin and stdout on various machines */
  369. /* There is NO command checking so watch what you send and who you */
  370. /* let accsess your machine. "C rm /usr/*.*" could be executed. */
  371. dcxqt()
  372. {
  373.     int    i;
  374.     char    command[60], input[60], output[60], line[BUFSIZ];
  375.     char    *cp;
  376.  
  377.     while (dscandir()) {
  378.         strcpy( line, cfile );
  379.         fw = FOPEN( line, "r", 'b' );/* imported X file */
  380.         strcpy(cfile, line);
  381.         printmsg( 2, "dcxqt:%s %ld", cfile, fw );
  382.         input[0]   = '\0';
  383.         output[0]  = '\0';
  384.         command[0] = '\0';
  385.         while ( fgets( line, BUFSIZ, fw ) != (char *)NULL ) {
  386.  
  387.             cp = index( line, '\n' );
  388.             if ( cp != (char *)NULL )
  389.                 *cp = '\0';
  390.  
  391.             printmsg( 8, "dcxqt: %s", line );
  392.             switch (line[0]) {
  393.             case 'U':
  394.                 break;
  395.             case 'I':
  396.                 strcpy( input,   &line[2] );
  397.                 break;
  398.             case 'O':
  399.                 strcpy( output,  &line[2] );
  400.                 break;
  401.             case 'C':
  402.                 strcpy( command, &line[2] );
  403.                 break;
  404.             case 'R':
  405.                 break;
  406.             default :
  407.                 break;
  408.             }
  409.         }
  410.         fclose( fw );
  411.  
  412.         printmsg( 0, "xqt: %s\n", command );
  413.  
  414.         shell( command, input, output, (char *)NULL );
  415.  
  416.  
  417.         unlink(cfile);
  418.          importpath( hostfile, input );
  419.          unlink(hostfile);
  420.         importpath( hostfile, output );
  421.          unlink(hostfile);
  422.     }
  423.     return(0);
  424. }
  425.  
  426. /**/
  427. /*
  428.  *  p r i n t m s g
  429.  *
  430.  *  Print error message on standard output if not remote.
  431.  */
  432. /*VARARGS1*/
  433. printmsg(level, fmt, a1, a2, a3, a4, a5)
  434. int     level;
  435. char    *fmt;
  436. char    *a1, *a2, *a3, *a4, *a5;
  437. {
  438.     char    msg[256];
  439.  
  440.     if ( debuglevel > level ) {
  441.         sprintf( msg, fmt, a1, a2, a3, a4, a5 );
  442.         strcat( msg, "\n" );
  443.         if ( remote == MASTER )
  444.             fputs( msg, stdout );
  445.         fputs( msg, logfile );
  446.     }
  447. }
  448.  
  449.  
  450.  
  451.  
  452.