home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / UUCP_Blars.lzh / dcpsys.c < prev    next >
Text File  |  1991-11-24  |  16KB  |  884 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.  * Ported to OS-9/68000:  Wolfgang Ocker    January 1988
  11.  *
  12.  */
  13. /*
  14.  * "DCP" a uucp clone. Copyright Richard H. Lamb 1985,1986,1987
  15.  * Get the next system, and other support routines
  16.  */
  17.  
  18.  
  19. #include          "dcp.h"
  20. #define PROTOS    "g"
  21. #define MAXLOGTRY 3
  22.  
  23. int     I_HAVE_HAYES = FALSE;
  24.  
  25. static char *days[] = {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"};
  26.  
  27. static int waitlogin;
  28.  
  29. char   *fstring();
  30.  
  31. Proto   Protolst[] = {'g', ggetpkt, gsendpkt, gopenpk, gclosepk,
  32. #ifdef FPROTO
  33.     'f', fgetpkt, fsendpkt, fopenpk, fclosepk,
  34. #endif
  35. '\0'};
  36.  
  37. #define EOTMSG "\004\r\004\r"
  38.  
  39. procref getpkt, sendpkt, openpk, closepk;
  40.  
  41. /*
  42.  * g e t s y s t e m
  43.  *
  44.  * Process an "systems" file entry (like L.sys)
  45.  */
  46. getsystem()
  47. {
  48.     int     i;
  49.  
  50.     if (fgets(sysline, BUFSIZ, fsys) == NULL)
  51.     return ('A');
  52.  
  53.     printmsg(2, "%s", sysline);
  54.  
  55.     if ((kflds = dgetargs(sysline, flds)) < FLD_PROTO + 1) {
  56.     printmsg(1, "wrong system line, only %d arguments\n", kflds);
  57.     return ('I');        /* next line */
  58.     }
  59.     strcpy(rmtname, flds[FLD_REMOTE]);
  60.     cctime = flds[FLD_CCTIME];
  61.     strcpy(device, flds[FLD_DEVICE]);
  62.  
  63.     /* strcpy(type, flds[FLD_TYPE]); */
  64.     strcpy(speed, flds[FLD_SPEED]);
  65.     strcpy(proto, flds[FLD_PROTO]);
  66.  
  67.  
  68.     fw = (FILE *) NULL;
  69.     if (((strcmp(Rmtname, rmtname) == SAME) ||
  70.             ((strcmp(Rmtname, "all") == SAME) && scandir(TRUE) == 'S')) &&
  71.         checktime(cctime) == 0) {
  72.     if (fw != (FILE *) NULL)
  73.         fclose(fw);        /* in case we matched with scandir */
  74.  
  75.     if (debuglevel > 3) {
  76.         for (i = FLD_EXPECT; i < kflds - 1; i += 2)
  77.         fprintf(stderr, "expect[%02d]:\t%s\nsend  [%02d]:\t%s\n",
  78.             i, flds[i], i + 1, flds[i + 1]);
  79.  
  80.         printmsg(2, "rmt= %s ctm= %s", rmtname, flds[FLD_CCTIME]);
  81.         printmsg(2, "dev= %s ", device);
  82.         printmsg(2, "spd= %s pro= %s", speed, proto);
  83.     }
  84.     return ('S');        /* startup this system */
  85.     } else {
  86.     if (fw != (FILE *) NULL)
  87.         fclose(fw);        /* in case we matched with scandir */
  88.     return ('I');
  89.     }
  90. }
  91.  
  92.  
  93. /*
  94.  * c h e c k n a m e
  95.  *
  96.  * Do we know the guy ?
  97.  */
  98. checkname(name)
  99. char    name[];
  100.  
  101. {
  102.     FILE   *ff;
  103.     char    line[BUFSIZ], tmp[20];    /* can change to 8 if %8s works */
  104.  
  105.     if ((ff = fopen(s_systems, "r")) == NULL)
  106.     return (FAILED);
  107.  
  108.     printmsg(0, "%s is calling", name);
  109.  
  110.     while (mfgets(line, BUFSIZ, ff) != NULL) {
  111.     sscanf(line, "%8s ", tmp);
  112.     printmsg(6, "rmt= %s sys= %s", name, tmp);
  113.  
  114.     if (strncmp(name, tmp, 7) == SAME) {
  115.         fclose(ff);
  116.         return (OK);    /* OK I like you */
  117.     }
  118.     }
  119.  
  120.     printmsg(0, "Unknown host = %s", name);
  121.  
  122.     fclose(ff);
  123.     return (FAILED);        /* Who are you ? */
  124.  
  125. }
  126.  
  127.  
  128. /*
  129.  *
  130.  * c h e c k t i m e
  131.  *
  132.  * check if we may make a call at this time
  133.  */
  134.  
  135. checktime(xtime)
  136. char   *xtime;
  137. {
  138.     time_t  tstamp;
  139.     struct tm *ltime;
  140.     int     frtime, totime, now;
  141.     char   *cp, *cp2;
  142.  
  143.     if (strcmp(xtime, "Never") == SAME || strcmp(xtime, "Slave") == SAME) {
  144.     printmsg(0, "Can't call %s (time or slave)", rmtname);
  145.     return (1);
  146.     }
  147.     time(&tstamp);
  148.     ltime = localtime(&tstamp);
  149.  
  150.     now = ltime->tm_hour * 100 + ltime->tm_min;
  151.     cp = xtime;
  152.  
  153.     while (1) {
  154.     if (!xtime)
  155.         break;        /* not allowed */
  156.  
  157.     if (xtime = index(xtime, '|'))
  158.         *xtime++ = '\0';
  159.  
  160.     if (isdigit(*cp) || fstring(0, cp, "Any") ||
  161.         (fstring(0, cp, "Wk") && ltime->tm_wday != 0 && ltime->tm_wday != 6) ||
  162.         fstring(0, cp, days[ltime->tm_wday])) {    /* Day Ok */
  163.         for (; *cp; cp++)
  164.         if (isdigit(*cp))
  165.             break;
  166.         if (!*cp)
  167.         return (0);    /* ok, no time given */
  168.  
  169.         frtime = atoi(cp);
  170.  
  171.         if (!(cp2 = index(cp, '-'))) {
  172.         printmsg(0, "Wrong system time in systems\n");
  173.         return (1);
  174.         }
  175.         totime = atoi(cp2 + 1);
  176.  
  177. printmsg(5, "now: %d from: %d to: %d", now, frtime, totime);
  178.  
  179.         if (frtime < totime) {
  180.         if ((frtime <= now) && (now <= totime))
  181.             return (0);
  182.         } else if ((now >= frtime) || (now <= totime))
  183.         return (0);
  184.     }
  185.     cp = xtime;
  186.     }
  187.  
  188.     printmsg(0, "Can't call %s (time)", rmtname);
  189.     return (1);
  190. }
  191.  
  192.  
  193.  
  194. /*
  195.  * s y s e n d
  196.  *
  197.  * end UUCP session negotiation
  198.  */
  199. sysend()
  200. {
  201.     char    msg[80];
  202.  
  203.     msg[1] = '\0';
  204.     msgtime = 2 * MSGTIME;
  205.     /* while (msg[1] != 'O') { */
  206.  
  207.     wmsg("OOOOOO", 2);
  208.     if (rmsg(msg, 2) == -1)
  209.     goto hang;
  210.     /* } */
  211.  
  212. hang:
  213.     wmsg("OOOOOO", 2);
  214.     sleep(2);
  215.  
  216.     swrite("\n", 1);
  217.     swrite("+++", 3);
  218.     sleep(2);
  219.     swrite("\nATZ\n", 5);
  220.     sleep(1);
  221.  
  222.     closeline();
  223.     if (remote == MASTER)
  224.     return ('I');
  225.     return ('A');
  226. }
  227.  
  228.  
  229. /*
  230.  * d d e l a y
  231.  */
  232. #ifdef NOTDEF
  233. ddelay(dtime)
  234. int     dtime;
  235. {
  236.     int     i, j;
  237.  
  238.     for (i = 0; i < dtime; i++);
  239. }
  240.  
  241. #endif
  242.  
  243. /*
  244.  * w m s g
  245.  *
  246.  * write a ^P type msg to the remote uucp
  247.  */
  248. wmsg(msg, syn)
  249. int     syn;
  250. char    msg[];
  251.  
  252. {
  253.     int     len;
  254.  
  255.     len = strlen(msg);
  256.     if (syn == 2)
  257.     swrite("\0\020", 2);
  258.     swrite(msg, len);
  259.     if (syn == 2)
  260.     swrite("\0", 1);
  261. }
  262.  
  263.  
  264. /*
  265.  * r m s g
  266.  *
  267.  * read a ^P msg from UUCP
  268.  */
  269. rmsg(msg, syn)
  270. int     syn;
  271. char    msg[];
  272.  
  273. {
  274.     int     ii;
  275.     char    c;
  276.     register char *cp = msg;
  277.  
  278.     printmsg(10, "rmsg(,%d)", syn);
  279.     if (syn == 2) {
  280.     do {
  281.         if (sread(&c, 1, msgtime) < 1)
  282.         return -1;
  283.         printmsg(9, "rmsg: got '%c' looking for ^P", c);
  284.     } while ((c & 0x7f) != '\020');
  285.     }
  286.     while (c && cp <= msg + 132) {
  287.     if (sread(&c, 1, msgtime) < 1)
  288.         return -1;
  289.     c &= 0x7f;
  290.     printmsg(9, "rmsg: got '%c'", c);
  291.     if (c == '\l' || c == '\r')
  292.         c = '\0';
  293.     *cp++ = c;
  294.     if (c == '\020')
  295.         cp = msg;
  296.     }
  297.  
  298.     return cp - msg - 1;
  299. }
  300.  
  301.  
  302.  
  303. /*
  304.  * s t a rt u p
  305.  */
  306. startup()
  307. {
  308.     char    msg[80], tmp1[20], tmp2[20];
  309.  
  310.     if (remote == MASTER) {
  311.     sleep(1);
  312.     msgtime = 5 * MSGTIME;
  313.     if (rmsg(msg, 2) == -1) {
  314.         printmsg(0, "Timeout during startup ...");
  315.         return ('Y');
  316.     }
  317.     printmsg(2, "1st msg = %s", msg);
  318.     if (msg[5] == '=' && strncmp(&msg[6], rmtname, 7))
  319.         return ('Y');
  320.  
  321.     printmsg(2, "sending nodename = %s", nodename);
  322.  
  323.     /* sprintf(msg, "S%.7s -Q0 -x%d", nodename, debuglevel); *//* -Q0 -x16
  324.      * remote debuglevel set */
  325.     sprintf(msg, "S%.7s", nodename);
  326.  
  327.     wmsg(msg, 2);
  328.     if (rmsg(msg, 2) == -1) {
  329.         printmsg(0, "Timeout during startup ...");
  330.         return ('Y');
  331.     }
  332.     printmsg(2, "2nd msg = %s", msg);
  333.     if (strncmp(&msg[1], "OK", 2))
  334.         return ('Y');
  335.  
  336.     if (rmsg(msg, 2) == -1) {
  337.         printmsg(0, "Timeout during startup ...");
  338.         return ('Y');
  339.     }
  340.     printmsg(2, "3rd msg = %s", msg);
  341.     if (msg[0] != 'P' || index(&msg[1], proto[0]) == (char *) NULL) {
  342.         wmsg("UN", 2);
  343.         return ('Y');
  344.     }
  345.     sprintf(msg, "U%c", proto[0]);
  346.     wmsg(msg, 2);
  347.     setproto(proto[0]);
  348.     return ('D');
  349.     } else {
  350.     msgtime = 5 * MSGTIME;
  351.     sprintf(msg, "Shere=%s", nodename);
  352.     wmsg(msg, 2);
  353.     if (rmsg(msg, 2) == -1) {
  354.         printmsg(0, "Timeout during startup ...");
  355.         return ('Y');
  356.     }
  357.     sscanf(&msg[1], "%s %s %s", rmtname, tmp1, tmp2);
  358.     sscanf(tmp2, "-x%d", &debuglevel);
  359.     printmsg(1, "debuglevel level = %d", debuglevel);
  360.     printmsg(2, "1st msg from remote = %s", msg);
  361.     if (checkname(rmtname))
  362.         return ('Y');
  363.  
  364.     wmsg("ROK", 2);
  365.     sprintf(msg, "P%s", PROTOS);
  366.     wmsg(msg, 2);
  367.     if (rmsg(msg, 2) == -1) {
  368.         printmsg(0, "Timeout during startup ...");
  369.         return ('Y');
  370.     }
  371.     if (msg[0] != 'U' || index(PROTOS, msg[1]) == (char *) NULL)
  372.         return ('Y');
  373.  
  374.     proto[0] = msg[1];
  375.     setproto(proto[0]);
  376.     return ('R');
  377.     }
  378. }
  379.  
  380.  
  381. /*
  382.  * s e t p r o t o
  383.  *
  384.  * set the protocol
  385.  */
  386. setproto(pr)
  387. char    pr;
  388. {
  389.     int     i;
  390.     Proto  *tproto;
  391.  
  392.     for (tproto = Protolst; tproto->type != '\0' && pr != tproto->type;
  393.         tproto++)
  394.     printmsg(3, "setproto: %c %c", pr, tproto->type);
  395.  
  396.     if (tproto->type == '\0') {
  397.     printmsg(0, "setproto: You said I had it but I cant find it");
  398.     exit(1);
  399.     }
  400.     getpkt = tproto->a;
  401.     sendpkt = tproto->b;
  402.     openpk = tproto->c;
  403.     closepk = tproto->d;
  404. }
  405.  
  406.  
  407. /*
  408.  * p r e f i x
  409.  */
  410. int
  411. prefix(sh, lg)
  412. char   *sh, *lg;
  413. {
  414.     return (strncmp(sh, lg, strlen(sh)) == SAME);
  415. }
  416.  
  417.  
  418. /*
  419.  * n o t i n
  420.  */
  421. int
  422. notin(sh, lg)
  423. char   *sh, *lg;
  424. {
  425.     while (*lg) {
  426.     if (prefix(sh, lg++))
  427.         return (FALSE);
  428.     }
  429.  
  430.     return (TRUE);
  431. }
  432.  
  433. #define MAXR 300
  434.  
  435.  
  436. /*
  437.  * e x p e c t s t r
  438.  */
  439. int
  440. expectstr(str, timeout)
  441. char   *str;
  442. int     timeout;
  443. {
  444.     char    rdvec[MAXR];
  445.     register char *rp = rdvec;
  446.     char    nextch;
  447.  
  448.     printmsg(3, "wanted %s", str);
  449.  
  450.     if (strcmp(str, "\"\"") == SAME)
  451.     return TRUE;
  452.     *rp = 0;
  453.     while (notin(str, rdvec)) {
  454.     if (sread(&nextch, 1, timeout) <= 0)
  455.         return FALSE;
  456.     if ((*rp++ = nextch & 0177) < ' ')
  457.         rp = rdvec;
  458.     *rp = '\0';
  459.     printmsg(8, "---------->%s<------\n", rdvec);
  460.     if (rp >= rdvec + MAXR) {
  461.         if ((rp = index(rdvec + MAXR - strlen(str) - 1, *str)) != NULL) {
  462.         strcpy(rdvec, rp);
  463.         rp = rdvec + strlen(rdvec);
  464.         } else
  465.         rp = rdvec;
  466.     }
  467.     }
  468.     return TRUE;
  469. }
  470.  
  471.  
  472. /*
  473.  * w r i t e s t r
  474.  */
  475. int
  476. writestr(s)
  477. register char *s;
  478. {
  479.     register char last;
  480.     register char *m;
  481.     int     nocr;
  482.     extern int fpw;
  483.  
  484.     last = '\0';
  485.     nocr = FALSE;
  486.  
  487.     while (*s) {
  488.     if (last == '\\') {
  489.         switch (*s) {
  490.         case 'd':
  491.         case 'D':        /* delay */
  492.         sleep(2);
  493.         break;
  494.         case 'c':
  495.         case 'C':        /* end string don't output CR */
  496.         nocr = TRUE;
  497.         break;
  498.         case 'r':
  499.         case 'R':        /* carriage return */
  500.         case 'm':
  501.         case 'M':
  502.         swrite("\r", 1);
  503.         break;
  504.         case 'n':
  505.         case 'N':
  506.         swrite("\l", 1);
  507.         break;
  508.         case 'b':
  509.         case 'B':
  510.         swrite("\b", 1);
  511.         break;
  512.         case 'u':
  513.         case 'U':
  514. #ifdef TOPS
  515.         _ss_break(fpw);
  516. #endif
  517.         break;
  518.         case 't':
  519.         case 'T':
  520.         swrite("\t", 1);
  521.         break;
  522.         case 's':
  523.         case 'S':
  524.         swrite(" ", 1);
  525.         break;
  526.         case 'z':
  527.         case 'Z':
  528.         SIOSpeed(++s);
  529.         while (*s != '\0' && *s != '\\')
  530.             s++;
  531.         if (*s == '\\')
  532.             s++;
  533.         break;
  534.         default:
  535.         swrite(s, 1);
  536.         }
  537.  
  538.         last = '\0';
  539.     } else if (*s != '\\') {
  540.         swrite(s, 1);
  541.         /* fputc(*s, stderr); */
  542.     } else
  543.         last = *s;
  544.  
  545.     s++;
  546.     }
  547.     return (nocr);
  548. }
  549.  
  550. /*
  551.  * s e n d s t r
  552.  *
  553.  * send line of login sequence
  554.  */
  555. void
  556. sendstr(str)
  557. char   *str;
  558. {
  559.     int     nw, ns;
  560.     int     nulls;
  561.  
  562.     printmsg(2, "sending %s", str);
  563.  
  564. #ifdef BREAK
  565.     if (prefix("BREAK", str)) {
  566.     sscanf(&str[5], "%1d", &nulls);
  567.     if (nulls <= 0 || nulls > 10)
  568.         nulls = 3;
  569.  
  570.     /* send break */
  571.     ssendbrk(nulls);
  572.     return;
  573.     }
  574. #endif
  575.  
  576.     if (strcmp(str, "EOT") == SAME) {
  577.     swrite(EOTMSG, strlen(EOTMSG));
  578.     return;
  579.     }
  580.     if (strcmp(str, "\"\"") == SAME)
  581.     *str = '\0';
  582.  
  583.     if (strcmp(str, "") != SAME) {
  584.     if (!writestr(str)) {
  585.         swrite("\r", 1);
  586.     }
  587.     } else {
  588.     swrite("\r", 1);
  589.     }
  590.     return;
  591. }
  592.  
  593.  
  594. /*
  595.  * s e n d e x p e c t
  596.  */
  597. int
  598. sendexpect(s, e, timeout)
  599. char   *s;
  600. char   *e;
  601. {
  602.     sendstr(s);
  603.     return (expectstr(e, timeout));
  604. }
  605.  
  606.  
  607. /*
  608.  * d i a l
  609.  */
  610. dial()
  611. {
  612.     extern int fpr, fpw;
  613.     int     i;
  614.     char    cmd[100];
  615.     int     fdsav0, fdsav1, err;
  616.  
  617.     if (!strncmp(flds[FLD_TYPE], "PRG-", 4)) {
  618.     if (openline(device, speed)) {
  619.         printmsg(0, "dial: CAN'T OPEN TTY");
  620.         return (FALSE);
  621.     }
  622.     fdsav0 = dup(0);
  623.     fdsav1 = dup(1);
  624.  
  625.     close(0);
  626.     dup(fpr);
  627.     close(1);
  628.     dup(fpw);
  629.  
  630.     sprintf(cmd, "%s %s", flds[FLD_TYPE] + 4, rmtname);
  631.     err = 0;
  632. #ifdef TOPS
  633.     if (xshell(cmd) < 0)
  634. #else
  635.     if (system(cmd) < 0)
  636. #endif
  637.         err = errno;
  638.  
  639.     if (fdsav0 >= 0) {
  640.         close(0);
  641.         dup(fdsav0);
  642.         close(fdsav0);
  643.     }
  644.     if (fdsav1 >= 0) {
  645.         close(1);
  646.         dup(fdsav1);
  647.         close(fdsav1);
  648.     }
  649.     if (err != 0) {
  650.         printmsg(0, "dial: dialer failed (%d)");
  651.         return (FALSE);
  652.     }
  653.     return (TRUE);
  654.     }
  655.     if (strncmp(flds[FLD_TYPE], "HAYES", 5) != SAME) {
  656.     printmsg(0, "dial: unsupported dialer %s", flds[FLD_TYPE]);
  657.     return (FALSE);
  658.     }
  659.     if (flds[FLD_TYPE][5] == '-')
  660.     waitlogin = atoi(flds[FLD_TYPE] + 6);
  661.  
  662.     printmsg(3, "calling host %s", rmtname);
  663.     if (openline(device, speed)) {
  664.     printmsg(0, "dial: CAN'T OPEN TTY");
  665.     return (FALSE);
  666.     }
  667.     printmsg(3, "hayes: trying %s", speed);
  668.     SIOSpeed(speed);
  669.     sendstr("ATZ");
  670.     sleep(1);
  671.     if (sendexpect("ATZ", "OK", 2) != TRUE) {
  672.     sendexpect("\\d+++\\d", "OK", 2);
  673.     if (sendexpect("ATZ", "OK", 2) != TRUE) {
  674.         printmsg(0, "dial: NO MODEM RESPONSE");
  675.         return (FALSE);
  676.     }
  677.     }
  678.     printmsg(3, "hayes: got modem response");
  679.  
  680. #ifdef SCREW_WITH_THE_MODEM_SETTINGS_FOR_NO_GOOD_REASON_OTHER_THAN_TO_BREAK_THINGS
  681.     if (sendexpect("\\d\\dATX4", "OK", 2) != TRUE) {
  682.     printmsg(0, "dial: NO MODEM RESPONSE");
  683.     return (FALSE);
  684.     } else {
  685.     sleep(1);
  686.     return (TRUE);
  687.     }
  688. #else
  689.     return TRUE;
  690. #endif
  691. }
  692.  
  693.  
  694. /*
  695.  * d o c a l l u p
  696.  *
  697.  * script processor - nothing fancy!
  698.  */
  699. docallup()
  700. {
  701.     int     flg, kk, jj, ll, firstflg;
  702.     char    exptmp[100];
  703.     char   *exp;
  704.     char   *alternate;
  705.     int     ok;
  706.     int     i;
  707.  
  708.     printmsg(1, "calling host %s", rmtname);
  709.     printmsg(1, "debuglevel=%d", debuglevel);
  710.  
  711.  
  712.     waitlogin = 30;
  713.  
  714.     if (strcmp(flds[FLD_TYPE], "DIR") != SAME) {
  715.     I_HAVE_HAYES = TRUE;
  716.     if (dial() == FALSE)
  717.         return ('G');
  718.     } else {
  719.     I_HAVE_HAYES = FALSE;
  720.     if (openline(device, speed))
  721.         return ('G');
  722.     }
  723.  
  724.     for (i = 6; i < kflds; i += 2) {
  725.     strcpy(exptmp, flds[i]);
  726.     exp = exptmp;
  727.     printmsg(2, "callup: expect %d of %d  \"%s\"", i, kflds, exp);
  728.  
  729.     ok = FALSE;
  730.  
  731.     while (ok != TRUE) {
  732.         alternate = index(exp, '-');
  733.         if (alternate != (char *) NULL)
  734.         *alternate++ = '\0';
  735.  
  736.         ok = expectstr(exp, waitlogin);
  737.  
  738.         printmsg(1, "got %s", ok != TRUE ? "?" : "that");
  739.  
  740.         if (ok == TRUE)
  741.         break;
  742.         if (alternate == (char *) NULL) {
  743.         printmsg(0, "LOGIN FAILED");
  744.         return ('Y');
  745.         }
  746.         exp = index(alternate, '-');
  747.         if (exp != (char *) NULL)
  748.         *exp++ = '\0';
  749.  
  750.         printmsg(1, "send alternate");
  751.  
  752.         sendstr(alternate);
  753.     }
  754.  
  755.     printmsg(2, "callup: send %d of %d  \"%s\"", i + 1, kflds, flds[i + 1]);
  756.     sleep(1);        /* (1) */
  757.     sendstr(flds[i + 1]);
  758.     }
  759.  
  760.     return ('P');
  761. }
  762.  
  763.  
  764. /*
  765.  * c a l l u p
  766.  */
  767. callup()
  768. {
  769.     int     trys;
  770.  
  771.     for (trys = 0; trys < 4; trys++) {
  772.     if (docallup() == 'P')
  773.         return ('P');
  774.     else {
  775.         closeline();
  776.         sleep(60);        /* Wait 60 secs and than try again */
  777.     }
  778.     }
  779.     printmsg(0, "LOGIN FAILED, ABORTING");
  780.     return ('I');
  781. }
  782.  
  783. /*
  784.  * s l o w r i t e
  785.  *
  786.  * comunication slow write. needed for auto-baud modems
  787.  */
  788. slowrite(st)
  789. register char *st;
  790. {
  791.     printmsg(2, "sent %s", st);
  792.     while (*st != '\0') {
  793.     swrite(st, 1);
  794.     tsleep(20);
  795.     }
  796. }
  797.  
  798. #include <dir.h>
  799.  
  800. /*
  801.  * s c a n d  i r
  802.  *
  803.  * scan work dir for C. files matching current remote host (rmtname)
  804.  * return
  805.  *   A  - abort
  806.  *   Y  - can't open file
  807.  *   S  - ok
  808.  *   Q  - no files
  809.  */
  810. scandir(closeit)
  811. int     closeit;
  812. {
  813.     int     fn, len, i;
  814.     char    cname[64], tmp[40];
  815.  
  816.     static DIR *dirp = NULL;
  817.     struct direct *dp;
  818.  
  819.     if (closeit && dirp) {
  820.         closedir(dirp);
  821.     dirp = NULL;
  822.     }
  823.     if (dirp == NULL)
  824.     if ((dirp = opendir(rmtname)) == (DIR *) NULL) {
  825.         fprintf(stderr, "couldn't open dir %s\n", rmtname);
  826.         return ('A');
  827.     }
  828.     sprintf(cname, CALLFILE, rmtname);
  829.     len = strlen(cname);
  830.  
  831.     while ((dp = readdir(dirp)) != (struct direct *) NULL) {
  832.     printmsg(4, "scandir: %s", dp->d_name);
  833.  
  834.     strcpy(tmp, dp->d_name);
  835.     tmp[strlen(tmp) - 5] = '\0';    /* WARNING: This is a hack */
  836.  
  837.     if (strcmp(cname, tmp) == SAME) {
  838.         printmsg(4, "scandir: match!!");
  839.         sprintf(cfile, "%s/%s", rmtname, dp->d_name);
  840.         if (closeit) {
  841.         closedir(dirp);
  842.         dirp = NULL;
  843.         }
  844.         if (fw)
  845.         fclose(fw);    /* added ... (weo) */
  846.  
  847.         if ((fw = fopen(cfile, "r")) == NULL) {
  848.         printmsg(0, "Can't open %s", cfile);
  849.         continue;    /* return('Y');  was here. We want to
  850.                  * continue! (weo) */
  851.         }
  852.         return ('S');
  853.     }
  854.     }
  855.  
  856.     closedir(dirp);
  857.     dirp = NULL;
  858.     return ('Q');
  859. }
  860.  
  861.  
  862. /*
  863.  * f s t r i n g
  864.  */
  865. char   *
  866. fstring(pos, str, pat)
  867. int     pos;
  868. char   *str, *pat;
  869. {
  870.     char   *cp;
  871.     int     len;
  872.  
  873.     if (pos >= strlen(str))
  874.     return (NULL);
  875.  
  876.     len = strlen(pat);
  877.  
  878.     for (cp = str + pos; *cp; cp++)
  879.     if (!strncmp(cp, pat, len))
  880.         return (cp);
  881.  
  882.     return (NULL);
  883. }
  884.