Annotation of qemu/slirp/misc.c, revision 1.1
1.1 ! root 1: /*
! 2: * Copyright (c) 1995 Danny Gasparovski.
! 3: *
! 4: * Please read the file COPYRIGHT for the
! 5: * terms and conditions of the copyright.
! 6: */
! 7:
! 8: #define WANT_SYS_IOCTL_H
! 9: #include <slirp.h>
! 10:
! 11: u_int curtime, time_fasttimo, last_slowtimo, detach_time;
! 12: u_int detach_wait = 600000; /* 10 minutes */
! 13:
! 14: #if 0
! 15: int x_port = -1;
! 16: int x_display = 0;
! 17: int x_screen = 0;
! 18:
! 19: int
! 20: show_x(buff, inso)
! 21: char *buff;
! 22: struct socket *inso;
! 23: {
! 24: if (x_port < 0) {
! 25: lprint("X Redir: X not being redirected.\r\n");
! 26: } else {
! 27: lprint("X Redir: In sh/bash/zsh/etc. type: DISPLAY=%s:%d.%d; export DISPLAY\r\n",
! 28: inet_ntoa(our_addr), x_port, x_screen);
! 29: lprint("X Redir: In csh/tcsh/etc. type: setenv DISPLAY %s:%d.%d\r\n",
! 30: inet_ntoa(our_addr), x_port, x_screen);
! 31: if (x_display)
! 32: lprint("X Redir: Redirecting to display %d\r\n", x_display);
! 33: }
! 34:
! 35: return CFG_OK;
! 36: }
! 37:
! 38:
! 39: /*
! 40: * XXX Allow more than one X redirection?
! 41: */
! 42: void
! 43: redir_x(inaddr, start_port, display, screen)
! 44: u_int32_t inaddr;
! 45: int start_port;
! 46: int display;
! 47: int screen;
! 48: {
! 49: int i;
! 50:
! 51: if (x_port >= 0) {
! 52: lprint("X Redir: X already being redirected.\r\n");
! 53: show_x(0, 0);
! 54: } else {
! 55: for (i = 6001 + (start_port-1); i <= 6100; i++) {
! 56: if (solisten(htons(i), inaddr, htons(6000 + display), 0)) {
! 57: /* Success */
! 58: x_port = i - 6000;
! 59: x_display = display;
! 60: x_screen = screen;
! 61: show_x(0, 0);
! 62: return;
! 63: }
! 64: }
! 65: lprint("X Redir: Error: Couldn't redirect a port for X. Weird.\r\n");
! 66: }
! 67: }
! 68: #endif
! 69:
! 70: #ifndef HAVE_INET_ATON
! 71: int
! 72: inet_aton(cp, ia)
! 73: const char *cp;
! 74: struct in_addr *ia;
! 75: {
! 76: u_int32_t addr = inet_addr(cp);
! 77: if (addr == 0xffffffff)
! 78: return 0;
! 79: ia->s_addr = addr;
! 80: return 1;
! 81: }
! 82: #endif
! 83:
! 84: /*
! 85: * Get our IP address and put it in our_addr
! 86: */
! 87: void
! 88: getouraddr()
! 89: {
! 90: char buff[256];
! 91: struct hostent *he;
! 92:
! 93: if (gethostname(buff,256) < 0)
! 94: return;
! 95:
! 96: if ((he = gethostbyname(buff)) == NULL)
! 97: return;
! 98:
! 99: our_addr = *(struct in_addr *)he->h_addr;
! 100: }
! 101:
! 102: #if SIZEOF_CHAR_P == 8
! 103:
! 104: struct quehead_32 {
! 105: u_int32_t qh_link;
! 106: u_int32_t qh_rlink;
! 107: };
! 108:
! 109: inline void
! 110: insque_32(a, b)
! 111: void *a;
! 112: void *b;
! 113: {
! 114: register struct quehead_32 *element = (struct quehead_32 *) a;
! 115: register struct quehead_32 *head = (struct quehead_32 *) b;
! 116: element->qh_link = head->qh_link;
! 117: head->qh_link = (u_int32_t)element;
! 118: element->qh_rlink = (u_int32_t)head;
! 119: ((struct quehead_32 *)(element->qh_link))->qh_rlink
! 120: = (u_int32_t)element;
! 121: }
! 122:
! 123: inline void
! 124: remque_32(a)
! 125: void *a;
! 126: {
! 127: register struct quehead_32 *element = (struct quehead_32 *) a;
! 128: ((struct quehead_32 *)(element->qh_link))->qh_rlink = element->qh_rlink;
! 129: ((struct quehead_32 *)(element->qh_rlink))->qh_link = element->qh_link;
! 130: element->qh_rlink = 0;
! 131: }
! 132:
! 133: #endif /* SIZEOF_CHAR_P == 8 */
! 134:
! 135: struct quehead {
! 136: struct quehead *qh_link;
! 137: struct quehead *qh_rlink;
! 138: };
! 139:
! 140: inline void
! 141: insque(a, b)
! 142: void *a, *b;
! 143: {
! 144: register struct quehead *element = (struct quehead *) a;
! 145: register struct quehead *head = (struct quehead *) b;
! 146: element->qh_link = head->qh_link;
! 147: head->qh_link = (struct quehead *)element;
! 148: element->qh_rlink = (struct quehead *)head;
! 149: ((struct quehead *)(element->qh_link))->qh_rlink
! 150: = (struct quehead *)element;
! 151: }
! 152:
! 153: inline void
! 154: remque(a)
! 155: void *a;
! 156: {
! 157: register struct quehead *element = (struct quehead *) a;
! 158: ((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink;
! 159: ((struct quehead *)(element->qh_rlink))->qh_link = element->qh_link;
! 160: element->qh_rlink = NULL;
! 161: /* element->qh_link = NULL; TCP FIN1 crashes if you do this. Why ? */
! 162: }
! 163:
! 164: /* #endif */
! 165:
! 166:
! 167: int
! 168: add_exec(ex_ptr, do_pty, exec, addr, port)
! 169: struct ex_list **ex_ptr;
! 170: int do_pty;
! 171: char *exec;
! 172: int addr;
! 173: int port;
! 174: {
! 175: struct ex_list *tmp_ptr;
! 176:
! 177: /* First, check if the port is "bound" */
! 178: for (tmp_ptr = *ex_ptr; tmp_ptr; tmp_ptr = tmp_ptr->ex_next) {
! 179: if (port == tmp_ptr->ex_fport && addr == tmp_ptr->ex_addr)
! 180: return -1;
! 181: }
! 182:
! 183: tmp_ptr = *ex_ptr;
! 184: *ex_ptr = (struct ex_list *)malloc(sizeof(struct ex_list));
! 185: (*ex_ptr)->ex_fport = port;
! 186: (*ex_ptr)->ex_addr = addr;
! 187: (*ex_ptr)->ex_pty = do_pty;
! 188: (*ex_ptr)->ex_exec = strdup(exec);
! 189: (*ex_ptr)->ex_next = tmp_ptr;
! 190: return 0;
! 191: }
! 192:
! 193: #ifndef HAVE_STRERROR
! 194:
! 195: /*
! 196: * For systems with no strerror
! 197: */
! 198:
! 199: extern int sys_nerr;
! 200: extern char *sys_errlist[];
! 201:
! 202: char *
! 203: strerror(error)
! 204: int error;
! 205: {
! 206: if (error < sys_nerr)
! 207: return sys_errlist[error];
! 208: else
! 209: return "Unknown error.";
! 210: }
! 211:
! 212: #endif
! 213:
! 214:
! 215: #ifdef _WIN32
! 216:
! 217: int
! 218: fork_exec(so, ex, do_pty)
! 219: struct socket *so;
! 220: char *ex;
! 221: int do_pty;
! 222: {
! 223: /* not implemented */
! 224: return 0;
! 225: }
! 226:
! 227: #else
! 228:
! 229: int
! 230: slirp_openpty(amaster, aslave)
! 231: int *amaster, *aslave;
! 232: {
! 233: register int master, slave;
! 234:
! 235: #ifdef HAVE_GRANTPT
! 236: char *ptr;
! 237:
! 238: if ((master = open("/dev/ptmx", O_RDWR)) < 0 ||
! 239: grantpt(master) < 0 ||
! 240: unlockpt(master) < 0 ||
! 241: (ptr = ptsname(master)) == NULL) {
! 242: close(master);
! 243: return -1;
! 244: }
! 245:
! 246: if ((slave = open(ptr, O_RDWR)) < 0 ||
! 247: ioctl(slave, I_PUSH, "ptem") < 0 ||
! 248: ioctl(slave, I_PUSH, "ldterm") < 0 ||
! 249: ioctl(slave, I_PUSH, "ttcompat") < 0) {
! 250: close(master);
! 251: close(slave);
! 252: return -1;
! 253: }
! 254:
! 255: *amaster = master;
! 256: *aslave = slave;
! 257: return 0;
! 258:
! 259: #else
! 260:
! 261: static char line[] = "/dev/ptyXX";
! 262: register const char *cp1, *cp2;
! 263:
! 264: for (cp1 = "pqrsPQRS"; *cp1; cp1++) {
! 265: line[8] = *cp1;
! 266: for (cp2 = "0123456789abcdefghijklmnopqrstuv"; *cp2; cp2++) {
! 267: line[9] = *cp2;
! 268: if ((master = open(line, O_RDWR, 0)) == -1) {
! 269: if (errno == ENOENT)
! 270: return (-1); /* out of ptys */
! 271: } else {
! 272: line[5] = 't';
! 273: /* These will fail */
! 274: (void) chown(line, getuid(), 0);
! 275: (void) chmod(line, S_IRUSR|S_IWUSR|S_IWGRP);
! 276: #ifdef HAVE_REVOKE
! 277: (void) revoke(line);
! 278: #endif
! 279: if ((slave = open(line, O_RDWR, 0)) != -1) {
! 280: *amaster = master;
! 281: *aslave = slave;
! 282: return 0;
! 283: }
! 284: (void) close(master);
! 285: line[5] = 'p';
! 286: }
! 287: }
! 288: }
! 289: errno = ENOENT; /* out of ptys */
! 290: return (-1);
! 291: #endif
! 292: }
! 293:
! 294: /*
! 295: * XXX This is ugly
! 296: * We create and bind a socket, then fork off to another
! 297: * process, which connects to this socket, after which we
! 298: * exec the wanted program. If something (strange) happens,
! 299: * the accept() call could block us forever.
! 300: *
! 301: * do_pty = 0 Fork/exec inetd style
! 302: * do_pty = 1 Fork/exec using slirp.telnetd
! 303: * do_ptr = 2 Fork/exec using pty
! 304: */
! 305: int
! 306: fork_exec(so, ex, do_pty)
! 307: struct socket *so;
! 308: char *ex;
! 309: int do_pty;
! 310: {
! 311: int s;
! 312: struct sockaddr_in addr;
! 313: int addrlen = sizeof(addr);
! 314: int opt;
! 315: int master;
! 316: char *argv[256];
! 317: #if 0
! 318: char buff[256];
! 319: #endif
! 320: /* don't want to clobber the original */
! 321: char *bptr;
! 322: char *curarg;
! 323: int c, i, ret;
! 324:
! 325: DEBUG_CALL("fork_exec");
! 326: DEBUG_ARG("so = %lx", (long)so);
! 327: DEBUG_ARG("ex = %lx", (long)ex);
! 328: DEBUG_ARG("do_pty = %lx", (long)do_pty);
! 329:
! 330: if (do_pty == 2) {
! 331: if (slirp_openpty(&master, &s) == -1) {
! 332: lprint("Error: openpty failed: %s\n", strerror(errno));
! 333: return 0;
! 334: }
! 335: } else {
! 336: addr.sin_family = AF_INET;
! 337: addr.sin_port = 0;
! 338: addr.sin_addr.s_addr = INADDR_ANY;
! 339:
! 340: if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ||
! 341: bind(s, (struct sockaddr *)&addr, addrlen) < 0 ||
! 342: listen(s, 1) < 0) {
! 343: lprint("Error: inet socket: %s\n", strerror(errno));
! 344: closesocket(s);
! 345:
! 346: return 0;
! 347: }
! 348: }
! 349:
! 350: switch(fork()) {
! 351: case -1:
! 352: lprint("Error: fork failed: %s\n", strerror(errno));
! 353: close(s);
! 354: if (do_pty == 2)
! 355: close(master);
! 356: return 0;
! 357:
! 358: case 0:
! 359: /* Set the DISPLAY */
! 360: if (do_pty == 2) {
! 361: (void) close(master);
! 362: #ifdef TIOCSCTTY /* XXXXX */
! 363: (void) setsid();
! 364: ioctl(s, TIOCSCTTY, (char *)NULL);
! 365: #endif
! 366: } else {
! 367: getsockname(s, (struct sockaddr *)&addr, &addrlen);
! 368: close(s);
! 369: /*
! 370: * Connect to the socket
! 371: * XXX If any of these fail, we're in trouble!
! 372: */
! 373: s = socket(AF_INET, SOCK_STREAM, 0);
! 374: addr.sin_addr = loopback_addr;
! 375: do {
! 376: ret = connect(s, (struct sockaddr *)&addr, addrlen);
! 377: } while (ret < 0 && errno == EINTR);
! 378: }
! 379:
! 380: #if 0
! 381: if (x_port >= 0) {
! 382: #ifdef HAVE_SETENV
! 383: sprintf(buff, "%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
! 384: setenv("DISPLAY", buff, 1);
! 385: #else
! 386: sprintf(buff, "DISPLAY=%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
! 387: putenv(buff);
! 388: #endif
! 389: }
! 390: #endif
! 391: dup2(s, 0);
! 392: dup2(s, 1);
! 393: dup2(s, 2);
! 394: for (s = 3; s <= 255; s++)
! 395: close(s);
! 396:
! 397: i = 0;
! 398: bptr = strdup(ex); /* No need to free() this */
! 399: if (do_pty == 1) {
! 400: /* Setup "slirp.telnetd -x" */
! 401: argv[i++] = "slirp.telnetd";
! 402: argv[i++] = "-x";
! 403: argv[i++] = bptr;
! 404: } else
! 405: do {
! 406: /* Change the string into argv[] */
! 407: curarg = bptr;
! 408: while (*bptr != ' ' && *bptr != (char)0)
! 409: bptr++;
! 410: c = *bptr;
! 411: *bptr++ = (char)0;
! 412: argv[i++] = strdup(curarg);
! 413: } while (c);
! 414:
! 415: argv[i] = 0;
! 416: execvp(argv[0], argv);
! 417:
! 418: /* Ooops, failed, let's tell the user why */
! 419: {
! 420: char buff[256];
! 421:
! 422: sprintf(buff, "Error: execvp of %s failed: %s\n",
! 423: argv[0], strerror(errno));
! 424: write(2, buff, strlen(buff)+1);
! 425: }
! 426: close(0); close(1); close(2); /* XXX */
! 427: exit(1);
! 428:
! 429: default:
! 430: if (do_pty == 2) {
! 431: close(s);
! 432: so->s = master;
! 433: } else {
! 434: /*
! 435: * XXX this could block us...
! 436: * XXX Should set a timer here, and if accept() doesn't
! 437: * return after X seconds, declare it a failure
! 438: * The only reason this will block forever is if socket()
! 439: * of connect() fail in the child process
! 440: */
! 441: do {
! 442: so->s = accept(s, (struct sockaddr *)&addr, &addrlen);
! 443: } while (so->s < 0 && errno == EINTR);
! 444: closesocket(s);
! 445: opt = 1;
! 446: setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
! 447: opt = 1;
! 448: setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
! 449: }
! 450: fd_nonblock(so->s);
! 451:
! 452: /* Append the telnet options now */
! 453: if (so->so_m != 0 && do_pty == 1) {
! 454: sbappend(so, so->so_m);
! 455: so->so_m = 0;
! 456: }
! 457:
! 458: return 1;
! 459: }
! 460: }
! 461: #endif
! 462:
! 463: #ifndef HAVE_STRDUP
! 464: char *
! 465: strdup(str)
! 466: const char *str;
! 467: {
! 468: char *bptr;
! 469:
! 470: bptr = (char *)malloc(strlen(str)+1);
! 471: strcpy(bptr, str);
! 472:
! 473: return bptr;
! 474: }
! 475: #endif
! 476:
! 477: #if 0
! 478: void
! 479: snooze_hup(num)
! 480: int num;
! 481: {
! 482: int s, ret;
! 483: #ifndef NO_UNIX_SOCKETS
! 484: struct sockaddr_un sock_un;
! 485: #endif
! 486: struct sockaddr_in sock_in;
! 487: char buff[256];
! 488:
! 489: ret = -1;
! 490: if (slirp_socket_passwd) {
! 491: s = socket(AF_INET, SOCK_STREAM, 0);
! 492: if (s < 0)
! 493: slirp_exit(1);
! 494: sock_in.sin_family = AF_INET;
! 495: sock_in.sin_addr.s_addr = slirp_socket_addr;
! 496: sock_in.sin_port = htons(slirp_socket_port);
! 497: if (connect(s, (struct sockaddr *)&sock_in, sizeof(sock_in)) != 0)
! 498: slirp_exit(1); /* just exit...*/
! 499: sprintf(buff, "kill %s:%d", slirp_socket_passwd, slirp_socket_unit);
! 500: write(s, buff, strlen(buff)+1);
! 501: }
! 502: #ifndef NO_UNIX_SOCKETS
! 503: else {
! 504: s = socket(AF_UNIX, SOCK_STREAM, 0);
! 505: if (s < 0)
! 506: slirp_exit(1);
! 507: sock_un.sun_family = AF_UNIX;
! 508: strcpy(sock_un.sun_path, socket_path);
! 509: if (connect(s, (struct sockaddr *)&sock_un,
! 510: sizeof(sock_un.sun_family) + sizeof(sock_un.sun_path)) != 0)
! 511: slirp_exit(1);
! 512: sprintf(buff, "kill none:%d", slirp_socket_unit);
! 513: write(s, buff, strlen(buff)+1);
! 514: }
! 515: #endif
! 516: slirp_exit(0);
! 517: }
! 518:
! 519:
! 520: void
! 521: snooze()
! 522: {
! 523: sigset_t s;
! 524: int i;
! 525:
! 526: /* Don't need our data anymore */
! 527: /* XXX This makes SunOS barf */
! 528: /* brk(0); */
! 529:
! 530: /* Close all fd's */
! 531: for (i = 255; i >= 0; i--)
! 532: close(i);
! 533:
! 534: signal(SIGQUIT, slirp_exit);
! 535: signal(SIGHUP, snooze_hup);
! 536: sigemptyset(&s);
! 537:
! 538: /* Wait for any signal */
! 539: sigsuspend(&s);
! 540:
! 541: /* Just in case ... */
! 542: exit(255);
! 543: }
! 544:
! 545: void
! 546: relay(s)
! 547: int s;
! 548: {
! 549: char buf[8192];
! 550: int n;
! 551: fd_set readfds;
! 552: struct ttys *ttyp;
! 553:
! 554: /* Don't need our data anymore */
! 555: /* XXX This makes SunOS barf */
! 556: /* brk(0); */
! 557:
! 558: signal(SIGQUIT, slirp_exit);
! 559: signal(SIGHUP, slirp_exit);
! 560: signal(SIGINT, slirp_exit);
! 561: signal(SIGTERM, slirp_exit);
! 562:
! 563: /* Fudge to get term_raw and term_restore to work */
! 564: if (NULL == (ttyp = tty_attach (0, slirp_tty))) {
! 565: lprint ("Error: tty_attach failed in misc.c:relay()\r\n");
! 566: slirp_exit (1);
! 567: }
! 568: ttyp->fd = 0;
! 569: ttyp->flags |= TTY_CTTY;
! 570: term_raw(ttyp);
! 571:
! 572: while (1) {
! 573: FD_ZERO(&readfds);
! 574:
! 575: FD_SET(0, &readfds);
! 576: FD_SET(s, &readfds);
! 577:
! 578: n = select(s+1, &readfds, (fd_set *)0, (fd_set *)0, (struct timeval *)0);
! 579:
! 580: if (n <= 0)
! 581: slirp_exit(0);
! 582:
! 583: if (FD_ISSET(0, &readfds)) {
! 584: n = read(0, buf, 8192);
! 585: if (n <= 0)
! 586: slirp_exit(0);
! 587: n = writen(s, buf, n);
! 588: if (n <= 0)
! 589: slirp_exit(0);
! 590: }
! 591:
! 592: if (FD_ISSET(s, &readfds)) {
! 593: n = read(s, buf, 8192);
! 594: if (n <= 0)
! 595: slirp_exit(0);
! 596: n = writen(0, buf, n);
! 597: if (n <= 0)
! 598: slirp_exit(0);
! 599: }
! 600: }
! 601:
! 602: /* Just in case.... */
! 603: exit(1);
! 604: }
! 605: #endif
! 606:
! 607: int (*lprint_print) _P((void *, const char *, va_list));
! 608: char *lprint_ptr, *lprint_ptr2, **lprint_arg;
! 609:
! 610: void
! 611: #ifdef __STDC__
! 612: lprint(const char *format, ...)
! 613: #else
! 614: lprint(va_alist) va_dcl
! 615: #endif
! 616: {
! 617: va_list args;
! 618:
! 619: #ifdef __STDC__
! 620: va_start(args, format);
! 621: #else
! 622: char *format;
! 623: va_start(args);
! 624: format = va_arg(args, char *);
! 625: #endif
! 626: #if 0
! 627: /* If we're printing to an sbuf, make sure there's enough room */
! 628: /* XXX +100? */
! 629: if (lprint_sb) {
! 630: if ((lprint_ptr - lprint_sb->sb_wptr) >=
! 631: (lprint_sb->sb_datalen - (strlen(format) + 100))) {
! 632: int deltaw = lprint_sb->sb_wptr - lprint_sb->sb_data;
! 633: int deltar = lprint_sb->sb_rptr - lprint_sb->sb_data;
! 634: int deltap = lprint_ptr - lprint_sb->sb_data;
! 635:
! 636: lprint_sb->sb_data = (char *)realloc(lprint_sb->sb_data,
! 637: lprint_sb->sb_datalen + TCP_SNDSPACE);
! 638:
! 639: /* Adjust all values */
! 640: lprint_sb->sb_wptr = lprint_sb->sb_data + deltaw;
! 641: lprint_sb->sb_rptr = lprint_sb->sb_data + deltar;
! 642: lprint_ptr = lprint_sb->sb_data + deltap;
! 643:
! 644: lprint_sb->sb_datalen += TCP_SNDSPACE;
! 645: }
! 646: }
! 647: #endif
! 648: if (lprint_print)
! 649: lprint_ptr += (*lprint_print)(*lprint_arg, format, args);
! 650:
! 651: /* Check if they want output to be logged to file as well */
! 652: if (lfd) {
! 653: /*
! 654: * Remove \r's
! 655: * otherwise you'll get ^M all over the file
! 656: */
! 657: int len = strlen(format);
! 658: char *bptr1, *bptr2;
! 659:
! 660: bptr1 = bptr2 = strdup(format);
! 661:
! 662: while (len--) {
! 663: if (*bptr1 == '\r')
! 664: memcpy(bptr1, bptr1+1, len+1);
! 665: else
! 666: bptr1++;
! 667: }
! 668: vfprintf(lfd, bptr2, args);
! 669: free(bptr2);
! 670: }
! 671: va_end(args);
! 672: }
! 673:
! 674: void
! 675: add_emu(buff)
! 676: char *buff;
! 677: {
! 678: u_int lport, fport;
! 679: u_int8_t tos = 0, emu = 0;
! 680: char buff1[256], buff2[256], buff4[128];
! 681: char *buff3 = buff4;
! 682: struct emu_t *emup;
! 683: struct socket *so;
! 684:
! 685: if (sscanf(buff, "%256s %256s", buff2, buff1) != 2) {
! 686: lprint("Error: Bad arguments\r\n");
! 687: return;
! 688: }
! 689:
! 690: if (sscanf(buff1, "%d:%d", &lport, &fport) != 2) {
! 691: lport = 0;
! 692: if (sscanf(buff1, "%d", &fport) != 1) {
! 693: lprint("Error: Bad first argument\r\n");
! 694: return;
! 695: }
! 696: }
! 697:
! 698: if (sscanf(buff2, "%128[^:]:%128s", buff1, buff3) != 2) {
! 699: buff3 = 0;
! 700: if (sscanf(buff2, "%256s", buff1) != 1) {
! 701: lprint("Error: Bad second argument\r\n");
! 702: return;
! 703: }
! 704: }
! 705:
! 706: if (buff3) {
! 707: if (strcmp(buff3, "lowdelay") == 0)
! 708: tos = IPTOS_LOWDELAY;
! 709: else if (strcmp(buff3, "throughput") == 0)
! 710: tos = IPTOS_THROUGHPUT;
! 711: else {
! 712: lprint("Error: Expecting \"lowdelay\"/\"throughput\"\r\n");
! 713: return;
! 714: }
! 715: }
! 716:
! 717: if (strcmp(buff1, "ftp") == 0)
! 718: emu = EMU_FTP;
! 719: else if (strcmp(buff1, "irc") == 0)
! 720: emu = EMU_IRC;
! 721: else if (strcmp(buff1, "none") == 0)
! 722: emu = EMU_NONE; /* ie: no emulation */
! 723: else {
! 724: lprint("Error: Unknown service\r\n");
! 725: return;
! 726: }
! 727:
! 728: /* First, check that it isn't already emulated */
! 729: for (emup = tcpemu; emup; emup = emup->next) {
! 730: if (emup->lport == lport && emup->fport == fport) {
! 731: lprint("Error: port already emulated\r\n");
! 732: return;
! 733: }
! 734: }
! 735:
! 736: /* link it */
! 737: emup = (struct emu_t *)malloc(sizeof (struct emu_t));
! 738: emup->lport = (u_int16_t)lport;
! 739: emup->fport = (u_int16_t)fport;
! 740: emup->tos = tos;
! 741: emup->emu = emu;
! 742: emup->next = tcpemu;
! 743: tcpemu = emup;
! 744:
! 745: /* And finally, mark all current sessions, if any, as being emulated */
! 746: for (so = tcb.so_next; so != &tcb; so = so->so_next) {
! 747: if ((lport && lport == ntohs(so->so_lport)) ||
! 748: (fport && fport == ntohs(so->so_fport))) {
! 749: if (emu)
! 750: so->so_emu = emu;
! 751: if (tos)
! 752: so->so_iptos = tos;
! 753: }
! 754: }
! 755:
! 756: lprint("Adding emulation for %s to port %d/%d\r\n", buff1, emup->lport, emup->fport);
! 757: }
! 758:
! 759: #ifdef BAD_SPRINTF
! 760:
! 761: #undef vsprintf
! 762: #undef sprintf
! 763:
! 764: /*
! 765: * Some BSD-derived systems have a sprintf which returns char *
! 766: */
! 767:
! 768: int
! 769: vsprintf_len(string, format, args)
! 770: char *string;
! 771: const char *format;
! 772: va_list args;
! 773: {
! 774: vsprintf(string, format, args);
! 775: return strlen(string);
! 776: }
! 777:
! 778: int
! 779: #ifdef __STDC__
! 780: sprintf_len(char *string, const char *format, ...)
! 781: #else
! 782: sprintf_len(va_alist) va_dcl
! 783: #endif
! 784: {
! 785: va_list args;
! 786: #ifdef __STDC__
! 787: va_start(args, format);
! 788: #else
! 789: char *string;
! 790: char *format;
! 791: va_start(args);
! 792: string = va_arg(args, char *);
! 793: format = va_arg(args, char *);
! 794: #endif
! 795: vsprintf(string, format, args);
! 796: return strlen(string);
! 797: }
! 798:
! 799: #endif
! 800:
! 801: void
! 802: u_sleep(usec)
! 803: int usec;
! 804: {
! 805: struct timeval t;
! 806: fd_set fdset;
! 807:
! 808: FD_ZERO(&fdset);
! 809:
! 810: t.tv_sec = 0;
! 811: t.tv_usec = usec * 1000;
! 812:
! 813: select(0, &fdset, &fdset, &fdset, &t);
! 814: }
! 815:
! 816: /*
! 817: * Set fd blocking and non-blocking
! 818: */
! 819:
! 820: void
! 821: fd_nonblock(fd)
! 822: int fd;
! 823: {
! 824: #ifdef FIONBIO
! 825: int opt = 1;
! 826:
! 827: ioctlsocket(fd, FIONBIO, &opt);
! 828: #else
! 829: int opt;
! 830:
! 831: opt = fcntl(fd, F_GETFL, 0);
! 832: opt |= O_NONBLOCK;
! 833: fcntl(fd, F_SETFL, opt);
! 834: #endif
! 835: }
! 836:
! 837: void
! 838: fd_block(fd)
! 839: int fd;
! 840: {
! 841: #ifdef FIONBIO
! 842: int opt = 0;
! 843:
! 844: ioctlsocket(fd, FIONBIO, &opt);
! 845: #else
! 846: int opt;
! 847:
! 848: opt = fcntl(fd, F_GETFL, 0);
! 849: opt &= ~O_NONBLOCK;
! 850: fcntl(fd, F_SETFL, opt);
! 851: #endif
! 852: }
! 853:
! 854:
! 855: #if 0
! 856: /*
! 857: * invoke RSH
! 858: */
! 859: int
! 860: rsh_exec(so,ns, user, host, args)
! 861: struct socket *so;
! 862: struct socket *ns;
! 863: char *user;
! 864: char *host;
! 865: char *args;
! 866: {
! 867: int fd[2];
! 868: int fd0[2];
! 869: int s;
! 870: char buff[256];
! 871:
! 872: DEBUG_CALL("rsh_exec");
! 873: DEBUG_ARG("so = %lx", (long)so);
! 874:
! 875: if (pipe(fd)<0) {
! 876: lprint("Error: pipe failed: %s\n", strerror(errno));
! 877: return 0;
! 878: }
! 879: /* #ifdef HAVE_SOCKETPAIR */
! 880: #if 1
! 881: if (socketpair(PF_UNIX,SOCK_STREAM,0, fd0) == -1) {
! 882: close(fd[0]);
! 883: close(fd[1]);
! 884: lprint("Error: openpty failed: %s\n", strerror(errno));
! 885: return 0;
! 886: }
! 887: #else
! 888: if (slirp_openpty(&fd0[0], &fd0[1]) == -1) {
! 889: close(fd[0]);
! 890: close(fd[1]);
! 891: lprint("Error: openpty failed: %s\n", strerror(errno));
! 892: return 0;
! 893: }
! 894: #endif
! 895:
! 896: switch(fork()) {
! 897: case -1:
! 898: lprint("Error: fork failed: %s\n", strerror(errno));
! 899: close(fd[0]);
! 900: close(fd[1]);
! 901: close(fd0[0]);
! 902: close(fd0[1]);
! 903: return 0;
! 904:
! 905: case 0:
! 906: close(fd[0]);
! 907: close(fd0[0]);
! 908:
! 909: /* Set the DISPLAY */
! 910: if (x_port >= 0) {
! 911: #ifdef HAVE_SETENV
! 912: sprintf(buff, "%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
! 913: setenv("DISPLAY", buff, 1);
! 914: #else
! 915: sprintf(buff, "DISPLAY=%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
! 916: putenv(buff);
! 917: #endif
! 918: }
! 919:
! 920: dup2(fd0[1], 0);
! 921: dup2(fd0[1], 1);
! 922: dup2(fd[1], 2);
! 923: for (s = 3; s <= 255; s++)
! 924: close(s);
! 925:
! 926: execlp("rsh","rsh","-l", user, host, args, NULL);
! 927:
! 928: /* Ooops, failed, let's tell the user why */
! 929:
! 930: sprintf(buff, "Error: execlp of %s failed: %s\n",
! 931: "rsh", strerror(errno));
! 932: write(2, buff, strlen(buff)+1);
! 933: close(0); close(1); close(2); /* XXX */
! 934: exit(1);
! 935:
! 936: default:
! 937: close(fd[1]);
! 938: close(fd0[1]);
! 939: ns->s=fd[0];
! 940: so->s=fd0[0];
! 941:
! 942: return 1;
! 943: }
! 944: }
! 945: #endif
unix.superglobalmegacorp.com
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / slirp