# 2.11BSD#431 - /usr/src/usr.bin/tip/aculib/ventel.c

##### Functions

    busyloop          X
    ven_abort         X
    ven_dialer        X
    ven_disconnect    X

##### Macros

    CPUSPEED          X
    DELAY             X
    MAXRETRY          X
    delay             X
    min               X

       1: /*
       2:  * Copyright (c) 1983 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #ifndef lint
       8: static char sccsid[] = "@(#)ventel.c	5.1 (Berkeley) 4/30/85";
       9: #endif not lint
      10:
      11: /*
      12:  * Routines for calling up on a Ventel Modem
      13:  * The Ventel is expected to be strapped for local echo (just like uucp)
      14:  */
      15: #include "tip.h"
      16:
      17: #define MAXRETRY    5
      18:
      19: static  int sigALRM();
      20: static  int timeout = 0;
      21: static  jmp_buf timeoutbuf;
      22:
      23: /*
      24:  * some sleep calls have been replaced by this macro
      25:  * because some ventel modems require two <cr>s in less than
      26:  * a second in order to 'wake up'... yes, it is dirty...
      27:  */
      28: #define delay(num,denom) busyloop(CPUSPEED*num/denom)
      29: #define CPUSPEED 1000000    /* VAX 780 is 1MIPS */
      30: #define DELAY(n)    { register long N = (n); while (--N > 0); }
      31: busyloop(n) { DELAY(n); }
      32:
      33: ven_dialer(num, acu)
      34:     register char *num;
      35:     char *acu;
      36: {
      37:     register char *cp;
      38:     register int connected = 0;
      39:     char *msg, *index(), line[80];
      40:
      41:     /*
      42: 	 * Get in synch with a couple of carriage returns
      43: 	 */
      44:     if (!vensync(FD)) {
      45:         printf("can't synchronize with ventel\n");
      46: #ifdef ACULOG
      47:         logent(value(HOST), num, "ventel", "can't synch up");
      48: #endif
      49:         return (0);
      50:     }
      51:     if (boolean(value(VERBOSE)))
      52:         printf("\ndialing...");
      53:     fflush(stdout);
      54:     ioctl(FD, TIOCHPCL, 0);
      55:     echo("#k$\r$\n$D$I$A$L$:$ ");
      56:     for (cp = num; *cp; cp++) {
      57:         delay(1, 10);
      58:         write(FD, cp, 1);
      59:     }
      60:     delay(1, 10);
      61:     write(FD, "\r", 1);
      62:     gobble('\n', line);
      63:     if (gobble('\n', line))
      64:         connected = gobble('!', line);
      65:     ioctl(FD, TIOCFLUSH);
      66: #ifdef ACULOG
      67:     if (timeout) {
      68:         sprintf(line, "%d second dial timeout",
      69:             number(value(DIALTIMEOUT)));
      70:         logent(value(HOST), num, "ventel", line);
      71:     }
      72: #endif
      73:     if (timeout)
      74:         ven_disconnect();   /* insurance */
      75:     if (connected || timeout || !boolean(value(VERBOSE)))
      76:         return (connected);
      77:     /* call failed, parse response for user */
      78:     cp = index(line, '\r');
      79:     if (cp)
      80:         *cp = '\0';
      81:     for (cp = line; cp = index(cp, ' '); cp++)
      82:         if (cp[1] == ' ')
      83:             break;
      84:     if (cp) {
      85:         while (*cp == ' ')
      86:             cp++;
      87:         msg = cp;
      88:         while (*cp) {
      89:             if (isupper(*cp))
      90:                 *cp = tolower(*cp);
      91:             cp++;
      92:         }
      93:         printf("%s...", msg);
      94:     }
      95:     return (connected);
      96: }
      97:
      98: ven_disconnect()
      99: {
     100:
     101:     close(FD);
     102: }
     103:
     104: ven_abort()
     105: {
     106:
     107:     write(FD, "\03", 1);
     108:     close(FD);
     109: }
     110:
     111: static int
     112: echo(s)
     113:     register char *s;
     114: {
     115:     char c;
     116:
     117:     while (c = *s++) switch (c) {
     118:
     119:     case '$':
     120:         read(FD, &c, 1);
     121:         s++;
     122:         break;
     123:
     124:     case '#':
     125:         c = *s++;
     126:         write(FD, &c, 1);
     127:         break;
     128:
     129:     default:
     130:         write(FD, &c, 1);
     131:         read(FD, &c, 1);
     132:     }
     133: }
     134:
     135: static int
     136: sigALRM()
     137: {
     138:
     139:     printf("\07timeout waiting for reply\n");
     140:     timeout = 1;
     141:     longjmp(timeoutbuf, 1);
     142: }
     143:
     144: static int
     145: gobble(match, response)
     146:     register char match;
     147:     char response[];
     148: {
     149:     register char *cp = response;
     150:     char c;
     151:     int (*f)();
     152:
     153:     signal(SIGALRM, sigALRM);
     154:     timeout = 0;
     155:     do {
     156:         if (setjmp(timeoutbuf)) {
     157:             signal(SIGALRM, f);
     158:             *cp = '\0';
     159:             return (0);
     160:         }
     161:         alarm(number(value(DIALTIMEOUT)));
     162:         read(FD, cp, 1);
     163:         alarm(0);
     164:         c = (*cp++ &= 0177);
     165: #ifdef notdef
     166:         if (boolean(value(VERBOSE)))
     167:             putchar(c);
     168: #endif
     169:     } while (c != '\n' && c != match);
     170:     signal(SIGALRM, SIG_DFL);
     171:     *cp = '\0';
     172:     return (c == match);
     173: }
     174:
     175: #define min(a,b)    ((a)>(b)?(b):(a))
     176: /*
     177:  * This convoluted piece of code attempts to get
     178:  * the ventel in sync.  If you don't have FIONREAD
     179:  * there are gory ways to simulate this.
     180:  */
     181: static int
     182: vensync(fd)
     183: {
     184:     int already = 0, nread;
     185:     char buf[60];
     186:
     187:     /*
     188: 	 * Toggle DTR to force anyone off that might have left
     189: 	 * the modem connected, and insure a consistent state
     190: 	 * to start from.
     191: 	 *
     192: 	 * If you don't have the ioctl calls to diddle directly
     193: 	 * with DTR, you can always try setting the baud rate to 0.
     194: 	 */
     195:     ioctl(FD, TIOCCDTR, 0);
     196:     sleep(1);
     197:     ioctl(FD, TIOCSDTR, 0);
     198:     while (already < MAXRETRY) {
     199:         /*
     200: 		 * After reseting the modem, send it two \r's to
     201: 		 * autobaud on. Make sure to delay between them
     202: 		 * so the modem can frame the incoming characters.
     203: 		 */
     204:         write(fd, "\r", 1);
     205:         delay(1,10);
     206:         write(fd, "\r", 1);
     207:         sleep(2);
     208:         if (ioctl(fd, FIONREAD, (caddr_t)&nread) < 0) {
     209:             perror("tip: ioctl");
     210:             continue;
     211:         }
     212:         while (nread > 0) {
     213:             read(fd, buf, min(nread, 60));
     214:             if ((buf[nread - 1] & 0177) == '$')
     215:                 return (1);
     216:             nread -= min(nread, 60);
     217:         }
     218:         sleep(1);
     219:         already++;
     220:     }
     221:     return (0);
     222: }

#### Defined functions

busyloop defined in line 31; used 1 times

- in line 28

echo defined in line 111; used 1 times

- in line 55

gobble defined in line 144; used 3 times

- in line 62-64(3)

sigALRM defined in line 135; used 2 times

- in line 19, 153

ven_abort defined in line 104; never used
ven_dialer defined in line 33; never used
ven_disconnect defined in line 98; used 1 times

- in line 74

vensync defined in line 181; used 1 times

- in line 44

#### Defined variables

sccsid defined in line 8; never used
timeout defined in line 20; used 5 times

- in line 67, 73-75(2), 140, 154

#### Defined macros

CPUSPEED defined in line 29; used 1 times

- in line 28

DELAY defined in line 30; used 1 times

- in line 31

MAXRETRY defined in line 17; used 1 times

- in line 198

delay defined in line 28; used 3 times

- in line 57-60(2), 205

min defined in line 175; used 2 times

- in line 213-216(2)

Last modified: 1985-04-30 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1426 |