![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chat.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|
Return to chat.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 ! root 1: /* chat.c ! 2: Chat routine for the UUCP package. ! 3: ! 4: Copyright (C) 1991, 1992 Ian Lance Taylor ! 5: ! 6: This file is part of the Taylor UUCP package. ! 7: ! 8: This program is free software; you can redistribute it and/or ! 9: modify it under the terms of the GNU General Public License as ! 10: published by the Free Software Foundation; either version 2 of the ! 11: License, or (at your option) any later version. ! 12: ! 13: This program is distributed in the hope that it will be useful, but ! 14: WITHOUT ANY WARRANTY; without even the implied warranty of ! 15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 16: General Public License for more details. ! 17: ! 18: You should have received a copy of the GNU General Public License ! 19: along with this program; if not, write to the Free Software ! 20: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ! 21: ! 22: The author of the program may be contacted at [email protected] or ! 23: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254. ! 24: */ ! 25: ! 26: #include "uucp.h" ! 27: ! 28: #if USE_RCS_ID ! 29: const char chat_rcsid[] = "$Id: chat.c,v 1.1 93/07/30 07:52:38 bin Exp Locker: bin $"; ! 30: #endif ! 31: ! 32: #include <ctype.h> ! 33: #include <errno.h> ! 34: ! 35: #include "uudefs.h" ! 36: #include "uuconf.h" ! 37: #include "conn.h" ! 38: #include "prot.h" ! 39: #include "system.h" ! 40: ! 41: /* Local functions. */ ! 42: ! 43: static int icexpect P((struct sconnection *qconn, int cstrings, ! 44: char **azstrings, size_t *aclens, ! 45: int ctimeout, boolean fstrip)); ! 46: static boolean fcsend P((struct sconnection *qconn, pointer puuconf, ! 47: const char *zsend, ! 48: const struct uuconf_system *qsys, ! 49: const struct uuconf_dialer *qdial, ! 50: const char *zphone, ! 51: boolean ftranslate, boolean fstrip)); ! 52: static boolean fcecho_send_strip P((struct sconnection *qconn, ! 53: const char *z, size_t clen)); ! 54: static boolean fcecho_send_nostrip P((struct sconnection *qconn, ! 55: const char *z, size_t clen)); ! 56: static boolean fcecho_send P((struct sconnection *qconn, const char *z, ! 57: size_t clen, boolean fstrip)); ! 58: static boolean fcphone P((struct sconnection *qconn, ! 59: pointer puuconf, ! 60: const struct uuconf_dialer *qdial, ! 61: const char *zphone, ! 62: boolean (*pfwrite) P((struct sconnection *qc, ! 63: const char *zwrite, ! 64: size_t cwrite)), ! 65: boolean ftranslate, boolean *pfquote)); ! 66: static boolean fctranslate P((pointer puuconf, const char *zphone, ! 67: const char **pzprefix, ! 68: const char **pzsuffix)); ! 69: static boolean fcprogram P((struct sconnection *qconn, pointer puuconf, ! 70: char **pzprogram, ! 71: const struct uuconf_system *qsys, ! 72: const struct uuconf_dialer *qdial, ! 73: const char *zphone, const char *zport, ! 74: long ibaud)); ! 75: ! 76: /* Run a chat script with the other system. The chat script is a ! 77: series of expect send pairs. We wait for the expect string to show ! 78: up, and then we send the send string. The chat string for a system ! 79: holds the expect and send strings separated by a single space. */ ! 80: ! 81: boolean ! 82: fchat (qconn, puuconf, qchat, qsys, qdial, zphone, ftranslate, zport, ibaud) ! 83: struct sconnection *qconn; ! 84: pointer puuconf; ! 85: const struct uuconf_chat *qchat; ! 86: const struct uuconf_system *qsys; ! 87: const struct uuconf_dialer *qdial; ! 88: const char *zphone; ! 89: boolean ftranslate; ! 90: const char *zport; ! 91: long ibaud; ! 92: { ! 93: int cstrings; ! 94: char **azstrings; ! 95: size_t *aclens; ! 96: char **pzchat; ! 97: char *zbuf; ! 98: size_t cbuflen; ! 99: boolean fret; ! 100: int i; ! 101: ! 102: /* First run the program, if any. */ ! 103: if (qchat->uuconf_pzprogram != NULL) ! 104: { ! 105: if (! fcprogram (qconn, puuconf, qchat->uuconf_pzprogram, qsys, qdial, ! 106: zphone, zport, ibaud)) ! 107: return FALSE; ! 108: } ! 109: ! 110: /* If there's no chat script, we're done. */ ! 111: if (qchat->uuconf_pzchat == NULL) ! 112: return TRUE; ! 113: ! 114: if (qchat->uuconf_pzfail == NULL) ! 115: { ! 116: cstrings = 1; ! 117: azstrings = (char **) xmalloc (sizeof (char *)); ! 118: aclens = (size_t *) xmalloc (sizeof (size_t)); ! 119: } ! 120: else ! 121: { ! 122: char **pz; ! 123: ! 124: /* We leave string number 0 for the chat script. */ ! 125: cstrings = 1; ! 126: for (pz = qchat->uuconf_pzfail; *pz != NULL; pz++) ! 127: ++cstrings; ! 128: ! 129: azstrings = (char **) xmalloc (cstrings * sizeof (char *)); ! 130: aclens = (size_t *) xmalloc (cstrings * sizeof (size_t)); ! 131: ! 132: /* Get the strings into the array, and handle all the escape ! 133: characters. */ ! 134: for (cstrings = 1, pz = qchat->uuconf_pzfail; ! 135: *pz != NULL; ! 136: cstrings++, pz++) ! 137: { ! 138: azstrings[cstrings] = zbufcpy (*pz); ! 139: aclens[cstrings] = cescape (azstrings[cstrings]); ! 140: } ! 141: } ! 142: ! 143: cbuflen = 0; ! 144: zbuf = NULL; ! 145: fret = TRUE; ! 146: ! 147: pzchat = qchat->uuconf_pzchat; ! 148: ! 149: while (*pzchat != NULL) ! 150: { ! 151: size_t clen; ! 152: ! 153: /* Loop over subexpects and subsends. */ ! 154: while (TRUE) ! 155: { ! 156: /* Copy the expect string into the buffer so that we can ! 157: modify it in cescape. */ ! 158: clen = strlen (*pzchat); ! 159: if (clen >= cbuflen) ! 160: { ! 161: ubuffree (zbuf); ! 162: zbuf = zbufalc (clen + 1); ! 163: cbuflen = clen; ! 164: } ! 165: memcpy (zbuf, *pzchat, clen + 1); ! 166: ! 167: azstrings[0] = zbuf; ! 168: if (azstrings[0][0] == '-') ! 169: ++azstrings[0]; ! 170: aclens[0] = cescape (azstrings[0]); ! 171: ! 172: if (aclens[0] == 0 ! 173: || (aclens[0] == 2 ! 174: && strcmp (azstrings[0], "\"\"") == 0)) ! 175: { ! 176: /* There is no subexpect sequence. If there is a ! 177: subsend sequence we move on to it. Otherwise we let ! 178: this expect succeed. This is somewhat inconsistent, ! 179: but it seems to be the traditional approach. */ ! 180: if (pzchat[1] == NULL || pzchat[1][0] != '-') ! 181: break; ! 182: } ! 183: else ! 184: { ! 185: int istr; ! 186: ! 187: istr = icexpect (qconn, cstrings, azstrings, aclens, ! 188: qchat->uuconf_ctimeout, ! 189: qchat->uuconf_fstrip); ! 190: ! 191: /* If we found the string, break out of the ! 192: subexpect/subsend loop. */ ! 193: if (istr == 0) ! 194: break; ! 195: ! 196: /* If we got an error, return FALSE. */ ! 197: if (istr < -1) ! 198: { ! 199: fret = FALSE; ! 200: break; ! 201: } ! 202: ! 203: /* If we found a failure string, log it and get out. */ ! 204: if (istr > 0) ! 205: { ! 206: ulog (LOG_ERROR, "Chat script failed: Got \"%s\"", ! 207: qchat->uuconf_pzfail[istr - 1]); ! 208: fret = FALSE; ! 209: break; ! 210: } ! 211: ! 212: /* We timed out; look for a send subsequence. If none, ! 213: the chat script has failed. */ ! 214: if (pzchat[1] == NULL || pzchat[1][0] != '-') ! 215: { ! 216: ulog (LOG_ERROR, "Timed out in chat script"); ! 217: fret = FALSE; ! 218: break; ! 219: } ! 220: } ! 221: ! 222: /* Send the send subsequence without the leading '-'. A ! 223: \"\" will send nothing. An empty string will send a ! 224: carriage return. */ ! 225: ++pzchat; ! 226: if (! fcsend (qconn, puuconf, *pzchat + 1, qsys, qdial, zphone, ! 227: ftranslate, qchat->uuconf_fstrip)) ! 228: { ! 229: fret = FALSE; ! 230: break; ! 231: } ! 232: ! 233: /* If there is no expect subsequence, we are done. */ ! 234: if (pzchat[1] == NULL || pzchat[1][0] != '-') ! 235: break; ! 236: ! 237: /* Move on to next expect subsequence. */ ! 238: ++pzchat; ! 239: } ! 240: ! 241: if (! fret) ! 242: break; ! 243: ! 244: /* Move on to the send string. If there is none, we have ! 245: succeeded. */ ! 246: do ! 247: { ! 248: ++pzchat; ! 249: } ! 250: while (*pzchat != NULL && (*pzchat)[0] == '-'); ! 251: ! 252: if (*pzchat == NULL) ! 253: break; ! 254: ! 255: if (**pzchat != '\0') ! 256: { ! 257: if (! fcsend (qconn, puuconf, *pzchat, qsys, qdial, zphone, ! 258: ftranslate, qchat->uuconf_fstrip)) ! 259: { ! 260: fret = FALSE; ! 261: break; ! 262: } ! 263: } ! 264: ! 265: ++pzchat; ! 266: } ! 267: ! 268: ubuffree (zbuf); ! 269: for (i = 1; i < cstrings; i++) ! 270: ubuffree (azstrings[i]); ! 271: xfree ((pointer) azstrings); ! 272: xfree ((pointer) aclens); ! 273: ! 274: return fret; ! 275: } ! 276: ! 277: /* Read characters and wait for one of a set of memory strings to come ! 278: in. This returns the index into the array of the string that ! 279: arrives, or -1 on timeout, or -2 on error. */ ! 280: ! 281: static int ! 282: icexpect (qconn, cstrings, azstrings, aclens, ctimeout, fstrip) ! 283: struct sconnection *qconn; ! 284: int cstrings; ! 285: char **azstrings; ! 286: size_t *aclens; ! 287: int ctimeout; ! 288: boolean fstrip; ! 289: { ! 290: int i; ! 291: size_t cmax; ! 292: char *zhave; ! 293: size_t chave; ! 294: long iendtime; ! 295: #if DEBUG > 1 ! 296: int cchars; ! 297: int iolddebug; ! 298: #endif ! 299: ! 300: cmax = aclens[0]; ! 301: for (i = 1; i < cstrings; i++) ! 302: if (cmax < aclens[i]) ! 303: cmax = aclens[i]; ! 304: ! 305: zhave = zbufalc (cmax); ! 306: chave = 0; ! 307: ! 308: iendtime = ixsysdep_time ((long *) NULL) + ctimeout; ! 309: ! 310: #if DEBUG > 1 ! 311: cchars = 0; ! 312: iolddebug = iDebug; ! 313: if (FDEBUGGING (DEBUG_CHAT)) ! 314: { ! 315: udebug_buffer ("icexpect: Looking for", azstrings[0], ! 316: aclens[0]); ! 317: ulog (LOG_DEBUG_START, "icexpect: Got \""); ! 318: iDebug &=~ (DEBUG_INCOMING | DEBUG_PORT); ! 319: } ! 320: #endif ! 321: ! 322: while (TRUE) ! 323: { ! 324: int bchar; ! 325: ! 326: /* If we have no more time, get out. */ ! 327: if (ctimeout <= 0) ! 328: { ! 329: #if DEBUG > 1 ! 330: if (FDEBUGGING (DEBUG_CHAT)) ! 331: { ! 332: ulog (LOG_DEBUG_END, "\" (timed out)"); ! 333: iDebug = iolddebug; ! 334: } ! 335: #endif ! 336: ubuffree (zhave); ! 337: return -1; ! 338: } ! 339: ! 340: /* Read one character at a time. We could use a more complex ! 341: algorithm to read in larger batches, but it's probably not ! 342: worth it. If the buffer is full, shift it left; we already ! 343: know that no string matches, and the buffer holds the largest ! 344: string, so this can't lose a match. */ ! 345: if (chave >= cmax) ! 346: { ! 347: size_t imove; ! 348: ! 349: for (imove = 0; imove < cmax - 1; imove++) ! 350: zhave[imove] = zhave[imove + 1]; ! 351: --chave; ! 352: } ! 353: ! 354: /* The timeout/error return values from breceive_char are the ! 355: same as for this function. */ ! 356: bchar = breceive_char (qconn, ctimeout, TRUE); ! 357: if (bchar < 0) ! 358: { ! 359: #if DEBUG > 1 ! 360: if (FDEBUGGING (DEBUG_CHAT)) ! 361: { ! 362: /* If there was an error, it will probably be logged in ! 363: the middle of our string, but this is only debugging ! 364: so it's not a big deal. */ ! 365: ulog (LOG_DEBUG_END, "\" (%s)", ! 366: bchar == -1 ? "timed out" : "error"); ! 367: iDebug = iolddebug; ! 368: } ! 369: #endif ! 370: ubuffree (zhave); ! 371: return bchar; ! 372: } ! 373: ! 374: /* Strip the parity bit if desired. */ ! 375: if (fstrip) ! 376: bchar &= 0x7f; ! 377: ! 378: zhave[chave] = (char) bchar; ! 379: ++chave; ! 380: ! 381: #if DEBUG > 1 ! 382: if (FDEBUGGING (DEBUG_CHAT)) ! 383: { ! 384: char ab[5]; ! 385: ! 386: ++cchars; ! 387: if (cchars > 60) ! 388: { ! 389: ulog (LOG_DEBUG_END, "\""); ! 390: ulog (LOG_DEBUG_START, "icexpect: Got \""); ! 391: cchars = 0; ! 392: } ! 393: (void) cdebug_char (ab, bchar); ! 394: ulog (LOG_DEBUG_CONTINUE, "%s", ab); ! 395: } ! 396: #endif ! 397: ! 398: /* See if any of the strings can be found in the buffer. Since ! 399: we read one character at a time, the string can only be found ! 400: at the end of the buffer. */ ! 401: for (i = 0; i < cstrings; i++) ! 402: { ! 403: if (aclens[i] <= chave ! 404: && memcmp (zhave + chave - aclens[i], azstrings[i], ! 405: aclens[i]) == 0) ! 406: { ! 407: #if DEBUG > 1 ! 408: if (FDEBUGGING (DEBUG_CHAT)) ! 409: { ! 410: if (i == 0) ! 411: ulog (LOG_DEBUG_END, "\" (found it)"); ! 412: else ! 413: { ! 414: ulog (LOG_DEBUG_END, "\""); ! 415: udebug_buffer ("icexpect: Found", azstrings[i], ! 416: aclens[i]); ! 417: } ! 418: iDebug = iolddebug; ! 419: } ! 420: #endif ! 421: ubuffree (zhave); ! 422: return i; ! 423: } ! 424: } ! 425: ! 426: ctimeout = (int) (iendtime - ixsysdep_time ((long *) NULL)); ! 427: } ! 428: } ! 429: ! 430: #if DEBUG > 1 ! 431: ! 432: /* Debugging function for fcsend. This takes the fquote variable, the ! 433: length of the string (0 if this an informational string which can ! 434: be printed directly) and the string itself. It returns the new ! 435: value for fquote. The fquote variable is TRUE if the debugging ! 436: output is in the middle of a quoted string. */ ! 437: ! 438: static size_t cCsend_chars; ! 439: static int iColddebug; ! 440: ! 441: static boolean fcsend_debug P((boolean, size_t, const char *)); ! 442: ! 443: static boolean ! 444: fcsend_debug (fquote, clen, zbuf) ! 445: boolean fquote; ! 446: size_t clen; ! 447: const char *zbuf; ! 448: { ! 449: size_t cwas; ! 450: ! 451: if (! FDEBUGGING (DEBUG_CHAT)) ! 452: return TRUE; ! 453: ! 454: cwas = cCsend_chars; ! 455: if (clen > 0) ! 456: cCsend_chars += clen; ! 457: else ! 458: cCsend_chars += strlen (zbuf); ! 459: if (cCsend_chars > 60 && cwas > 10) ! 460: { ! 461: ulog (LOG_DEBUG_END, "%s", fquote ? "\"" : ""); ! 462: fquote = FALSE; ! 463: ulog (LOG_DEBUG_START, "fcsend: Writing"); ! 464: cCsend_chars = 0; ! 465: } ! 466: ! 467: if (clen == 0) ! 468: { ! 469: ulog (LOG_DEBUG_CONTINUE, "%s %s", fquote ? "\"" : "", zbuf); ! 470: return FALSE; ! 471: } ! 472: else ! 473: { ! 474: int i; ! 475: ! 476: if (! fquote) ! 477: ulog (LOG_DEBUG_CONTINUE, " \""); ! 478: for (i = 0; i < clen; i++) ! 479: { ! 480: char ab[5]; ! 481: ! 482: (void) cdebug_char (ab, zbuf[i]); ! 483: ulog (LOG_DEBUG_CONTINUE, "%s", ab); ! 484: } ! 485: ! 486: return TRUE; ! 487: } ! 488: } ! 489: ! 490: /* Finish up the debugging information for fcsend. */ ! 491: ! 492: static void ucsend_debug_end P((boolean, boolean)); ! 493: ! 494: static void ! 495: ucsend_debug_end (fquote, ferr) ! 496: boolean fquote; ! 497: boolean ferr; ! 498: { ! 499: if (! FDEBUGGING (DEBUG_CHAT)) ! 500: return; ! 501: ! 502: if (fquote) ! 503: ulog (LOG_DEBUG_CONTINUE, "\""); ! 504: ! 505: if (ferr) ! 506: ulog (LOG_DEBUG_CONTINUE, " (error)"); ! 507: ! 508: ulog (LOG_DEBUG_END, "%s", ""); ! 509: ! 510: iDebug = iColddebug; ! 511: } ! 512: ! 513: #else /* DEBUG <= 1 */ ! 514: ! 515: /* Use macro definitions to make fcsend look neater. */ ! 516: ! 517: #define fcsend_debug(fquote, clen, zbuf) TRUE ! 518: ! 519: #define ucsend_debug_end(fquote, ferror) ! 520: ! 521: #endif /* DEBUG <= 1 */ ! 522: ! 523: /* Send a string out. This has to parse escape sequences as it goes. ! 524: Note that it handles the dialer escape sequences (\e, \E, \D, \T) ! 525: although they make no sense for chatting with a system. */ ! 526: ! 527: static boolean ! 528: fcsend (qconn, puuconf, z, qsys, qdial, zphone, ftranslate, fstrip) ! 529: struct sconnection *qconn; ! 530: pointer puuconf; ! 531: const char *z; ! 532: const struct uuconf_system *qsys; ! 533: const struct uuconf_dialer *qdial; ! 534: const char *zphone; ! 535: boolean ftranslate; ! 536: boolean fstrip; ! 537: { ! 538: boolean fnocr; ! 539: boolean (*pfwrite) P((struct sconnection *, const char *, size_t)); ! 540: char *zcallout_login; ! 541: char *zcallout_pass; ! 542: boolean fquote; ! 543: ! 544: if (strcmp (z, "\"\"") == 0) ! 545: return TRUE; ! 546: ! 547: fnocr = FALSE; ! 548: pfwrite = fconn_write; ! 549: zcallout_login = NULL; ! 550: zcallout_pass = NULL; ! 551: ! 552: #if DEBUG > 1 ! 553: if (FDEBUGGING (DEBUG_CHAT)) ! 554: { ! 555: ulog (LOG_DEBUG_START, "fcsend: Writing"); ! 556: fquote = FALSE; ! 557: cCsend_chars = 0; ! 558: iColddebug = iDebug; ! 559: iDebug &=~ (DEBUG_OUTGOING | DEBUG_PORT); ! 560: } ! 561: #endif ! 562: ! 563: while (*z != '\0') ! 564: { ! 565: const char *zlook; ! 566: boolean fsend; ! 567: char bsend; ! 568: ! 569: zlook = z + strcspn ((char *) z, "\\BE"); ! 570: ! 571: if (zlook > z) ! 572: { ! 573: size_t c; ! 574: ! 575: c = zlook - z; ! 576: fquote = fcsend_debug (fquote, c, z); ! 577: if (! (*pfwrite) (qconn, z, c)) ! 578: { ! 579: ucsend_debug_end (fquote, TRUE); ! 580: return FALSE; ! 581: } ! 582: } ! 583: ! 584: if (*zlook == '\0') ! 585: break; ! 586: ! 587: z = zlook; ! 588: ! 589: fsend = FALSE; ! 590: switch (*z) ! 591: { ! 592: case 'B': ! 593: if (strncmp (z, "BREAK", 5) == 0) ! 594: { ! 595: fquote = fcsend_debug (fquote, (size_t) 0, "break"); ! 596: if (! fconn_break (qconn)) ! 597: { ! 598: ucsend_debug_end (fquote, TRUE); ! 599: return FALSE; ! 600: } ! 601: fnocr = TRUE; ! 602: z += 5; ! 603: } ! 604: else ! 605: { ! 606: fsend = TRUE; ! 607: bsend = 'B'; ! 608: ++z; ! 609: } ! 610: break; ! 611: case 'E': ! 612: if (strncmp (z, "EOT", 3) == 0) ! 613: { ! 614: fsend = TRUE; ! 615: bsend = '\004'; ! 616: fnocr = TRUE; ! 617: z += 3; ! 618: } ! 619: else ! 620: { ! 621: fsend = TRUE; ! 622: bsend = 'E'; ! 623: ++z; ! 624: } ! 625: break; ! 626: case '\\': ! 627: ++z; ! 628: switch (*z) ! 629: { ! 630: case '-': ! 631: fsend = TRUE; ! 632: bsend = '-'; ! 633: break; ! 634: case 'b': ! 635: fsend = TRUE; ! 636: bsend = '\b'; ! 637: break; ! 638: case 'c': ! 639: fnocr = TRUE; ! 640: break; ! 641: case 'd': ! 642: fquote = fcsend_debug (fquote, (size_t) 0, "sleep"); ! 643: usysdep_sleep (2); ! 644: break; ! 645: case 'e': ! 646: fquote = fcsend_debug (fquote, (size_t) 0, "echo-check-off"); ! 647: pfwrite = fconn_write; ! 648: break; ! 649: case 'E': ! 650: fquote = fcsend_debug (fquote, (size_t) 0, "echo-check-on"); ! 651: if (fstrip) ! 652: pfwrite = fcecho_send_strip; ! 653: else ! 654: pfwrite = fcecho_send_nostrip; ! 655: break; ! 656: case 'K': ! 657: fquote = fcsend_debug (fquote, (size_t) 0, "break"); ! 658: if (! fconn_break (qconn)) ! 659: { ! 660: ucsend_debug_end (fquote, TRUE); ! 661: return FALSE; ! 662: } ! 663: break; ! 664: case 'n': ! 665: fsend = TRUE; ! 666: bsend = '\n'; ! 667: break; ! 668: case 'N': ! 669: fsend = TRUE; ! 670: bsend = '\0'; ! 671: break; ! 672: case 'p': ! 673: fquote = fcsend_debug (fquote, (size_t) 0, "pause"); ! 674: usysdep_pause (); ! 675: break; ! 676: case 'r': ! 677: fsend = TRUE; ! 678: bsend = '\r'; ! 679: break; ! 680: case 's': ! 681: fsend = TRUE; ! 682: bsend = ' '; ! 683: break; ! 684: case 't': ! 685: fsend = TRUE; ! 686: bsend = '\t'; ! 687: break; ! 688: case '\0': ! 689: --z; ! 690: /* Fall through. */ ! 691: case '\\': ! 692: fsend = TRUE; ! 693: bsend = '\\'; ! 694: break; ! 695: case '0': case '1': case '2': case '3': case '4': ! 696: case '5': case '6': case '7': case '8': case '9': ! 697: fsend = TRUE; ! 698: bsend = *z - '0'; ! 699: if (z[1] >= '0' && z[1] <= '7') ! 700: bsend = (char) (8 * bsend + *++z - '0'); ! 701: if (z[1] >= '0' && z[1] <= '7') ! 702: bsend = (char) (8 * bsend + *++z - '0'); ! 703: break; ! 704: case 'x': ! 705: fsend = TRUE; ! 706: bsend = 0; ! 707: while (isxdigit (BUCHAR (z[1]))) ! 708: { ! 709: if (isdigit (BUCHAR (z[1]))) ! 710: bsend = (char) (16 * bsend + *++z - '0'); ! 711: else if (isupper (BUCHAR (z[1]))) ! 712: bsend = (char) (16 * bsend + *++z - 'A'); ! 713: else ! 714: bsend = (char) (16 * bsend + *++z - 'a'); ! 715: } ! 716: break; ! 717: case 'L': ! 718: { ! 719: const char *zlog; ! 720: ! 721: if (qsys == NULL) ! 722: { ! 723: ucsend_debug_end (fquote, TRUE); ! 724: ulog (LOG_ERROR, "Illegal use of \\L"); ! 725: return FALSE; ! 726: } ! 727: zlog = qsys->uuconf_zcall_login; ! 728: if (zlog == NULL) ! 729: { ! 730: ucsend_debug_end (fquote, TRUE); ! 731: ulog (LOG_ERROR, "No login defined"); ! 732: return FALSE; ! 733: } ! 734: if (zlog[0] == '*' && zlog[1] == '\0') ! 735: { ! 736: if (zcallout_login == NULL) ! 737: { ! 738: int iuuconf; ! 739: ! 740: iuuconf = uuconf_callout (puuconf, qsys, ! 741: &zcallout_login, ! 742: &zcallout_pass); ! 743: if (iuuconf == UUCONF_NOT_FOUND ! 744: || zcallout_login == NULL) ! 745: { ! 746: ucsend_debug_end (fquote, TRUE); ! 747: ulog (LOG_ERROR, "No login defined"); ! 748: return FALSE; ! 749: } ! 750: else if (iuuconf != UUCONF_SUCCESS) ! 751: { ! 752: ucsend_debug_end (fquote, TRUE); ! 753: ulog_uuconf (LOG_ERROR, puuconf, iuuconf); ! 754: return FALSE; ! 755: } ! 756: } ! 757: zlog = zcallout_login; ! 758: } ! 759: fquote = fcsend_debug (fquote, (size_t) 0, "login"); ! 760: fquote = fcsend_debug (fquote, strlen (zlog), zlog); ! 761: if (! (*pfwrite) (qconn, zlog, strlen (zlog))) ! 762: { ! 763: ucsend_debug_end (fquote, TRUE); ! 764: return FALSE; ! 765: } ! 766: } ! 767: break; ! 768: case 'P': ! 769: { ! 770: const char *zpass; ! 771: ! 772: if (qsys == NULL) ! 773: { ! 774: ucsend_debug_end (fquote, TRUE); ! 775: ulog (LOG_ERROR, "Illegal use of \\P"); ! 776: return FALSE; ! 777: } ! 778: zpass = qsys->uuconf_zcall_password; ! 779: if (zpass == NULL) ! 780: { ! 781: ucsend_debug_end (fquote, TRUE); ! 782: ulog (LOG_ERROR, "No password defined"); ! 783: return FALSE; ! 784: } ! 785: if (zpass[0] == '*' && zpass[1] == '\0') ! 786: { ! 787: if (zcallout_pass == NULL) ! 788: { ! 789: int iuuconf; ! 790: ! 791: iuuconf = uuconf_callout (puuconf, qsys, ! 792: &zcallout_login, ! 793: &zcallout_pass); ! 794: if (iuuconf == UUCONF_NOT_FOUND ! 795: || zcallout_pass == NULL) ! 796: { ! 797: ucsend_debug_end (fquote, TRUE); ! 798: ulog (LOG_ERROR, "No password defined"); ! 799: return FALSE; ! 800: } ! 801: else if (iuuconf != UUCONF_SUCCESS) ! 802: { ! 803: ucsend_debug_end (fquote, TRUE); ! 804: ulog_uuconf (LOG_ERROR, puuconf, iuuconf); ! 805: return FALSE; ! 806: } ! 807: } ! 808: zpass = zcallout_pass; ! 809: } ! 810: fquote = fcsend_debug (fquote, (size_t) 0, "password"); ! 811: fquote = fcsend_debug (fquote, strlen (zpass), zpass); ! 812: if (! (*pfwrite) (qconn, zpass, strlen (zpass))) ! 813: { ! 814: ucsend_debug_end (fquote, TRUE); ! 815: return FALSE; ! 816: } ! 817: } ! 818: break; ! 819: case 'D': ! 820: if (qdial == NULL || zphone == NULL) ! 821: { ! 822: ucsend_debug_end (fquote, TRUE); ! 823: ulog (LOG_ERROR, "Illegal use of \\D"); ! 824: return FALSE; ! 825: } ! 826: fquote = fcsend_debug (fquote, (size_t) 0, "\\D"); ! 827: if (! fcphone (qconn, puuconf, qdial, zphone, pfwrite, ! 828: ftranslate, &fquote)) ! 829: { ! 830: ucsend_debug_end (fquote, TRUE); ! 831: return FALSE; ! 832: } ! 833: break; ! 834: case 'T': ! 835: if (qdial == NULL || zphone == NULL) ! 836: { ! 837: ucsend_debug_end (fquote, TRUE); ! 838: ulog (LOG_ERROR, "Illegal use of \\T"); ! 839: return FALSE; ! 840: } ! 841: fquote = fcsend_debug (fquote, (size_t) 0, "\\T"); ! 842: if (! fcphone (qconn, puuconf, qdial, zphone, pfwrite, TRUE, ! 843: &fquote)) ! 844: { ! 845: ucsend_debug_end (fquote, TRUE); ! 846: return FALSE; ! 847: } ! 848: break; ! 849: case 'M': ! 850: if (qdial == NULL) ! 851: { ! 852: ucsend_debug_end (fquote, TRUE); ! 853: ulog (LOG_ERROR, "Illegal use of \\M"); ! 854: return FALSE; ! 855: } ! 856: fquote = fcsend_debug (fquote, (size_t) 0, "ignore-carrier"); ! 857: if (! fconn_carrier (qconn, FALSE)) ! 858: { ! 859: ucsend_debug_end (fquote, TRUE); ! 860: return FALSE; ! 861: } ! 862: break; ! 863: case 'm': ! 864: if (qdial == NULL) ! 865: { ! 866: ucsend_debug_end (fquote, TRUE); ! 867: ulog (LOG_ERROR, "Illegal use of \\m"); ! 868: return FALSE; ! 869: } ! 870: if (qdial->uuconf_fcarrier) ! 871: { ! 872: fquote = fcsend_debug (fquote, (size_t) 0, "need-carrier"); ! 873: if (! fconn_carrier (qconn, TRUE)) ! 874: { ! 875: ucsend_debug_end (fquote, TRUE); ! 876: return FALSE; ! 877: } ! 878: } ! 879: break; ! 880: default: ! 881: /* This error message will screw up any debugging ! 882: information, but it's easily avoidable. */ ! 883: ulog (LOG_ERROR, ! 884: "Unrecognized escape sequence \\%c in send string", ! 885: *z); ! 886: fsend = TRUE; ! 887: bsend = *z; ! 888: break; ! 889: } ! 890: ++z; ! 891: break; ! 892: #if DEBUG > 0 ! 893: default: ! 894: ulog (LOG_FATAL, "fcsend: Can't happen"); ! 895: break; ! 896: #endif ! 897: } ! 898: ! 899: if (fsend) ! 900: { ! 901: fquote = fcsend_debug (fquote, (size_t) 1, &bsend); ! 902: if (! (*pfwrite) (qconn, &bsend, (size_t) 1)) ! 903: { ! 904: ucsend_debug_end (fquote, TRUE); ! 905: return FALSE; ! 906: } ! 907: } ! 908: } ! 909: ! 910: xfree ((pointer) zcallout_login); ! 911: xfree ((pointer) zcallout_pass); ! 912: ! 913: /* Output a final carriage return, unless there was a \c. Don't ! 914: bother to check for an echo. */ ! 915: if (! fnocr) ! 916: { ! 917: char b; ! 918: ! 919: b = '\r'; ! 920: fquote = fcsend_debug (fquote, (size_t) 1, &b); ! 921: if (! fconn_write (qconn, &b, (size_t) 1)) ! 922: { ! 923: ucsend_debug_end (fquote, TRUE); ! 924: return FALSE; ! 925: } ! 926: } ! 927: ! 928: ucsend_debug_end (fquote, FALSE); ! 929: ! 930: return TRUE; ! 931: } ! 932: ! 933: /* Write out a phone number with optional dialcode translation. The ! 934: pfquote argument is only used for debugging. */ ! 935: ! 936: static boolean ! 937: fcphone (qconn, puuconf, qdial, zphone, pfwrite, ftranslate, pfquote) ! 938: struct sconnection *qconn; ! 939: pointer puuconf; ! 940: const struct uuconf_dialer *qdial; ! 941: const char *zphone; ! 942: boolean (*pfwrite) P((struct sconnection *qc, const char *zwrite, ! 943: size_t cwrite)); ! 944: boolean ftranslate; ! 945: boolean *pfquote; ! 946: { ! 947: const char *zprefix, *zsuffix; ! 948: ! 949: if (ftranslate) ! 950: { ! 951: if (! fctranslate (puuconf, zphone, &zprefix, &zsuffix)) ! 952: return FALSE; ! 953: } ! 954: else ! 955: { ! 956: zprefix = zphone; ! 957: zsuffix = NULL; ! 958: } ! 959: ! 960: while (zprefix != NULL) ! 961: { ! 962: while (TRUE) ! 963: { ! 964: const char *z; ! 965: const char *zstr; ! 966: ! 967: z = zprefix + strcspn ((char *) zprefix, "=-"); ! 968: if (z > zprefix) ! 969: { ! 970: size_t clen; ! 971: ! 972: clen = z - zprefix; ! 973: *pfquote = fcsend_debug (*pfquote, clen, zprefix); ! 974: if (! (*pfwrite) (qconn, zprefix, clen)) ! 975: return FALSE; ! 976: } ! 977: ! 978: if (*z == '=') ! 979: zstr = qdial->uuconf_zdialtone; ! 980: else if (*z == '-') ! 981: zstr = qdial->uuconf_zpause; ! 982: else /* *z == '\0' */ ! 983: break; ! 984: ! 985: if (zstr != NULL) ! 986: { ! 987: *pfquote = fcsend_debug (*pfquote, strlen (zstr), zstr); ! 988: if (! (*pfwrite) (qconn, zstr, strlen (zstr))) ! 989: return FALSE; ! 990: } ! 991: ! 992: zprefix = z + 1; ! 993: } ! 994: ! 995: zprefix = zsuffix; ! 996: zsuffix = NULL; ! 997: } ! 998: ! 999: return TRUE; ! 1000: } ! 1001: ! 1002: /* Given a phone number, run it through dial code translation ! 1003: returning two strings. */ ! 1004: ! 1005: static boolean ! 1006: fctranslate (puuconf, zphone, pzprefix, pzsuffix) ! 1007: pointer puuconf; ! 1008: const char *zphone; ! 1009: const char **pzprefix; ! 1010: const char **pzsuffix; ! 1011: { ! 1012: int iuuconf; ! 1013: char *zdialcode, *zto; ! 1014: const char *zfrom; ! 1015: char *ztrans; ! 1016: ! 1017: *pzprefix = zphone; ! 1018: *pzsuffix = NULL; ! 1019: ! 1020: zdialcode = zbufalc (strlen (zphone) + 1); ! 1021: zfrom = zphone; ! 1022: zto = zdialcode; ! 1023: while (*zfrom != '\0' && isalpha (BUCHAR (*zfrom))) ! 1024: *zto++ = *zfrom++; ! 1025: *zto = '\0'; ! 1026: ! 1027: if (*zdialcode == '\0') ! 1028: { ! 1029: ubuffree (zdialcode); ! 1030: return TRUE; ! 1031: } ! 1032: ! 1033: iuuconf = uuconf_dialcode (puuconf, zdialcode, &ztrans); ! 1034: ! 1035: ubuffree (zdialcode); ! 1036: ! 1037: if (iuuconf == UUCONF_NOT_FOUND) ! 1038: return TRUE; ! 1039: else if (iuuconf != UUCONF_SUCCESS) ! 1040: { ! 1041: ulog_uuconf (LOG_ERROR, puuconf, iuuconf); ! 1042: return FALSE; ! 1043: } ! 1044: else ! 1045: { ! 1046: /* We really should figure out a way to free up ztrans here. */ ! 1047: *pzprefix = ztrans; ! 1048: *pzsuffix = zfrom; ! 1049: return TRUE; ! 1050: } ! 1051: } ! 1052: ! 1053: /* Write out a string making sure the each character is echoed back. ! 1054: There are two versions of this function, one which strips the ! 1055: parity bit from the characters and one which does not. This is so ! 1056: that I can use a single function pointer in fcsend, and to avoid ! 1057: using any static variables so that I can put chat scripts in a ! 1058: library some day. */ ! 1059: ! 1060: static boolean ! 1061: fcecho_send_strip (qconn, zwrite, cwrite) ! 1062: struct sconnection *qconn; ! 1063: const char *zwrite; ! 1064: size_t cwrite; ! 1065: { ! 1066: return fcecho_send (qconn, zwrite, cwrite, TRUE); ! 1067: } ! 1068: ! 1069: static boolean ! 1070: fcecho_send_nostrip (qconn, zwrite, cwrite) ! 1071: struct sconnection *qconn; ! 1072: const char *zwrite; ! 1073: size_t cwrite; ! 1074: { ! 1075: return fcecho_send (qconn, zwrite, cwrite, FALSE); ! 1076: } ! 1077: ! 1078: static boolean ! 1079: fcecho_send (qconn, zwrite, cwrite, fstrip) ! 1080: struct sconnection *qconn; ! 1081: const char *zwrite; ! 1082: size_t cwrite; ! 1083: boolean fstrip; ! 1084: { ! 1085: const char *zend; ! 1086: ! 1087: zend = zwrite + cwrite; ! 1088: ! 1089: for (; zwrite < zend; zwrite++) ! 1090: { ! 1091: int b; ! 1092: char bwrite; ! 1093: ! 1094: bwrite = *zwrite; ! 1095: if (! fconn_write (qconn, &bwrite, (size_t) 1)) ! 1096: return FALSE; ! 1097: if (fstrip) ! 1098: bwrite &= 0x7f; ! 1099: do ! 1100: { ! 1101: /* We arbitrarily wait five seconds for the echo. */ ! 1102: b = breceive_char (qconn, 5, TRUE); ! 1103: /* Now b == -1 on timeout, -2 on error. */ ! 1104: if (b < 0) ! 1105: { ! 1106: if (b == -1) ! 1107: ulog (LOG_ERROR, "Character not echoed"); ! 1108: return FALSE; ! 1109: } ! 1110: if (fstrip) ! 1111: b &= 0x7f; ! 1112: } ! 1113: while (b != BUCHAR (bwrite)); ! 1114: } ! 1115: ! 1116: return TRUE; ! 1117: } ! 1118: ! 1119: /* Run a chat program. Expand any escape sequences and call a system ! 1120: dependent program to run it. */ ! 1121: ! 1122: static boolean ! 1123: fcprogram (qconn, puuconf, pzprogram, qsys, qdial, zphone, zport, ibaud) ! 1124: struct sconnection *qconn; ! 1125: pointer puuconf; ! 1126: char **pzprogram; ! 1127: const struct uuconf_system *qsys; ! 1128: const struct uuconf_dialer *qdial; ! 1129: const char *zphone; ! 1130: const char *zport; ! 1131: long ibaud; ! 1132: { ! 1133: size_t cargs; ! 1134: char **pzpass, **pzarg; ! 1135: char **pz; ! 1136: char *zcallout_login; ! 1137: char *zcallout_pass; ! 1138: boolean fret; ! 1139: ! 1140: cargs = 1; ! 1141: for (pz = pzprogram; *pz != NULL; pz++) ! 1142: ++cargs; ! 1143: ! 1144: pzpass = (char **) xmalloc (cargs * sizeof (char *)); ! 1145: ! 1146: zcallout_login = NULL; ! 1147: zcallout_pass = NULL; ! 1148: fret = TRUE; ! 1149: ! 1150: /* Copy the string into memory expanding escape sequences. */ ! 1151: for (pz = pzprogram, pzarg = pzpass; *pz != NULL; pz++, pzarg++) ! 1152: { ! 1153: const char *zfrom; ! 1154: size_t calc, clen; ! 1155: char *zto; ! 1156: ! 1157: if (strchr (*pz, '\\') == NULL) ! 1158: { ! 1159: *pzarg = zbufcpy (*pz); ! 1160: continue; ! 1161: } ! 1162: ! 1163: *pzarg = NULL; ! 1164: zto = NULL; ! 1165: calc = 0; ! 1166: clen = 0; ! 1167: ! 1168: for (zfrom = *pz; *zfrom != '\0'; zfrom++) ! 1169: { ! 1170: const char *zadd = NULL; ! 1171: size_t cadd; ! 1172: char abadd[15]; ! 1173: ! 1174: if (*zfrom != '\\') ! 1175: { ! 1176: if (clen + 2 > calc) ! 1177: { ! 1178: char *znew; ! 1179: ! 1180: calc = clen + 50; ! 1181: znew = zbufalc (calc); ! 1182: memcpy (znew, *pzarg, clen); ! 1183: ubuffree (*pzarg); ! 1184: *pzarg = znew; ! 1185: zto = znew + clen; ! 1186: } ! 1187: *zto++ = *zfrom; ! 1188: ++clen; ! 1189: continue; ! 1190: } ! 1191: ! 1192: ++zfrom; ! 1193: switch (*zfrom) ! 1194: { ! 1195: case '\0': ! 1196: --zfrom; ! 1197: /* Fall through. */ ! 1198: case '\\': ! 1199: zadd = "\\"; ! 1200: break; ! 1201: case 'L': ! 1202: { ! 1203: const char *zlog; ! 1204: ! 1205: if (qsys == NULL) ! 1206: { ! 1207: ulog (LOG_ERROR, "chat-program: Illegal use of \\L"); ! 1208: fret = FALSE; ! 1209: break; ! 1210: } ! 1211: zlog = qsys->uuconf_zcall_login; ! 1212: if (zlog == NULL) ! 1213: { ! 1214: ulog (LOG_ERROR, "chat-program: No login defined"); ! 1215: fret = FALSE; ! 1216: break; ! 1217: } ! 1218: if (zlog[0] == '*' && zlog[1] == '\0') ! 1219: { ! 1220: if (zcallout_login == NULL) ! 1221: { ! 1222: int iuuconf; ! 1223: ! 1224: iuuconf = uuconf_callout (puuconf, qsys, ! 1225: &zcallout_login, ! 1226: &zcallout_pass); ! 1227: if (iuuconf == UUCONF_NOT_FOUND ! 1228: || zcallout_login == NULL) ! 1229: { ! 1230: ulog (LOG_ERROR, ! 1231: "chat-program: No login defined"); ! 1232: fret = FALSE; ! 1233: break; ! 1234: } ! 1235: else if (iuuconf != UUCONF_SUCCESS) ! 1236: { ! 1237: ulog_uuconf (LOG_ERROR, puuconf, iuuconf); ! 1238: fret = FALSE; ! 1239: break; ! 1240: } ! 1241: } ! 1242: zlog = zcallout_login; ! 1243: } ! 1244: zadd = zlog; ! 1245: } ! 1246: break; ! 1247: case 'P': ! 1248: { ! 1249: const char *zpass; ! 1250: ! 1251: if (qsys == NULL) ! 1252: { ! 1253: ulog (LOG_ERROR, "chat-program: Illegal use of \\P"); ! 1254: fret = FALSE; ! 1255: break; ! 1256: } ! 1257: zpass = qsys->uuconf_zcall_password; ! 1258: if (zpass == NULL) ! 1259: { ! 1260: ulog (LOG_ERROR, "chat-program: No password defined"); ! 1261: fret = FALSE; ! 1262: break; ! 1263: } ! 1264: if (zpass[0] == '*' && zpass[1] == '\0') ! 1265: { ! 1266: if (zcallout_pass == NULL) ! 1267: { ! 1268: int iuuconf; ! 1269: ! 1270: iuuconf = uuconf_callout (puuconf, qsys, ! 1271: &zcallout_login, ! 1272: &zcallout_pass); ! 1273: if (iuuconf == UUCONF_NOT_FOUND ! 1274: || zcallout_pass == NULL) ! 1275: { ! 1276: ulog (LOG_ERROR, ! 1277: "chat-program: No password defined"); ! 1278: fret = FALSE; ! 1279: break; ! 1280: } ! 1281: else if (iuuconf != UUCONF_SUCCESS) ! 1282: { ! 1283: ulog_uuconf (LOG_ERROR, puuconf, iuuconf); ! 1284: fret = FALSE; ! 1285: break; ! 1286: } ! 1287: } ! 1288: zpass = zcallout_pass; ! 1289: } ! 1290: zadd = zpass; ! 1291: } ! 1292: break; ! 1293: case 'D': ! 1294: if (qdial == NULL || zphone == NULL) ! 1295: { ! 1296: ulog (LOG_ERROR, "chat-program: Illegal use of \\D"); ! 1297: fret = FALSE; ! 1298: break; ! 1299: } ! 1300: zadd = zphone; ! 1301: break; ! 1302: case 'T': ! 1303: { ! 1304: const char *zprefix, *zsuffix; ! 1305: ! 1306: if (qdial == NULL || zphone == NULL) ! 1307: { ! 1308: ulog (LOG_ERROR, "chat-program: Illegal use of \\T"); ! 1309: fret = FALSE; ! 1310: break; ! 1311: } ! 1312: ! 1313: if (! fctranslate (puuconf, zphone, &zprefix, &zsuffix)) ! 1314: { ! 1315: fret = FALSE; ! 1316: break; ! 1317: } ! 1318: ! 1319: if (zsuffix == NULL) ! 1320: zadd = zprefix; ! 1321: else ! 1322: { ! 1323: size_t cprefix; ! 1324: ! 1325: cprefix = strlen (zprefix); ! 1326: if (clen + cprefix + 1 > calc) ! 1327: { ! 1328: char *znew; ! 1329: ! 1330: calc = clen + cprefix + 20; ! 1331: znew = zbufalc (calc); ! 1332: memcpy (znew, *pzarg, clen); ! 1333: ubuffree (*pzarg); ! 1334: *pzarg = znew; ! 1335: zto = znew + clen; ! 1336: } ! 1337: memcpy (zto, zprefix, cprefix); ! 1338: zto += cprefix; ! 1339: clen += cprefix; ! 1340: zadd = zsuffix; ! 1341: } ! 1342: } ! 1343: break; ! 1344: case 'Y': ! 1345: if (zLdevice == NULL && zport == NULL) ! 1346: { ! 1347: ulog (LOG_ERROR, "chat-program: Illegal use of \\Y"); ! 1348: fret = FALSE; ! 1349: break; ! 1350: } ! 1351: /* zLdevice will generally make more sense than zport, but ! 1352: it might not be set yet. */ ! 1353: zadd = zLdevice; ! 1354: if (zadd == NULL) ! 1355: zadd = zport; ! 1356: break; ! 1357: case 'Z': ! 1358: if (qsys == NULL) ! 1359: { ! 1360: ulog (LOG_ERROR, "chat-program: Illegal use of \\Z"); ! 1361: fret = FALSE; ! 1362: break; ! 1363: } ! 1364: zadd = qsys->uuconf_zname; ! 1365: break; ! 1366: case 'S': ! 1367: { ! 1368: if (ibaud == 0) ! 1369: { ! 1370: ulog (LOG_ERROR, "chat-program: Illegal use of \\S"); ! 1371: fret = FALSE; ! 1372: break; ! 1373: } ! 1374: sprintf (abadd, "%ld", ibaud); ! 1375: zadd = abadd; ! 1376: } ! 1377: break; ! 1378: default: ! 1379: { ! 1380: ulog (LOG_ERROR, ! 1381: "chat-program: Unrecognized escape sequence \\%c", ! 1382: *zfrom); ! 1383: abadd[0] = *zfrom; ! 1384: abadd[1] = '\0'; ! 1385: zadd = abadd; ! 1386: } ! 1387: break; ! 1388: } ! 1389: ! 1390: if (! fret) ! 1391: break; ! 1392: ! 1393: cadd = strlen (zadd); ! 1394: if (clen + cadd + 1 > calc) ! 1395: { ! 1396: char *znew; ! 1397: ! 1398: calc = clen + cadd + 20; ! 1399: znew = zbufalc (calc); ! 1400: memcpy (znew, *pzarg, clen); ! 1401: ubuffree (*pzarg); ! 1402: *pzarg = znew; ! 1403: zto = znew + clen; ! 1404: } ! 1405: memcpy (zto, zadd, cadd + 1); ! 1406: zto += cadd; ! 1407: clen += cadd; ! 1408: } ! 1409: ! 1410: if (! fret) ! 1411: break; ! 1412: ! 1413: *zto++ = '\0'; ! 1414: ++clen; ! 1415: } ! 1416: ! 1417: *pzarg = NULL; ! 1418: ! 1419: if (fret) ! 1420: fret = fconn_run_chat (qconn, pzpass); ! 1421: ! 1422: for (pz = pzpass; *pz != NULL; pz++) ! 1423: ubuffree (*pz); ! 1424: xfree ((pointer) pzpass); ! 1425: xfree ((pointer) zcallout_login); ! 1426: xfree ((pointer) zcallout_pass); ! 1427: ! 1428: return fret; ! 1429: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.