1 /*- 2 * Copyright (c) 1997 3 * David L Nugent <davidn@blaze.net.au>. 4 * All rights reserved. 5 * 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, is permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice immediately at the beginning of the file, without modification, 12 * this list of conditions, and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. This work was done expressly for inclusion into FreeBSD. Other use 17 * is permitted provided this notation is included. 18 * 4. Absolutely no warranty of function or purpose is made by the authors. 19 * 5. Modifications may be freely made to this file providing the above 20 * conditions are met. 21 * 22 * Modem chat module - send/expect style functions for getty 23 * For semi-intelligent modem handling. 24 */ 25 26 #ifndef lint 27 static const char rcsid[] = 28 "$FreeBSD$"; 29 #endif /* not lint */ 30 31 #include <sys/param.h> 32 #include <sys/stat.h> 33 #include <sys/ioctl.h> 34 #include <sys/resource.h> 35 #include <sys/ttydefaults.h> 36 #include <sys/utsname.h> 37 #include <ctype.h> 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <libutil.h> 41 #include <locale.h> 42 #include <setjmp.h> 43 #include <signal.h> 44 #include <stdlib.h> 45 #include <string.h> 46 #include <syslog.h> 47 #include <time.h> 48 #include <termios.h> 49 #include <unistd.h> 50 #include <sys/socket.h> 51 52 #include "extern.h" 53 54 #define PAUSE_CH (unsigned char)'\xff' /* pause kludge */ 55 56 #define CHATDEBUG_RECEIVE 0x01 57 #define CHATDEBUG_SEND 0x02 58 #define CHATDEBUG_EXPECT 0x04 59 #define CHATDEBUG_MISC 0x08 60 61 #define CHATDEBUG_DEFAULT 0 62 #define CHAT_DEFAULT_TIMEOUT 10 63 64 65 static int chat_debug = CHATDEBUG_DEFAULT; 66 static int chat_alarm = CHAT_DEFAULT_TIMEOUT; /* Default */ 67 68 static volatile int alarmed = 0; 69 70 71 static void chat_alrm __P((int)); 72 static int chat_unalarm __P((void)); 73 static int getdigit __P((unsigned char **, int, int)); 74 static char **read_chat __P((char **)); 75 static char *cleanchr __P((char **, unsigned char)); 76 static char *cleanstr __P((const unsigned char *, int)); 77 static const char *result __P((int)); 78 static int chat_expect __P((const char *)); 79 static int chat_send __P((char const *)); 80 81 82 /* 83 * alarm signal handler 84 * handle timeouts in read/write 85 * change stdin to non-blocking mode to prevent 86 * possible hang in read(). 87 */ 88 89 static void 90 chat_alrm(signo) 91 int signo; 92 { 93 int on = 1; 94 95 alarm(1); 96 alarmed = 1; 97 signal(SIGALRM, chat_alrm); 98 ioctl(STDIN_FILENO, FIONBIO, &on); 99 } 100 101 102 /* 103 * Turn back on blocking mode reset by chat_alrm() 104 */ 105 106 static int 107 chat_unalarm() 108 { 109 int off = 0; 110 return ioctl(STDIN_FILENO, FIONBIO, &off); 111 } 112 113 114 /* 115 * convert a string of a given base (octal/hex) to binary 116 */ 117 118 static int 119 getdigit(ptr, base, max) 120 unsigned char **ptr; 121 int base, max; 122 { 123 int i, val = 0; 124 char * q; 125 126 static const char xdigits[] = "0123456789abcdef"; 127 128 for (i = 0, q = *ptr; i++ < max; ++q) { 129 int sval; 130 const char * s = strchr(xdigits, tolower(*q)); 131 132 if (s == NULL || (sval = s - xdigits) >= base) 133 break; 134 val = (val * base) + sval; 135 } 136 *ptr = q; 137 return val; 138 } 139 140 141 /* 142 * read_chat() 143 * Convert a whitespace delimtied string into an array 144 * of strings, being expect/send pairs 145 */ 146 147 static char ** 148 read_chat(chatstr) 149 char **chatstr; 150 { 151 char *str = *chatstr; 152 char **res = NULL; 153 154 if (str != NULL) { 155 char *tmp = NULL; 156 int l; 157 158 if ((l=strlen(str)) > 0 && (tmp=malloc(l + 1)) != NULL && 159 (res=malloc((l / 2 + 1) * sizeof(char *))) != NULL) { 160 static char ws[] = " \t"; 161 char * p; 162 163 for (l = 0, p = strtok(strcpy(tmp, str), ws); 164 p != NULL; 165 p = strtok(NULL, ws)) 166 { 167 unsigned char *q, *r; 168 169 /* Read escapes */ 170 for (q = r = (unsigned char *)p; *r; ++q) 171 { 172 if (*q == '\\') 173 { 174 /* handle special escapes */ 175 switch (*++q) 176 { 177 case 'a': /* bell */ 178 *r++ = '\a'; 179 break; 180 case 'r': /* cr */ 181 *r++ = '\r'; 182 break; 183 case 'n': /* nl */ 184 *r++ = '\n'; 185 break; 186 case 'f': /* ff */ 187 *r++ = '\f'; 188 break; 189 case 'b': /* bs */ 190 *r++ = '\b'; 191 break; 192 case 'e': /* esc */ 193 *r++ = 27; 194 break; 195 case 't': /* tab */ 196 *r++ = '\t'; 197 break; 198 case 'p': /* pause */ 199 *r++ = PAUSE_CH; 200 break; 201 case 's': 202 case 'S': /* space */ 203 *r++ = ' '; 204 break; 205 case 'x': /* hexdigit */ 206 ++q; 207 *r++ = getdigit(&q, 16, 2); 208 --q; 209 break; 210 case '0': /* octal */ 211 ++q; 212 *r++ = getdigit(&q, 8, 3); 213 --q; 214 break; 215 default: /* literal */ 216 *r++ = *q; 217 break; 218 case 0: /* not past eos */ 219 --q; 220 break; 221 } 222 } else { 223 /* copy standard character */ 224 *r++ = *q; 225 } 226 } 227 228 /* Remove surrounding quotes, if any 229 */ 230 if (*p == '"' || *p == '\'') { 231 q = strrchr(p+1, *p); 232 if (q != NULL && *q == *p && q[1] == '\0') { 233 *q = '\0'; 234 strcpy(p, p+1); 235 } 236 } 237 238 res[l++] = p; 239 } 240 res[l] = NULL; 241 *chatstr = tmp; 242 return res; 243 } 244 free(tmp); 245 } 246 return res; 247 } 248 249 250 /* 251 * clean a character for display (ctrl/meta character) 252 */ 253 254 static char * 255 cleanchr(buf, ch) 256 char **buf; 257 unsigned char ch; 258 { 259 int l; 260 static char tmpbuf[5]; 261 char * tmp = buf ? *buf : tmpbuf; 262 263 if (ch & 0x80) { 264 strcpy(tmp, "M-"); 265 l = 2; 266 ch &= 0x7f; 267 } else 268 l = 0; 269 270 if (ch < 32) { 271 tmp[l++] = '^'; 272 tmp[l++] = ch + '@'; 273 } else if (ch == 127) { 274 tmp[l++] = '^'; 275 tmp[l++] = '?'; 276 } else 277 tmp[l++] = ch; 278 tmp[l] = '\0'; 279 280 if (buf) 281 *buf = tmp + l; 282 return tmp; 283 } 284 285 286 /* 287 * clean a string for display (ctrl/meta characters) 288 */ 289 290 static char * 291 cleanstr(s, l) 292 const unsigned char *s; 293 int l; 294 { 295 static unsigned char * tmp = NULL; 296 static int tmplen = 0; 297 298 if (tmplen < l * 4 + 1) 299 tmp = realloc(tmp, tmplen = l * 4 + 1); 300 301 if (tmp == NULL) { 302 tmplen = 0; 303 return (char *)"(mem alloc error)"; 304 } else { 305 int i = 0; 306 char * p = tmp; 307 308 while (i < l) 309 cleanchr(&p, s[i++]); 310 *p = '\0'; 311 } 312 313 return tmp; 314 } 315 316 317 /* 318 * return result as an pseudo-english word 319 */ 320 321 static const char * 322 result(r) 323 int r; 324 { 325 static const char * results[] = { 326 "OK", "MEMERROR", "IOERROR", "TIMEOUT" 327 }; 328 return results[r & 3]; 329 } 330 331 332 /* 333 * chat_expect() 334 * scan input for an expected string 335 */ 336 337 static int 338 chat_expect(str) 339 const char *str; 340 { 341 int len, r = 0; 342 343 if (chat_debug & CHATDEBUG_EXPECT) 344 syslog(LOG_DEBUG, "chat_expect '%s'", cleanstr(str, strlen(str))); 345 346 if ((len = strlen(str)) > 0) { 347 int i = 0; 348 char * got; 349 350 if ((got = malloc(len + 1)) == NULL) 351 r = 1; 352 else { 353 354 memset(got, 0, len+1); 355 alarm(chat_alarm); 356 alarmed = 0; 357 358 while (r == 0 && i < len) { 359 if (alarmed) 360 r = 3; 361 else { 362 unsigned char ch; 363 364 if (read(STDIN_FILENO, &ch, 1) == 1) { 365 366 if (chat_debug & CHATDEBUG_RECEIVE) 367 syslog(LOG_DEBUG, "chat_recv '%s' m=%d", 368 cleanchr(NULL, ch), i); 369 370 if (ch == str[i]) 371 got[i++] = ch; 372 else if (i > 0) { 373 int j = 1; 374 375 /* See if we can resync on a 376 * partial match in our buffer 377 */ 378 while (j < i && memcmp(got + j, str, i - j) != NULL) 379 j++; 380 if (j < i) 381 memcpy(got, got + j, i - j); 382 i -= j; 383 } 384 } else 385 r = alarmed ? 3 : 2; 386 } 387 } 388 alarm(0); 389 chat_unalarm(); 390 alarmed = 0; 391 free(got); 392 } 393 } 394 395 if (chat_debug & CHATDEBUG_EXPECT) 396 syslog(LOG_DEBUG, "chat_expect %s", result(r)); 397 398 return r; 399 } 400 401 402 /* 403 * chat_send() 404 * send a chat string 405 */ 406 407 static int 408 chat_send(str) 409 char const *str; 410 { 411 int r = 0; 412 413 if (chat_debug && CHATDEBUG_SEND) 414 syslog(LOG_DEBUG, "chat_send '%s'", cleanstr(str, strlen(str))); 415 416 if (*str) { 417 alarm(chat_alarm); 418 alarmed = 0; 419 while (r == 0 && *str) 420 { 421 unsigned char ch = (unsigned char)*str++; 422 423 if (alarmed) 424 r = 3; 425 else if (ch == PAUSE_CH) 426 usleep(500000); /* 1/2 second */ 427 else { 428 usleep(10000); /* be kind to modem */ 429 if (write(STDOUT_FILENO, &ch, 1) != 1) 430 r = alarmed ? 3 : 2; 431 } 432 } 433 alarm(0); 434 chat_unalarm(); 435 alarmed = 0; 436 } 437 438 if (chat_debug & CHATDEBUG_SEND) 439 syslog(LOG_DEBUG, "chat_send %s", result(r)); 440 441 return r; 442 } 443 444 445 /* 446 * getty_chat() 447 * 448 * Termination codes: 449 * -1 - no script supplied 450 * 0 - script terminated correctly 451 * 1 - invalid argument, expect string too large, etc. 452 * 2 - error on an I/O operation or fatal error condition 453 * 3 - timeout waiting for a simple string 454 * 455 * Parameters: 456 * char *scrstr - unparsed chat script 457 * timeout - seconds timeout 458 * debug - debug value (bitmask) 459 */ 460 461 int 462 getty_chat(scrstr, timeout, debug) 463 char *scrstr; 464 int timeout, debug; 465 { 466 int r = -1; 467 468 chat_alarm = timeout ? timeout : CHAT_DEFAULT_TIMEOUT; 469 chat_debug = debug; 470 471 if (scrstr != NULL) { 472 char **script; 473 474 if (chat_debug & CHATDEBUG_MISC) 475 syslog(LOG_DEBUG, "getty_chat script='%s'", scrstr); 476 477 if ((script = read_chat(&scrstr)) != NULL) { 478 int i = r = 0; 479 int off = 0; 480 sig_t old_alarm; 481 482 /* 483 * We need to be in raw mode for all this 484 * Rely on caller... 485 */ 486 487 old_alarm = signal(SIGALRM, chat_alrm); 488 chat_unalarm(); /* Force blocking mode at start */ 489 490 /* 491 * This is the send/expect loop 492 */ 493 while (r == 0 && script[i] != NULL) 494 if ((r = chat_expect(script[i++])) == 0 && script[i] != NULL) 495 r = chat_send(script[i++]); 496 497 signal(SIGALRM, old_alarm); 498 free(script); 499 free(scrstr); 500 501 /* 502 * Ensure stdin is in blocking mode 503 */ 504 ioctl(STDIN_FILENO, FIONBIO, &off); 505 } 506 507 if (chat_debug & CHATDEBUG_MISC) 508 syslog(LOG_DEBUG, "getty_chat %s", result(r)); 509 510 } 511 return r; 512 } 513