![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xchat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / contrib|
Return to xchat.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / contrib |
1.1 root 1: /*
2: * ***********
3: * * XCHAT.C *
4: * ***********
5: *
6: * Extended chat processor for Taylor UUCP. See accompanying documentation.
7: *
8: * Written by:
9: * Bob Denny ([email protected])
10: * Based on code in DECUS UUCP (for VAX/VMS)
11: *
12: * History:
13: * Version 1.0 shipped with Taylor 1.03. No configuration info inside.
14: *
15: * Bob Denny - Sun Aug 30 18:41:30 1992
16: * V1.1 - long overdue changes for other systems. Rip out interval
17: * timer code, use timer code from Taylor UUCP, use select()
18: * for timed reads. Use Taylor UUCP "conf.h" file to set
19: * configuration for this program. Add defaulting of script
20: * and log file paths.
21: *
22: * Bugs:
23: * Does not support BSD terminal I/O. Anyone care to add it?
24: */
25:
26: #include <sys/types.h>
27: #include <stdio.h>
28: #include <string.h>
29: #include <ctype.h>
30: #include <signal.h>
31: #include <time.h>
32: #include <sys/ioctl.h>
33: #include <sys/termio.h>
34:
35: #include "xc-conf.h"
36:
37: /*
38: * Pick a timing routine to use, as done in Taylor UUCP.
39: */
40: #if HAVE_USLEEP || HAVE_NAP || HAVE_NAPMS || HAVE_POLL
41: #define USE_SELECT_TIMER 0
42: #else
43: #define USE_SELECT_TIMER HAVE_SELECT
44: #if USE_SELECT_TIMER
45: #include <sys/time.h>
46: #endif
47: #endif
48:
49: #if HAVE_USLEEP || HAVE_NAP || HAVE_NAPMS
50: #undef HAVE_POLL
51: #define HAVE_POLL 0
52: #endif
53:
54: #if HAVE_USLEEP || HAVE_NAP
55: #undef HAVE_NAPMS
56: #define HAVE_NAPMS 0
57: #endif
58:
59: #if HAVE_USLEEP
60: #undef HAVE_NAP
61: #define HAVE_NAP 0
62: #endif
63:
64: static int ttblind();
65: static int ttcd();
66:
67: /* script entry -- "compiled" form of dial, hangup, or login script */
68:
69: struct script {
70: struct script *next; /* pointer to next entry, or null */
71: int opcode; /* numeric opcode */
72: char *strprm; /* pointer to string param */
73: long intprm; /* integer parameter */
74: char *newstate; /* new state name */
75: };
76:
77: /* opcode definition array element -- one for each possible opcode */
78:
79: struct script_opdef {
80: char *opname;
81: int opcode; /* numeric opcode -- same as array index */
82: int prmtype; /* one of SC_NONE, SC_STR, SC_XSTR, SC_INT */
83: int newstate; /* one of SC_NONE, SC_NWST */
84: };
85:
86: /* values for opcode */
87:
88: #define SC_LABEL 0 /* "label" (state name) */
89: #define SC_CDLY 1 /* set char output delay in msec */
90: #define SC_PCHR 2 /* pause char for dial string (from P in input) */
91: #define SC_PTIM 3 /* seconds to allow for pause char */
92: #define SC_WCHR 4 /* wait char for dial string (from W in input) */
93: #define SC_WTIM 5 /* seconds to allow for wait char */
94: #define SC_ZERO 6 /* zero counter */
95: #define SC_INCR 7 /* increment counter */
96: #define SC_IFGT 8 /* change state if counter > int param */
97: #define SC_WAIT 9 /* wait for int param seconds */
98: #define SC_GOTO 10 /* unconditional change to new state */
99: #define SC_SEND 11 /* send strparam (after sprintf substitutions) */
100: #define SC_BRK 12 /* send a break */
101: #define SC_HANG 13 /* drop DTR */
102: #define SC_DIAL 14 /* send telno string (after subst PCHR & WCHR) */
103: #define SC_DTIM 15 /* time in msec per digit (for timeout calculations) */
104: /* default = 100 (one tenth second) */
105: #define SC_CTIM 16 /* additional time (in seconds) to wait for carrier */
106: /* default = 45 seconds */
107: #define SC_EXIT 17 /* script done, success */
108: #define SC_FAIL 18 /* script done, failure */
109: #define SC_LOG 19 /* write strparam to uucp.log */
110: #define SC_LOGE 20 /* write strparam to uucp.log w/error ind */
111: #define SC_DBG 21 /* write strparam to debug log if debug lvl = LGI */
112: #define SC_DBGE 22 /* write strparam to debug log if debug lvl = LGIE */
113: #define SC_DBST 23 /* 'or' intparam into debug mask */
114: #define SC_DBCL 24 /* 'bicl' intparam into debug mask */
115: #define SC_TIMO 25 /* newstate if no match in intparam secs */
116: /* (uses calculated dial time if intparam is 0) */
117: #define SC_XPCT 26 /* wait for strparam, goto _newstate if found */
118: #define SC_CARR 27 /* goto _newstate if carrier detected */
119: #define SC_FLSH 28 /* flush typeahead buffer */
120: #define SC_IFBL 29 /* change state if controller is blind w/o CD */
121: #define SC_IFBG 30 /* chg state if ctlr is blind and counter > intprm */
122: #define SC_SNDP 31 /* send parameter n */
123: #define SC_IF1P 32 /* if parameter n present */
124: #define SC_IF0P 33 /* if parameter n absent */
125: #define SC_DBOF 34 /* open debugging file */
126: #define SC_TELN 35 /* Set telno from parameter n */
127: #define SC_7BIT 36 /* Set port to 7-bit stripping */
128: #define SC_8BIT 37 /* Set port for 8-bit characters */
129: #define SC_PNON 38 /* Set port for 8-bit, no parity */
130: #define SC_PEVN 39 /* Set port for 7-bit, even parity */
131: #define SC_PODD 40 /* Set port for 7-bit, odd parity */
132: #define SC_HUPS 41 /* Change state on HUP signal */
133: #define SC_END 42 /* end of array */
134:
135: /* values for prmtype, prm2type */
136:
137: #define SC_NONE 0 /* no parameter */
138: #define SC_STR 1 /* simple string */
139: #define SC_INT 2 /* integer */
140: #define SC_NWST 3 /* new state name */
141: #define SC_XSTR 4 /* translated string */
142:
143: /* opcode definition table for dial/login/hangup scripts */
144:
145: static struct script_opdef sc_opdef[] =
146: {
147: {"label", SC_LABEL, SC_NONE, SC_NONE},
148: {"chrdly", SC_CDLY, SC_INT, SC_NONE},
149: {"pchar", SC_PCHR, SC_STR, SC_NONE},
150: {"ptime", SC_PTIM, SC_INT, SC_NONE},
151: {"wchar", SC_WCHR, SC_STR, SC_NONE},
152: {"wtime", SC_WTIM, SC_INT, SC_NONE},
153: {"zero", SC_ZERO, SC_NONE, SC_NONE},
154: {"count", SC_INCR, SC_NONE, SC_NONE},
155: {"ifgtr", SC_IFGT, SC_INT, SC_NWST},
156: {"sleep", SC_WAIT, SC_INT, SC_NONE},
157: {"goto", SC_GOTO, SC_NONE, SC_NWST},
158: {"send", SC_SEND, SC_XSTR, SC_NONE},
159: {"break", SC_BRK, SC_NONE, SC_NONE},
160: {"hangup", SC_HANG, SC_NONE, SC_NONE},
161: {"7bit", SC_7BIT, SC_NONE, SC_NONE},
162: {"8bit", SC_8BIT, SC_NONE, SC_NONE},
163: {"nopar", SC_PNON, SC_NONE, SC_NONE},
164: {"evenpar", SC_PEVN, SC_NONE, SC_NONE},
165: {"oddpar", SC_PODD, SC_NONE, SC_NONE},
166: {"telno", SC_TELN, SC_INT, SC_NONE},
167: {"dial", SC_DIAL, SC_NONE, SC_NONE},
168: {"dgttime", SC_DTIM, SC_INT, SC_NONE},
169: {"ctime", SC_CTIM, SC_INT, SC_NONE},
170: {"success", SC_EXIT, SC_NONE, SC_NONE},
171: {"failed", SC_FAIL, SC_NONE, SC_NONE},
172: {"log", SC_LOG, SC_XSTR, SC_NONE},
173: {"logerr", SC_LOGE, SC_XSTR, SC_NONE},
174: {"debug", SC_DBG, SC_XSTR, SC_NONE},
175: {"debuge", SC_DBGE, SC_XSTR, SC_NONE},
176: {"dbgset", SC_DBST, SC_INT, SC_NONE},
177: {"dbgclr", SC_DBCL, SC_INT, SC_NONE},
178: {"dbgfile", SC_DBOF, SC_XSTR, SC_NONE},
179: {"timeout", SC_TIMO, SC_INT, SC_NWST},
180: {"expect", SC_XPCT, SC_XSTR, SC_NWST},
181: {"ifcarr", SC_CARR, SC_NONE, SC_NWST},
182: {"ifhang", SC_HUPS, SC_NONE, SC_NWST},
183: {"flush", SC_FLSH, SC_NONE, SC_NONE},
184: {"ifblind", SC_IFBL, SC_NONE, SC_NWST},
185: {"ifblgtr", SC_IFBG, SC_INT, SC_NWST},
186: {"sendstr", SC_SNDP, SC_INT, SC_NONE},
187: {"ifstr", SC_IF1P, SC_INT, SC_NWST},
188: {"ifnstr", SC_IF0P, SC_INT, SC_NWST},
189: {"table end", SC_END, SC_NONE, SC_NONE}
190: };
191:
192: #define SUCCESS 0
193: #define FAIL 1
194: #define ERROR -1
195: #define MAX_SCLINE 255 /* max length of a line in a script file */
196: #define MAX_EXPCT 127 /* max length of an expect string */
197: #define CTL_DELIM " \t\n\r" /* Delimiters for tokens */
198: #define SAME 0 /* if (strcmp(a,b) == SAME) ... */
199: #define SLOP 10 /* Slop space on arrays */
200: #define MAX_STRING 200 /* Max length string to send/expect */
201:
202: #define DEBUG_LEVEL(level) \
203: (Debug & (1 << level))
204:
205: #define DB_LOG 0 /* error messages and a copy of the LOGFILE output */
206: #define DB_LGIE 1 /* dial,login,init trace -- errors only */
207: #define DB_LGI 2 /* dial,login,init trace -- nonerrors (incl chr I/O) */
208: #define DB_LGII 3 /* script processing internals */
209:
210: #define TRUE 1
211: #define FALSE 0
212:
213: #define NONE 0
214: #define EVEN 1
215: #define ODD 2
216:
217: #define logit(m, p1) fprintf(stderr, "%s %s\n", m, p1)
218:
219: static char **paramv; /* Parameter vector */
220: static int paramc; /* Parameter count */
221: static char telno[64]; /* Telephone number w/meta-chars */
222: static int Debug;
223: static int fShangup = FALSE; /* TRUE if HUP signal received */
224: static FILE *dbf = NULL;
225: static struct termio old, new;
226:
227: extern int usignal();
228: extern int uhup();
229:
230: static struct siglist
231: {
232: int signal;
233: int (*o_catcher) ();
234: int (*n_catcher) ();
235: } sigtbl[] = {
236: { SIGHUP, NULL, uhup },
237: { SIGINT, NULL, usignal },
238: { SIGIOT, NULL, usignal },
239: { SIGQUIT, NULL, usignal },
240: { SIGTERM, NULL, usignal },
241: { SIGALRM, NULL, usignal },
242: { 0, NULL, NULL } /* Table end */
243: };
244:
245: extern struct script *read_script();
246: extern void msleep();
247: extern char xgetc();
248: extern void charlog();
249: extern void setup_tty();
250: extern void restore_tty();
251: extern void ttoslow();
252: extern void ttflui();
253: extern void tthang();
254: extern void ttbreak();
255: extern void tt7bit();
256: extern void ttpar();
257: extern void DEBUG();
258:
259: extern void *malloc();
260:
261:
262: /*
263: * **********************************
264: * * BEGIN EXECUTION - MAIN PROGRAM *
265: * **********************************
266: *
267: * This program is called by Taylor UUCP with a list of
268: * arguments in argc/argv, and stdin/stdout mapped to the
269: * tty device, and stderr mapped to the Taylor logfile, where
270: * anything written to stdout will be logged as an error.
271: *
272: */
273: int main(argc, argv)
274: int argc;
275: char *argv[];
276: {
277: int i, stat;
278: FILE *sf;
279: char sfname[256];
280: struct script *script;
281: struct siglist *sigs;
282:
283: /*
284: * The following is needed because my cpp does not have the
285: * #error directive...
286: */
287: #if ! HAVE_SELECT
288: no_select_sorry(); /* Sad way to fail make */
289: #endif
290:
291: paramv = &argv[2]; /* Parameters start at 2nd arg */
292: paramc = argc - 2; /* Number of live parameters */
293:
294: telno[0] = '\0';
295:
296: if (argc < 2)
297: {
298: fprintf(stderr, "%s: no script file supplied\n", argv[0]);
299: exit(FAIL);
300: }
301:
302: /*
303: * If the script file argument begins with '/', then we assume
304: * it is an absolute pathname, otherwise, we prepend the
305: * SCRIPT_DIR path.
306: */
307: *sfname = '\0'; /* Empty name string */
308: if(argv[1][0] != '/') /* If relative path */
309: strcat(sfname, SCRIPT_DIR); /* Prepend the default dir. */
310: strcat(sfname, argv[1]); /* Add the script file name */
311:
312: /*
313: * Now open the script file.
314: */
315: if ((sf = fopen(sfname, "r")) == NULL)
316: {
317: fprintf(stderr, "%s: Failed to open script %s\n", argv[0], sfname);
318: perror(" ");
319: exit(FAIL);
320: }
321:
322: /*
323: * COMPILE SCRIPT
324: */
325: if ((script = read_script(sf)) == NULL)
326: {
327: fprintf(stderr, "%s: script error in \"%s\"\n", argv[0], argv[1]);
328: exit(FAIL);
329: }
330:
331: /*
332: * Set up a signal catcher so the line can be returned to
333: * it's current state if something nasty happens.
334: */
335: sigs = &sigtbl[0];
336: while(sigs->signal)
337: {
338: sigs->o_catcher = (int (*) ())signal(sigs->signal, sigs->n_catcher);
339: sigs += 1;
340: }
341:
342: /*
343: * Save current tty settings, then set up raw, single
344: * character input processing, with 7-bit stripping.
345: */
346: setup_tty();
347:
348: /*
349: * EXECUTE SCRIPT
350: */
351: if ((stat = do_script(script)) != SUCCESS)
352: fprintf(stderr, "%s: script %s failed.\n", argv[0], argv[1]);
353:
354: /*
355: * Clean up and exit.
356: */
357: restore_tty();
358: #ifdef FIXSIGS
359: sigs = &sigtbl[0];
360: while(sigs->signal)
361: if(sigs->o_catcher != -1)
362: signal(sigs->signal, sigs->o_catcher);
363: #endif
364: exit(stat);
365: }
366:
367: /*
368: * deal_script - deallocate a script and all strings it points to
369: */
370: int deal_script(loc)
371: struct script *loc;
372: {
373: /*
374: * If pointer is null, just exit
375: */
376: if (loc == (struct script *)NULL)
377: return SUCCESS;
378:
379: /*
380: * Deallocate the rest of the script
381: */
382: deal_script(loc->next);
383:
384: /*
385: * Deallocate the string parameter, if any
386: */
387: if (loc->strprm != (char *)NULL)
388: free(loc->strprm);
389:
390: /*
391: * Deallocate the new state name parameter, if any
392: */
393: if (loc->newstate != (char *)NULL)
394: free(loc->newstate);
395:
396: /*
397: * Deallocate this entry
398: */
399: free(loc);
400:
401: return SUCCESS;
402: }
403:
404:
405: /*
406: * read_script
407: *
408: * Read & compile a script, return pointer to first entry, or null if bad
409: */
410: struct script *read_script(fd)
411: FILE *fd;
412: {
413: struct script *this = NULL;
414: struct script *prev = NULL;
415: struct script *first = NULL;
416: long len, i;
417: char inpline[MAX_SCLINE];
418: char inpcopy[MAX_SCLINE];
419: char *c, *cln, *opc, *cp;
420:
421: /*
422: * MAIN COMPILATION LOOP
423: */
424: while ((c = fgets(inpline, (sizeof inpline - 1), fd)) != (char *)NULL)
425: {
426: /*
427: * Skip comments and blank lines
428: */
429: if (*c == '#' || *c == '\n')
430: continue;
431:
432: /*
433: * Get rid of the trailing newline, and copy the string
434: */
435: inpline[strlen(inpline)-1] = '\0';
436: strcpy(inpcopy, inpline);
437:
438: /*
439: * Look for text starting in the first col (a label)
440: */
441: if ((!isspace(inpline[0])) &&
442: (cln = strchr (inpline, ':')) != (char *)NULL) {
443: this = (struct script *)malloc (sizeof (struct script));
444: if (prev != (struct script *)NULL)
445: prev->next = this;
446: prev = this;
447: if (first == (struct script *)NULL)
448: first = this;
449: this->next = (struct script *)NULL;
450: this->opcode = SC_LABEL;
451: len = cln - c;
452: this->strprm = (char *)malloc(len+1);
453: strncpy(this->strprm, c, len);
454: (this->strprm)[len] = '\0';
455: this->intprm = 0;
456: this->newstate = (char *)NULL;
457: c = cln + 1;
458: }
459:
460: /*
461: * Now handle the opcode. Fold it to lower case.
462: */
463: opc = strtok(c, CTL_DELIM);
464: if (opc == (char *)NULL) /* If no opcode... */
465: continue; /* ...read the next line */
466: cp = opc;
467: while(*cp)
468: tolower(*cp++);
469:
470: /*
471: * If we have an opcode but we haven't seen anything
472: * else (like a label) yet, i.e., this is the first
473: * entry, and there was no label. We need to
474: * cobble up a label so that read_script is happy
475: */
476: if (first == (struct script *)NULL)
477: {
478: this = (struct script *)malloc (sizeof (struct script));
479: prev = this;
480: first = this;
481: this->next = (struct script *)NULL;
482: this->opcode = SC_LABEL;
483: this->strprm = (char *)malloc(2);
484: strcpy(this->strprm, ":");
485: this->intprm = 0;
486: this->newstate = (char *)NULL;
487: }
488:
489: /*
490: * Find opcode - ndex through the opcode definition table
491: */
492: for (i=1; sc_opdef[i].opcode != SC_END; i++)
493: if (strcmp(opc, sc_opdef[i].opname) == SAME)
494: break;
495: if ((sc_opdef[i].opcode) == SC_END)
496: {
497: logit ("Bad opcode in script", opc);
498: deal_script(first);
499: return (struct script *)NULL;
500: }
501:
502: /*
503: * Found opcode. Allocate a new command node and initialize
504: */
505: this = (struct script *)malloc(sizeof (struct script));
506: prev->next = this;
507: prev = this;
508: this->next = (struct script *)NULL;
509: this->opcode = sc_opdef[i].opcode;
510: this->strprm = (char *)NULL;
511: this->intprm = 0;
512: this->newstate = (char *)NULL;
513:
514: /*
515: * Pick up new state parameter, if any
516: */
517: if (sc_opdef[i].newstate == SC_NWST)
518: {
519: c = strtok((char *)NULL, CTL_DELIM);
520: if (c == (char *)NULL)
521: {
522: logit("Missing new state", opc);
523: deal_script(first);
524: return (struct script *)NULL;
525: }
526: else
527: {
528: this->newstate = (char *)malloc(strlen(c)+1);
529: strcpy(this->newstate, c);
530: }
531: }
532:
533: /*
534: * Pick up the string or integer parameter. Handle missing
535: * parameter gracefully.
536: */
537: switch (sc_opdef[i].prmtype)
538: {
539: /*
540: * INT parameter - convert and store in node
541: */
542: case SC_INT:
543: c = strtok((char *)NULL, CTL_DELIM);
544: if (c == (char *)NULL)
545: {
546: logit("Missing script param", opc);
547: deal_script(first);
548: return (struct script *)NULL;
549: }
550: /*
551: * If this is the parameter to DBST or DBCL, force
552: * base-10 conversion, else convert per parameter.
553: */
554: if (sc_opdef[i].opcode == SC_DBST ||
555: sc_opdef[i].opcode == SC_DBCL)
556: this->intprm = strtol(c, (char **)NULL, 0);
557: else
558: this->intprm = strtol(c, (char **)NULL, 10);
559: break;
560:
561: /*
562: * STR/XSTR strings.
563: */
564: case SC_STR:
565: case SC_XSTR:
566: c = strtok((char *)NULL, CTL_DELIM);
567: if (c == (char *)NULL)
568: {
569: logit("Missing script param", opc);
570: deal_script(first);
571: return (struct script *)NULL;
572: }
573: /*
574: * For XSTR opcode, use c to find out where
575: * the string param begins in the copy of the
576: * input line, and pick up all that's left of
577: * the line (to allow imbedded blanks, etc.).
578: */
579: if (sc_opdef[i].prmtype == SC_XSTR)
580: c = &inpcopy[0] + (c - &inpline[0]);
581:
582: /*
583: * Allocate a buffer for the string parameter
584: */
585: this->strprm = (char *)malloc(strlen(c)+1);
586:
587: /*
588: * For XSTR, Translate the string and store its
589: * length. Note that, after escape sequences are
590: * compressed, the resulting string may well be a
591: * few bytes shorter than the input string (whose
592: * length was the basis for the malloc above),
593: * but it will never be longer.
594: */
595: if (sc_opdef[i].prmtype == SC_XSTR)
596: {
597: this->intprm = xlat_str(this->strprm, c);
598: this->strprm[this->intprm] = '\0';
599: }
600: else
601: strcpy(this->strprm, c);
602: break;
603:
604: }
605: }
606:
607: /*
608: * EOF
609: */
610: return first;
611: }
612:
613:
614: /*
615: * xlat_str
616: *
617: * Translate embedded escape characters in a "send" or "expect" string.
618: *
619: * Called by read_script(), above.
620: *
621: * Returns the actual length of the resulting string. Note that imbedded
622: * nulls (specified by \000 in the input) ARE allowed in the result.
623: */
624: xlat_str(out, in)
625: char *out, *in;
626: {
627: register int i = 0, j = 0;
628: int byte, k;
629:
630: while (in[i])
631: {
632: if (in[i] != '\\')
633: {
634: out[j++] = in[i++];
635: }
636: else
637: {
638: switch (in[++i])
639: {
640: case 'd': /* EOT */
641: out[j++] = 0x04;
642: break;
643: case 'N': /* null */
644: out[j++] = 0x00;
645: break;
646: case 'n': /* line feed */
647: out[j++] = 0x0a;
648: break;
649: case 'r': /* carriage return */
650: out[j++] = 0x0d;
651: break;
652: case 's': /* space */
653: out[j++] = ' ';
654: break;
655: case 't': /* tab */
656: out[j++] = '\t';
657: break;
658: case '-': /* hyphen */
659: out[j++] = '-';
660: break;
661: case '\\': /* back slash */
662: out[j++] = '\\';
663: break;
664: case '0': /* '\nnn' format */
665: case '1':
666: case '2':
667: case '3':
668: case '4':
669: case '5':
670: case '6':
671: case '7':
672: byte = in[i] - '0';
673: k = 0;
674:
675: while (3 > ++k)
676: if ((in[i+1] < '0') || (in[i+1] > '7'))
677: break;
678: else
679: {
680: byte = (byte<<3) + in[i+1] - '0';
681: ++i;
682: }
683: out[j++] = byte;
684: break;
685: default: /* don't know so skip it */
686: break;
687: }
688: ++i;
689: }
690: }
691: return j;
692: }
693:
694:
695: /* find a state within a script */
696:
697: struct script *
698: find_state(begin, newstate)
699: struct script *begin;
700: char *newstate;
701: {
702: struct script *here;
703:
704: for (here=begin; here != (struct script *)NULL; here=here->next) {
705: if (here->opcode == SC_LABEL &&
706: strcmp(here->strprm, newstate) == SAME)
707: return here;
708: }
709: return (struct script *)NULL;
710: }
711:
712:
713: /*
714: * do_script() - execute a script
715: */
716: int do_script(begin)
717: struct script *begin;
718: {
719: struct script *curstate, *newstate, *curscr;
720: int dbgsave;
721: char tempstr[MAX_SCLINE];
722: char dfname[256];
723: char *c, chr;
724: int prmlen;
725: int dbfd;
726:
727: time_t sc_carrtime = 45000; /* time to wf carr after dial */
728: time_t sc_chrdly = 100; /* delay time for ttoslow */
729: time_t sc_ptime = 2000; /* time to allow for pause char */
730: time_t sc_wtime = 10000; /* time to allow for wait char */
731: time_t sc_dtime = 100; /* time to allow for each digit */
732: time_t sc_dtmo; /* total time to dial number */
733: int sc_counter; /* random counter */
734: char sc_pchar = ','; /* modem pause character */
735: char sc_wchar = 'W'; /* modem wait-for-dialtone character */
736: time_t sc_begwait; /* time at beg of wait */
737: time_t sc_secs; /* timeout period */
738:
739: int expcnt;
740: int expin;
741: static char expbuf[MAX_EXPCT];
742:
743: dbgsave = Debug;
744: curstate = begin;
745:
746: if (curstate == (struct script *)NULL)
747: return SUCCESS;
748:
749: _newstate:
750: /*
751: * do all of curstate's actions. Enter with curstate pointing
752: * to a label entry
753: */
754: expin = 0;
755:
756: for (curscr = curstate->next; /* point to 1st scr after label */
757: (curscr != (struct script *)NULL) && /* do until end of scr */
758: (curscr->opcode != SC_LABEL); /* or next label */
759: curscr = curscr->next)
760: {
761: expcnt = 0;
762: switch (curscr->opcode)
763: {
764: case SC_LABEL:
765: logit("Script proc err", curstate->strprm);
766: return FAIL;
767:
768: case SC_FLSH:
769: DEBUG(DB_LGII, "Flushing typeahead buffer\n", 0);
770: ttflui();
771: break;
772:
773: case SC_CDLY:
774: sc_chrdly = curscr->intprm;
775: DEBUG(DB_LGII, "Set chrdly to %d\n", sc_chrdly);
776: break;
777:
778: case SC_PCHR:
779: sc_pchar = *(curscr->strprm);
780: DEBUG(DB_LGII, "Set pause char to %c\n", sc_pchar);
781: break;
782:
783: case SC_PTIM:
784: sc_ptime = curscr->intprm;
785: DEBUG(DB_LGII, "Set pause time to %d\n", sc_ptime);
786: break;
787:
788: case SC_WCHR:
789: sc_wchar = *(curscr->strprm);
790: DEBUG(DB_LGII, "Set wait char to %c\n", sc_wchar);
791: break;
792:
793: case SC_WTIM:
794: sc_wtime = curscr->intprm;
795: DEBUG(DB_LGII, "Set wait time to %d\n", sc_wtime);
796: break;
797:
798: case SC_ZERO:
799: sc_counter = 0;
800: DEBUG(DB_LGII, "Set counter to %d\n", sc_counter);
801: break;
802:
803: case SC_INCR:
804: sc_counter++;
805: DEBUG(DB_LGII, "Incr counter to %d\n", sc_counter);
806: break;
807:
808: case SC_WAIT:
809: DEBUG(DB_LGII, "Sleeping %d tenth-secs\n", curscr->intprm);
810: msleep(curscr->intprm);
811: break;
812:
813: case SC_DTIM:
814: sc_dtime = curscr->intprm;
815: DEBUG(DB_LGII, "Digit time is %d\n", sc_dtime);
816: break;
817:
818: case SC_CTIM:
819: sc_carrtime = curscr->intprm;
820: DEBUG(DB_LGII, "Carrier time is %d\n", sc_carrtime);
821: break;
822:
823: case SC_EXIT:
824: Debug = dbgsave;
825: DEBUG(DB_LGI, "Script ended successfully\n", 0);
826: return SUCCESS;
827:
828: case SC_FAIL:
829: Debug = dbgsave;
830: if (DEBUG_LEVEL(DB_LGI) && dbf != NULL)
831: fprintf(dbf, "Script failed\n");
832: else if (expin)
833: charlog(expbuf, expin, DB_LOG,
834: "Script failed. Last received data");
835: return FAIL;
836:
837: case SC_LOG:
838: logit(curscr->strprm, "");
839: break;
840:
841: case SC_LOGE:
842: logit("ERROR: ", curscr->strprm);
843: break;
844:
845: case SC_DBOF:
846: /*
847: * If the debug file name does not begin with "/", then
848: * we prepend the LOG_DIR to the string. Then CREATE the
849: * file. This WIPES OUT previous logs.
850: */
851: *dfname = '\0'; /* Zero name string */
852: if(curscr->strprm[0] != '/')
853: strcat(dfname, LOG_DIR); /* Prepend default directory */
854: strcat(dfname, curscr->strprm); /* Add given string */
855: DEBUG(DB_LGII, "Open debug file %s\n", dfname);
856: if ((dbfd = creat (dfname, 0600)) <= 0)
857: {
858: logit("Failed to create debug log %s", dfname);
859: perror("");
860: return FAIL;
861: }
862: if ((dbf = fdopen(dbfd, "w")) == NULL)
863: {
864: logit("Failed to open debug log fildes.", "");
865: perror("");
866: return FAIL;
867: }
868: break;
869:
870: case SC_DBG:
871: DEBUG(DB_LGI, "<%s>\n", curscr->strprm);
872: break;
873:
874: case SC_DBGE:
875: DEBUG(DB_LGIE, "ERROR: <%s>\n", curscr->strprm);
876: break;
877:
878: case SC_DBST:
879: Debug |= curscr->intprm;
880: DEBUG(DB_LGII, "Debug mask set to %04o (octal)\n", Debug);
881: break;
882:
883: case SC_DBCL:
884: Debug &= ~(curscr->intprm);
885: DEBUG(DB_LGII, "Debug mask set to %04o (octal)\n", Debug);
886: break;
887:
888: case SC_BRK:
889: DEBUG(DB_LGI, "Sending break\n", 0);
890: ttbreak();
891: break;
892:
893: case SC_HANG:
894: DEBUG(DB_LGI, "Dropping DTR\n", 0);
895: tthang();
896: break;
897:
898: case SC_7BIT:
899: DEBUG(DB_LGI, "Enabling 7-bit stripping\n", 0);
900: tt7bit(TRUE);
901: break;
902:
903: case SC_8BIT:
904: DEBUG(DB_LGI, "Disabling 7-bit stripping\n", 0);
905: tt7bit(FALSE);
906: break;
907:
908: case SC_PNON:
909: DEBUG(DB_LGI, "Setting 8-bit, no parity\n", 0);
910: ttpar(NONE);
911: break;
912:
913: case SC_PEVN:
914: DEBUG(DB_LGI, "Setting 7-bit, even parity\n", 0);
915: ttpar(EVEN);
916: break;
917:
918: case SC_PODD:
919: DEBUG(DB_LGI, "Setting 7-bit, odd parity\n", 0);
920: ttpar(ODD);
921: break;
922:
923: case SC_IFBL:
924: if (ttblind())
925: {
926: DEBUG(DB_LGI, "Blind mux,\n", 0);
927: goto _chgstate;
928: }
929: break;
930:
931: case SC_IFBG:
932: if (ttblind() && sc_counter > curscr->intprm)
933: {
934: DEBUG(DB_LGI, "Blind mux & ctr > %d\n",
935: curscr->intprm);
936: goto _chgstate;
937: }
938: break;
939:
940: case SC_IFGT:
941: if (sc_counter > curscr->intprm)
942: {
943: DEBUG(DB_LGI, "Counter > %d\n", curscr->intprm);
944: goto _chgstate;
945: }
946: break;
947:
948: case SC_GOTO:
949: _chgstate:
950: DEBUG(DB_LGI, "Changing to state %s\n",
951: curscr->newstate);
952: curstate = find_state(begin, curscr->newstate);
953: if (curstate == NULL)
954: {
955: logit("New state not found",
956: curscr->newstate);
957: return FAIL;
958: }
959: goto _newstate;
960:
961: case SC_SEND:
962: ttoslow(curscr->strprm, curscr->intprm, sc_chrdly);
963: break;
964:
965: case SC_TELN:
966: if (curscr->intprm > paramc - 1)
967: {
968: sprintf(tempstr, "telno - param #%d", curscr->intprm);
969: logit(tempstr, " not present");
970: return FAIL;
971: }
972: strcpy(telno, paramv[curscr->intprm]);
973: DEBUG(DB_LGII, "telno set to %s\n", telno);
974: break;
975:
976: case SC_SNDP:
977: if (curscr->intprm > paramc - 1)
978: {
979: sprintf(tempstr, "sendstr - param #%d", curscr->intprm);
980: logit(tempstr, " not present");
981: return FAIL;
982: }
983: prmlen = xlat_str(tempstr, paramv[curscr->intprm]);
984: ttoslow(tempstr, prmlen, sc_chrdly);
985: break;
986:
987: case SC_IF1P:
988: if (curscr->intprm < paramc)
989: goto _chgstate;
990: break;
991:
992: case SC_IF0P:
993: if (curscr->intprm >= paramc)
994: goto _chgstate;
995: break;
996:
997: case SC_DIAL:
998: if(telno[0] == '\0')
999: {
1000: logit("telno not set", "");
1001: return(FAIL);
1002: }
1003: /*
1004: * Compute and set a default timeout for the 'timeout'
1005: * command. Some parameters in this computation may be
1006: * changed by the script. See the man page xchat(8) for
1007: * details.
1008: */
1009: sc_dtmo = (sc_dtime+sc_chrdly)*strlen(telno)
1010: + sc_carrtime;
1011: c=strcpy(tempstr, telno);
1012: for (; *c!='\0'; c++)
1013: {
1014: if (*c == 'W')
1015: {
1016: *c = sc_wchar;
1017: sc_dtmo += sc_wtime;
1018: }
1019: else if (*c == 'P')
1020: {
1021: *c = sc_pchar;
1022: sc_dtmo += sc_ptime;
1023: }
1024: }
1025: DEBUG(DB_LGI, "Dialing, default timeout is %d millisecs\n", sc_dtmo);
1026: ttoslow(tempstr, 0, sc_chrdly);
1027: break;
1028:
1029: case SC_TIMO: /* these are "expects", don't bother */
1030: case SC_XPCT: /* with them yet, other than noting that */
1031: case SC_CARR: /* they exist */
1032: expcnt++;
1033: break;
1034: }
1035:
1036: }
1037:
1038: /* we've done the current state's actions, now do its expects, if any */
1039:
1040: if (expcnt == 0)
1041: {
1042: if (curscr != (struct script *)NULL &&
1043: (curscr->opcode == SC_LABEL))
1044: {
1045: curstate = curscr;
1046: DEBUG(DB_LGI, "Fell through to state %s\n",
1047: curstate->strprm);
1048: goto _newstate;
1049: }
1050: else
1051: {
1052: logit("No way out of state", curstate->strprm);
1053: return FAIL;
1054: }
1055: }
1056:
1057: time(&sc_begwait); /* log time at beg of expect */
1058: DEBUG(DB_LGI, "Doing expects for state %s\n", curstate->strprm);
1059: charlog((char *)NULL, 0, DB_LGI, "Received");
1060:
1061: while (1)
1062: {
1063: chr = xgetc(1); /* Returns upon char input or 1 sec. tmo */
1064:
1065: charlog(&chr, 1, DB_LGI, (char *)NULL);
1066:
1067: if (chr != EOF)
1068: {
1069: if (expin < MAX_EXPCT)
1070: {
1071: expbuf[expin++] = chr & 0x7f;
1072: }
1073: else
1074: {
1075: strncpy(expbuf, &expbuf[1], MAX_EXPCT-1);
1076: expbuf[MAX_EXPCT-1] = chr & 0x7f;
1077: }
1078: }
1079:
1080: /* for each entry in the current state... */
1081:
1082: for (curscr = curstate->next;
1083: (curscr != (struct script *)NULL) &&
1084: (curscr->opcode != SC_LABEL);
1085: curscr = curscr->next)
1086: {
1087:
1088: switch (curscr->opcode)
1089: {
1090: case SC_TIMO:
1091: sc_secs = curscr->intprm;
1092: if (sc_secs == 0)
1093: sc_secs = sc_dtmo;
1094: sc_secs /= 1000;
1095: if (time(NULL)-sc_begwait > sc_secs)
1096: {
1097: DEBUG(DB_LGI,
1098: "\nTimed out (%d secs)\n", sc_secs);
1099: goto _chgstate;
1100: }
1101: break;
1102:
1103: case SC_CARR:
1104: if (ttcd())
1105: {
1106: DEBUG(DB_LGI, "\nGot carrier\n", 0);
1107: goto _chgstate;
1108: }
1109: break;
1110:
1111: case SC_HUPS:
1112: if (fShangup)
1113: {
1114: DEBUG(DB_LGI, "\nGot data set hangup\n", 0);
1115: goto _chgstate;
1116: }
1117: break;
1118:
1119: case SC_XPCT:
1120: if ((expin >= curscr->intprm) &&
1121: (strncmp(curscr->strprm,
1122: &expbuf[expin - curscr->intprm],
1123: curscr->intprm) == SAME))
1124: {
1125: charlog(curscr->strprm, curscr->intprm,
1126: DB_LGI, "Matched");
1127: goto _chgstate;
1128: }
1129: break;
1130:
1131: }
1132: }
1133: }
1134: }
1135:
1136: /*
1137: * SIGNAL HANDLERS
1138: */
1139:
1140: /*
1141: * usignal - generic signal catcher
1142: */
1143: static int usignal(isig)
1144: int isig;
1145: {
1146: DEBUG(DB_LOG, "Caught signal %d. Exiting...\n", isig);
1147: restore_tty();
1148: exit(FAIL);
1149: }
1150:
1151: /*
1152: * uhup - HUP catcher
1153: */
1154: static int uhup(isig)
1155: int isig;
1156: {
1157: DEBUG(DB_LOG, "Data set hangup.\n");
1158: fShangup = TRUE;
1159: }
1160:
1161: /*
1162: * TERMINAL I/O ROUTINES
1163: */
1164:
1165: /*
1166: * xgetc - get a character with timeout
1167: *
1168: * Assumes that stdin is opened on a terminal or TCP socket
1169: * with O_NONBLOCK.
1170: */
1171: static char xgetc(tmo)
1172: int tmo; /* Timeout, seconds */
1173: {
1174: char c;
1175: struct timeval s;
1176: int f = 1; /* Select on stdin */
1177: int result;
1178:
1179: if(read(0, &c, 1) <= 0) /* If no data available */
1180: {
1181: s.tv_sec = (long)tmo;
1182: s.tv_usec = 0L;
1183: if(select (1, &f, (int *) NULL, &f, &s) == 1)
1184: read(0, &c, 1);
1185: else
1186: c = '\377';
1187: }
1188:
1189: return(c);
1190: }
1191:
1192: /*
1193: * Pause for an interval in milliseconds
1194: */
1195: void msleep(msec)
1196: long msec;
1197: {
1198:
1199: #if HAVE_USLEEP
1200: if(msec == 0) /* Skip all of this if delay = 0 */
1201: return;
1202: usleep (msec * (long)1000);
1203: #endif /* HAVE_USLEEP */
1204:
1205: #if HAVE_NAPMS
1206: if(msec == 0) /* Skip all of this if delay = 0 */
1207: return;
1208: napms (msec);
1209: #endif /* HAVE_NAPMS */
1210:
1211: #if HAVE_NAP
1212: if(msec == 0) /* Skip all of this if delay = 0 */
1213: return;
1214: nap (msec);
1215: #endif /* HAVE_NAP */
1216:
1217: #if HAVE_POLL
1218: struct pollfd sdummy;
1219:
1220: if(msec == 0)
1221: return;
1222: /*
1223: * We need to pass an unused pollfd structure because poll checks
1224: * the address before checking the number of elements.
1225: */
1226: poll (&sdummy, 0, msec);
1227: #endif /* HAVE_POLL */
1228:
1229: #if USE_SELECT_TIMER
1230: struct timeval s;
1231:
1232: if(msec == 0)
1233: return;
1234: s.tv_sec = msec / 1000L;
1235: s.tv_usec = (msec % 1000L) * 1000L;
1236: select (0, (int *) NULL, (int *) NULL, (int *) NULL, &s);
1237: #endif /* USE_SELECT_TIMER */
1238:
1239: #if ! HAVE_NAPMS && ! HAVE_NAP && ! HAVE_USLEEP && \
1240: ! HAVE_POLL && ! USE_SELECT_TIMER
1241: if(msec == 0)
1242: return;
1243: sleep (1); /* Sleep for a whole second (UGH!) */
1244: #endif /* HAVE_ and USE_ nothing */
1245: }
1246:
1247: /*
1248: * Debugging output
1249: */
1250: static void DEBUG(level, msg1, msg2)
1251: int level;
1252: char *msg1, *msg2;
1253: {
1254: if ((dbf != NULL) && DEBUG_LEVEL(level))
1255: fprintf(dbf, msg1, msg2);
1256: }
1257:
1258: /*
1259: * charlog - log a string of characters
1260: *
1261: * SPECIAL CASE: msg=NULL, len=1 and msg[0]='\377' gets logged
1262: * when read does its 1 sec. timeout. Log "<1 sec.>"
1263: * so user can see elapsed time
1264: */
1265: static void charlog(buf, len, mask, msg)
1266: char *buf;
1267: int len, mask;
1268: char *msg;
1269: {
1270: char tbuf[256];
1271:
1272: if (DEBUG_LEVEL(mask) && dbf != NULL)
1273: {
1274: if(msg == (char *)NULL)
1275: msg = "";
1276: strncpy(tbuf, buf, len);
1277: tbuf[len] = '\0';
1278: if(len == 1 && tbuf[0] == '\377')
1279: strcpy(tbuf, "<1 sec.>");
1280: fprintf(dbf, "%s %s\n", msg, tbuf);
1281: }
1282: }
1283:
1284: /*
1285: * setup_tty()
1286: *
1287: * Save current tty settings, then set up raw, single
1288: * character input processing, with 7-bit stripping.
1289: */
1290: static void setup_tty()
1291: {
1292: register int i;
1293:
1294: ioctl(0, TCGETA, &old);
1295:
1296: new = old;
1297:
1298: for(i = 0; i < 7; i++)
1299: new.c_cc[i] = '\0';
1300: new.c_cc[VMIN] = 0; /* MIN = 0, use requested count */
1301: new.c_cc[VTIME] = 10; /* TIME = 1 sec. */
1302: new.c_iflag = ISTRIP; /* Raw mode, 7-bit stripping */
1303: new.c_lflag = 0; /* No special line discipline */
1304:
1305: ioctl(0, TCSETA, &new);
1306: }
1307:
1308: /*
1309: * restore_tty() - restore signal handlers and tty modes on exit.
1310: */
1311: static void restore_tty(sig)
1312: int sig;
1313: {
1314: ioctl(0, TCSETA, &old);
1315: return;
1316: }
1317:
1318: /*
1319: * ttoslow() - Send characters with pacing delays
1320: */
1321: static void ttoslow(s, len, delay)
1322: char *s;
1323: int len;
1324: time_t delay;
1325: {
1326: int i;
1327:
1328: if (len == 0)
1329: len = strlen(s);
1330:
1331: charlog (s, len, DB_LGI, "Sending slowly");
1332:
1333: for (i = 0; i < len; i++, s++)
1334: {
1335: write(1, s, 1);
1336: msleep(delay);
1337: }
1338: }
1339:
1340: /*
1341: * ttflui - flush input buffer
1342: */
1343: static void ttflui()
1344: {
1345: if(isatty(0))
1346: (void) ioctl ( 0, TCFLSH, 0);
1347: }
1348:
1349: /*
1350: * ttcd - Test if carrier is present
1351: *
1352: * NOT IMPLEMENTED. I don't know how!!!
1353: */
1354: static int ttcd()
1355: {
1356: return TRUE;
1357: }
1358:
1359: /*
1360: * tthang - Force DTR low for 1-2 sec.
1361: */
1362: static void tthang()
1363: {
1364: if(!isatty())
1365: return;
1366:
1367: #ifdef TCCLRDTR
1368: (void) ioctl (1, TCCLRDTR, 0);
1369: sleep (2);
1370: (void) ioctl (1, TCSETDTR, 0);
1371: #endif
1372:
1373: return;
1374: }
1375:
1376: /*
1377: * ttbreak - Send a "break" on the line
1378: */
1379: static void ttbreak()
1380: {
1381: (void) ioctl (1, TCSBRK, 0);
1382: }
1383:
1384: /*
1385: * ttblind - return TRUE if tty is "blind"
1386: *
1387: * NOT IMPLEMENTED - Don't know how!!!
1388: */
1389: static int ttblind()
1390: {
1391: return FALSE;
1392: }
1393:
1394: /*
1395: * tt7bit - enable/disable 7-bit stripping on line
1396: */
1397: static void tt7bit(enable)
1398: int enable;
1399: {
1400: if(enable)
1401: new.c_iflag |= ISTRIP;
1402: else
1403: new.c_iflag &= ~ISTRIP;
1404:
1405: ioctl(0, TCSETA, &new);
1406: }
1407:
1408: /*
1409: * ttpar - Set parity mode on line. Ignore parity errors on input.
1410: */
1411: static void ttpar(mode)
1412: int mode;
1413: {
1414: switch(mode)
1415: {
1416: case NONE:
1417: new.c_iflag &= ~(INPCK | IGNPAR);
1418: new.c_cflag &= ~(CSIZE | PARENB | PARODD);
1419: new.c_cflag |= CS8;
1420: break;
1421:
1422: case EVEN:
1423: new.c_iflag |= (INPCK | IGNPAR);
1424: new.c_cflag &= ~(CSIZE | PARODD);
1425: new.c_cflag |= (CS7 | PARENB);
1426:
1427: break;
1428:
1429: case ODD:
1430: new.c_iflag |= (INPCK | IGNPAR);
1431: new.c_cflag &= ~(CSIZE);
1432: new.c_cflag |= (CS7 | PARENB | PARODD);
1433: break;
1434: }
1435:
1436: ioctl(0, TCSETA, &new);
1437: }
1438:
1439:
1440:
1441:
1442:
1443:
1444:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.