![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckuscr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / kermit|
Return to ckuscr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / kermit |
1.1 root 1: char *loginv = "Script Command, V2.0(007) 5 Jul 85";
2:
3: /* C K U S C R -- Login script for logging onto remote system */
4:
5: /*
6: This module should work under all versions of Unix. It calls externally
7: defined system-depended functions for i/o.
8:
9: The module expects a login string of the expect send [expect send] ...
10: format. It is intended to operate similarly to the way the common
11: uucp "L.sys" login entries work. Conditional responses are supported
12: expect[-send-expect[...]] as with uucp. The send keyword EOT sends a
13: control-d, and the keyword BREAK sends a break. Letters prefixed
14: by '~' are '~b' backspace, '~s' space, '~n' linefeed, '~r' return, '~x' xon,
15: '~t' tab, '~q' ? (not allowed on kermit command lines), '~' ~, '~'',
16: '~"', '~c' don't append return, '~o[o[o]]' octal character. As with
17: some uucp systems, sent strings are followed by ~r (not ~n) unless they
18: end with ~c. Null expect strings (e.g., ~0 or --) cause a short
19: delay, and are useful for sending sequences requiring slight pauses.
20:
21: Author: Herm Fischer (HFISCHER@USC-ECLB)
22: Contributed to Columbia University for inclusion in C-Kermit.
23: Copyright (C) 1985, Herman Fischer, 16400 Ventura Blvd, Encino CA 91436
24: Permission is granted to any individual or institution to use, copy, or
25: redistribute this software so long as it is not sold for profit, provided this
26: copyright notice is retained.
27: */
28:
29: #include "ckcdeb.h"
30: #include <stdio.h>
31: #include <ctype.h>
32: #include <signal.h>
33: #include <setjmp.h>
34: #include "ckcker.h"
35:
36: extern int local, speed, flow, seslog, mdmtyp;
37: extern char ttname[];
38: extern CHAR dopar();
39: static char * chstr();
40:
41: static int EXP_ALRM = 15; /* Time to wait for expect string */
42: #define SND_ALRM 15 /* Time to allow for sending string */
43: #define NULL_EXP 2 /* Time to pause on null expect strg*/
44: #define DEL_MSEC 300 /* milliseconds to pause on ~d */
45:
46: #define SBUFL 300 /* Login Sequence buffer */
47: static char seq_buf[SBUFL], *s;
48: static int got_it, no_cr;
49:
50: /* connect state parent/child communication signal handlers */
51:
52: static jmp_buf alrmRng; /* Envir ptr for connect errors */
53:
54: scrtime() { /* modem read failure handler, */
55: longjmp(alrmRng,1); /* notifies parent process to stop */
56: }
57:
58:
59: /*
60: Sequence interpreter -- pick up next sequence from command string,
61: decode escapes and place into seq_buf
62:
63: If string contains a ~d (delay) then sequenc returns a 1 expecting
64: to be called again after the ~d executes.
65: */
66: static
67: sequenc() {
68:
69: int i;
70: char c, oct_char;
71:
72: no_cr = 0; /* output needs cr appended */
73:
74: for (i=0; i<SBUFL; ) {
75: if (*s == '\0' || *s == '-' || isspace(*s) ) { /* done */
76: seq_buf[i] = '\0';
77: return(0) ;
78: }
79:
80: if (*s == '~') { /* escape character */
81: switch (c = *(++s) ) {
82: case 'n': seq_buf[i++] = '\n'; break;
83: case 'r': seq_buf[i++] = '\r'; break;
84: case 't': seq_buf[i++] = '\t'; break;
85: case 'b': seq_buf[i++] = '\b'; break;
86: case 'q': seq_buf[i++] = '?'; break;
87: case '~': seq_buf[i++] = '~'; break;
88: case '\'': seq_buf[i++] = '\''; break;
89: case '\"': seq_buf[i++] = '\"'; break;
90: case 's': seq_buf[i++] = ' '; break;
91: case 'x': seq_buf[i++] = '\021'; break;
92: case 'c': no_cr = 1; break;
93: case 'd': { /* send what we have and then */
94: seq_buf[i] = '\0'; /* expect to send rest after */
95: no_cr = 1; /* sender delays a little */
96: s++;
97: return(1);
98: }
99: case 'w': { /* wait count */
100: EXP_ALRM = 15; /* default to 15 sec */
101: if ( isdigit( *(s+1) ) ) {
102: EXP_ALRM = (*(++s)) & 15;
103: if ( isdigit( *(s+1) ) ) {
104: EXP_ALRM = EXP_ALRM*10 + ( (*(++s)) & 15 );
105: }
106: }
107: break;
108: }
109: default:
110: if ( isdigit(c) ) { /* octal character */
111: oct_char = (c & 7); /* most significant digit */
112: if (isdigit( *(s+1) ) ) {
113: oct_char = (oct_char<<3) | ( (*(++s)) & 7 ) ;
114: if (isdigit( *(s+1) ) ) {
115: oct_char = (oct_char<<3) | ( (*(++s)) & 7 ) ;
116: }
117: }
118: seq_buf[i++] = oct_char;
119: break;
120: }
121: }
122: }
123: else seq_buf[i++] = *s; /* plain old character */
124: s++;
125: }
126: seq_buf[i] = '\0';
127: return(0); /* end of space, return anyway */
128: }
129:
130:
131: /*
132: Receive sequence -- see if expected response comes return success
133: (or failure) in got_it
134: */
135: static
136: recvSeq() {
137:
138: char *e, got[7], trace[300];
139: int i, l;
140:
141: sequenc();
142: l = strlen(e=seq_buf); /* no more than 7 chars allowed */
143: if (l > 7) {
144: e += l-7;
145: l = 7;
146: }
147:
148: tlog(F111,"expecting sequence",e,(long) l);
149: if (l == 0) { /* null sequence, just delay a little */
150: sleep (NULL_EXP);
151: got_it = 1;
152: tlog(F100,"got it (null sequence)","",0l);
153: return;
154: }
155: *trace = '\0';
156: for (i=0; i<7; i++) got[i]='\0';
157:
158: signal(SIGALRM,scrtime); /* did we get it? */
159: if (!setjmp(alrmRng)) { /* not timed out yet */
160: alarm(EXP_ALRM);
161: while (!got_it) {
162: for (i=0; i<(l-1); i++) got[i] = got[i+1]; /* shift over one */
163: got[l-1] = ttinc(0) & 0177; /* next char */
164: if (strlen(trace) < sizeof(trace)-2 )
165: strcat(trace,chstr(got[l-1]));
166: got_it = (!strncmp(seq_buf, got, l) ) ;
167: }
168: } else got_it = 0; /* timed out here */
169:
170: alarm(0);
171: signal(SIGALRM,SIG_IGN);
172: tlog(F110,"received sequence: ",trace,0l);
173: tlog(F101,"returning with got-it code","",(long) got_it);
174: return;
175: }
176:
177:
178: /*
179: Output A Sequence starting at pointer s,
180: return 0 if okay,
181: 1 if failed to read (modem hangup or whatever)
182: */
183: static int
184: outSeq() {
185: char *sb;
186: int l;
187: int delay;
188: int retCode = 0;
189:
190: while(1) {
191: delay = sequenc();
192: l = strlen(seq_buf);
193: tlog(F111,"sending sequence ",seq_buf,(long) l);
194: signal(SIGALRM,scrtime);
195: if (!setjmp(alrmRng)) {
196: alarm(SND_ALRM);
197: if (!strcmp(seq_buf,"EOT")) ttoc(dopar('\004'));
198: else if (!strcmp(seq_buf,"BREAK")) ttsndb();
199: else {
200: if (l > 0) {
201: for ( sb=seq_buf; *sb; sb++) *sb = dopar(*sb);
202: ttol(seq_buf,l); /* with parity */
203: }
204: if (!no_cr) ttoc( dopar('\r') );
205: }
206: }
207: else retCode |= -1; /* else -- alarm rang */
208: alarm(0);
209: signal(SIGALRM,SIG_IGN);
210: if (!delay) return ( retCode );
211: msleep(DEL_MSEC); /* delay, and loop to next stuff to send */
212: }
213: }
214:
215:
216: /* L O G I N -- Login to remote system */
217:
218: login(cmdstr) char *cmdstr; {
219:
220: int (*saveAlm)(); /* save incomming alarm function */
221: char *e;
222:
223: s = cmdstr; /* make global to ckuscr.c */
224:
225: tlog(F100,loginv,"",0l);
226:
227: if (!local) {
228: printf("Sorry, you must 'set line' first\n");
229: return(-2);
230: }
231: if (speed < 0) {
232: printf("Sorry, you must 'set speed' first\n");
233: return(-2);
234: }
235: if (ttopen(ttname,&local,mdmtyp) < 0) {
236: sprintf(seq_buf,"Sorry, can't open %s",ttname);
237: perror(seq_buf);
238: return(-2);
239: }
240: printf("Executing script thru %s, speed %d.\r\n",ttname,speed);
241: *seq_buf=0;
242: for (e=s; *e; e++) strcat(seq_buf, chstr(*e) );
243: printf("The logon string is: %s\r\n",seq_buf);
244: tlog(F110,"Logon command string: ",seq_buf, 0l);
245:
246: /* Condition console terminal and communication line */
247:
248: if (ttvt(speed,flow) < 0) {
249: printf("Sorry, Can't condition communication line\n");
250: return(-2);
251: }
252: /* save initial timer interrupt value */
253: saveAlm = signal(SIGALRM,SIG_IGN);
254:
255: ttflui(); /* flush stale input */
256:
257: /* cont'd... */
258:
259:
260: /* ...login, cont'd */
261:
262: /* start expect - send sequence */
263:
264: while (*s) { /* while not done with buffer */
265:
266: while (*s && isspace(*s)) s++; /* skip over separating whitespaces */
267: /* gather up expect sequence */
268: got_it = 0;
269: recvSeq();
270:
271: while (!got_it) {
272: /* no, is there a conditional send */
273: if (*s++ != '-') goto failRet; /* no -- return failure */
274:
275: /* start of conditional send */
276: ttflui(); /* flush out input buffer */
277: if (outSeq()) goto failRet; /* if unable to send! */
278:
279: if (*s++ != '-') goto failRet; /* must have condit respon.*/
280: recvSeq();
281: } /* loop back and check got_it */
282:
283: while (*s && !isspace(*s++) ) ; /* skip over conditionals */
284: while (*s && isspace(*s)) s++; /* skip over separating whitespaces */
285: ttflui(); /* Flush */
286: if (*s) if (outSeq()) goto failRet; /* if any */
287: }
288: signal(SIGALRM,saveAlm);
289: printf("Logged on!\r\n");
290: tlog(F100,"Logged on!","",0l);
291: return(0);
292:
293: failRet:
294: signal(SIGALRM,saveAlm);
295: printf("Sorry, logon failed\r\n");
296: tlog(F100,"Logon failed","",0l);
297: return(-2);
298: }
299:
300:
301: /* C H S T R -- Make printable string from a character */
302:
303: static char *
304: chstr(c) char c; {
305: static char sc[4];
306:
307: if (c < SP) sprintf(sc, "^%c",ctl(c) );
308: else sprintf(sc, "%c", c);
309:
310: return(sc);
311: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.