chat.c (8874) | chat.c (11990) |
---|---|
1/* 2 * Chat -- a program for automatic session establishment (i.e. dial 3 * the phone and log in). 4 * | 1/* 2 * Chat -- a program for automatic session establishment (i.e. dial 3 * the phone and log in). 4 * |
5 * Standard termination codes: 6 * 0 - successful completion of the script 7 * 1 - invalid argument, expect string too large, etc. 8 * 2 - error on an I/O operation or fatal error condtion. 9 * 3 - timeout waiting for a simple string. 10 * 4 - the first string declared as "ABORT" 11 * 5 - the second string declared as "ABORT" 12 * 6 - ... and so on for successive ABORT strings. 13 * |
|
5 * This software is in the public domain. 6 * 7 * Please send all bug reports, requests for information, etc. to: 8 * 9 * Al Longyear (longyear@netcom.com) 10 * (I was the last person to change this code.) 11 * | 14 * This software is in the public domain. 15 * 16 * Please send all bug reports, requests for information, etc. to: 17 * 18 * Al Longyear (longyear@netcom.com) 19 * (I was the last person to change this code.) 20 * |
21 * Added -r "report file" switch & REPORT keyword. 22 * Robert Geer <bgeer@xmission.com> 23 * |
|
12 * The original author is: 13 * 14 * Karl Fox <karl@MorningStar.Com> 15 * Morning Star Technologies, Inc. 16 * 1760 Zollinger Road 17 * Columbus, OH 43221 18 * (614)451-1883 | 24 * The original author is: 25 * 26 * Karl Fox <karl@MorningStar.Com> 27 * Morning Star Technologies, Inc. 28 * 1760 Zollinger Road 29 * Columbus, OH 43221 30 * (614)451-1883 |
31 * |
|
19 */ 20 | 32 */ 33 |
21static char rcsid[] = "$Id: chat.c,v 1.2 1994/12/19 01:02:11 ache Exp $"; | 34static char rcsid[] = "$Id: chat.c,v 1.1.1.1 1994/11/12 05:25:32 lars Exp $"; |
22 23#include <stdio.h> | 35 36#include <stdio.h> |
37#include <time.h> |
|
24#include <fcntl.h> 25#include <signal.h> 26#include <errno.h> 27#include <string.h> 28#include <stdlib.h> 29#include <sys/types.h> 30#include <sys/stat.h> 31#include <syslog.h> 32 33#ifndef TERMIO 34#undef TERMIOS 35#define TERMIOS 36#endif 37 | 38#include <fcntl.h> 39#include <signal.h> 40#include <errno.h> 41#include <string.h> 42#include <stdlib.h> 43#include <sys/types.h> 44#include <sys/stat.h> 45#include <syslog.h> 46 47#ifndef TERMIO 48#undef TERMIOS 49#define TERMIOS 50#endif 51 |
38#ifdef sun 39# if defined(SUNOS) && SUNOS >= 41 40# ifndef HDB 41# define HDB 42# endif 43# endif 44#endif 45 | |
46#ifdef TERMIO 47#include <termio.h> 48#endif 49#ifdef TERMIOS 50#include <termios.h> 51#endif 52 53#define STR_LEN 1024 --- 5 unchanged lines hidden (view full) --- 59#ifdef __STDC__ 60#undef __P 61#define __P(x) x 62#else 63#define __P(x) () 64#define const 65#endif 66 | 52#ifdef TERMIO 53#include <termio.h> 54#endif 55#ifdef TERMIOS 56#include <termios.h> 57#endif 58 59#define STR_LEN 1024 --- 5 unchanged lines hidden (view full) --- 65#ifdef __STDC__ 66#undef __P 67#define __P(x) x 68#else 69#define __P(x) () 70#define const 71#endif 72 |
73#ifndef O_NONBLOCK 74#define O_NONBLOCK O_NDELAY 75#endif 76 |
|
67/*************** Micro getopt() *********************************************/ 68#define OPTION(c,v) (_O&2&&**v?*(*v)++:!c||_O&4?0:(!(_O&1)&& \ 69 (--c,++v),_O=4,c&&**v=='-'&&v[0][1]?*++*v=='-'\ 70 &&!v[0][1]?(--c,++v,0):(_O=2,*(*v)++):0)) 71#define OPTARG(c,v) (_O&2?**v||(++v,--c)?(_O=1,--c,*v++): \ 72 (_O=4,(char*)0):(char*)0) 73#define OPTONLYARG(c,v) (_O&2&&**v?(_O=1,--c,*v++):(char*)0) 74#define ARG(c,v) (c?(--c,*v++):(char*)0) 75 76static int _O = 0; /* Internal state */ 77/*************** Micro getopt() *********************************************/ 78 79char *program_name; 80 | 77/*************** Micro getopt() *********************************************/ 78#define OPTION(c,v) (_O&2&&**v?*(*v)++:!c||_O&4?0:(!(_O&1)&& \ 79 (--c,++v),_O=4,c&&**v=='-'&&v[0][1]?*++*v=='-'\ 80 &&!v[0][1]?(--c,++v,0):(_O=2,*(*v)++):0)) 81#define OPTARG(c,v) (_O&2?**v||(++v,--c)?(_O=1,--c,*v++): \ 82 (_O=4,(char*)0):(char*)0) 83#define OPTONLYARG(c,v) (_O&2&&**v?(_O=1,--c,*v++):(char*)0) 84#define ARG(c,v) (c?(--c,*v++):(char*)0) 85 86static int _O = 0; /* Internal state */ 87/*************** Micro getopt() *********************************************/ 88 89char *program_name; 90 |
81#ifndef LOCK_DIR 82# if defined(__NetBSD__) || defined(__FreeBSD__) 83# define PIDSTRING 84# define LOCK_DIR "/var/spool/lock" 85# else 86# ifdef HDB 87# define PIDSTRING 88# define LOCK_DIR "/usr/spool/locks" 89# else /* HDB */ 90# define LOCK_DIR "/usr/spool/uucp" 91# endif /* HDB */ 92# endif 93#endif /* LOCK_DIR */ 94 | |
95#define MAX_ABORTS 50 | 91#define MAX_ABORTS 50 |
92#define MAX_REPORTS 50 |
|
96#define DEFAULT_CHAT_TIMEOUT 45 97 | 93#define DEFAULT_CHAT_TIMEOUT 45 94 |
98int verbose = 0; 99int quiet = 0; 100char *lock_file = (char *)0; 101char *chat_file = (char *)0; 102int timeout = DEFAULT_CHAT_TIMEOUT; | 95int verbose = 0; 96int quiet = 0; 97int report = 0; 98int exit_code = 0; 99FILE* report_fp = (FILE *) 0; 100char *report_file = (char *) 0; 101char *chat_file = (char *) 0; 102int timeout = DEFAULT_CHAT_TIMEOUT; |
103 104int have_tty_parameters = 0; | 103 104int have_tty_parameters = 0; |
105 |
|
105#ifdef TERMIO | 106#ifdef TERMIO |
107#define term_parms struct termio 108#define get_term_param(param) ioctl(0, TCGETA, param) 109#define set_term_param(param) ioctl(0, TCSETA, param) |
|
106struct termio saved_tty_parameters; 107#endif | 110struct termio saved_tty_parameters; 111#endif |
112 |
|
108#ifdef TERMIOS | 113#ifdef TERMIOS |
114#define term_parms struct termios 115#define get_term_param(param) tcgetattr(0, param) 116#define set_term_param(param) tcsetattr(0, TCSANOW, param) |
|
109struct termios saved_tty_parameters; 110#endif 111 112char *abort_string[MAX_ABORTS], *fail_reason = (char *)0, 113 fail_buffer[50]; 114int n_aborts = 0, abort_next = 0, timeout_next = 0; 115 | 117struct termios saved_tty_parameters; 118#endif 119 120char *abort_string[MAX_ABORTS], *fail_reason = (char *)0, 121 fail_buffer[50]; 122int n_aborts = 0, abort_next = 0, timeout_next = 0; 123 |
124char *report_string[MAX_REPORTS] ; 125char report_buffer[50] ; 126int n_reports = 0, report_next = 0, report_gathering = 0 ; 127 |
|
116void *dup_mem __P((void *b, size_t c)); 117void *copy_of __P((char *s)); 118void usage __P((void)); 119void logf __P((const char *str)); 120void logflush __P((void)); 121void fatal __P((const char *msg)); 122void sysfatal __P((const char *msg)); 123SIGTYPE sigalrm __P((int signo)); 124SIGTYPE sigint __P((int signo)); 125SIGTYPE sigterm __P((int signo)); 126SIGTYPE sighup __P((int signo)); 127void unalarm __P((void)); 128void init __P((void)); 129void set_tty_parameters __P((void)); 130void break_sequence __P((void)); 131void terminate __P((int status)); 132void do_file __P((char *chat_file)); | 128void *dup_mem __P((void *b, size_t c)); 129void *copy_of __P((char *s)); 130void usage __P((void)); 131void logf __P((const char *str)); 132void logflush __P((void)); 133void fatal __P((const char *msg)); 134void sysfatal __P((const char *msg)); 135SIGTYPE sigalrm __P((int signo)); 136SIGTYPE sigint __P((int signo)); 137SIGTYPE sigterm __P((int signo)); 138SIGTYPE sighup __P((int signo)); 139void unalarm __P((void)); 140void init __P((void)); 141void set_tty_parameters __P((void)); 142void break_sequence __P((void)); 143void terminate __P((int status)); 144void do_file __P((char *chat_file)); |
133void lock __P((void)); 134void delay __P((void)); | |
135int get_string __P((register char *string)); 136int put_string __P((register char *s)); 137int write_char __P((int c)); | 145int get_string __P((register char *string)); 146int put_string __P((register char *s)); 147int write_char __P((int c)); |
138int put_char __P((char c)); | 148int put_char __P((int c)); |
139int get_char __P((void)); 140void chat_send __P((register char *s)); | 149int get_char __P((void)); 150void chat_send __P((register char *s)); |
141char *character __P((char c)); | 151char *character __P((int c)); |
142void chat_expect __P((register char *s)); 143char *clean __P((register char *s, int sending)); | 152void chat_expect __P((register char *s)); 153char *clean __P((register char *s, int sending)); |
144void unlock __P((void)); 145void lock __P((void)); | |
146void break_sequence __P((void)); 147void terminate __P((int status)); 148void die __P((void)); 149 150void *dup_mem(b, c) 151void *b; 152size_t c; 153 { 154 void *ans = malloc (c); 155 if (!ans) | 154void break_sequence __P((void)); 155void terminate __P((int status)); 156void die __P((void)); 157 158void *dup_mem(b, c) 159void *b; 160size_t c; 161 { 162 void *ans = malloc (c); 163 if (!ans) |
164 { |
|
156 fatal ("memory error!\n"); | 165 fatal ("memory error!\n"); |
166 } |
|
157 memcpy (ans, b, c); 158 return ans; 159 } 160 161void *copy_of (s) 162char *s; 163 { 164 return dup_mem (s, strlen (s) + 1); 165 } 166 167/* | 167 memcpy (ans, b, c); 168 return ans; 169 } 170 171void *copy_of (s) 172char *s; 173 { 174 return dup_mem (s, strlen (s) + 1); 175 } 176 177/* |
168 * chat [ -v ] [ -t timeout ] [ -l lock-file ] [ -f chat-file ] \ | 178 * chat [ -v ] [ -t timeout ] [ -f chat-file ] [ -r report-file ] \ |
169 * [...[[expect[-say[-expect...]] say expect[-say[-expect]] ...]]] 170 * 171 * Perform a UUCP-dialer-like chat script on stdin and stdout. 172 */ 173int 174main(argc, argv) 175int argc; 176char **argv; 177 { 178 int option; 179 char *arg; 180 181 program_name = *argv; | 179 * [...[[expect[-say[-expect...]] say expect[-say[-expect]] ...]]] 180 * 181 * Perform a UUCP-dialer-like chat script on stdin and stdout. 182 */ 183int 184main(argc, argv) 185int argc; 186char **argv; 187 { 188 int option; 189 char *arg; 190 191 program_name = *argv; |
192 tzset(); |
|
182 183 while (option = OPTION(argc, argv)) | 193 194 while (option = OPTION(argc, argv)) |
195 { |
|
184 switch (option) 185 { 186 case 'v': 187 ++verbose; 188 break; 189 190 case 'f': 191 if (arg = OPTARG(argc, argv)) | 196 switch (option) 197 { 198 case 'v': 199 ++verbose; 200 break; 201 202 case 'f': 203 if (arg = OPTARG(argc, argv)) |
204 { |
|
192 chat_file = copy_of(arg); | 205 chat_file = copy_of(arg); |
206 } |
|
193 else | 207 else |
208 { |
|
194 usage(); | 209 usage(); |
195 | 210 } |
196 break; 197 | 211 break; 212 |
198 case 'l': 199 if (arg = OPTARG(argc, argv)) 200 lock_file = copy_of(arg); 201 else 202 usage(); 203 204 break; 205 | |
206 case 't': 207 if (arg = OPTARG(argc, argv)) | 213 case 't': 214 if (arg = OPTARG(argc, argv)) |
215 { |
|
208 timeout = atoi(arg); | 216 timeout = atoi(arg); |
217 } |
|
209 else | 218 else |
219 { |
|
210 usage(); | 220 usage(); |
221 } 222 break; |
|
211 | 223 |
224 case 'r': 225 arg = OPTARG (argc, argv); 226 if (arg) 227 { 228 if (report_fp != NULL) 229 { 230 fclose (report_fp); 231 } 232 report_file = copy_of (arg); 233 report_fp = fopen (report_file, "a"); 234 if (report_fp != NULL) 235 { 236 if (verbose) 237 { 238 fprintf (report_fp, "Opening \"%s\"...\n", 239 report_file); 240 } 241 report = 1; 242 } 243 } |
|
212 break; 213 214 default: 215 usage(); | 244 break; 245 246 default: 247 usage(); |
248 break; |
|
216 } | 249 } |
250 } 251/* 252 * Default the report file to the stderr location 253 */ 254 if (report_fp == NULL) 255 { 256 report_fp = stderr; 257 } |
|
217 218#ifdef ultrix 219 openlog("chat", LOG_PID); 220#else 221 openlog("chat", LOG_PID | LOG_NDELAY, LOG_LOCAL2); 222 | 258 259#ifdef ultrix 260 openlog("chat", LOG_PID); 261#else 262 openlog("chat", LOG_PID | LOG_NDELAY, LOG_LOCAL2); 263 |
223 if (verbose) { | 264 if (verbose) 265 { |
224 setlogmask(LOG_UPTO(LOG_INFO)); | 266 setlogmask(LOG_UPTO(LOG_INFO)); |
225 } else { | 267 } 268 else 269 { |
226 setlogmask(LOG_UPTO(LOG_WARNING)); | 270 setlogmask(LOG_UPTO(LOG_WARNING)); |
227 } | 271 } |
228#endif 229 230 init(); | 272#endif 273 274 init(); |
231 | 275 |
232 if (chat_file != NULL) 233 { 234 arg = ARG(argc, argv); 235 if (arg != NULL) | 276 if (chat_file != NULL) 277 { 278 arg = ARG(argc, argv); 279 if (arg != NULL) |
280 { |
|
236 usage(); | 281 usage(); |
282 } |
|
237 else | 283 else |
284 { |
|
238 do_file (chat_file); | 285 do_file (chat_file); |
286 } |
|
239 } 240 else 241 { 242 while (arg = ARG(argc, argv)) 243 { 244 chat_expect(arg); 245 246 if (arg = ARG(argc, argv)) | 287 } 288 else 289 { 290 while (arg = ARG(argc, argv)) 291 { 292 chat_expect(arg); 293 294 if (arg = ARG(argc, argv)) |
295 { |
|
247 chat_send(arg); | 296 chat_send(arg); |
297 } |
|
248 } 249 } 250 251 terminate(0); 252 } 253 254/* 255 * Process a chat script when read from a file. 256 */ 257 258void do_file (chat_file) 259char *chat_file; 260 { 261 int linect, len, sendflg; 262 char *sp, *arg, quote; 263 char buf [STR_LEN]; 264 FILE *cfp; 265 | 298 } 299 } 300 301 terminate(0); 302 } 303 304/* 305 * Process a chat script when read from a file. 306 */ 307 308void do_file (chat_file) 309char *chat_file; 310 { 311 int linect, len, sendflg; 312 char *sp, *arg, quote; 313 char buf [STR_LEN]; 314 FILE *cfp; 315 |
266 if ((cfp = fopen (chat_file, "r")) == NULL) | 316 cfp = fopen (chat_file, "r"); 317 if (cfp == NULL) |
267 { 268 syslog (LOG_ERR, "%s -- open failed: %m", chat_file); 269 terminate (1); 270 } 271 272 linect = 0; 273 sendflg = 0; 274 275 while (fgets(buf, STR_LEN, cfp) != NULL) 276 { 277 sp = strchr (buf, '\n'); 278 if (sp) | 318 { 319 syslog (LOG_ERR, "%s -- open failed: %m", chat_file); 320 terminate (1); 321 } 322 323 linect = 0; 324 sendflg = 0; 325 326 while (fgets(buf, STR_LEN, cfp) != NULL) 327 { 328 sp = strchr (buf, '\n'); 329 if (sp) |
330 { |
|
279 *sp = '\0'; | 331 *sp = '\0'; |
332 } |
|
280 281 linect++; 282 sp = buf; 283 while (*sp != '\0') 284 { 285 if (*sp == ' ' || *sp == '\t') 286 { 287 ++sp; --- 7 unchanged lines hidden (view full) --- 295 while (*sp != quote) 296 { 297 if (*sp == '\0') 298 { 299 syslog (LOG_ERR, "unterminated quote (line %d)", 300 linect); 301 terminate (1); 302 } | 333 334 linect++; 335 sp = buf; 336 while (*sp != '\0') 337 { 338 if (*sp == ' ' || *sp == '\t') 339 { 340 ++sp; --- 7 unchanged lines hidden (view full) --- 348 while (*sp != quote) 349 { 350 if (*sp == '\0') 351 { 352 syslog (LOG_ERR, "unterminated quote (line %d)", 353 linect); 354 terminate (1); 355 } |
303 | 356 |
304 if (*sp++ == '\\') | 357 if (*sp++ == '\\') |
358 { |
|
305 if (*sp != '\0') | 359 if (*sp != '\0') |
360 { |
|
306 ++sp; | 361 ++sp; |
362 } 363 } |
|
307 } 308 } 309 else 310 { 311 arg = sp; 312 while (*sp != '\0' && *sp != ' ' && *sp != '\t') | 364 } 365 } 366 else 367 { 368 arg = sp; 369 while (*sp != '\0' && *sp != ' ' && *sp != '\t') |
370 { |
|
313 ++sp; | 371 ++sp; |
372 } |
|
314 } 315 316 if (*sp != '\0') | 373 } 374 375 if (*sp != '\0') |
376 { |
|
317 *sp++ = '\0'; | 377 *sp++ = '\0'; |
378 } |
|
318 319 if (sendflg) 320 { 321 chat_send (arg); 322 } 323 else 324 { 325 chat_expect (arg); --- 5 unchanged lines hidden (view full) --- 331 } 332 333/* 334 * We got an error parsing the command line. 335 */ 336void usage() 337 { 338 fprintf(stderr, "\ | 379 380 if (sendflg) 381 { 382 chat_send (arg); 383 } 384 else 385 { 386 chat_expect (arg); --- 5 unchanged lines hidden (view full) --- 392 } 393 394/* 395 * We got an error parsing the command line. 396 */ 397void usage() 398 { 399 fprintf(stderr, "\ |
339Usage: %s [-v] [-l lock-file] [-t timeout] {-f chat-file || chat-script}\n", | 400Usage: %s [-v] [-t timeout] [-r report-file] {-f chat-file | chat-script}\n", |
340 program_name); 341 exit(1); 342 } 343 344char line[256]; 345char *p; 346 347void logf (str) --- 14 unchanged lines hidden (view full) --- 362 if (line[0] != 0) 363 { 364 syslog(LOG_INFO, "%s", line); 365 line[0] = 0; 366 } 367 } 368 369/* | 401 program_name); 402 exit(1); 403 } 404 405char line[256]; 406char *p; 407 408void logf (str) --- 14 unchanged lines hidden (view full) --- 423 if (line[0] != 0) 424 { 425 syslog(LOG_INFO, "%s", line); 426 line[0] = 0; 427 } 428 } 429 430/* |
370 * Unlock and terminate with an error. | 431 * Terminate with an error. |
371 */ 372void die() 373 { | 432 */ 433void die() 434 { |
374 unlock(); | |
375 terminate(1); 376 } 377 378/* 379 * Print an error message and terminate. 380 */ 381 382void fatal (msg) 383const char *msg; 384 { 385 syslog(LOG_ERR, "%s", msg); | 435 terminate(1); 436 } 437 438/* 439 * Print an error message and terminate. 440 */ 441 442void fatal (msg) 443const char *msg; 444 { 445 syslog(LOG_ERR, "%s", msg); |
386 unlock(); 387 terminate(1); | 446 terminate(2); |
388 } 389 390/* 391 * Print an error message along with the system error message and 392 * terminate. 393 */ 394 395void sysfatal (msg) 396const char *msg; 397 { 398 syslog(LOG_ERR, "%s: %m", msg); | 447 } 448 449/* 450 * Print an error message along with the system error message and 451 * terminate. 452 */ 453 454void sysfatal (msg) 455const char *msg; 456 { 457 syslog(LOG_ERR, "%s: %m", msg); |
399 unlock(); 400 terminate(1); | 458 terminate(2); |
401 } 402 403int alarmed = 0; 404 405SIGTYPE sigalrm(signo) 406int signo; 407 { 408 int flags; 409 410 alarm(1); 411 alarmed = 1; /* Reset alarm to avoid race window */ 412 signal(SIGALRM, sigalrm); /* that can cause hanging in read() */ 413 414 logflush(); 415 if ((flags = fcntl(0, F_GETFL, 0)) == -1) | 459 } 460 461int alarmed = 0; 462 463SIGTYPE sigalrm(signo) 464int signo; 465 { 466 int flags; 467 468 alarm(1); 469 alarmed = 1; /* Reset alarm to avoid race window */ 470 signal(SIGALRM, sigalrm); /* that can cause hanging in read() */ 471 472 logflush(); 473 if ((flags = fcntl(0, F_GETFL, 0)) == -1) |
474 { |
|
416 sysfatal("Can't get file mode flags on stdin"); | 475 sysfatal("Can't get file mode flags on stdin"); |
476 } |
|
417 else | 477 else |
418 if (fcntl(0, F_SETFL, flags | FNDELAY) == -1) | 478 { 479 if (fcntl(0, F_SETFL, flags | O_NONBLOCK) == -1) 480 { |
419 sysfatal("Can't set file mode flags on stdin"); | 481 sysfatal("Can't set file mode flags on stdin"); |
482 } 483 } |
|
420 421 if (verbose) 422 { 423 syslog(LOG_INFO, "alarm"); 424 } 425 } 426 427void unalarm() 428 { 429 int flags; 430 431 if ((flags = fcntl(0, F_GETFL, 0)) == -1) | 484 485 if (verbose) 486 { 487 syslog(LOG_INFO, "alarm"); 488 } 489 } 490 491void unalarm() 492 { 493 int flags; 494 495 if ((flags = fcntl(0, F_GETFL, 0)) == -1) |
496 { |
|
432 sysfatal("Can't get file mode flags on stdin"); | 497 sysfatal("Can't get file mode flags on stdin"); |
498 } |
|
433 else | 499 else |
434 if (fcntl(0, F_SETFL, flags & ~FNDELAY) == -1) | 500 { 501 if (fcntl(0, F_SETFL, flags & ~O_NONBLOCK) == -1) 502 { |
435 sysfatal("Can't set file mode flags on stdin"); | 503 sysfatal("Can't set file mode flags on stdin"); |
504 } 505 } |
|
436 } 437 438SIGTYPE sigint(signo) 439int signo; 440 { 441 fatal("SIGINT"); 442 } 443 --- 10 unchanged lines hidden (view full) --- 454 } 455 456void init() 457 { 458 signal(SIGINT, sigint); 459 signal(SIGTERM, sigterm); 460 signal(SIGHUP, sighup); 461 | 506 } 507 508SIGTYPE sigint(signo) 509int signo; 510 { 511 fatal("SIGINT"); 512 } 513 --- 10 unchanged lines hidden (view full) --- 524 } 525 526void init() 527 { 528 signal(SIGINT, sigint); 529 signal(SIGTERM, sigterm); 530 signal(SIGHUP, sighup); 531 |
462 if (lock_file) 463 lock(); 464 | |
465 set_tty_parameters(); 466 signal(SIGALRM, sigalrm); 467 alarm(0); 468 alarmed = 0; 469 } 470 471void set_tty_parameters() 472 { | 532 set_tty_parameters(); 533 signal(SIGALRM, sigalrm); 534 alarm(0); 535 alarmed = 0; 536 } 537 538void set_tty_parameters() 539 { |
473#ifdef TERMIO 474 struct termio t; | 540#if defined(get_term_param) 541 term_parms t; |
475 | 542 |
476 if (ioctl(0, TCGETA, &t) < 0) | 543 if (get_term_param (&t) < 0) 544 { |
477 sysfatal("Can't get terminal parameters"); | 545 sysfatal("Can't get terminal parameters"); |
478#endif 479#ifdef TERMIOS 480 struct termios t; | 546 } |
481 | 547 |
482 if (tcgetattr(0, &t) < 0) 483 sysfatal("Can't get terminal parameters"); 484#endif 485 | |
486 saved_tty_parameters = t; | 548 saved_tty_parameters = t; |
487 have_tty_parameters = 1; | 549 have_tty_parameters = 1; |
488 | 550 |
489 t.c_iflag |= IGNBRK | ISTRIP | IGNPAR; 490 t.c_oflag = 0; 491 t.c_lflag = 0; 492 t.c_cc[VERASE] = t.c_cc[VKILL] = 0; 493 t.c_cc[VMIN] = 1; 494 t.c_cc[VTIME] = 0; | 551 t.c_iflag |= IGNBRK | ISTRIP | IGNPAR; 552 t.c_oflag = 0; 553 t.c_lflag = 0; 554 t.c_cc[VERASE] = 555 t.c_cc[VKILL] = 0; 556 t.c_cc[VMIN] = 1; 557 t.c_cc[VTIME] = 0; |
495 | 558 |
496#ifdef TERMIO 497 if (ioctl(0, TCSETA, &t) < 0) | 559 if (set_term_param (&t) < 0) 560 { |
498 sysfatal("Can't set terminal parameters"); | 561 sysfatal("Can't set terminal parameters"); |
562 } |
|
499#endif | 563#endif |
500#ifdef TERMIOS 501 if (tcsetattr(0, TCSANOW, &t) < 0) 502 sysfatal("Can't set terminal parameters"); 503#endif | |
504 } 505 506void break_sequence() 507 { 508#ifdef TERMIOS 509 tcsendbreak (0, 0); 510#endif 511 } 512 513void terminate(status) 514int status; 515 { | 564 } 565 566void break_sequence() 567 { 568#ifdef TERMIOS 569 tcsendbreak (0, 0); 570#endif 571 } 572 573void terminate(status) 574int status; 575 { |
516 if (have_tty_parameters && 517#ifdef TERMIO 518 ioctl(0, TCSETA, &saved_tty_parameters) < 0 519#endif 520#ifdef TERMIOS 521 tcsetattr(0, TCSANOW, &saved_tty_parameters) < 0 522#endif 523 ) { 524 syslog(LOG_ERR, "Can't restore terminal parameters: %m"); 525 unlock(); 526 exit(1); | 576 if (report_file != (char *) 0 && report_fp != (FILE *) NULL) 577 { 578 if (verbose) 579 { 580 fprintf (report_fp, "Closing \"%s\".\n", report_file); 581 } 582 fclose (report_fp); 583 report_fp = (FILE*) NULL; |
527 } | 584 } |
528 exit(status); 529 } | |
530 | 585 |
531/* 532 * Create a lock file for the named lock device 533 */ 534void lock() 535 { 536 int fd, pid; 537# ifdef PIDSTRING 538 char hdb_lock_buffer[12]; 539# endif | 586#if defined(get_term_param) 587 if (have_tty_parameters) 588 { 589 if (set_term_param (&saved_tty_parameters) < 0) 590 { 591 syslog(LOG_ERR, "Can't restore terminal parameters: %m"); 592 exit(1); 593 } 594 } 595#endif |
540 | 596 |
541 lock_file = strcat(strcat(strcpy(malloc(strlen(LOCK_DIR) 542 + 1 + strlen(lock_file) + 1), 543 LOCK_DIR), "/"), lock_file); 544 545 if ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) 546 { 547 char *s = lock_file; 548 lock_file = (char *)0; /* Don't remove someone else's lock file! */ 549 syslog(LOG_ERR, "Can't get lock file '%s': %m", s); 550 die(); 551 } 552 553# ifdef PIDSTRING 554 sprintf(hdb_lock_buffer, "%10d\n", getpid()); 555 write(fd, hdb_lock_buffer, 11); 556# else 557 pid = getpid(); 558 write(fd, &pid, sizeof pid); 559# endif 560 561 close(fd); | 597 exit(status); |
562 } 563 564/* | 598 } 599 600/* |
565 * Remove our lockfile 566 */ 567void unlock() 568 { 569 if (lock_file) 570 { 571 unlink(lock_file); 572 lock_file = (char *)0; 573 } 574 } 575 576/* | |
577 * 'Clean up' this string. 578 */ 579char *clean(s, sending) 580register char *s; 581int sending; 582 { 583 char temp[STR_LEN], cur_chr; 584 register char *s1; --- 9 unchanged lines hidden (view full) --- 594 cur_chr = *s++; 595 if (cur_chr == '\0') 596 { 597 *s1++ = '^'; 598 break; 599 } 600 cur_chr &= 0x1F; 601 if (cur_chr != 0) | 601 * 'Clean up' this string. 602 */ 603char *clean(s, sending) 604register char *s; 605int sending; 606 { 607 char temp[STR_LEN], cur_chr; 608 register char *s1; --- 9 unchanged lines hidden (view full) --- 618 cur_chr = *s++; 619 if (cur_chr == '\0') 620 { 621 *s1++ = '^'; 622 break; 623 } 624 cur_chr &= 0x1F; 625 if (cur_chr != 0) |
626 { |
|
602 *s1++ = cur_chr; | 627 *s1++ = cur_chr; |
628 } |
|
603 continue; 604 } 605 606 if (cur_chr != '\\') 607 { 608 *s1++ = cur_chr; 609 continue; 610 } --- 12 unchanged lines hidden (view full) --- 623 switch (cur_chr) 624 { 625 case 'b': 626 *s1++ = '\b'; 627 break; 628 629 case 'c': 630 if (sending && *s == '\0') | 629 continue; 630 } 631 632 if (cur_chr != '\\') 633 { 634 *s1++ = cur_chr; 635 continue; 636 } --- 12 unchanged lines hidden (view full) --- 649 switch (cur_chr) 650 { 651 case 'b': 652 *s1++ = '\b'; 653 break; 654 655 case 'c': 656 if (sending && *s == '\0') |
657 { |
|
631 add_return = 0; | 658 add_return = 0; |
659 } |
|
632 else | 660 else |
661 { |
|
633 *s1++ = cur_chr; | 662 *s1++ = cur_chr; |
663 } |
|
634 break; 635 636 case '\\': 637 case 'K': 638 case 'p': 639 case 'd': 640 if (sending) | 664 break; 665 666 case '\\': 667 case 'K': 668 case 'p': 669 case 'd': 670 if (sending) |
671 { |
|
641 *s1++ = '\\'; | 672 *s1++ = '\\'; |
673 } |
|
642 643 *s1++ = cur_chr; 644 break; 645 646 case 'q': 647 quiet = ! quiet; 648 break; 649 --- 15 unchanged lines hidden (view full) --- 665 666 case 'N': 667 if (sending) 668 { 669 *s1++ = '\\'; 670 *s1++ = '\0'; 671 } 672 else | 674 675 *s1++ = cur_chr; 676 break; 677 678 case 'q': 679 quiet = ! quiet; 680 break; 681 --- 15 unchanged lines hidden (view full) --- 697 698 case 'N': 699 if (sending) 700 { 701 *s1++ = '\\'; 702 *s1++ = '\0'; 703 } 704 else |
705 { |
|
673 *s1++ = 'N'; | 706 *s1++ = 'N'; |
707 } |
|
674 break; | 708 break; |
675 | 709 |
676 default: 677 if (isoctal (cur_chr)) 678 { 679 cur_chr &= 0x07; 680 if (isoctal (*s)) 681 { 682 cur_chr <<= 3; 683 cur_chr |= *s++ - '0'; 684 if (isoctal (*s)) 685 { 686 cur_chr <<= 3; 687 cur_chr |= *s++ - '0'; 688 } 689 } 690 691 if (cur_chr != 0 || sending) 692 { 693 if (sending && (cur_chr == '\\' || cur_chr == 0)) | 710 default: 711 if (isoctal (cur_chr)) 712 { 713 cur_chr &= 0x07; 714 if (isoctal (*s)) 715 { 716 cur_chr <<= 3; 717 cur_chr |= *s++ - '0'; 718 if (isoctal (*s)) 719 { 720 cur_chr <<= 3; 721 cur_chr |= *s++ - '0'; 722 } 723 } 724 725 if (cur_chr != 0 || sending) 726 { 727 if (sending && (cur_chr == '\\' || cur_chr == 0)) |
728 { |
|
694 *s1++ = '\\'; | 729 *s1++ = '\\'; |
730 } |
|
695 *s1++ = cur_chr; 696 } 697 break; 698 } 699 700 if (sending) | 731 *s1++ = cur_chr; 732 } 733 break; 734 } 735 736 if (sending) |
737 { |
|
701 *s1++ = '\\'; | 738 *s1++ = '\\'; |
739 } |
|
702 *s1++ = cur_chr; 703 break; 704 } 705 } 706 707 if (add_return) | 740 *s1++ = cur_chr; 741 break; 742 } 743 } 744 745 if (add_return) |
746 { |
|
708 *s1++ = '\r'; | 747 *s1++ = '\r'; |
748 } |
|
709 710 *s1++ = '\0'; /* guarantee closure */ 711 *s1++ = '\0'; /* terminate the string */ 712 return dup_mem (temp, (size_t) (s1 - temp)); /* may have embedded nuls */ 713 } 714 715/* 716 * Process the expect string 717 */ 718void chat_expect(s) 719register char *s; 720 { 721 if (strcmp(s, "ABORT") == 0) 722 { 723 ++abort_next; 724 return; 725 } 726 | 749 750 *s1++ = '\0'; /* guarantee closure */ 751 *s1++ = '\0'; /* terminate the string */ 752 return dup_mem (temp, (size_t) (s1 - temp)); /* may have embedded nuls */ 753 } 754 755/* 756 * Process the expect string 757 */ 758void chat_expect(s) 759register char *s; 760 { 761 if (strcmp(s, "ABORT") == 0) 762 { 763 ++abort_next; 764 return; 765 } 766 |
767 if (strcmp(s, "REPORT") == 0) 768 { 769 ++report_next; 770 return; 771 } 772 |
|
727 if (strcmp(s, "TIMEOUT") == 0) 728 { 729 ++timeout_next; 730 return; 731 } 732 733 while (*s) 734 { 735 register char *hyphen; 736 737 for (hyphen = s; *hyphen; ++hyphen) | 773 if (strcmp(s, "TIMEOUT") == 0) 774 { 775 ++timeout_next; 776 return; 777 } 778 779 while (*s) 780 { 781 register char *hyphen; 782 783 for (hyphen = s; *hyphen; ++hyphen) |
784 { |
|
738 if (*hyphen == '-') | 785 if (*hyphen == '-') |
786 { |
|
739 if (hyphen == s || hyphen[-1] != '\\') | 787 if (hyphen == s || hyphen[-1] != '\\') |
788 { |
|
740 break; | 789 break; |
741 | 790 } 791 } 792 } 793 |
742 if (*hyphen == '-') 743 { 744 *hyphen = '\0'; 745 746 if (get_string(s)) | 794 if (*hyphen == '-') 795 { 796 *hyphen = '\0'; 797 798 if (get_string(s)) |
799 { |
|
747 return; | 800 return; |
801 } |
|
748 else 749 { 750 s = hyphen + 1; 751 752 for (hyphen = s; *hyphen; ++hyphen) | 802 else 803 { 804 s = hyphen + 1; 805 806 for (hyphen = s; *hyphen; ++hyphen) |
807 { |
|
753 if (*hyphen == '-') | 808 if (*hyphen == '-') |
809 { |
|
754 if (hyphen == s || hyphen[-1] != '\\') | 810 if (hyphen == s || hyphen[-1] != '\\') |
811 { |
|
755 break; | 812 break; |
813 } 814 } 815 } |
|
756 757 if (*hyphen == '-') 758 { 759 *hyphen = '\0'; 760 761 chat_send(s); 762 s = hyphen + 1; 763 } 764 else 765 { 766 chat_send(s); 767 return; 768 } 769 } 770 } 771 else | 816 817 if (*hyphen == '-') 818 { 819 *hyphen = '\0'; 820 821 chat_send(s); 822 s = hyphen + 1; 823 } 824 else 825 { 826 chat_send(s); 827 return; 828 } 829 } 830 } 831 else |
832 { |
|
772 if (get_string(s)) | 833 if (get_string(s)) |
834 { |
|
773 return; | 835 return; |
836 } |
|
774 else 775 { 776 if (fail_reason) | 837 else 838 { 839 if (fail_reason) |
840 { |
|
777 syslog(LOG_INFO, "Failed (%s)", fail_reason); | 841 syslog(LOG_INFO, "Failed (%s)", fail_reason); |
842 } |
|
778 else | 843 else |
844 { |
|
779 syslog(LOG_INFO, "Failed"); | 845 syslog(LOG_INFO, "Failed"); |
846 } |
|
780 | 847 |
781 unlock(); 782 terminate(1); | 848 terminate(exit_code); |
783 } | 849 } |
850 } |
|
784 } 785 } 786 787char *character(c) | 851 } 852 } 853 854char *character(c) |
788char c; | 855int c; |
789 { 790 static char string[10]; 791 char *meta; 792 793 meta = (c & 0x80) ? "M-" : ""; 794 c &= 0x7F; 795 796 if (c < 32) | 856 { 857 static char string[10]; 858 char *meta; 859 860 meta = (c & 0x80) ? "M-" : ""; 861 c &= 0x7F; 862 863 if (c < 32) |
864 { |
|
797 sprintf(string, "%s^%c", meta, (int)c + '@'); | 865 sprintf(string, "%s^%c", meta, (int)c + '@'); |
866 } |
|
798 else | 867 else |
868 { |
|
799 if (c == 127) | 869 if (c == 127) |
870 { |
|
800 sprintf(string, "%s^?", meta); | 871 sprintf(string, "%s^?", meta); |
872 } |
|
801 else | 873 else |
874 { |
|
802 sprintf(string, "%s%c", meta, c); | 875 sprintf(string, "%s%c", meta, c); |
876 } 877 } |
|
803 804 return (string); 805 } 806 807/* 808 * process the reply string 809 */ 810void chat_send (s) 811register char *s; 812 { 813 if (abort_next) | 878 879 return (string); 880 } 881 882/* 883 * process the reply string 884 */ 885void chat_send (s) 886register char *s; 887 { 888 if (abort_next) |
814 { | 889 { |
815 char *s1; | 890 char *s1; |
816 | 891 |
817 abort_next = 0; | 892 abort_next = 0; |
818 | 893 |
819 if (n_aborts >= MAX_ABORTS) | 894 if (n_aborts >= MAX_ABORTS) |
895 { |
|
820 fatal("Too many ABORT strings"); | 896 fatal("Too many ABORT strings"); |
821 | 897 } 898 |
822 s1 = clean(s, 0); | 899 s1 = clean(s, 0); |
823 824 if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1) | 900 901 if (strlen(s1) > strlen(s) 902 || strlen(s1) + 1 > sizeof(fail_buffer)) |
825 { 826 syslog(LOG_WARNING, "Illegal or too-long ABORT string ('%s')", s); 827 die(); 828 } 829 830 abort_string[n_aborts++] = s1; 831 832 if (verbose) 833 { 834 logf("abort on ("); 835 836 for (s1 = s; *s1; ++s1) | 903 { 904 syslog(LOG_WARNING, "Illegal or too-long ABORT string ('%s')", s); 905 die(); 906 } 907 908 abort_string[n_aborts++] = s1; 909 910 if (verbose) 911 { 912 logf("abort on ("); 913 914 for (s1 = s; *s1; ++s1) |
915 { |
|
837 logf(character(*s1)); | 916 logf(character(*s1)); |
917 } |
|
838 839 logf(")\n"); 840 } | 918 919 logf(")\n"); 920 } |
921 return; |
|
841 } | 922 } |
842 else 843 if (timeout_next) | 923 924 if (report_next) 925 { 926 char *s1; 927 928 report_next = 0; 929 if (n_reports >= MAX_REPORTS) |
844 { | 930 { |
845 timeout_next = 0; 846 timeout = atoi(s); | 931 fatal("Too many REPORT strings"); 932 } 933 934 s1 = clean(s, 0); 935 936 if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1) 937 { 938 syslog(LOG_WARNING, "Illegal or too-long REPORT string ('%s')", s); 939 die(); 940 } 941 942 report_string[n_reports++] = s1; 943 944 if (verbose) 945 { 946 logf("report ("); 947 s1 = s; 948 while (*s1) 949 { 950 logf(character(*s1)); 951 ++s1; 952 } 953 logf(")\n"); 954 } 955 return; 956 } |
847 | 957 |
848 if (timeout <= 0) 849 timeout = DEFAULT_CHAT_TIMEOUT; | 958 if (timeout_next) 959 { 960 timeout_next = 0; 961 timeout = atoi(s); 962 963 if (timeout <= 0) 964 { 965 timeout = DEFAULT_CHAT_TIMEOUT; 966 } |
850 | 967 |
851 if (verbose) 852 { 853 syslog(LOG_INFO, "timeout set to %d seconds", timeout); 854 } | 968 if (verbose) 969 { 970 syslog(LOG_INFO, "timeout set to %d seconds", timeout); |
855 } | 971 } |
856 else | 972 return; 973 } 974 975 if (strcmp(s, "EOT") == 0) 976 { 977 s = "^D\\c"; 978 } 979 else 980 { 981 if (strcmp(s, "BREAK") == 0) |
857 { | 982 { |
858 if (strcmp(s, "EOT") == 0) 859 s = "^D\\c"; 860 else 861 if (strcmp(s, "BREAK") == 0) 862 s = "\\K\\c"; 863 if ( ! put_string(s)) 864 { 865 syslog(LOG_INFO, "Failed"); 866 unlock(); 867 terminate(1); 868 } | 983 s = "\\K\\c"; |
869 } | 984 } |
985 } 986 987 if (!put_string(s)) 988 { 989 syslog(LOG_INFO, "Failed"); 990 terminate(1); 991 } |
|
870 } 871 872int get_char() 873 { 874 int status; 875 char c; 876 877 status = read(0, &c, 1); 878 879 switch (status) | 992 } 993 994int get_char() 995 { 996 int status; 997 char c; 998 999 status = read(0, &c, 1); 1000 1001 switch (status) |
880 { 881 case 1: 882 return ((int)c & 0x7F); | 1002 { 1003 case 1: 1004 return ((int)c & 0x7F); |
883 | 1005 |
884 default: 885 syslog(LOG_WARNING, "warning: read() on stdin returned %d", 886 status); | 1006 default: 1007 syslog(LOG_WARNING, "warning: read() on stdin returned %d", 1008 status); |
887 | 1009 |
888 case -1: 889 if ((status = fcntl(0, F_GETFL, 0)) == -1) 890 sysfatal("Can't get file mode flags on stdin"); 891 else 892 if (fcntl(0, F_SETFL, status & ~FNDELAY) == -1) 893 sysfatal("Can't set file mode flags on stdin"); 894 895 return (-1); 896 } | 1010 case -1: 1011 if ((status = fcntl(0, F_GETFL, 0)) == -1) 1012 { 1013 sysfatal("Can't get file mode flags on stdin"); 1014 } 1015 else 1016 { 1017 if (fcntl(0, F_SETFL, status & ~O_NONBLOCK) == -1) 1018 { 1019 sysfatal("Can't set file mode flags on stdin"); 1020 } 1021 } 1022 1023 return (-1); 1024 } |
897 } 898 899int put_char(c) | 1025 } 1026 1027int put_char(c) |
900char c; | 1028int c; |
901 { 902 int status; | 1029 { 1030 int status; |
1031 char ch = c; |
|
903 | 1032 |
904 delay(); | 1033 usleep(10000); /* inter-character typing delay (?) */ |
905 | 1034 |
906 status = write(1, &c, 1); | 1035 status = write(1, &ch, 1); |
907 908 switch (status) | 1036 1037 switch (status) |
909 { 910 case 1: 911 return (0); 912 913 default: 914 syslog(LOG_WARNING, "warning: write() on stdout returned %d", 915 status); 916 917 case -1: 918 if ((status = fcntl(0, F_GETFL, 0)) == -1) 919 sysfatal("Can't get file mode flags on stdin"); 920 else 921 if (fcntl(0, F_SETFL, status & ~FNDELAY) == -1) 922 sysfatal("Can't set file mode flags on stdin"); 923 924 return (-1); 925 } | 1038 { 1039 case 1: 1040 return (0); 1041 1042 default: 1043 syslog(LOG_WARNING, "warning: write() on stdout returned %d", 1044 status); 1045 1046 case -1: 1047 if ((status = fcntl(0, F_GETFL, 0)) == -1) 1048 { 1049 sysfatal("Can't get file mode flags on stdin"); 1050 } 1051 else 1052 { 1053 if (fcntl(0, F_SETFL, status & ~O_NONBLOCK) == -1) 1054 { 1055 sysfatal("Can't set file mode flags on stdin"); 1056 } 1057 } 1058 1059 return (-1); 1060 } |
926 } 927 928int write_char (c) 929int c; 930 { 931 if (alarmed || put_char(c) < 0) 932 { 933 extern int errno; 934 | 1061 } 1062 1063int write_char (c) 1064int c; 1065 { 1066 if (alarmed || put_char(c) < 0) 1067 { 1068 extern int errno; 1069 |
935 alarm(0); alarmed = 0; | 1070 alarm(0); 1071 alarmed = 0; |
936 937 if (verbose) 938 { 939 if (errno == EINTR || errno == EWOULDBLOCK) | 1072 1073 if (verbose) 1074 { 1075 if (errno == EINTR || errno == EWOULDBLOCK) |
1076 { |
|
940 syslog(LOG_INFO, " -- write timed out"); | 1077 syslog(LOG_INFO, " -- write timed out"); |
1078 } |
|
941 else | 1079 else |
1080 { |
|
942 syslog(LOG_INFO, " -- write failed: %m"); | 1081 syslog(LOG_INFO, " -- write failed: %m"); |
1082 } |
|
943 } 944 return (0); 945 } 946 return (1); 947 } 948 949int put_string (s) 950register char *s; 951 { 952 s = clean(s, 1); 953 954 if (verbose) 955 { 956 logf("send ("); 957 958 if (quiet) | 1083 } 1084 return (0); 1085 } 1086 return (1); 1087 } 1088 1089int put_string (s) 1090register char *s; 1091 { 1092 s = clean(s, 1); 1093 1094 if (verbose) 1095 { 1096 logf("send ("); 1097 1098 if (quiet) |
1099 { |
|
959 logf("??????"); | 1100 logf("??????"); |
1101 } |
|
960 else 961 { 962 register char *s1 = s; 963 964 for (s1 = s; *s1; ++s1) | 1102 else 1103 { 1104 register char *s1 = s; 1105 1106 for (s1 = s; *s1; ++s1) |
1107 { |
|
965 logf(character(*s1)); | 1108 logf(character(*s1)); |
1109 } |
|
966 } 967 968 logf(")\n"); 969 } 970 971 alarm(timeout); alarmed = 0; 972 973 while (*s) 974 { 975 register char c = *s++; 976 977 if (c != '\\') 978 { 979 if (!write_char (c)) | 1110 } 1111 1112 logf(")\n"); 1113 } 1114 1115 alarm(timeout); alarmed = 0; 1116 1117 while (*s) 1118 { 1119 register char c = *s++; 1120 1121 if (c != '\\') 1122 { 1123 if (!write_char (c)) |
1124 { |
|
980 return 0; | 1125 return 0; |
1126 } |
|
981 continue; 982 } 983 984 c = *s++; 985 switch (c) 986 { 987 case 'd': 988 sleep(1); 989 break; 990 991 case 'K': 992 break_sequence(); 993 break; 994 995 case 'p': | 1127 continue; 1128 } 1129 1130 c = *s++; 1131 switch (c) 1132 { 1133 case 'd': 1134 sleep(1); 1135 break; 1136 1137 case 'K': 1138 break_sequence(); 1139 break; 1140 1141 case 'p': |
996 usleep(10000); /* 1/100th of a second. */ | 1142 usleep(10000); /* 1/100th of a second (arg is microseconds) */ |
997 break; 998 999 default: 1000 if (!write_char (c)) 1001 return 0; 1002 break; 1003 } 1004 } --- 20 unchanged lines hidden (view full) --- 1025 1026 if (verbose) 1027 { 1028 register char *s1; 1029 1030 logf("expect ("); 1031 1032 for (s1 = string; *s1; ++s1) | 1143 break; 1144 1145 default: 1146 if (!write_char (c)) 1147 return 0; 1148 break; 1149 } 1150 } --- 20 unchanged lines hidden (view full) --- 1171 1172 if (verbose) 1173 { 1174 register char *s1; 1175 1176 logf("expect ("); 1177 1178 for (s1 = string; *s1; ++s1) |
1179 { |
|
1033 logf(character(*s1)); | 1180 logf(character(*s1)); |
1181 } |
|
1034 1035 logf(")\n"); 1036 } 1037 1038 if (len > STR_LEN) 1039 { 1040 syslog(LOG_INFO, "expect string is too long"); | 1182 1183 logf(")\n"); 1184 } 1185 1186 if (len > STR_LEN) 1187 { 1188 syslog(LOG_INFO, "expect string is too long"); |
1189 exit_code = 1; |
|
1041 return 0; 1042 } 1043 1044 if (len == 0) 1045 { 1046 if (verbose) 1047 { 1048 syslog(LOG_INFO, "got it"); 1049 } 1050 1051 return (1); 1052 } 1053 | 1190 return 0; 1191 } 1192 1193 if (len == 0) 1194 { 1195 if (verbose) 1196 { 1197 syslog(LOG_INFO, "got it"); 1198 } 1199 1200 return (1); 1201 } 1202 |
1054 alarm(timeout); alarmed = 0; | 1203 alarm(timeout); 1204 alarmed = 0; |
1055 1056 while ( ! alarmed && (c = get_char()) >= 0) 1057 { | 1205 1206 while ( ! alarmed && (c = get_char()) >= 0) 1207 { |
1058 int n, abort_len; | 1208 int n, abort_len, report_len; |
1059 1060 if (verbose) 1061 { 1062 if (c == '\n') | 1209 1210 if (verbose) 1211 { 1212 if (c == '\n') |
1213 { |
|
1063 logf("\n"); | 1214 logf("\n"); |
1215 } |
|
1064 else | 1216 else |
1217 { |
|
1065 logf(character(c)); | 1218 logf(character(c)); |
1219 } |
|
1066 } 1067 1068 *s++ = c; 1069 1070 if (s - temp >= len && 1071 c == string[len - 1] && 1072 strncmp(s - len, string, len) == 0) 1073 { 1074 if (verbose) 1075 { 1076 logf(" -- got it\n"); 1077 } 1078 | 1220 } 1221 1222 *s++ = c; 1223 1224 if (s - temp >= len && 1225 c == string[len - 1] && 1226 strncmp(s - len, string, len) == 0) 1227 { 1228 if (verbose) 1229 { 1230 logf(" -- got it\n"); 1231 } 1232 |
1079 alarm(0); alarmed = 0; | 1233 alarm(0); 1234 alarmed = 0; |
1080 return (1); 1081 } 1082 1083 for (n = 0; n < n_aborts; ++n) | 1235 return (1); 1236 } 1237 1238 for (n = 0; n < n_aborts; ++n) |
1239 { |
|
1084 if (s - temp >= (abort_len = strlen(abort_string[n])) && 1085 strncmp(s - abort_len, abort_string[n], abort_len) == 0) | 1240 if (s - temp >= (abort_len = strlen(abort_string[n])) && 1241 strncmp(s - abort_len, abort_string[n], abort_len) == 0) |
1086 { | 1242 { |
1087 if (verbose) 1088 { 1089 logf(" -- failed\n"); 1090 } | 1243 if (verbose) 1244 { 1245 logf(" -- failed\n"); 1246 } |
1091 1092 alarm(0); alarmed = 0; | 1247 1248 alarm(0); 1249 alarmed = 0; 1250 exit_code = n + 4; |
1093 strcpy(fail_reason = fail_buffer, abort_string[n]); 1094 return (0); | 1251 strcpy(fail_reason = fail_buffer, abort_string[n]); 1252 return (0); |
1095 } | 1253 } 1254 } |
1096 | 1255 |
1256 if (!report_gathering) 1257 { 1258 for (n = 0; n < n_reports; ++n) 1259 { 1260 if ((report_string[n] != (char*) NULL) && 1261 s - temp >= (report_len = strlen(report_string[n])) && 1262 strncmp(s - report_len, report_string[n], report_len) == 0) 1263 { 1264 time_t time_now = time ((time_t*) NULL); 1265 struct tm* tm_now = localtime (&time_now); 1266 1267 strftime (report_buffer, 20, "%b %d %H:%M:%S ", tm_now); 1268 strcat (report_buffer, report_string[n]); 1269 1270 report_string[n] = (char *) NULL; 1271 report_gathering = 1; 1272 break; 1273 } 1274 } 1275 } 1276 else 1277 { 1278 if (!iscntrl (c)) 1279 { 1280 int rep_len = strlen (report_buffer); 1281 report_buffer[rep_len] = c; 1282 report_buffer[rep_len + 1] = '\0'; 1283 } 1284 else 1285 { 1286 report_gathering = 0; 1287 fprintf (report_fp, "chat: %s\n", report_buffer); 1288 } 1289 } 1290 |
|
1097 if (s >= end) 1098 { | 1291 if (s >= end) 1292 { |
1099 strncpy(temp, s - minlen, minlen); | 1293 strncpy (temp, s - minlen, minlen); |
1100 s = temp + minlen; 1101 } 1102 1103 if (alarmed && verbose) | 1294 s = temp + minlen; 1295 } 1296 1297 if (alarmed && verbose) |
1298 { |
|
1104 syslog(LOG_WARNING, "warning: alarm synchronization problem"); | 1299 syslog(LOG_WARNING, "warning: alarm synchronization problem"); |
1300 } |
|
1105 } 1106 1107 alarm(0); | 1301 } 1302 1303 alarm(0); |
1108 | 1304 |
1109 if (verbose && printed) 1110 { 1111 if (alarmed) | 1305 if (verbose && printed) 1306 { 1307 if (alarmed) |
1308 { |
|
1112 logf(" -- read timed out\n"); | 1309 logf(" -- read timed out\n"); |
1310 } |
|
1113 else 1114 { 1115 logflush(); 1116 syslog(LOG_INFO, " -- read failed: %m"); 1117 } 1118 } 1119 | 1311 else 1312 { 1313 logflush(); 1314 syslog(LOG_INFO, " -- read failed: %m"); 1315 } 1316 } 1317 |
1120 alarmed = 0; | 1318 exit_code = 3; 1319 alarmed = 0; |
1121 return (0); 1122 } 1123 | 1320 return (0); 1321 } 1322 |
1124#ifdef ultrix 1125#undef NO_USLEEP | 1323#ifdef NO_USLEEP |
1126#include <sys/types.h> 1127#include <sys/time.h> 1128 1129/* 1130 usleep -- support routine for 4.2BSD system call emulations 1131 last edit: 29-Oct-1984 D A Gwyn 1132 */ 1133 1134extern int select(); 1135 1136int 1137usleep( usec ) /* returns 0 if ok, else -1 */ 1138 long usec; /* delay in microseconds */ 1139{ 1140 static struct /* `timeval' */ | 1324#include <sys/types.h> 1325#include <sys/time.h> 1326 1327/* 1328 usleep -- support routine for 4.2BSD system call emulations 1329 last edit: 29-Oct-1984 D A Gwyn 1330 */ 1331 1332extern int select(); 1333 1334int 1335usleep( usec ) /* returns 0 if ok, else -1 */ 1336 long usec; /* delay in microseconds */ 1337{ 1338 static struct /* `timeval' */ |
1141 { 1142 long tv_sec; /* seconds */ 1143 long tv_usec; /* microsecs */ 1144 } delay; /* _select() timeout */ | 1339 { 1340 long tv_sec; /* seconds */ 1341 long tv_usec; /* microsecs */ 1342 } delay; /* _select() timeout */ |
1145 | 1343 |
1146 delay.tv_sec = usec / 1000000L; | 1344 delay.tv_sec = usec / 1000000L; |
1147 delay.tv_usec = usec % 1000000L; 1148 1149 return select( 0, (long *)0, (long *)0, (long *)0, &delay ); 1150} 1151#endif | 1345 delay.tv_usec = usec % 1000000L; 1346 1347 return select( 0, (long *)0, (long *)0, (long *)0, &delay ); 1348} 1349#endif |
1152 1153/* 1154 * Delay an amount appropriate for between typed characters. 1155 */ 1156void delay() 1157 { 1158# ifdef NO_USLEEP 1159 register int i; 1160 1161 for (i = 0; i < 30000; ++i) /* ... did we just say appropriate? */ 1162 ; 1163# else /* NO_USLEEP */ 1164 usleep(100); 1165# endif /* NO_USLEEP */ 1166 } | |