Mercurial > illumos > onarm
annotate usr/src/cmd/cmd-inet/usr.bin/telnet/utilities.c @ 4:1a15d5aaf794
synchronized with onnv_86 (6202) in onnv-gate
| author | Koji Uno <koji.uno@sun.com> |
|---|---|
| date | Mon, 31 Aug 2009 14:38:03 +0900 |
| parents | c9caec207d52 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 * Copyright 1994-2002 Sun Microsystems, Inc. All rights reserved. | |
| 3 * Use is subject to license terms. | |
| 4 */ | |
| 5 | |
|
4
1a15d5aaf794
synchronized with onnv_86 (6202) in onnv-gate
Koji Uno <koji.uno@sun.com>
parents:
0
diff
changeset
|
6 #pragma ident "%Z%%M% %I% %E% SMI" |
| 0 | 7 |
| 8 /* | |
| 9 * usr/src/cmd/cmd-inet/usr.bin/telnet/utilities.c | |
| 10 */ | |
| 11 | |
| 12 /* | |
| 13 * Copyright (c) 1988, 1993 | |
| 14 * The Regents of the University of California. All rights reserved. | |
| 15 * | |
| 16 * Redistribution and use in source and binary forms, with or without | |
| 17 * modification, are permitted provided that the following conditions | |
| 18 * are met: | |
| 19 * 1. Redistributions of source code must retain the above copyright | |
| 20 * notice, this list of conditions and the following disclaimer. | |
| 21 * 2. Redistributions in binary form must reproduce the above copyright | |
| 22 * notice, this list of conditions and the following disclaimer in the | |
| 23 * documentation and/or other materials provided with the distribution. | |
| 24 * 3. All advertising materials mentioning features or use of this software | |
| 25 * must display the following acknowledgement: | |
| 26 * This product includes software developed by the University of | |
| 27 * California, Berkeley and its contributors. | |
| 28 * 4. Neither the name of the University nor the names of its contributors | |
| 29 * may be used to endorse or promote products derived from this software | |
| 30 * without specific prior written permission. | |
| 31 * | |
| 32 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
| 33 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| 34 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| 35 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
| 36 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
| 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
| 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
| 40 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
| 41 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
| 42 * SUCH DAMAGE. | |
| 43 */ | |
| 44 | |
| 45 #ifndef lint | |
| 46 static char sccsid[] = "@(#)utilities.c 8.1 (Berkeley) 6/6/93"; | |
| 47 #endif /* not lint */ | |
| 48 | |
| 49 #define TELOPTS | |
| 50 #ifdef lint | |
| 51 static char *telcmds[] = {0}; | |
| 52 static char *slc_names[] = {0}; | |
| 53 static char *encrypt_names[] = {0}; | |
| 54 static char *enctype_names[] = {0}; | |
| 55 #else /* lint */ | |
| 56 #define TELCMDS | |
| 57 #define SLC_NAMES | |
| 58 #endif /* lint */ | |
| 59 #include <arpa/telnet.h> | |
| 60 #include <sys/types.h> | |
| 61 #include <sys/time.h> | |
| 62 #include <sys/param.h> | |
| 63 #include <sys/socket.h> | |
| 64 #include <errno.h> | |
| 65 | |
| 66 #include <ctype.h> | |
| 67 | |
| 68 #include "general.h" | |
| 69 | |
| 70 #include "ring.h" | |
| 71 | |
| 72 #include "defines.h" | |
| 73 | |
| 74 #include "externs.h" | |
| 75 | |
| 76 FILE *NetTrace = 0; /* Not in bss, since needs to stay */ | |
| 77 int prettydump; | |
| 78 | |
| 79 /* | |
| 80 * upcase() | |
| 81 * | |
| 82 * Upcase (in place) the argument. | |
| 83 */ | |
| 84 | |
| 85 void | |
| 86 upcase(argument) | |
| 87 register char *argument; | |
| 88 { | |
| 89 register int c; | |
| 90 | |
| 91 while ((c = *argument) != 0) { | |
| 92 if (islower(c)) { | |
| 93 *argument = toupper(c); | |
| 94 } | |
| 95 argument++; | |
| 96 } | |
| 97 } | |
| 98 | |
| 99 /* | |
| 100 * SetSockOpt() | |
| 101 * | |
| 102 * Compensate for differences in 4.2 and 4.3 systems. | |
| 103 */ | |
| 104 | |
| 105 int | |
| 106 SetSockOpt(fd, level, option, yesno) | |
| 107 int fd, level, option, yesno; | |
| 108 { | |
| 109 return (setsockopt(fd, level, option, &yesno, sizeof (yesno))); | |
| 110 } | |
| 111 | |
| 112 /* | |
| 113 * The following are routines used to print out debugging information. | |
| 114 */ | |
| 115 | |
| 116 unsigned char NetTraceFile[MAXPATHLEN] = "(standard output)"; | |
| 117 | |
| 118 void | |
| 119 SetNetTrace(file) | |
| 120 register char *file; | |
| 121 { | |
| 122 if (NetTrace && NetTrace != stdout) | |
| 123 (void) fclose(NetTrace); | |
| 124 if (file && (strcmp(file, "-") != 0)) { | |
| 125 NetTrace = fopen(file, "w"); | |
| 126 if (NetTrace) { | |
| 127 (void) strcpy((char *)NetTraceFile, file); | |
| 128 return; | |
| 129 } | |
| 130 (void) fprintf(stderr, "Cannot open %s.\n", file); | |
| 131 } | |
| 132 NetTrace = stdout; | |
| 133 (void) strcpy((char *)NetTraceFile, "(standard output)"); | |
| 134 } | |
| 135 | |
| 136 void | |
| 137 Dump(direction, buffer, length) | |
| 138 char direction; | |
| 139 unsigned char *buffer; | |
| 140 int length; | |
| 141 { | |
| 142 #define BYTES_PER_LINE 32 | |
| 143 #define min(x, y) ((x < y) ? x:y) | |
| 144 unsigned char *pThis; | |
| 145 int offset; | |
| 146 | |
| 147 offset = 0; | |
| 148 | |
| 149 while (length) { | |
| 150 /* print one line */ | |
| 151 (void) fprintf(NetTrace, "%c 0x%x\t", direction, offset); | |
| 152 pThis = buffer; | |
| 153 if (prettydump) { | |
| 154 buffer = buffer + min(length, BYTES_PER_LINE/2); | |
| 155 while (pThis < buffer) { | |
| 156 (void) fprintf(NetTrace, "%c%.2x", | |
| 157 (((*pThis)&0xff) == 0xff) ? '*' : ' ', | |
| 158 (*pThis)&0xff); | |
| 159 pThis++; | |
| 160 } | |
| 161 length -= BYTES_PER_LINE/2; | |
| 162 offset += BYTES_PER_LINE/2; | |
| 163 } else { | |
| 164 buffer = buffer + min(length, BYTES_PER_LINE); | |
| 165 while (pThis < buffer) { | |
| 166 (void) fprintf(NetTrace, "%.2x", (*pThis)&0xff); | |
| 167 pThis++; | |
| 168 } | |
| 169 length -= BYTES_PER_LINE; | |
| 170 offset += BYTES_PER_LINE; | |
| 171 } | |
| 172 if (NetTrace == stdout) { | |
| 173 (void) fprintf(NetTrace, "\r\n"); | |
| 174 } else { | |
| 175 (void) fprintf(NetTrace, "\n"); | |
| 176 } | |
| 177 if (length < 0) { | |
| 178 (void) fflush(NetTrace); | |
| 179 return; | |
| 180 } | |
| 181 /* find next unique line */ | |
| 182 } | |
| 183 (void) fflush(NetTrace); | |
| 184 } | |
| 185 | |
| 186 | |
| 187 void | |
| 188 printoption(direction, cmd, option) | |
| 189 char *direction; | |
| 190 int cmd, option; | |
| 191 { | |
| 192 if (!showoptions) | |
| 193 return; | |
| 194 if (cmd == IAC) { | |
| 195 if (TELCMD_OK(option)) | |
| 196 (void) fprintf(NetTrace, "%s IAC %s", direction, | |
| 197 TELCMD(option)); | |
| 198 else | |
| 199 (void) fprintf(NetTrace, "%s IAC %d", direction, | |
| 200 option); | |
| 201 } else { | |
| 202 register char *fmt; | |
| 203 fmt = (cmd == WILL) ? "WILL" : (cmd == WONT) ? "WONT" : | |
| 204 (cmd == DO) ? "DO" : (cmd == DONT) ? "DONT" : 0; | |
| 205 if (fmt) { | |
| 206 (void) fprintf(NetTrace, "%s %s ", direction, fmt); | |
| 207 if (TELOPT_OK(option)) | |
| 208 (void) fprintf(NetTrace, "%s", TELOPT(option)); | |
| 209 else if (option == TELOPT_EXOPL) | |
| 210 (void) fprintf(NetTrace, "EXOPL"); | |
| 211 else | |
| 212 (void) fprintf(NetTrace, "%d", option); | |
| 213 } else | |
| 214 (void) fprintf(NetTrace, "%s %d %d", direction, cmd, | |
| 215 option); | |
| 216 } | |
| 217 if (NetTrace == stdout) { | |
| 218 (void) fprintf(NetTrace, "\r\n"); | |
| 219 (void) fflush(NetTrace); | |
| 220 } else { | |
| 221 (void) fprintf(NetTrace, "\n"); | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 void | |
| 226 optionstatus() | |
| 227 { | |
| 228 register int i; | |
| 229 extern char will_wont_resp[], do_dont_resp[]; | |
| 230 | |
| 231 for (i = 0; i < SUBBUFSIZE; i++) { | |
| 232 if (do_dont_resp[i]) { | |
| 233 if (TELOPT_OK(i)) | |
| 234 (void) printf("resp DO_DONT %s: %d\n", | |
| 235 TELOPT(i), do_dont_resp[i]); | |
| 236 else if (TELCMD_OK(i)) | |
| 237 (void) printf("resp DO_DONT %s: %d\n", | |
| 238 TELCMD(i), do_dont_resp[i]); | |
| 239 else | |
| 240 (void) printf("resp DO_DONT %d: %d\n", i, | |
| 241 do_dont_resp[i]); | |
| 242 if (my_want_state_is_do(i)) { | |
| 243 if (TELOPT_OK(i)) | |
| 244 (void) printf("want DO %s\n", | |
| 245 TELOPT(i)); | |
| 246 else if (TELCMD_OK(i)) | |
| 247 (void) printf("want DO %s\n", | |
| 248 TELCMD(i)); | |
| 249 else | |
| 250 (void) printf("want DO %d\n", i); | |
| 251 } else { | |
| 252 if (TELOPT_OK(i)) | |
| 253 (void) printf("want DONT %s\n", | |
| 254 TELOPT(i)); | |
| 255 else if (TELCMD_OK(i)) | |
| 256 (void) printf("want DONT %s\n", | |
| 257 TELCMD(i)); | |
| 258 else | |
| 259 (void) printf("want DONT %d\n", i); | |
| 260 } | |
| 261 } else { | |
| 262 if (my_state_is_do(i)) { | |
| 263 if (TELOPT_OK(i)) | |
| 264 (void) printf(" DO %s\n", | |
| 265 TELOPT(i)); | |
| 266 else if (TELCMD_OK(i)) | |
| 267 (void) printf(" DO %s\n", | |
| 268 TELCMD(i)); | |
| 269 else | |
| 270 (void) printf(" DO %d\n", i); | |
| 271 } | |
| 272 } | |
| 273 if (will_wont_resp[i]) { | |
| 274 if (TELOPT_OK(i)) | |
| 275 (void) printf("resp WILL_WONT %s: %d\n", | |
| 276 TELOPT(i), will_wont_resp[i]); | |
| 277 else if (TELCMD_OK(i)) | |
| 278 (void) printf("resp WILL_WONT %s: %d\n", | |
| 279 TELCMD(i), will_wont_resp[i]); | |
| 280 else | |
| 281 (void) printf("resp WILL_WONT %d: %d\n", | |
| 282 i, will_wont_resp[i]); | |
| 283 if (my_want_state_is_will(i)) { | |
| 284 if (TELOPT_OK(i)) | |
| 285 (void) printf("want WILL %s\n", | |
| 286 TELOPT(i)); | |
| 287 else if (TELCMD_OK(i)) | |
| 288 (void) printf("want WILL %s\n", | |
| 289 TELCMD(i)); | |
| 290 else | |
| 291 (void) printf("want WILL %d\n", i); | |
| 292 } else { | |
| 293 if (TELOPT_OK(i)) | |
| 294 (void) printf("want WONT %s\n", | |
| 295 TELOPT(i)); | |
| 296 else if (TELCMD_OK(i)) | |
| 297 (void) printf("want WONT %s\n", | |
| 298 TELCMD(i)); | |
| 299 else | |
| 300 (void) printf("want WONT %d\n", i); | |
| 301 } | |
| 302 } else { | |
| 303 if (my_state_is_will(i)) { | |
| 304 if (TELOPT_OK(i)) | |
| 305 (void) printf(" WILL %s\n", | |
| 306 TELOPT(i)); | |
| 307 else if (TELCMD_OK(i)) | |
| 308 (void) printf(" WILL %s\n", | |
| 309 TELCMD(i)); | |
| 310 else | |
| 311 (void) printf(" WILL %d\n", i); | |
| 312 } | |
| 313 } | |
| 314 } | |
| 315 | |
| 316 } | |
| 317 | |
| 318 void | |
| 319 printsub(direction, pointer, length) | |
| 320 char direction; /* '<' or '>' */ | |
| 321 unsigned char *pointer; /* where suboption data sits */ | |
| 322 int length; /* length of suboption data */ | |
| 323 { | |
| 324 register int i; | |
| 325 char buf[512]; | |
| 326 extern int want_status_response; | |
| 327 | |
| 328 if (showoptions || direction == 0 || | |
| 329 (want_status_response && (pointer[0] == TELOPT_STATUS))) { | |
| 330 if (direction) { | |
| 331 (void) fprintf(NetTrace, "%s IAC SB ", | |
| 332 (direction == '<')? "RCVD":"SENT"); | |
| 333 if (length >= 3) { | |
| 334 register int j; | |
| 335 | |
| 336 i = pointer[length-2]; | |
| 337 j = pointer[length-1]; | |
| 338 | |
| 339 if (i != IAC || j != SE) { | |
| 340 (void) fprintf(NetTrace, | |
| 341 "(terminated by "); | |
| 342 if (TELOPT_OK(i)) | |
| 343 (void) fprintf(NetTrace, "%s ", | |
| 344 TELOPT(i)); | |
| 345 else if (TELCMD_OK(i)) | |
| 346 (void) fprintf(NetTrace, "%s ", | |
| 347 TELCMD(i)); | |
| 348 else | |
| 349 (void) fprintf(NetTrace, "%d ", | |
| 350 i); | |
| 351 if (TELOPT_OK(j)) | |
| 352 (void) fprintf(NetTrace, "%s", | |
| 353 TELOPT(j)); | |
| 354 else if (TELCMD_OK(j)) | |
| 355 (void) fprintf(NetTrace, "%s", | |
| 356 TELCMD(j)); | |
| 357 else | |
| 358 (void) fprintf(NetTrace, "%d", | |
| 359 j); | |
| 360 (void) fprintf(NetTrace, | |
| 361 ", not IAC SE!) "); | |
| 362 } | |
| 363 } | |
| 364 length -= 2; | |
| 365 } | |
| 366 if (length < 1) { | |
| 367 (void) fprintf(NetTrace, "(Empty suboption??\?)"); | |
| 368 if (NetTrace == stdout) | |
| 369 (void) fflush(NetTrace); | |
| 370 return; | |
| 371 } | |
| 372 switch (pointer[0]) { | |
| 373 case TELOPT_TTYPE: | |
| 374 (void) fprintf(NetTrace, "TERMINAL-TYPE "); | |
| 375 switch (pointer[1]) { | |
| 376 case TELQUAL_IS: | |
| 377 (void) fprintf(NetTrace, "IS \"%.*s\"", | |
| 378 length-2, | |
| 379 (char *)pointer+2); | |
| 380 break; | |
| 381 case TELQUAL_SEND: | |
| 382 (void) fprintf(NetTrace, "SEND"); | |
| 383 break; | |
| 384 default: | |
| 385 (void) fprintf(NetTrace, | |
| 386 "- unknown qualifier %d (0x%x).", | |
| 387 pointer[1], pointer[1]); | |
| 388 } | |
| 389 break; | |
| 390 case TELOPT_TSPEED: | |
| 391 (void) fprintf(NetTrace, "TERMINAL-SPEED"); | |
| 392 if (length < 2) { | |
| 393 (void) fprintf(NetTrace, | |
| 394 " (empty suboption??\?)"); | |
| 395 break; | |
| 396 } | |
| 397 switch (pointer[1]) { | |
| 398 case TELQUAL_IS: | |
| 399 (void) fprintf(NetTrace, " IS "); | |
| 400 (void) fprintf(NetTrace, "%.*s", length-2, | |
| 401 (char *)pointer+2); | |
| 402 break; | |
| 403 default: | |
| 404 if (pointer[1] == 1) | |
| 405 (void) fprintf(NetTrace, " SEND"); | |
| 406 else | |
| 407 (void) fprintf(NetTrace, | |
| 408 " %d (unknown)", pointer[1]); | |
| 409 for (i = 2; i < length; i++) | |
| 410 (void) fprintf(NetTrace, " ?%d?", | |
| 411 pointer[i]); | |
| 412 break; | |
| 413 } | |
| 414 break; | |
| 415 | |
| 416 case TELOPT_LFLOW: | |
| 417 (void) fprintf(NetTrace, "TOGGLE-FLOW-CONTROL"); | |
| 418 if (length < 2) { | |
| 419 (void) fprintf(NetTrace, | |
| 420 " (empty suboption??\?)"); | |
| 421 break; | |
| 422 } | |
| 423 switch (pointer[1]) { | |
| 424 case LFLOW_OFF: | |
| 425 (void) fprintf(NetTrace, " OFF"); | |
| 426 break; | |
| 427 case LFLOW_ON: | |
| 428 (void) fprintf(NetTrace, " ON"); | |
| 429 break; | |
| 430 case LFLOW_RESTART_ANY: | |
| 431 (void) fprintf(NetTrace, " RESTART-ANY"); | |
| 432 break; | |
| 433 case LFLOW_RESTART_XON: | |
| 434 (void) fprintf(NetTrace, " RESTART-XON"); | |
| 435 break; | |
| 436 default: | |
| 437 (void) fprintf(NetTrace, " %d (unknown)", | |
| 438 pointer[1]); | |
| 439 } | |
| 440 for (i = 2; i < length; i++) | |
| 441 (void) fprintf(NetTrace, " ?%d?", | |
| 442 pointer[i]); | |
| 443 break; | |
| 444 | |
| 445 case TELOPT_NAWS: | |
| 446 (void) fprintf(NetTrace, "NAWS"); | |
| 447 if (length < 2) { | |
| 448 (void) fprintf(NetTrace, | |
| 449 " (empty suboption??\?)"); | |
| 450 break; | |
| 451 } | |
| 452 if (length == 2) { | |
| 453 (void) fprintf(NetTrace, " ?%d?", pointer[1]); | |
| 454 break; | |
| 455 } | |
| 456 (void) fprintf(NetTrace, " %d %d (%d)", | |
| 457 pointer[1], pointer[2], | |
| 458 (int)((((unsigned int)pointer[1])<<8)| | |
| 459 ((unsigned int)pointer[2]))); | |
| 460 if (length == 4) { | |
| 461 (void) fprintf(NetTrace, " ?%d?", pointer[3]); | |
| 462 break; | |
| 463 } | |
| 464 (void) fprintf(NetTrace, " %d %d (%d)", | |
| 465 pointer[3], pointer[4], | |
| 466 (int)((((unsigned int)pointer[3])<<8)| | |
| 467 ((unsigned int)pointer[4]))); | |
| 468 for (i = 5; i < length; i++) | |
| 469 (void) fprintf(NetTrace, " ?%d?", pointer[i]); | |
| 470 break; | |
| 471 | |
| 472 case TELOPT_AUTHENTICATION: | |
| 473 (void) fprintf(NetTrace, "AUTHENTICATION"); | |
| 474 if (length < 2) { | |
| 475 (void) fprintf(NetTrace, | |
| 476 " (empty suboption??\?)"); | |
| 477 break; | |
| 478 } | |
| 479 switch (pointer[1]) { | |
| 480 case TELQUAL_REPLY: | |
| 481 case TELQUAL_IS: | |
| 482 (void) fprintf(NetTrace, " %s ", | |
| 483 (pointer[1] == TELQUAL_IS) ? | |
| 484 "IS" : "REPLY"); | |
| 485 if (AUTHTYPE_NAME_OK(pointer[2])) | |
| 486 (void) fprintf(NetTrace, "%s ", | |
| 487 AUTHTYPE_NAME(pointer[2])); | |
| 488 else | |
| 489 (void) fprintf(NetTrace, "%d ", | |
| 490 pointer[2]); | |
| 491 if (length < 3) { | |
| 492 (void) fprintf(NetTrace, | |
| 493 "(partial suboption??\?)"); | |
| 494 break; | |
| 495 } | |
| 496 (void) fprintf(NetTrace, "%s|%s", | |
| 497 ((pointer[3] & AUTH_WHO_MASK) == | |
| 498 AUTH_WHO_CLIENT) ? "CLIENT" : "SERVER", | |
| 499 ((pointer[3] & AUTH_HOW_MASK) == | |
| 500 AUTH_HOW_MUTUAL) ? "MUTUAL" : "ONE-WAY"); | |
| 501 | |
| 502 auth_printsub(&pointer[1], length - 1, | |
| 503 (uchar_t *)buf, sizeof (buf)); | |
| 504 (void) fprintf(NetTrace, "%s", buf); | |
| 505 break; | |
| 506 | |
| 507 case TELQUAL_SEND: | |
| 508 i = 2; | |
| 509 (void) fprintf(NetTrace, " SEND "); | |
| 510 while (i < length) { | |
| 511 if (AUTHTYPE_NAME_OK(pointer[i])) | |
| 512 (void) fprintf(NetTrace, "%s ", | |
| 513 AUTHTYPE_NAME(pointer[i])); | |
| 514 else | |
| 515 (void) fprintf(NetTrace, "%d ", | |
| 516 pointer[i]); | |
| 517 if (++i >= length) { | |
| 518 (void) fprintf(NetTrace, | |
| 519 "(partial " | |
| 520 "suboption??\?)"); | |
| 521 break; | |
| 522 } | |
| 523 (void) fprintf(NetTrace, "%s|%s ", | |
| 524 ((pointer[i] & AUTH_WHO_MASK) == | |
| 525 AUTH_WHO_CLIENT) ? | |
| 526 "CLIENT" : "SERVER", | |
| 527 ((pointer[i] & AUTH_HOW_MASK) == | |
| 528 AUTH_HOW_MUTUAL) ? | |
| 529 "MUTUAL" : "ONE-WAY"); | |
| 530 ++i; | |
| 531 } | |
| 532 break; | |
| 533 | |
| 534 case TELQUAL_NAME: | |
| 535 i = 2; | |
| 536 (void) fprintf(NetTrace, " NAME \""); | |
| 537 while (i < length) | |
| 538 (void) putc(pointer[i++], NetTrace); | |
| 539 (void) putc('"', NetTrace); | |
| 540 break; | |
| 541 | |
| 542 default: | |
| 543 for (i = 2; i < length; i++) | |
| 544 (void) fprintf(NetTrace, " ?%d?", pointer[i]); | |
| 545 break; | |
| 546 } | |
| 547 break; | |
| 548 | |
| 549 case TELOPT_ENCRYPT: | |
| 550 (void) fprintf(NetTrace, "ENCRYPT"); | |
| 551 if (length < 2) { | |
| 552 (void) fprintf(NetTrace, | |
| 553 " (empty suboption??\?)"); | |
| 554 break; | |
| 555 } | |
| 556 switch (pointer[1]) { | |
| 557 case ENCRYPT_START: | |
| 558 (void) fprintf(NetTrace, " START"); | |
| 559 break; | |
| 560 | |
| 561 case ENCRYPT_END: | |
| 562 (void) fprintf(NetTrace, " END"); | |
| 563 break; | |
| 564 | |
| 565 case ENCRYPT_REQSTART: | |
| 566 (void) fprintf(NetTrace, " REQUEST-START"); | |
| 567 break; | |
| 568 | |
| 569 case ENCRYPT_REQEND: | |
| 570 (void) fprintf(NetTrace, " REQUEST-END"); | |
| 571 break; | |
| 572 | |
| 573 case ENCRYPT_IS: | |
| 574 case ENCRYPT_REPLY: | |
| 575 (void) fprintf(NetTrace, " %s ", | |
| 576 (pointer[1] == ENCRYPT_IS) ? | |
| 577 "IS" : "REPLY"); | |
| 578 if (length < 3) { | |
| 579 (void) fprintf(NetTrace, " (partial " | |
| 580 "suboption??\?)"); | |
| 581 break; | |
| 582 } | |
| 583 if (ENCTYPE_NAME_OK(pointer[2])) | |
| 584 (void) fprintf(NetTrace, "%s ", | |
| 585 ENCTYPE_NAME(pointer[2])); | |
| 586 else | |
| 587 (void) fprintf(NetTrace, | |
| 588 " %d (unknown)", pointer[2]); | |
| 589 | |
| 590 encrypt_printsub(&pointer[1], length - 1, | |
| 591 (uchar_t *)buf, sizeof (buf)); | |
| 592 (void) fprintf(NetTrace, "%s", buf); | |
| 593 break; | |
| 594 | |
| 595 case ENCRYPT_SUPPORT: | |
| 596 i = 2; | |
| 597 (void) fprintf(NetTrace, " SUPPORT "); | |
| 598 while (i < length) { | |
| 599 if (ENCTYPE_NAME_OK(pointer[i])) | |
| 600 (void) fprintf(NetTrace, "%s ", | |
| 601 ENCTYPE_NAME(pointer[i])); | |
| 602 else | |
| 603 (void) fprintf(NetTrace, "%d ", | |
| 604 pointer[i]); | |
| 605 i++; | |
| 606 } | |
| 607 break; | |
| 608 | |
| 609 case ENCRYPT_ENC_KEYID: | |
| 610 (void) fprintf(NetTrace, " ENC_KEYID "); | |
| 611 goto encommon; | |
| 612 | |
| 613 case ENCRYPT_DEC_KEYID: | |
| 614 (void) fprintf(NetTrace, " DEC_KEYID "); | |
| 615 goto encommon; | |
| 616 | |
| 617 default: | |
| 618 (void) fprintf(NetTrace, " %d (unknown)", | |
| 619 pointer[1]); | |
| 620 encommon: | |
| 621 for (i = 2; i < length; i++) | |
| 622 (void) fprintf(NetTrace, " %d", | |
| 623 pointer[i]); | |
| 624 break; | |
| 625 } | |
| 626 break; | |
| 627 | |
| 628 case TELOPT_LINEMODE: | |
| 629 (void) fprintf(NetTrace, "LINEMODE "); | |
| 630 if (length < 2) { | |
| 631 (void) fprintf(NetTrace, | |
| 632 " (empty suboption??\?)"); | |
| 633 break; | |
| 634 } | |
| 635 switch (pointer[1]) { | |
| 636 case WILL: | |
| 637 (void) fprintf(NetTrace, "WILL "); | |
| 638 goto common; | |
| 639 case WONT: | |
| 640 (void) fprintf(NetTrace, "WONT "); | |
| 641 goto common; | |
| 642 case DO: | |
| 643 (void) fprintf(NetTrace, "DO "); | |
| 644 goto common; | |
| 645 case DONT: | |
| 646 (void) fprintf(NetTrace, "DONT "); | |
| 647 common: | |
| 648 if (length < 3) { | |
| 649 (void) fprintf(NetTrace, | |
| 650 "(no option??\?)"); | |
| 651 break; | |
| 652 } | |
| 653 switch (pointer[2]) { | |
| 654 case LM_FORWARDMASK: | |
| 655 (void) fprintf(NetTrace, | |
| 656 "Forward Mask"); | |
| 657 for (i = 3; i < length; i++) | |
| 658 (void) fprintf(NetTrace, " %x", | |
| 659 pointer[i]); | |
| 660 break; | |
| 661 default: | |
| 662 (void) fprintf(NetTrace, "%d (unknown)", | |
| 663 pointer[2]); | |
| 664 for (i = 3; i < length; i++) | |
| 665 (void) fprintf(NetTrace, | |
| 666 " %d", pointer[i]); | |
| 667 break; | |
| 668 } | |
| 669 break; | |
| 670 | |
| 671 case LM_SLC: | |
| 672 (void) fprintf(NetTrace, "SLC"); | |
| 673 for (i = 2; i < length - 2; i += 3) { | |
| 674 if (SLC_NAME_OK(pointer[i+SLC_FUNC])) | |
| 675 (void) fprintf(NetTrace, " %s", | |
| 676 SLC_NAME(pointer[ | |
| 677 i+SLC_FUNC])); | |
| 678 else | |
| 679 (void) fprintf(NetTrace, " %d", | |
| 680 pointer[i+SLC_FUNC]); | |
| 681 switch (pointer[i+SLC_FLAGS] & | |
| 682 SLC_LEVELBITS) { | |
| 683 case SLC_NOSUPPORT: | |
| 684 (void) fprintf(NetTrace, | |
| 685 " NOSUPPORT"); | |
| 686 break; | |
| 687 case SLC_CANTCHANGE: | |
| 688 (void) fprintf(NetTrace, | |
| 689 " CANTCHANGE"); | |
| 690 break; | |
| 691 case SLC_VARIABLE: | |
| 692 (void) fprintf(NetTrace, | |
| 693 " VARIABLE"); | |
| 694 break; | |
| 695 case SLC_DEFAULT: | |
| 696 (void) fprintf(NetTrace, | |
| 697 " DEFAULT"); | |
| 698 break; | |
| 699 } | |
| 700 (void) fprintf(NetTrace, "%s%s%s", | |
| 701 pointer[i+SLC_FLAGS]&SLC_ACK ? | |
| 702 "|ACK" : "", | |
| 703 pointer[i+SLC_FLAGS]&SLC_FLUSHIN ? | |
| 704 "|FLUSHIN" : "", | |
| 705 pointer[i+SLC_FLAGS]&SLC_FLUSHOUT ? | |
| 706 "|FLUSHOUT" : ""); | |
| 707 if (pointer[i+SLC_FLAGS] & | |
| 708 ~(SLC_ACK|SLC_FLUSHIN| | |
| 709 SLC_FLUSHOUT| SLC_LEVELBITS)) | |
| 710 (void) fprintf(NetTrace, "(0x%x)", | |
| 711 pointer[i+SLC_FLAGS]); | |
| 712 (void) fprintf(NetTrace, " %d;", | |
| 713 pointer[i+SLC_VALUE]); | |
| 714 if ((pointer[i+SLC_VALUE] == IAC) && | |
| 715 (pointer[i+SLC_VALUE+1] == IAC)) | |
| 716 i++; | |
| 717 } | |
| 718 for (; i < length; i++) | |
| 719 (void) fprintf(NetTrace, " ?%d?", | |
| 720 pointer[i]); | |
| 721 break; | |
| 722 | |
| 723 case LM_MODE: | |
| 724 (void) fprintf(NetTrace, "MODE "); | |
| 725 if (length < 3) { | |
| 726 (void) fprintf(NetTrace, | |
| 727 "(no mode??\?)"); | |
| 728 break; | |
| 729 } | |
| 730 { | |
| 731 char tbuf[64]; | |
| 732 (void) sprintf(tbuf, "%s%s%s%s%s", | |
| 733 pointer[2]&MODE_EDIT ? "|EDIT" : "", | |
| 734 pointer[2]&MODE_TRAPSIG ? | |
| 735 "|TRAPSIG" : "", | |
| 736 pointer[2]&MODE_SOFT_TAB ? | |
| 737 "|SOFT_TAB" : "", | |
| 738 pointer[2]&MODE_LIT_ECHO ? | |
| 739 "|LIT_ECHO" : "", | |
| 740 pointer[2]&MODE_ACK ? "|ACK" : ""); | |
| 741 (void) fprintf(NetTrace, "%s", tbuf[1] ? | |
| 742 &tbuf[1] : "0"); | |
| 743 } | |
| 744 if (pointer[2]&~(MODE_MASK)) | |
| 745 (void) fprintf(NetTrace, " (0x%x)", | |
| 746 pointer[2]); | |
| 747 for (i = 3; i < length; i++) | |
| 748 (void) fprintf(NetTrace, " ?0x%x?", | |
| 749 pointer[i]); | |
| 750 break; | |
| 751 default: | |
| 752 (void) fprintf(NetTrace, "%d (unknown)", | |
| 753 pointer[1]); | |
| 754 for (i = 2; i < length; i++) | |
| 755 (void) fprintf(NetTrace, " %d", | |
| 756 pointer[i]); | |
| 757 } | |
| 758 break; | |
| 759 | |
| 760 case TELOPT_STATUS: { | |
| 761 register char *cp; | |
| 762 register int j, k; | |
| 763 | |
| 764 (void) fprintf(NetTrace, "STATUS"); | |
| 765 | |
| 766 switch (pointer[1]) { | |
| 767 default: | |
| 768 if (pointer[1] == TELQUAL_SEND) | |
| 769 (void) fprintf(NetTrace, | |
| 770 " SEND"); | |
| 771 else | |
| 772 (void) fprintf(NetTrace, | |
| 773 " %d (unknown)", | |
| 774 pointer[1]); | |
| 775 for (i = 2; i < length; i++) | |
| 776 (void) fprintf(NetTrace, " ?%d?", | |
| 777 pointer[i]); | |
| 778 break; | |
| 779 case TELQUAL_IS: | |
| 780 if (--want_status_response < 0) | |
| 781 want_status_response = 0; | |
| 782 if (NetTrace == stdout) | |
| 783 (void) fprintf(NetTrace, | |
| 784 " IS\r\n"); | |
| 785 else | |
| 786 (void) fprintf(NetTrace, | |
| 787 " IS\n"); | |
| 788 | |
| 789 for (i = 2; i < length; i++) { | |
| 790 switch (pointer[i]) { | |
| 791 case DO: | |
| 792 cp = "DO"; | |
| 793 goto common2; | |
| 794 case DONT: | |
| 795 cp = "DONT"; | |
| 796 goto common2; | |
| 797 case WILL: | |
| 798 cp = "WILL"; | |
| 799 goto common2; | |
| 800 case WONT: | |
| 801 cp = "WONT"; | |
| 802 goto common2; | |
| 803 common2: | |
| 804 i++; | |
| 805 if (TELOPT_OK( | |
| 806 (int)pointer[i])) | |
| 807 (void) fprintf( | |
| 808 NetTrace, | |
| 809 " %s %s", | |
| 810 cp, | |
| 811 TELOPT( | |
| 812 pointer[ | |
| 813 i])); | |
| 814 else | |
| 815 (void) fprintf( | |
| 816 NetTrace, | |
| 817 " %s %d", | |
| 818 cp, | |
| 819 pointer[i]); | |
| 820 | |
| 821 if (NetTrace == stdout) | |
| 822 (void) fprintf( | |
| 823 NetTrace, | |
| 824 "\r\n"); | |
| 825 else | |
| 826 (void) fprintf( | |
| 827 NetTrace, | |
| 828 "\n"); | |
| 829 break; | |
| 830 | |
| 831 case SB: | |
| 832 (void) fprintf(NetTrace, | |
| 833 " SB "); | |
| 834 i++; | |
| 835 j = k = i; | |
| 836 while (j < length) { | |
| 837 if (pointer[j] == SE) { | |
| 838 if (j+1 == length) | |
| 839 break; | |
| 840 if (pointer[j+1] == SE) | |
| 841 j++; | |
| 842 else | |
| 843 break; | |
| 844 } | |
| 845 pointer[k++] = pointer[j++]; | |
| 846 } | |
| 847 printsub(0, | |
| 848 &pointer[i], k - i); | |
| 849 if (i < length) { | |
| 850 (void) fprintf(NetTrace, " SE"); | |
| 851 i = j; | |
| 852 } else | |
| 853 i = j - 1; | |
| 854 | |
| 855 if (NetTrace == stdout) | |
| 856 (void) fprintf(NetTrace, "\r\n"); | |
| 857 else | |
| 858 (void) fprintf(NetTrace, "\n"); | |
| 859 | |
| 860 break; | |
| 861 | |
| 862 default: | |
| 863 (void) fprintf(NetTrace, | |
| 864 " %d", pointer[i]); | |
| 865 break; | |
| 866 } | |
| 867 } | |
| 868 break; | |
| 869 } | |
| 870 break; | |
| 871 } | |
| 872 | |
| 873 case TELOPT_XDISPLOC: | |
| 874 (void) fprintf(NetTrace, "X-DISPLAY-LOCATION "); | |
| 875 switch (pointer[1]) { | |
| 876 case TELQUAL_IS: | |
| 877 (void) fprintf(NetTrace, "IS \"%.*s\"", | |
| 878 length-2, (char *)pointer+2); | |
| 879 break; | |
| 880 case TELQUAL_SEND: | |
| 881 (void) fprintf(NetTrace, "SEND"); | |
| 882 break; | |
| 883 default: | |
| 884 (void) fprintf(NetTrace, | |
| 885 "- unknown qualifier %d (0x%x).", | |
| 886 pointer[1], pointer[1]); | |
| 887 } | |
| 888 break; | |
| 889 | |
| 890 case TELOPT_NEW_ENVIRON: | |
| 891 (void) fprintf(NetTrace, "NEW-ENVIRON "); | |
| 892 #ifdef OLD_ENVIRON | |
| 893 goto env_common1; | |
| 894 case TELOPT_OLD_ENVIRON: | |
| 895 (void) fprintf(NetTrace, "OLD-ENVIRON "); | |
| 896 env_common1: | |
| 897 #endif | |
| 898 switch (pointer[1]) { | |
| 899 case TELQUAL_IS: | |
| 900 (void) fprintf(NetTrace, "IS "); | |
| 901 goto env_common; | |
| 902 case TELQUAL_SEND: | |
| 903 (void) fprintf(NetTrace, "SEND "); | |
| 904 goto env_common; | |
| 905 case TELQUAL_INFO: | |
| 906 (void) fprintf(NetTrace, "INFO "); | |
| 907 env_common: | |
| 908 { | |
| 909 register int noquote = 2; | |
| 910 #if defined(ENV_HACK) && defined(OLD_ENVIRON) | |
| 911 extern int old_env_var, old_env_value; | |
| 912 #endif | |
| 913 for (i = 2; i < length; i++) { | |
| 914 switch (pointer[i]) { | |
| 915 case NEW_ENV_VALUE: | |
| 916 #ifdef OLD_ENVIRON | |
| 917 /* case NEW_ENV_OVAR: */ | |
| 918 if (pointer[0] == TELOPT_OLD_ENVIRON) { | |
| 919 #ifdef ENV_HACK | |
| 920 if (old_env_var == OLD_ENV_VALUE) | |
| 921 (void) fprintf(NetTrace, | |
| 922 "\" (VALUE) " + noquote); | |
| 923 else | |
| 924 #endif | |
| 925 (void) fprintf(NetTrace, | |
| 926 "\" VAR " + noquote); | |
| 927 } else | |
| 928 #endif /* OLD_ENVIRON */ | |
| 929 (void) fprintf(NetTrace, "\" VALUE " + noquote); | |
| 930 noquote = 2; | |
| 931 break; | |
| 932 | |
| 933 case NEW_ENV_VAR: | |
| 934 #ifdef OLD_ENVIRON | |
| 935 /* case OLD_ENV_VALUE: */ | |
| 936 if (pointer[0] == TELOPT_OLD_ENVIRON) { | |
| 937 #ifdef ENV_HACK | |
| 938 if (old_env_value == OLD_ENV_VAR) | |
| 939 (void) fprintf(NetTrace, | |
| 940 "\" (VAR) " + noquote); | |
| 941 else | |
| 942 #endif | |
| 943 (void) fprintf(NetTrace, | |
| 944 "\" VALUE " + noquote); | |
| 945 } else | |
| 946 #endif /* OLD_ENVIRON */ | |
| 947 (void) fprintf(NetTrace, "\" VAR " + noquote); | |
| 948 noquote = 2; | |
| 949 break; | |
| 950 | |
| 951 case ENV_ESC: | |
| 952 (void) fprintf(NetTrace, "\" ESC " + noquote); | |
| 953 noquote = 2; | |
| 954 break; | |
| 955 | |
| 956 case ENV_USERVAR: | |
| 957 (void) fprintf(NetTrace, "\" USERVAR " + noquote); | |
| 958 noquote = 2; | |
| 959 break; | |
| 960 | |
| 961 default: | |
| 962 def_case: | |
| 963 if (isprint(pointer[i]) && pointer[i] != '"') { | |
| 964 if (noquote) { | |
| 965 (void) putc('"', NetTrace); | |
| 966 noquote = 0; | |
| 967 } | |
| 968 (void) putc(pointer[i], NetTrace); | |
| 969 } else { | |
| 970 (void) fprintf(NetTrace, "\" %03o " + noquote, | |
| 971 pointer[i]); | |
| 972 noquote = 2; | |
| 973 } | |
| 974 break; | |
| 975 } | |
| 976 } | |
| 977 if (!noquote) | |
| 978 (void) putc('"', NetTrace); | |
| 979 break; | |
| 980 } | |
| 981 } | |
| 982 break; | |
| 983 | |
| 984 default: | |
| 985 if (TELOPT_OK(pointer[0])) | |
| 986 (void) fprintf(NetTrace, "%s (unknown)", TELOPT(pointer[0])); | |
| 987 else | |
| 988 (void) fprintf(NetTrace, "%d (unknown)", pointer[0]); | |
| 989 for (i = 1; i < length; i++) | |
| 990 (void) fprintf(NetTrace, " %d", pointer[i]); | |
| 991 break; | |
| 992 } | |
| 993 if (direction) { | |
| 994 if (NetTrace == stdout) | |
| 995 (void) fprintf(NetTrace, "\r\n"); | |
| 996 else | |
| 997 (void) fprintf(NetTrace, "\n"); | |
| 998 } | |
| 999 if (NetTrace == stdout) | |
| 1000 (void) fflush(NetTrace); | |
| 1001 } | |
| 1002 } | |
| 1003 | |
| 1004 /* | |
| 1005 * EmptyTerminal - called to make sure that the terminal buffer is empty. | |
| 1006 * Note that we consider the buffer to run all the | |
| 1007 * way to the kernel (thus the select). | |
| 1008 */ | |
| 1009 | |
| 1010 static void | |
| 1011 EmptyTerminal() | |
| 1012 { | |
| 1013 fd_set o; | |
| 1014 | |
| 1015 FD_ZERO(&o); | |
| 1016 | |
| 1017 if (TTYBYTES() == 0) { | |
| 1018 FD_SET(tout, &o); | |
| 1019 /* wait for TTLOWAT */ | |
| 1020 (void) select(tout+1, NULL, &o, NULL, NULL); | |
| 1021 } else { | |
| 1022 while (TTYBYTES()) { | |
| 1023 if (ttyflush(0) == -2) { | |
| 1024 /* This will not return. */ | |
| 1025 fatal_tty_error("write"); | |
| 1026 } | |
| 1027 FD_SET(tout, &o); | |
| 1028 /* wait for TTLOWAT */ | |
| 1029 (void) select(tout+1, NULL, &o, NULL, NULL); | |
| 1030 } | |
| 1031 } | |
| 1032 } | |
| 1033 | |
| 1034 static void | |
| 1035 SetForExit() | |
| 1036 { | |
| 1037 setconnmode(0); | |
| 1038 do { | |
| 1039 (void) telrcv(); /* Process any incoming data */ | |
| 1040 EmptyTerminal(); | |
| 1041 } while (ring_full_count(&netiring)); /* While there is any */ | |
| 1042 setcommandmode(); | |
| 1043 (void) fflush(stdout); | |
| 1044 (void) fflush(stderr); | |
| 1045 setconnmode(0); | |
| 1046 EmptyTerminal(); /* Flush the path to the tty */ | |
| 1047 setcommandmode(); | |
| 1048 } | |
| 1049 | |
| 1050 void | |
| 1051 Exit(returnCode) | |
| 1052 int returnCode; | |
| 1053 { | |
| 1054 SetForExit(); | |
| 1055 exit(returnCode); | |
| 1056 } | |
| 1057 | |
| 1058 void | |
| 1059 ExitString(string, returnCode) | |
| 1060 char *string; | |
| 1061 int returnCode; | |
| 1062 { | |
| 1063 SetForExit(); | |
| 1064 (void) fwrite(string, 1, strlen(string), stderr); | |
| 1065 exit(returnCode); | |
| 1066 } | |
| 1067 | |
| 1068 #define BUFFER_CHUNK_SIZE 64 | |
| 1069 | |
| 1070 /* Round up to a multiple of BUFFER_CHUNK_SIZE */ | |
| 1071 #define ROUND_CHUNK_SIZE(s) ((((s) + BUFFER_CHUNK_SIZE - 1) / \ | |
| 1072 BUFFER_CHUNK_SIZE) * BUFFER_CHUNK_SIZE) | |
| 1073 | |
| 1074 /* | |
| 1075 * Optionally allocate a buffer, and optionally read a string from a stream | |
| 1076 * into the buffer, starting at the given offset. If the buffer isn't | |
| 1077 * large enough for the given offset, or if buffer space is exhausted | |
| 1078 * when reading the string, the size of the buffer is increased. | |
| 1079 * | |
| 1080 * A buffer can be supplied when the function is called, passing the | |
| 1081 * buffer address via the first argument. The buffer size can be | |
| 1082 * passed as well, in the second argument. If the second argument is | |
| 1083 * NULL, the function makes no assumptions about the buffer size. | |
| 1084 * The address of the buffer is returned via the first argument, and the | |
| 1085 * buffer size via the second argument if this is not NULL. | |
| 1086 * These returned values may differ from the supplied values if the buffer | |
| 1087 * was reallocated. | |
| 1088 * | |
| 1089 * If no buffer is to be supplied, specify a buffer address of NULL, via | |
| 1090 * the first argument. | |
| 1091 * | |
| 1092 * If the pointer to the buffer address is NULL, the function just returns | |
| 1093 * NULL, and performs no other processing. | |
| 1094 * | |
| 1095 * If a NULL stream is passed, the function will just make sure the | |
| 1096 * supplied buffer is large enough to hold the supplied offset, | |
| 1097 * reallocating it if is too small or too large. | |
| 1098 * | |
| 1099 * The returned buffer will be a multiple of BUFFER_CHUNK_SIZE in size. | |
| 1100 * | |
| 1101 * The function stops reading from the stream when a newline is read, | |
| 1102 * end of file is reached, or an error occurs. The newline is not | |
| 1103 * returned in the buffer. The returned string will be NULL terminated. | |
| 1104 * | |
| 1105 * The function returns the address of the buffer if any characters | |
| 1106 * are read and no error occurred, otherwise it returns NULL. | |
| 1107 * | |
| 1108 * If the function returns NULL, a buffer may have been allocated. The | |
| 1109 * buffer address will be returned via the first argument, together with | |
| 1110 * the buffer size if the second argument is not NULL. | |
| 1111 * | |
| 1112 */ | |
| 1113 static char * | |
| 1114 GetStringAtOffset(bufp, cbufsiz, off, st) | |
| 1115 char **bufp; | |
| 1116 unsigned int *cbufsiz; | |
| 1117 unsigned int off; | |
| 1118 FILE *st; | |
| 1119 { | |
| 1120 unsigned int bufsiz; | |
| 1121 char *buf; | |
| 1122 char *nbuf; | |
| 1123 unsigned int idx = off; | |
| 1124 | |
| 1125 if (bufp == NULL) | |
| 1126 return (NULL); | |
| 1127 | |
| 1128 buf = *bufp; | |
| 1129 | |
| 1130 bufsiz = ROUND_CHUNK_SIZE(off + 1); | |
| 1131 | |
| 1132 if (buf == NULL || cbufsiz == NULL || *cbufsiz != bufsiz) { | |
| 1133 if ((nbuf = realloc(buf, bufsiz)) == NULL) | |
| 1134 return (NULL); | |
| 1135 | |
| 1136 buf = nbuf; | |
| 1137 *bufp = buf; | |
| 1138 if (cbufsiz != NULL) | |
| 1139 *cbufsiz = bufsiz; | |
| 1140 } | |
| 1141 | |
| 1142 | |
| 1143 if (st == NULL) | |
| 1144 return (buf); | |
| 1145 | |
| 1146 clearerr(st); | |
| 1147 for (;;) { | |
| 1148 int c = getc(st); | |
| 1149 | |
| 1150 /* Expand the buffer as needed. */ | |
| 1151 if (idx == bufsiz) { | |
| 1152 bufsiz += BUFFER_CHUNK_SIZE; | |
| 1153 if ((nbuf = realloc(buf, bufsiz)) == NULL) { | |
| 1154 /* Discard everything we read. */ | |
| 1155 buf[off] = 0; | |
| 1156 buf = NULL; | |
| 1157 break; | |
| 1158 } | |
| 1159 buf = nbuf; | |
| 1160 *bufp = buf; | |
| 1161 if (cbufsiz != NULL) | |
| 1162 *cbufsiz = bufsiz; | |
| 1163 } | |
| 1164 | |
| 1165 if (c == EOF || c == '\n') { | |
| 1166 buf[idx] = 0; | |
| 1167 if (ferror(st) != 0) { | |
| 1168 /* Retry if interrupted by a signal. */ | |
| 1169 if (errno == EINTR) { | |
| 1170 clearerr(st); | |
| 1171 continue; | |
| 1172 } | |
| 1173 buf = NULL; | |
| 1174 } else if (feof(st) != 0) { | |
| 1175 /* No characters transferred? */ | |
| 1176 if (off == idx) | |
| 1177 buf = NULL; | |
| 1178 } | |
| 1179 break; | |
| 1180 } | |
| 1181 buf[idx++] = c; | |
| 1182 } | |
| 1183 return (buf); | |
| 1184 } | |
| 1185 | |
| 1186 /* | |
| 1187 * Read a string from the supplied stream. Stop reading when a newline | |
| 1188 * is read, end of file reached, or an error occurs. | |
| 1189 * | |
| 1190 * A buffer can be supplied by specifying the buffer address via the | |
| 1191 * first argument. The buffer size can be passed via the second argument. | |
| 1192 * If the second argument is NULL, the function makes no assumptions | |
| 1193 * about the buffer size. The buffer will be reallocated if it is too | |
| 1194 * small or too large for the returned string. | |
| 1195 * | |
| 1196 * If no buffer is to be supplied, specify a buffer address of NULL, | |
| 1197 * via the first argument. | |
| 1198 * | |
| 1199 * If the first argument is NULL, the function just returns NULL, and | |
| 1200 * performs no other processing. | |
| 1201 * | |
| 1202 * The function returns the address of the buffer if any characters are | |
| 1203 * read and no error occurred. | |
| 1204 * | |
| 1205 * If the function returns NULL, a buffer may have been allocated. The | |
| 1206 * buffer address and buffer size will be returned via the first argument, | |
| 1207 * and the buffer size via the second argument, if this isn't NULL. | |
| 1208 */ | |
| 1209 char * | |
| 1210 GetString(bufp, bufsiz, st) | |
| 1211 char **bufp; | |
| 1212 unsigned int *bufsiz; | |
| 1213 FILE *st; | |
| 1214 { | |
| 1215 return (GetStringAtOffset(bufp, bufsiz, 0, st)); | |
| 1216 } | |
| 1217 | |
| 1218 /* | |
| 1219 * Allocate a buffer to hold a string of given length. | |
| 1220 * | |
| 1221 * An existing buffer can be reallocated by passing its address and via | |
| 1222 * the first argument. The buffer size can be passed via the second | |
| 1223 * argument. If the second argument is NULL, the function makes no | |
| 1224 * assumptions about the buffer size. | |
| 1225 * | |
| 1226 * If no existing buffer is to be supplied, pass a NULL buffer address via | |
| 1227 * the first argument. | |
| 1228 * | |
| 1229 * If the first argument is NULL, the function just returns NULL, | |
| 1230 * and performs no other processing. | |
| 1231 */ | |
| 1232 char * | |
| 1233 AllocStringBuffer(bufp, bufsiz, size) | |
| 1234 char **bufp; | |
| 1235 unsigned int *bufsiz; | |
| 1236 unsigned int size; | |
| 1237 { | |
| 1238 return (GetStringAtOffset(bufp, bufsiz, size, (FILE *)NULL)); | |
| 1239 } | |
| 1240 | |
| 1241 /* | |
| 1242 * This function is similar to GetString(), except that the string read | |
| 1243 * from the stream is appended to the supplied string. | |
| 1244 */ | |
| 1245 char * | |
| 1246 GetAndAppendString(bufp, bufsiz, str, st) | |
| 1247 char **bufp; | |
| 1248 unsigned int *bufsiz; | |
| 1249 char *str; | |
| 1250 FILE *st; | |
| 1251 { | |
| 1252 unsigned int off = strlen(str); | |
| 1253 | |
| 1254 if (GetStringAtOffset(bufp, bufsiz, off, st) == NULL) | |
| 1255 return (NULL); | |
| 1256 | |
| 1257 return (memcpy(*bufp, str, off)); | |
| 1258 } |