home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d109 / uupc.lha / UUpc / Source / dcpsys.c < prev    next >
C/C++ Source or Header  |  1987-10-28  |  13KB  |  716 lines
  1.  
  2. /*            dcpsys.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. */
  12. /* "DCP" a uucp clone. Copyright Richard H. Lamb 1985,1986,1987 */
  13. /* Get the next system, and other support routines  */
  14. #include "dcp.h"
  15. /*#define PROTOS  "trkg"*/
  16. #define PROTOS  "g"
  17. #define MAXLOGTRY       3
  18.  
  19. Proto Protolst[] = {  
  20.         'g', ggetpkt, gsendpkt, gopenpk, gclosepk,
  21. /*
  22.         'k', kgetpkt, ksendpkt, kopenpk, kclosepk,
  23.         'r', rgetpkt, rsendpkt, ropenpk, rclosepk,
  24.         't', tgetpkt, tsendpkt, topenpk, tclosepk,
  25. */
  26.          '0'};
  27.  
  28. #define EOTMSG "\004\r\004\r"
  29.  
  30. procref         getpkt, sendpkt, openpk, closepk;
  31.  
  32. /* */
  33.  
  34. /***************************************************************/
  35. /***            Sub Systems             */
  36. /*
  37. **
  38. **getsystem
  39. ** Process an "systems" file entry (like L.sys)
  40. */
  41. getsystem()
  42. {
  43.     int    i;
  44.  
  45.     if ( fgets( sysline, BUFSIZ, fsys ) == (char *)NULL )
  46.         return( 'A' );
  47.     printmsg( 2, "%s", sysline );
  48.         
  49.     kflds = getargs( sysline, flds );
  50.     strcpy( rmtname, flds[FLD_REMOTE] );
  51.     cctime = flds[FLD_CCTIME];
  52.     strcpy( device, flds[FLD_DEVICE] );
  53.     
  54.     /* strcpy( type, flds[FLD_TYPE] ); */
  55.     strcpy( speed, flds[FLD_SPEED] );
  56.     strcpy( proto, flds[FLD_PROTO] );
  57.     
  58.  
  59.     if (debuglevel > 3) 
  60.         for (i = FLD_EXPECT; i < kflds; i += 2)
  61.             fprintf( stderr, "expect[%02d]:\t%s\nsend  [%02d]:\t%s\n",
  62.                 i, flds[i], i+1, flds[i+1] );
  63.         
  64.     printmsg( 2, "rmt= %s ctm= %s", rmtname, flds[FLD_CCTIME] );
  65.     printmsg( 2, "dev= %s ", device );
  66.     printmsg( 2, "spd= %s pro= %s", speed, proto );
  67.     fw = (FILE *)NULL;
  68.     if ( 
  69.         /* (checktime( cctime )) || */
  70.         ( strcmp( Rmtname, "all" ) == SAME ) ||
  71.         ( strcmp( Rmtname, rmtname ) == SAME ) ||
  72.          ( (strcmp( Rmtname, "any" ) == SAME) && scandir() == 'S' ) 
  73.          ) 
  74.     {
  75.         if ( fw != (FILE *)NULL )
  76.           fclose( fw );    /* in case we matched with scandir */
  77.         return( 'S' );  /* startup this system */
  78.     }
  79.     else
  80.         return('G');  
  81. }
  82.  
  83.  
  84. /* */
  85. /*
  86. **
  87. **checkname
  88. ** Do we know the guy ?
  89. */
  90. checkname(name)
  91. char    name[];
  92. {
  93.     FILE *ff;
  94.     char line[BUFSIZ], tmp[20]; /* can change to 8 if %8s works */
  95.  
  96.     if ( ( ff = FOPEN( s_systems, "r" )) == (char *)NULL ) 
  97.         return( FAILED );
  98.  
  99.     while ( fgets( line, BUFSIZ, ff ) != (char *)NULL ){
  100.         sscanf( line, "%8s ", tmp );
  101.         printmsg( 3, "rmt= %s sys= %s", name, tmp );
  102.         if ( strncmp( tmp, line, 7 ) == 0 ) {
  103.             fclose( ff );
  104.             return ( OK ); /*OK I like you */
  105.         }
  106.     }
  107.     fclose( ff );
  108.     return( FAILED ); /* Who are you ? */
  109.         
  110. }
  111.  
  112.  
  113. /* */
  114. /*
  115. **
  116. **checktime
  117. ** check if we may make a call at this time 
  118. **------------>to be implemented. Again. Didnt think it crucial
  119. */
  120. checktime(xtime)
  121. char    xtime[];
  122. {
  123.     return(0); /* OK go to it */
  124. }
  125.  
  126.  
  127.  
  128. /* */
  129. /*
  130. **
  131. **sysend
  132. ** end UUCP session negotiation
  133. */
  134. sysend()
  135. {
  136.     char    msg[80];
  137.  
  138.     msg[1] = '\0';
  139.     msgtime = 2 * MSGTIME;
  140.     /* while (msg[1] != 'O') { */
  141.         wmsg("OOOOOO", 2);
  142.         if (rmsg(msg, 2) == -1) 
  143.             goto hang;
  144.     /*}*/
  145. hang:
  146.     wmsg("OOOOOO", 2);
  147.     closeline();
  148.     if ( remote == MASTER ) 
  149.         return('I');
  150.     return('A');
  151. }
  152.  
  153.  
  154. /* */
  155. /*
  156. **
  157. **      delay
  158. **
  159. */
  160. /*ddelay(dtime)
  161. int    dtime;
  162. {
  163.     int    i, j;
  164.     for (i = 0; i < dtime; i++) { 
  165.     }
  166. }
  167. */
  168.  
  169. /* */
  170. /*
  171. **
  172. **wmsg
  173. ** write a ^P type msg to the remote uucp
  174. */
  175. wmsg(msg, syn)
  176. int    syn;
  177. char    msg[];
  178. {
  179.     int    len;
  180.     len = strlen(msg);
  181.     if (syn == 2) 
  182.         swrite("\0\020", 2);
  183.     swrite(msg, len);
  184.     if (syn == 2) 
  185.         swrite("\0", 1);
  186. }
  187.  
  188.  
  189. /*
  190. **
  191. **rmsg
  192. ** read a ^P msg from UUCP
  193. */
  194. rmsg(msg, syn)
  195. int    syn;
  196. char    msg[];
  197. {
  198.     int    ii;
  199.     char    c, cc[5];
  200.     /* *msg0;*/
  201.     /*msg0 = msg;*/
  202.     c = 'a';
  203.     if (syn == 2) {
  204.         while ((c & 0x7f) != '\020') {
  205.             if (sread(cc, 1, msgtime) < 1) 
  206.                 return(-1);
  207.             c = cc[0]; /* Dont ask. MSC needs more than a byte to breathe */
  208.             /*        printf("Hello im in rmsg c=%x\n",c); */
  209.         }
  210.     }
  211.     for (ii = 0; ii < 132 && c ; ii++) {
  212.         if (sread(cc, 1, msgtime) < 1) 
  213.             return(-1);
  214.         c = cc[0] & 0x7f;
  215.         if (c == '\r' || c == '\n') 
  216.             c = '\0';
  217.         msg[ii] = c;
  218.         /*if(c == '\020') msg = msg0; */
  219.     }
  220.     return(strlen(msg));
  221. }
  222.  
  223.  
  224.  
  225. /* */
  226. /*
  227. **
  228. **
  229. **startup
  230. **
  231. **
  232. */
  233. startup()
  234. {
  235.     char    msg[80], tmp1[20], tmp2[20];
  236.     if ( remote == MASTER ) {
  237.         msgtime = 2 * MSGTIME;
  238.         if (rmsg(msg, 2) == -1) 
  239.             return('Y');
  240.         printmsg( 2, "1st msg = %s", msg );
  241.         if (msg[5] == '=' && strncmp(&msg[6], rmtname, 7)) 
  242.             return('Y');
  243.             
  244.         
  245.         /*sprintf(msg, "S%.7s -Q0 -x%d", nodename, debuglevel);*/  /* -Q0 -x16 remote debuglevel set */
  246.         sprintf(msg, "S%.7s", nodename);
  247.         
  248.         wmsg(msg, 2);
  249.         if (rmsg(msg, 2) == -1) 
  250.             return('Y');
  251.         printmsg( 2, "2nd msg = %s", msg );
  252.         if (strncmp(&msg[1], "OK", 2)) 
  253.             return('Y');
  254.         if (rmsg(msg, 2) == -1) 
  255.             return('Y');
  256.         printmsg( 2, "3rd msg = %s", msg );
  257.         if (msg[0] != 'P' || index(&msg[1], proto[0]) == (char *)NULL) {
  258.             wmsg("UN", 2);
  259.             return('Y');
  260.         }
  261.         sprintf(msg, "U%c", proto[0]);
  262.         wmsg(msg, 2);
  263.         setproto(proto[0]);
  264.         return('D');
  265.     } else {
  266.         msgtime = 2 * MSGTIME;
  267.         sprintf(msg, "Shere=%s", nodename);
  268.         wmsg(msg, 2);
  269.         if (rmsg(msg, 2) == -1) 
  270.             return('Y');
  271.         sscanf(&msg[1], "%s %s %s", rmtname, tmp1, tmp2);
  272.         sscanf(tmp2, "-x%d", &debuglevel);
  273.         printmsg( 1, "debuglevel level = %d", debuglevel );
  274.         printmsg( 2, "1st msg from remote = %s", msg );
  275.         if (checkname(rmtname)) 
  276.             return('Y');
  277.         wmsg("ROK", 2);
  278.         sprintf(msg, "P%s", PROTOS);
  279.         wmsg(msg, 2);
  280.         if (rmsg(msg, 2) == -1) 
  281.             return('Y');
  282.         if (msg[0] != 'U' || index(PROTOS, msg[1]) == (char *)NULL ) 
  283.             return('Y');
  284.         proto[0] = msg[1];
  285.         setproto(proto[0]);
  286.         return('R');
  287.     }
  288. }
  289.  
  290.  
  291. /******* set the protocol **********/
  292. setproto(pr)
  293. char    pr;
  294. {
  295.     int    i;
  296.     Proto * tproto;
  297.     for (tproto = Protolst; tproto->type != '\0' && pr != tproto->type; tproto++) {
  298.         printmsg( 3, "setproto: %c %c", pr, tproto->type ); 
  299.     }
  300.     if (tproto->type == '\0') {
  301.         printmsg( 0, "setproto:You said I had it but I cant find it" );
  302.         exit(1); 
  303.     }
  304.     getpkt = tproto->a; 
  305.     sendpkt = tproto->b;
  306.     openpk = tproto->c;  
  307.     closepk = tproto->d;
  308. }
  309.  
  310.  
  311.  
  312. /* */
  313. int prefix(sh,lg)
  314. char *sh,*lg;
  315. {
  316.     return( strncmp(sh,lg,strlen(sh)) == SAME);
  317. }
  318.  
  319. int notin(sh,lg)
  320. char *sh,*lg;
  321. {
  322.     while (*lg) {
  323.         if (prefix(sh,lg++))
  324.             return( FALSE );
  325.     }
  326.     return( TRUE );
  327. }
  328.  
  329. #define MAXR 300
  330. int expectstr( str, timeout )
  331. char *str;
  332. {
  333.     static char rdvec[MAXR];
  334.     char *rp = rdvec;
  335.     int kr;
  336.     char nextch;
  337.  
  338.     printmsg( 0, "wanted %s", str );
  339.                 
  340.     if ( strcmp(str, "\"\"") == SAME ) {
  341.         return( TRUE );
  342.     }
  343.     *rp = 0;
  344.     while ( notin( str,rdvec ) ) {
  345.         /* fprintf(stderr, "---------->%s<------\n", rdvec);/**/
  346.         kr = sread( &nextch, 1, timeout /* 40 */ );
  347.         /* nextch &= 0177;
  348.         fprintf(stderr, "kr - %2d '%c'\n", kr, nextch); */
  349.         if (kr <= 0) {
  350.             return( FALSE );
  351.         }
  352.         if ((*rp = nextch & 0177) != '\0') {
  353.             rp++;
  354.         }
  355.         *rp = '\0';
  356.         if (rp >= rdvec + MAXR) {
  357.             return( FALSE );
  358.         }
  359.     }
  360.     return( TRUE );
  361. }
  362.  
  363. int writestr(s)
  364.     register char *s;
  365. {
  366.     register char last;
  367.     register char * m;
  368.     int nocr;
  369.     last = '\0';
  370.     nocr = FALSE;
  371.     while (*s) {
  372.         if (last == '\\') {
  373.             switch (*s) {
  374.             case 'd': 
  375.             case 'D': /* delay */
  376.                sleep(2);
  377.                break;
  378.             case 'c': 
  379.             case 'C': /* end string don't output CR */
  380.                nocr = TRUE;
  381.                break;
  382.             case 'r': 
  383.             case 'R': /* carriage return */
  384.             case 'm': 
  385.             case 'M':
  386.                   swrite( "\r", 1 );
  387.                    break;
  388.             case 'n': 
  389.             case 'N':
  390.                   swrite( "\n", 1 );
  391.                    break;
  392.             case 'b': 
  393.             case 'B':
  394.                   swrite( "\b", 1 );
  395.                    break;
  396.             case 't': 
  397.             case 'T':
  398.                   swrite( "\t", 1 );
  399.                    break;
  400.             case 's': 
  401.             case 'S':
  402.                   swrite( " ", 1 );
  403.                    break;
  404.             case 'z':
  405.             case 'Z':
  406.                 SIOSpeed( ++s );
  407.                 while ( *s != '\0' && *s != '\\' ) 
  408.                     s++;
  409.                 if ( *s == '\\' )
  410.                     s++;
  411.                 break;
  412.             default:
  413.                   swrite( s, 1 );
  414.             }
  415.             last = '\0';
  416.         }
  417.         else if (*s != '\\') {
  418.               swrite( s, 1 );
  419.             /* fputc(*s,stderr); */
  420.         }
  421.         else {
  422.             last = *s;
  423.         }
  424.         s++;
  425.     }
  426.     return( nocr );
  427. }
  428.  
  429. /***
  430.  *   void sendthem(str)   send line of login sequence
  431.  *         char *str;
  432.  *
  433.  *   return codes:  none
  434.  */
  435.  
  436. void sendstr(str)
  437. char *str;
  438. {
  439.     int nw, ns;
  440.     int nulls;
  441.  
  442.     printmsg( 2, "sending %s", str );
  443.  
  444. #ifdef BREAK
  445.     if (prefix("BREAK", str)) {
  446.         sscanf(&str[5], "%1d", &nulls);
  447.         if (nulls <= 0 || nulls > 10)
  448.             nulls = 3;
  449.         /* send break */
  450.         ssendbrk(nulls);
  451.         return;
  452.     }
  453. #endif
  454.  
  455.     if ( strcmp(str, "EOT") == SAME ) {
  456.         swrite(EOTMSG, strlen(EOTMSG));
  457.         return;
  458.     }
  459.  
  460.     if ( strcmp(str,"\"\"") == SAME )
  461.         *str = '\0';
  462.         /*fprintf(stderr,"'%s'\n",str);*/
  463.         
  464.     if ( strcmp(str,"") != SAME ) {
  465.         if (!writestr(str)) {
  466.             swrite ("\r", 1);
  467.         }
  468.     }
  469.     else {
  470.         swrite("\r", 1);
  471.     }
  472.     return;
  473. }
  474.  
  475. int sendexpect( s, e, timeout )
  476. char * s;
  477. char * e;
  478. {
  479.     sendstr( s );
  480.     return( expectstr( e, timeout ) );
  481. }
  482.  
  483. dial()
  484. {
  485.     int    flg, kk, jj, ll, firstflg;
  486.     char    buf[4], *prsend;
  487.  
  488.     char *exp;
  489.     char *alternate;
  490.     int    ok;
  491.     int i;
  492.  
  493.     if ( strcmp( flds[FLD_TYPE], "HAYES" ) != SAME ) {
  494.         printmsg( 0, "dial: unsupported dialer %s", flds[FLD_TYPE] );
  495.         return( FALSE );
  496.     }
  497.     
  498.     printmsg( 3, "calling host %s", rmtname );
  499.     if (openline(device, "2400" )) 
  500.         return( FALSE );
  501.  
  502.     printmsg( 0, "hayes: trying 2400" );
  503.     if ( sendexpect( "ATZ", "OK", 2 ) != TRUE ) {
  504.         sendexpect( "\\d+++\\d", "OK", 2 );
  505.         if ( sendexpect( "ATZ", "OK", 2 ) != TRUE ) {
  506.             printmsg( 0, "hayes: trying 1200" );
  507.             SIOSpeed( "1200" );
  508.             if ( sendexpect( "ATZ", "OK", 2 ) != TRUE ) {
  509.                 sendexpect( "\\d+++\\d", "OK", 2 );
  510.                 if ( sendexpect( "ATZ", "OK", 2 ) != TRUE )
  511.                     return( FALSE);
  512.                 }
  513.         }
  514.     }
  515.     printmsg( 0, "hayes: got modem response" );
  516.     
  517.     /*(sendstr( "\\d\\dATS7=30" );
  518.     expectstr( "OK", 40 );*/
  519.     
  520.     sendstr( "\\d\\dATX4\\c" );
  521.  
  522.     if ( sendexpect( speed, "CONNECT ", 40 ) == TRUE ) {
  523.         printmsg( 3, "hayes: got CONNECT" );
  524.     
  525.         if ( sread( buf, 4, 4 ) == 4 ) {
  526.             printmsg( 3, "hayes: speed select %s", buf );
  527.             /* set speed appropriately */
  528.             SIOSpeed( buf );
  529.         }
  530.         return( TRUE );
  531.     }
  532.     else
  533.         return( FALSE );
  534.     
  535. }
  536.  
  537.  
  538. /*
  539. **
  540. **callup
  541. ** script processor - nothing fancy! 
  542. */
  543. callup()
  544. {
  545.     int    flg, kk, jj, ll, firstflg;
  546.     char    *prsend;
  547.  
  548.     char *exp;
  549.     char *alternate;
  550.     int    ok;
  551.     int i;
  552.  
  553.     printmsg( 0, "calling host %s", rmtname );
  554.  
  555.     if ( strcmp( flds[FLD_TYPE], "DIR" ) != SAME ) {
  556.         if ( dial() == FALSE )
  557.             return( 'G' );
  558.     }
  559.     else if (openline(device, speed)) 
  560.         return( 'G' );
  561.  
  562.     for (i = 6; i < kflds; i+=2) {
  563.  
  564.         exp = flds[i];
  565.         printmsg( 2, "callup: expect %d of %d  \"%s\"", i, kflds, exp );
  566.             
  567.         ok = FALSE;
  568.         while (ok != TRUE) {
  569.         
  570.             alternate = index( exp, '-' );
  571.             if (alternate != (char *)NULL) 
  572.                 *alternate++ = '\0';
  573.                 
  574.             ok = expectstr( exp, 30 );
  575.             
  576.             printmsg( 1, "got %s", ok != TRUE ? "?" : "that" );
  577.             
  578.             if ( ok == TRUE ) {
  579.                 printmsg( 0, "got that" );
  580.                 break;
  581.             }
  582.  
  583.             if ( alternate == (char *)NULL ) {
  584.                 printmsg( 0, "LOGIN FAILED" );
  585.                 return( 'Y' );
  586.             }
  587.                 
  588.             exp = index( alternate, '-' );
  589.             if ( exp != (char *)NULL )
  590.                 *exp++ = '\0';
  591.  
  592.             printmsg( 0, "send alternate" );
  593.             
  594.             sendstr( alternate );
  595.         }
  596.         
  597.     printmsg( 2, "callup: send %d of %d  \"%s\"", i+1, kflds, flds[i+1] );
  598.     sleep(1); /* (1)*/
  599.     sendstr(flds[i+1]);
  600.     }
  601.     return('P');
  602.  
  603. }
  604.  
  605. /* */
  606. /*
  607. **
  608. **      slowrite
  609. ** comunication slow write. needed for auto-baud modems
  610. */
  611. /*slowrite(st)
  612. register char    *st;
  613. {
  614.     int    len, j;
  615.     char    c;
  616.     len = strlen(st);
  617.     printmsg( 2, "sent %s", st );
  618.     for (j = 0; j < len; j++) {
  619.         swrite(&st[j], 1);
  620.         ddelay(80000);
  621.     }
  622. }
  623. */
  624.  
  625. /* */
  626. /*
  627. **
  628. **scandir
  629. **
  630. */
  631.  
  632. #include "ndir.h"
  633.  
  634.  
  635. /*    scandir
  636.  
  637.     scan work dir for C. files matching current remote host (rmtname)
  638.  
  639.     return
  640.  
  641.         A    - abort
  642.         Y    - can't open file
  643.         S    - ok
  644.         Q    - no files
  645.  
  646. */
  647. scandir()
  648. {
  649.     int    fn, len, i;
  650.     char    cname[40], tmp[132];
  651.  
  652.     DIR *dirp;
  653.     struct direct *dp;
  654.  
  655.     if ((dirp = opendir( spooldir )) == (DIR *)NULL ) {
  656.         fprintf( stderr, "couldn't open dir %s\n", spooldir );
  657.         return( 'A' );
  658.     }
  659.     sprintf(cname, CALLFILE, rmtname); 
  660.     len = strlen(cname);
  661.     while ((dp = readdir(dirp)) != (struct direct *)NULL) {
  662.         printmsg( 4, "scandir: %s", dp->d_name );
  663.         if ( strncmp( cname, dp->d_name, len ) == SAME ) {
  664.             printmsg( 4, "scandir: match!!" );
  665.             strcpy(cfile, dp->d_name);
  666.             closedir( dirp );
  667.             if ((fw = FOPEN( cfile, "r", 't' )) == (char *)NULL ) 
  668.                 return('Y');
  669.             return('S');
  670.         }
  671.     }
  672.     closedir( dirp );
  673.     return('Q');
  674.  
  675. }
  676.  
  677.  
  678. /* */
  679. /*
  680. **
  681. **dscandir
  682. ** scan the directory
  683. */
  684.  
  685. dscandir()
  686. {
  687.     int    fn, len, i;
  688.     char    cname[40], tmp[132];
  689.  
  690.     struct DIR *dirp;
  691.     struct direct *dp;
  692.  
  693.  
  694.     if ((dirp = opendir( spooldir )) == (DIR *)NULL ) {
  695.         fprintf( stderr, "couldn't open dir %s\n", spooldir );
  696.         return(0);
  697.     }
  698.     sprintf(cname, XQTFILE, rmtname); /* sprintf(cname,"c%.4s",rmtname); */
  699.     len = strlen(cname);
  700.     while ((dp = readdir(dirp)) != (struct direct *)NULL) {
  701.         printmsg( 4, "dcxqt:dir file = %s cfile = %s", dp->d_name, cname );
  702.         if ( strncmp( cname, dp->d_name, len ) == SAME ) {
  703.             printmsg( 4, "scandir: match!!" );
  704.             strcpy(cfile, dp->d_name);
  705.             closedir( dirp );
  706.             return( -1 );
  707.         }
  708.     }
  709.     closedir( dirp );
  710.     return( 0 );
  711.  
  712. }
  713.  
  714.  
  715.  
  716.