ckuscr.c

   1 #include "ckcsym.h"
   2
   3 #ifndef NOICP
   4 #ifndef NOSCRIPT
   5 char *loginv = "Script Command, 9.0.032, 16 Oct 2009";
   6
   7 /*  C K U S C R  --  expect-send script implementation  */
   8
   9 /*
  10   Copyright (C) 1985, 2009,
  11     Trustees of Columbia University in the City of New York.
  12     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  13     copyright text in the ckcmai.c module for disclaimer and permissions.
  14
  15   Original (version 1, 1985) author: Herm Fischer, Encino, CA.
  16   Contributed to Columbia University in 1985 for inclusion in C-Kermit 4.0.
  17   Maintained since 1985 by Frank da Cruz, Columbia University,
  18   fdc@columbia.edu.
  19
  20   The module takes a UUCP-style script of the "expect send [expect send] ..."
  21   format.  It is intended to operate similarly to the way the common
  22   UUCP L.sys login entries work.  Conditional responses are supported:
  23   expect[-send-expect[...]], as with UUCP.  The send keyword EOT sends a
  24   Control-d, and the keyword BREAK sends a break.  Letters prefixed
  25   by '~' are '~b' backspace, '~s' space, '~n' linefeed, '~r' return, '~x' xon,
  26   '~t' tab, '~q' ? (not allowed on kermit command lines), '~' ~, '~'',
  27   '~"', '~c' don't append return, '~o[o[o]]' octal character.  As with
  28   some uucp systems, sent strings are followed by ~r (not ~n) unless they
  29   end with ~c. Null expect strings (e.g., ~0 or --) cause a short
  30   delay, and are useful for sending sequences requiring slight pauses.
  31
  32   This module calls externally defined system-dependent functions for
  33   communications i/o, as defined in ckcplm.txt, the C-Kermit Program Logic
  34   Manual, and thus should be portable to all systems that implement those
  35   functions, and where alarm() and signal() work as they do in UNIX.
  36 */
  37 #include "ckcdeb.h"
  38 #include <signal.h>
  39 #ifdef NT
  40 #include <setjmpex.h>
  41 #else /* NT */
  42 #include <setjmp.h>
  43 #endif /* NT */
  44 #include "ckcasc.h"
  45 #include "ckcker.h"
  46 #include "ckuusr.h"
  47 #include "ckcnet.h"
  48 #include "ckcsig.h"
  49
  50 _PROTOTYP( VOID flushi, (void) );
  51 _PROTOTYP( static VOID myflsh, (void) );
  52 _PROTOTYP( static int sequenc, (void) );
  53 _PROTOTYP( static VOID recvseq, (void) );
  54 _PROTOTYP( static int outseq, (void) );
  55
  56 #ifdef MAC
  57 #define signal msignal
  58 #define SIGTYP long
  59 #define alarm malarm
  60 #define SIG_IGN 0
  61 #define SIGALRM 1
  62 #define SIGINT  2
  63 SIGTYP (*msignal(int type, SIGTYP (*func)(int)))(int);
  64 #endif /* MAC */
  65
  66 #ifdef AMIGA
  67 #define signal asignal
  68 #define alarm aalarm
  69 #define SIGALRM (_NUMSIG+1)
  70 #define SIGTYP void
  71 SIGTYP (*asignal(int type, SIGTYP (*func)(int)))(int);
  72 unsigned aalarm(unsigned);
  73 #endif /* AMIGA */
  74
  75 #ifdef STRATUS
  76 /* VOS doesn't have alarm(), but it does have some things we can work with. */
  77 /* however, we have to catch all the signals in one place to do this, so    */
  78 /* we intercept the signal() routine and call it from our own replacement.  */
  79 #define signal vsignal
  80 #define alarm valarm
  81 SIGTYP (*vsignal(int type, SIGTYP (*func)(int)))(int);
  82 int valarm(int interval);
  83 #endif /* STRATUS */
  84
  85 extern int sessft;
  86 extern int local, flow, seslog, mdmtyp, msgflg, duplex, backgrd, secho, quiet;
  87 extern int network, nettype, ttnproto;
  88 extern long speed;
  89 extern char ttname[];
  90
  91 #ifdef NTSIG
  92 extern int TlsIndex;
  93 #endif /* NTSIG */
  94 #ifdef IKSD
  95 extern int inserver;
  96 #endif /* IKSD */
  97
  98 static int is_tn = 0;                   /* Do Telnet negotiations */
  99
 100 #ifndef NOSPL
 101 #ifdef DCMDBUF
 102 extern struct cmdptr *cmdstk;
 103 #else
 104 extern struct cmdptr cmdstk[];
 105 #endif /* DCMDBUF */
 106 extern int techo, cmdlvl;
 107 extern int mecho;
 108 #endif /* NOSPL */
 109
 110 static int scr_echo;                    /* Whether to echo script commands */
 111
 112 static int exp_alrm = 15;               /* Time to wait for expect string */
 113 #define SND_ALRM 15                     /* Time to allow for sending string */
 114 #define NULL_EXP 2                      /* Time to pause on null expect strg*/
 115 #define DEL_MSEC 300                    /* Milliseconds to pause on ~d */
 116
 117 #define SBUFL 512
 118 static char seq_buf[SBUFL+2], *s;       /* expect-send sequence buffer */
 119 static int got_it, no_cr;
 120
 121 /*  Connect state parent/child communication signal handlers */
 122
 123 #ifdef COMMENT
 124 #ifdef CK_POSIX_SIG
 125 static sigjmp_buf alrmrng;
 126 #else
 127 static jmp_buf alrmrng;
 128 #endif /* CK_POSIX_SIG */
 129 #else
 130 static ckjmpbuf alrmrng;
 131 #endif /* COMMENT */
 132
 133 static SIGTYP
 134 #ifdef CK_ANSIC
 135 scrtime(int foo)                        /* modem read failure handler, */
 136 #else
 137 scrtime(foo) int foo;                   /* Alarm handler */
 138 #endif /* CK_ANSIC */
 139 /* scrtime */ {
 140
 141 #ifdef BEBOX
 142 #ifdef BE_DR_7
 143     alarm_expired();
 144 #endif /* BE_DR_7 */
 145 #endif /* BEBOX */
 146 #ifdef NTSIG
 147     if (foo == SIGALRM)
 148       PostAlarmSigSem();
 149     else
 150       PostCtrlCSem();
 151 #else /* NTSIG */
 152 #ifdef NT
 153     cklongjmp(ckjaddr(alrmrng),1);
 154 #else /* NT */
 155     cklongjmp(alrmrng,1);
 156 #endif /* NT */
 157 #endif /* NTSIG */
 158     SIGRETURN;
 159 }
 160
 161 /*
 162  Sequence interpreter -- pick up next sequence from command string,
 163  decode escapes and place into seq_buf.
 164
 165  If string contains a ~d (delay) then sequenc() returns a 1 expecting
 166  to be called again after the ~d executes.
 167 */
 168 static int
 169 sequenc() {
 170     int i;
 171     char c, oct_char;
 172
 173     no_cr = 0;                          /* output needs cr appended */
 174     for (i = 0; i < SBUFL; ) {
 175         if (*s == '\0' || *s == '-' || isspace(*s) ) { /* done */
 176             seq_buf[i] = '\0';
 177             return(0) ;
 178         }
 179         if (*s == '~') {                /* escape character */
 180             s++;
 181             switch (c = *s) {
 182                 case 'n':  seq_buf[i++] = LF; break;
 183                 case 'r':  seq_buf[i++] = CR; break;
 184                 case 't':  seq_buf[i++] = '\t'; break;
 185                 case 'b':  seq_buf[i++] = '\b'; break;
 186                 case 'q':  seq_buf[i++] = '?';  break;
 187 #ifdef COMMENT
 188 /* The default case should catch these now... */
 189                 case '~':  seq_buf[i++] = '~';  break;
 190                 case '-':  seq_buf[i++] = '-';  break;
 191 #endif /* COMMENT */
 192                 case '\'': seq_buf[i++] = '\''; break;
 193                 case '\"': seq_buf[i++] = '\"'; break;
 194                 case 's':  seq_buf[i++] = ' ';  break;
 195                 case 'x':  seq_buf[i++] = '\021'; break;
 196                 case 'c':  no_cr = 1; break;
 197                 case 'd': {                     /* send what we have & then */
 198                     seq_buf[i] = '\0';          /* expect to send rest after */
 199                     no_cr = 1;                  /* sender delays a little */
 200                     s++;
 201                     return(1);
 202                 }
 203                 case 'w': {                     /* wait count */
 204                     exp_alrm = 15;              /* default to 15 sec */
 205                     if (isdigit(*(s+1))) {
 206                         s++;
 207                         exp_alrm = *s & 15;
 208                         if (isdigit(*(s+1)) ) {
 209                             s++;
 210                             exp_alrm = exp_alrm * 10 + (*s & 15);
 211                         }
 212                     }
 213                     break;
 214                 }
 215                 default:
 216                     if ( isdigit(c) ) {         /* octal character */
 217                         oct_char = (char) (c & 7); /* most significant digit */
 218                         if (isdigit( *(s+1) ) ) {
 219                             s++;
 220                             oct_char = (char) ((oct_char<<3) | ( *s & 7 ));
 221                             if (isdigit( *(s+1) ) ) {
 222                                 s++;
 223                                 oct_char = (char) ((oct_char<<3) | ( *s & 7 ));
 224                             }
 225                         }
 226                         seq_buf[i++] = oct_char;
 227                         break;
 228                     } else seq_buf[i++] = *s; /* Treat ~ as quote */
 229               }
 230         } else seq_buf[i++] = *s;       /* Plain old character */
 231         s++;
 232     }
 233     seq_buf[i] = '\0';
 234     return(0);                          /* end of space, return anyway */
 235 }
 236
 237
 238 /* Output buffering for "recvseq" and "flushi" */
 239
 240 #define MAXBURST 256            /* maximum size of input burst */
 241 static CHAR conbuf[MAXBURST];   /* buffer to hold output for console */
 242 static int concnt = 0;          /* number of characters buffered */
 243 static CHAR sesbuf[MAXBURST];   /* buffer to hold output for session log */
 244 static int sescnt = 0;          /* number of characters buffered */
 245
 246 static VOID
 247 myflsh() {
 248     if (concnt > 0) {
 249         conxo(concnt, (char *) conbuf);
 250         concnt = 0;
 251     }
 252     if (sescnt > 0) {
 253         logstr((char *) sesbuf, sescnt);
 254         sescnt = 0;
 255     }
 256 }
 257
 258 /* these variables are used to pass data between the recvseq() */
 259 /* and the dorseq().  They are necessary because in some versions */
 260 /* dorseq() is executed in a separate thread and data cannot be */
 261 /* passed by parameter. */
 262
 263 static char *rseqe, * rseqgot, * rseqtrace ;
 264 static int rseql;
 265
 266 static SIGTYP
 267 #ifdef CK_ANSIC
 268 dorseq(void * threadinfo)
 269 #else /* CK_ANSIC */
 270 dorseq(threadinfo) VOID * threadinfo;
 271 #endif /* CK_ANSIC */
 272 /* dorseq */ {
 273     int i, x;
 274     int burst = 0;                      /* chars remaining in input burst */
 275
 276 #ifdef NTSIG
 277     setint();
 278     if (threadinfo) {                   /* Thread local storage... */
 279         TlsSetValue(TlsIndex,threadinfo);
 280     }
 281 #endif /* NTSIG */
 282 #ifdef CK_LOGIN
 283 #ifdef NT
 284 #ifdef IKSD
 285     if (inserver)
 286       setntcreds();
 287 #endif /* IKSD */
 288 #endif /* NT */
 289 #endif /* CK_LOGIN */
 290
 291     while (!got_it) {
 292         for (i = 0; i < rseql-1; i++) rseqgot[i] = rseqgot[i+1];
 293         x = ttinc(0);                   /* Read a character */
 294         debug(F101,"recvseq","",x);
 295         if (x < 0) {
 296 #ifdef NTSIG
 297             ckThreadEnd(threadinfo);
 298 #endif /* NTSIG */
 299             SIGRETURN;                  /* Check for error */
 300         }
 301 #ifdef NETCONN
 302 #ifdef TNCODE
 303 /* Check for telnet protocol negotiation */
 304         if (((x & 0xff) == IAC) && is_tn) { /* Telnet negotiation */
 305             myflsh();
 306             burst = 0;
 307             switch (tn_doop((CHAR)(x & 0xff),duplex,ttinc)) {
 308               case 2: duplex = 0; continue;
 309               case 1: duplex = 1;
 310               default: continue;
 311             }
 312         }
 313 #endif /* TNCODE */
 314 #endif /* NETCONN */
 315         rseqgot[rseql-1] = (char) (x & 0x7f); /* Got a character */
 316         burst--;                        /* One less waiting */
 317         if (scr_echo) conbuf[concnt++] = rseqgot[rseql-1]; /* Buffer it */
 318         if (seslog)                     /* Log it in session log */
 319 #ifdef UNIX
 320           if (sessft != 0 || rseqgot[rseql-1] != '\r')
 321 #else
 322 #ifdef OSK
 323             if (sessft != 0 || rseqgot[rseql-1] != '\012')
 324 #endif /* OSK */
 325 #endif /* UNIX */
 326               if (rseqgot[rseql-1])     /* Filter out NULs */
 327                 sesbuf[sescnt++] = rseqgot[rseql-1];
 328         if ((int)strlen(rseqtrace) < SBUFL-2 )
 329           strcat(rseqtrace,dbchr(rseqgot[rseql-1]));
 330         got_it = (!strncmp(rseqe, rseqgot, rseql));
 331         if (burst <= 0) {               /* Flush buffered output */
 332             myflsh();
 333             if ((burst = ttchk()) < 0) { /* Get size of next input burst */
 334 #ifdef NTSIG
 335                 ckThreadEnd(threadinfo);
 336 #endif /* NTSIG */
 337                 SIGRETURN;
 338             }
 339             /* prevent overflow of "conbuf" and "sesbuf" */
 340             if (burst > MAXBURST)
 341               burst = MAXBURST;
 342         }
 343     }
 344 #ifdef NTSIG
 345     ckThreadEnd(threadinfo);
 346 #endif /* NTSIG */
 347     SIGRETURN;
 348 }
 349
 350 static SIGTYP
 351 #ifdef CK_ANSIC
 352 failrseq(void * threadinfo)
 353 #else /* CK_ANSIC */
 354 failrseq(threadinfo) VOID * threadinfo;
 355 #endif /* CK_ANSIC */
 356 /* failrseq */ {
 357      got_it = 0;                        /* Timed out here */
 358      SIGRETURN;
 359 }
 360
 361 /*
 362   Receive sequence -- see if expected response comes,
 363   return success (or failure) in got_it.
 364 */
 365 static VOID
 366 recvseq() {
 367     char *e, got[7], trace[SBUFL];
 368     int i, l;
 369
 370     sequenc();
 371     l = (int)strlen(e=seq_buf);         /* no more than 7 chars allowed */
 372     if (l > 7) {
 373         e += l-7;
 374         l = 7;
 375     }
 376     tlog(F111,"expecting sequence",e,(long) l);
 377     if (l == 0) {                       /* null sequence, delay a little */
 378         sleep (NULL_EXP);
 379         got_it = 1;
 380         tlog(F100,"got it (null sequence)","",0L);
 381         return;
 382     }
 383     *trace = '\0';
 384     for (i = 0; i < 7; i++) got[i]='\0';
 385
 386     rseqtrace = trace;
 387     rseqe = e;
 388     rseqgot = got;
 389     rseql = l;
 390
 391     alrm_execute(ckjaddr(alrmrng), exp_alrm, scrtime, dorseq, failrseq);
 392
 393     tlog(F110,"received sequence: ",trace,0L);
 394     tlog(F101,"returning with got-it code","",(long) got_it);
 395     myflsh();                           /* Flush buffered output */
 396     return;
 397 }
 398
 399 /*
 400  Output A Sequence starting at pointer s,
 401  return 0 if okay,
 402  1 if failed to read (modem hangup or whatever)
 403 */
 404 static int oseqret = 0;                 /* Return code for outseq */
 405                                         /* Out here to prevent clobbering */
 406                                         /* by longjmp. */
 407
 408 static SIGTYP
 409 #ifdef CK_ANSIC
 410 dooseq(void * threadinfo)
 411 #else /* CK_ANSIC */
 412 dooseq(threadinfo) VOID * threadinfo;
 413 #endif /* CK_ANSIC */
 414 {
 415     int l;
 416     char *sb;
 417 #ifdef TCPSOCKET
 418     extern int tn_nlm, tn_b_nlm;
 419 #endif /* TCPSOCKET */
 420
 421 #ifdef NTSIG
 422     setint();
 423     if (threadinfo) {                   /* Thread local storage... */
 424         TlsSetValue(TlsIndex,threadinfo);
 425     }
 426 #endif /* NTSIG */
 427 #ifdef CK_LOGIN
 428 #ifdef NT
 429 #ifdef IKSD
 430     if (inserver)
 431       setntcreds();
 432 #endif /* IKSD */
 433 #endif /* NT */
 434 #endif /* CK_LOGIN */
 435
 436     l = (int)strlen(seq_buf);
 437     tlog(F111,"sending sequence ",seq_buf,(long) l);
 438
 439     if (!strcmp(seq_buf,"EOT")) {
 440         ttoc(dopar('\004'));
 441         if (scr_echo) conol("<EOT>");
 442         if (seslog && duplex)
 443             logstr("<EOT>",5);
 444     } else if (!strcmp(seq_buf,"BREAK") ||
 445                !strcmp(seq_buf,"\\b") ||
 446                !strcmp(seq_buf,"\\B")) {
 447         ttsndb();
 448         if (scr_echo) conol("<BREAK>");
 449         if (seslog)
 450           logstr("{BREAK}",7);
 451     } else {
 452         if (l > 0) {
 453             for ( sb = seq_buf; *sb; sb++)
 454               *sb = dopar(*sb); /* add parity */
 455             ttol((CHAR *)seq_buf,l); /* send it */
 456             if (scr_echo && duplex) {
 457 #ifndef NOLOCAL
 458 #ifdef OS2
 459                 {                       /* Echo to emulator */
 460                     char *s = seq_buf;
 461                     while (*s) {
 462                         scriptwrtbuf((USHORT)*s);
 463                     }
 464                 }
 465 #endif /* OS2 */
 466 #endif /* NOLOCAL */
 467                 conxo(l,seq_buf);
 468             }
 469             if (seslog && duplex) /* log it */
 470               logstr(seq_buf,strlen(seq_buf));
 471         }
 472         if (!no_cr) {
 473             ttoc( dopar(CR) );
 474 #ifdef TCPSOCKET
 475             if (is_tn) {
 476                 if (!TELOPT_ME(TELOPT_BINARY) && tn_nlm != TNL_CR)
 477                   ttoc((char)((tn_nlm == TNL_CRLF) ?
 478                               dopar(LF) : dopar(NUL)));
 479                 else if (TELOPT_ME(TELOPT_BINARY) &&
 480                          (tn_b_nlm == TNL_CRLF || tn_b_nlm == TNL_CRNUL))
 481                   ttoc((char)((tn_b_nlm == TNL_CRLF) ?
 482                               dopar(LF) : dopar(NUL)));
 483             }
 484 #endif /* TCPSOCKET */
 485             if (seslog && duplex)
 486               logchar(dopar(CR));
 487         }
 488     }
 489 #ifdef NTSIG
 490     ckThreadEnd(threadinfo);
 491 #endif /* NTSIG */
 492     SIGRETURN;
 493 }
 494
 495 SIGTYP
 496 #ifdef CK_ANSIC
 497 failoseq(void * threadinfo)
 498 #else /* CK_ANSIC */
 499 failoseq(threadinfo) VOID * threadinfo;
 500 #endif /* CK_ANSIC */
 501 /* failoseq */ {
 502      oseqret = -1;              /* else -- alarm rang */
 503      SIGRETURN;
 504 }
 505
 506 static int
 507 outseq() {
 508     int delay;
 509
 510     oseqret = 0;                        /* Initialize return code */
 511     while(1) {
 512         delay = sequenc();
 513         alrm_execute( ckjaddr(alrmrng), SND_ALRM, scrtime, dooseq, failoseq ) ;
 514
 515         if (!delay)
 516           return(oseqret);
 517 #ifndef MAC
 518         msleep(DEL_MSEC);               /* delay, loop to next send */
 519 #endif /* MAC */
 520     }
 521 }
 522
 523
 524 /*  L O G I N  --  (historical misnomer) Execute the SCRIPT command */
 525
 526 int
 527 dologin(cmdstr) char *cmdstr; {
 528
 529 #ifdef OS2
 530 #ifdef NT
 531     SIGTYP (* savealm)(int);            /* Save incoming alarm function */
 532 #else /* NT */
 533     SIGTYP (* volatile savealm)(int);   /* Save incoming alarm function */
 534 #endif /* NT */
 535 #else /* OS2 */
 536     SIGTYP (*savealm)();                /* Save incoming alarm function */
 537 #endif /* OS2 */
 538     char *e;
 539
 540     s = cmdstr;                         /* Make global to this module */
 541
 542     tlog(F100,loginv,"",0L);
 543
 544     if (speed < 0L) speed = ttgspd();
 545     if (ttopen(ttname,&local,mdmtyp,0) < 0) {
 546         ckmakmsg(seq_buf,SBUFL,"Sorry, can't open ",ttname,NULL,NULL);
 547         perror(seq_buf);
 548         return(0);
 549     }
 550     /* Whether to echo script commands ... */
 551     scr_echo = (!quiet && !backgrd && secho);
 552 #ifndef NOSPL
 553     if (scr_echo && cmdlvl > 1) {
 554         if (cmdstk[cmdlvl].src == CMD_TF)
 555           scr_echo = techo;
 556         if (cmdstk[cmdlvl].src == CMD_MD)
 557           scr_echo = mecho;
 558     }
 559 #endif /* NOSPL */
 560     if (scr_echo) {
 561 #ifdef NETCONN
 562         if (network)
 563           printf("Executing SCRIPT to host %s.\n",ttname);
 564         else
 565 #endif /* NETCONN */
 566           printf("Executing SCRIPT through %s, speed %ld.\n",ttname,speed);
 567     }
 568 #ifdef TNCODE
 569     /* TELNET input must be scanned for IAC */
 570     is_tn = (local && network && IS_TELNET()) ||
 571             (!local && sstelnet);
 572 #endif /* TNCODE */
 573
 574     *seq_buf = 0;
 575     for (e = s; *e; e++) ckstrncat(seq_buf,dbchr(*e),SBUFL);
 576 #ifdef COMMENT
 577 /* Skip this because it tends to contain a password... */
 578     if (scr_echo) printf("SCRIPT string: %s\n",seq_buf);
 579 #endif /* COMMENT */
 580     tlog(F110,"SCRIPT string: ",seq_buf, 0L);
 581
 582 /* Condition console terminal and communication line... */
 583
 584     if (ttvt(speed,flow) < 0) {
 585         printf("Sorry, Can't condition communication line\n");
 586         return(0);
 587     }
 588     /* Save initial timer interrupt value */
 589     savealm = signal(SIGALRM,SIG_IGN);
 590
 591     flushi();                           /* Flush stale input */
 592
 593 /* start expect - send sequence */
 594
 595     while (*s) {                        /* While not done with buffer */
 596
 597         while (*s && isspace(*s)) s++;  /* Skip over separating whitespaces */
 598                                         /* Gather up expect sequence */
 599         got_it = 0;
 600         recvseq();
 601
 602         while (!got_it) {               /* Have it yet? */
 603             if (*s++ != '-')            /* No, is there a conditional send? */
 604               goto failret;             /* No, return failure */
 605             flushi();                   /* Yes, flush out input buffer */
 606             if (outseq())               /* If unable to send, */
 607               goto failret;             /* return failure. */
 608             if (*s++ != '-')            /* If no conditional response here, */
 609               goto failret;             /* return failure. */
 610             recvseq();                  /* All OK, read response from host. */
 611         }                               /* Loop back and check got_it */
 612
 613         while (*s && !isspace(*s++) ) ; /* Skip over conditionals */
 614         while (*s && isspace(*s)) s++;  /* Skip over separating whitespaces */
 615         flushi();                       /* Flush */
 616         if (*s) if (outseq()) goto failret; /* If any */
 617     }
 618     signal(SIGALRM,savealm);
 619     if (scr_echo) printf("Script successful.\n");
 620     tlog(F100,"Script successful.","",0L);
 621     return(1);
 622
 623 failret:
 624     signal(SIGALRM,savealm);
 625     if (scr_echo) printf("Sorry, script failed\n");
 626     tlog(F100,"Script failed","",0L);
 627     return(0);
 628 }
 629
 630 /*  F L U S H I  --  Flush, but log, SCRIPT input buffer  */
 631
 632 VOID
 633 flushi() {
 634     int n, x;
 635     if (
 636         seslog                          /* Logging session? */
 637         || scr_echo                     /* Or console echoing? */
 638 #ifdef NETCONN
 639 #ifdef TNCODE
 640         /* TELNET input must be scanned for IAC */
 641         || is_tn
 642 #endif /* TNCODE */
 643 #endif /* NETCONN */
 644         ) {
 645         if ((n = ttchk()) < 0)          /* Yes, anything in buffer? */
 646           return;
 647         if (n > MAXBURST) n = MAXBURST; /* Make sure not too much, */
 648         myflsh();                       /* and that buffers are empty. */
 649         while (n-- > 0) {
 650             x = ttinc(0);               /* Collect a character */
 651 #ifdef NETCONN
 652 #ifdef TNCODE
 653 /* Check for telnet protocol negotiation */
 654             if (is_tn && ((x & 0xff) == IAC) ) {
 655                 myflsh();               /* Sync output */
 656                 switch (tn_doop((CHAR)(x & 0xff),duplex,ttinc)) {
 657                   case 2: duplex = 0; break;
 658                   case 1: duplex = 1;
 659                   default: break;
 660                 }
 661
 662                 /* Recalculate flush count */
 663                 if ((n = ttchk()) < 0)
 664                   return;
 665                 if (n > MAXBURST) n = MAXBURST;
 666                 continue;
 667             }
 668 #endif /* TNCODE */
 669 #endif /* NETCONN */
 670             if (scr_echo) conbuf[concnt++] = (CHAR) x; /* buffer for console */
 671             if (seslog)
 672 #ifdef UNIX
 673               if (sessft != 0 || x != '\r')
 674 #else
 675 #ifdef OSK
 676               if (sessft != 0 || x != '\012')
 677 #endif /* OSK */
 678 #endif /* UNIX */
 679                 sesbuf[sescnt++] = (CHAR) x; /* buffer for session log */
 680         }
 681         myflsh();
 682     } else ttflui();                    /* Otherwise just flush. */
 683 }
 684
 685 #else /* NOSCRIPT */
 686 char *loginv = "Script Command Disabled";
 687 #endif /* NOSCRIPT */
 688 #endif /* NOICP */