Diff for /qemu/slirp/misc.c between versions 1.1.1.2 and 1.1.1.3

version 1.1.1.2, 2018/04/24 16:41:51 version 1.1.1.3, 2018/04/24 16:49:21
Line 1 Line 1
 /*  /*
  * Copyright (c) 1995 Danny Gasparovski.   * Copyright (c) 1995 Danny Gasparovski.
  *    *
  * Please read the file COPYRIGHT for the   * Please read the file COPYRIGHT for the
  * terms and conditions of the copyright.   * terms and conditions of the copyright.
  */   */
Line 8 Line 8
 #define WANT_SYS_IOCTL_H  #define WANT_SYS_IOCTL_H
 #include <slirp.h>  #include <slirp.h>
   
 u_int curtime, time_fasttimo, last_slowtimo, detach_time;  u_int curtime, time_fasttimo, last_slowtimo;
 u_int detach_wait = 600000;     /* 10 minutes */  
   
 #if 0  #if 0
 int x_port = -1;  int x_port = -1;
Line 31  show_x(buff, inso) Line 30  show_x(buff, inso)
                 if (x_display)                  if (x_display)
                    lprint("X Redir: Redirecting to display %d\r\n", x_display);                     lprint("X Redir: Redirecting to display %d\r\n", x_display);
         }          }
           
         return CFG_OK;          return CFG_OK;
 }  }
   
Line 47  redir_x(inaddr, start_port, display, scr Line 46  redir_x(inaddr, start_port, display, scr
         int screen;          int screen;
 {  {
         int i;          int i;
           
         if (x_port >= 0) {          if (x_port >= 0) {
                 lprint("X Redir: X already being redirected.\r\n");                  lprint("X Redir: X already being redirected.\r\n");
                 show_x(0, 0);                  show_x(0, 0);
Line 89  getouraddr() Line 88  getouraddr()
 {  {
         char buff[256];          char buff[256];
         struct hostent *he = NULL;          struct hostent *he = NULL;
           
         if (gethostname(buff,256) == 0)          if (gethostname(buff,256) == 0)
             he = gethostbyname(buff);              he = gethostbyname(buff);
         if (he)          if (he)
Line 172  add_exec(ex_ptr, do_pty, exec, addr, por Line 171  add_exec(ex_ptr, do_pty, exec, addr, por
         int port;          int port;
 {  {
         struct ex_list *tmp_ptr;          struct ex_list *tmp_ptr;
           
         /* First, check if the port is "bound" */          /* First, check if the port is "bound" */
         for (tmp_ptr = *ex_ptr; tmp_ptr; tmp_ptr = tmp_ptr->ex_next) {          for (tmp_ptr = *ex_ptr; tmp_ptr; tmp_ptr = tmp_ptr->ex_next) {
                 if (port == tmp_ptr->ex_fport && addr == tmp_ptr->ex_addr)                  if (port == tmp_ptr->ex_fport && addr == tmp_ptr->ex_addr)
                    return -1;                     return -1;
         }          }
           
         tmp_ptr = *ex_ptr;          tmp_ptr = *ex_ptr;
         *ex_ptr = (struct ex_list *)malloc(sizeof(struct ex_list));          *ex_ptr = (struct ex_list *)malloc(sizeof(struct ex_list));
         (*ex_ptr)->ex_fport = port;          (*ex_ptr)->ex_fport = port;
Line 214  strerror(error) Line 213  strerror(error)
 #ifdef _WIN32  #ifdef _WIN32
   
 int  int
 fork_exec(so, ex, do_pty)  fork_exec(struct socket *so, const char *ex, int do_pty)
         struct socket *so;  
         char *ex;  
         int do_pty;  
 {  {
     /* not implemented */      /* not implemented */
     return 0;      return 0;
Line 225  fork_exec(so, ex, do_pty) Line 221  fork_exec(so, ex, do_pty)
   
 #else  #else
   
   #ifndef CONFIG_QEMU
 int  int
 slirp_openpty(amaster, aslave)  slirp_openpty(amaster, aslave)
      int *amaster, *aslave;       int *amaster, *aslave;
Line 233  slirp_openpty(amaster, aslave) Line 230  slirp_openpty(amaster, aslave)
   
 #ifdef HAVE_GRANTPT  #ifdef HAVE_GRANTPT
         char *ptr;          char *ptr;
           
         if ((master = open("/dev/ptmx", O_RDWR)) < 0 ||          if ((master = open("/dev/ptmx", O_RDWR)) < 0 ||
             grantpt(master) < 0 ||              grantpt(master) < 0 ||
             unlockpt(master) < 0 ||              unlockpt(master) < 0 ||
Line 241  slirp_openpty(amaster, aslave) Line 238  slirp_openpty(amaster, aslave)
                 close(master);                  close(master);
                 return -1;                  return -1;
         }          }
           
         if ((slave = open(ptr, O_RDWR)) < 0 ||          if ((slave = open(ptr, O_RDWR)) < 0 ||
             ioctl(slave, I_PUSH, "ptem") < 0 ||              ioctl(slave, I_PUSH, "ptem") < 0 ||
             ioctl(slave, I_PUSH, "ldterm") < 0 ||              ioctl(slave, I_PUSH, "ldterm") < 0 ||
Line 250  slirp_openpty(amaster, aslave) Line 247  slirp_openpty(amaster, aslave)
                 close(slave);                  close(slave);
                 return -1;                  return -1;
         }          }
           
         *amaster = master;          *amaster = master;
         *aslave = slave;          *aslave = slave;
         return 0;          return 0;
           
 #else  #else
           
         static char line[] = "/dev/ptyXX";          static char line[] = "/dev/ptyXX";
         register const char *cp1, *cp2;          register const char *cp1, *cp2;
           
         for (cp1 = "pqrsPQRS"; *cp1; cp1++) {          for (cp1 = "pqrsPQRS"; *cp1; cp1++) {
                 line[8] = *cp1;                  line[8] = *cp1;
                 for (cp2 = "0123456789abcdefghijklmnopqrstuv"; *cp2; cp2++) {                  for (cp2 = "0123456789abcdefghijklmnopqrstuv"; *cp2; cp2++) {
Line 289  slirp_openpty(amaster, aslave) Line 286  slirp_openpty(amaster, aslave)
         return (-1);          return (-1);
 #endif  #endif
 }  }
   #endif
   
 /*  /*
  * XXX This is ugly   * XXX This is ugly
Line 296  slirp_openpty(amaster, aslave) Line 294  slirp_openpty(amaster, aslave)
  * process, which connects to this socket, after which we   * process, which connects to this socket, after which we
  * exec the wanted program.  If something (strange) happens,   * exec the wanted program.  If something (strange) happens,
  * the accept() call could block us forever.   * the accept() call could block us forever.
  *    *
  * do_pty = 0   Fork/exec inetd style   * do_pty = 0   Fork/exec inetd style
  * do_pty = 1   Fork/exec using slirp.telnetd   * do_pty = 1   Fork/exec using slirp.telnetd
  * do_ptr = 2   Fork/exec using pty   * do_ptr = 2   Fork/exec using pty
  */   */
 int  int
 fork_exec(so, ex, do_pty)  fork_exec(struct socket *so, const char *ex, int do_pty)
         struct socket *so;  
         char *ex;  
         int do_pty;  
 {  {
         int s;          int s;
         struct sockaddr_in addr;          struct sockaddr_in addr;
         int addrlen = sizeof(addr);          int addrlen = sizeof(addr);
         int opt;          int opt;
         int master;          int master = -1;
         char *argv[256];          char *argv[256];
 #if 0  #if 0
         char buff[256];          char buff[256];
 #endif  #endif
         /* don't want to clobber the original */          /* don't want to clobber the original */
         char *bptr;          char *bptr;
         char *curarg;          const char *curarg;
         int c, i, ret;          int c, i, ret;
           
         DEBUG_CALL("fork_exec");          DEBUG_CALL("fork_exec");
         DEBUG_ARG("so = %lx", (long)so);          DEBUG_ARG("so = %lx", (long)so);
         DEBUG_ARG("ex = %lx", (long)ex);          DEBUG_ARG("ex = %lx", (long)ex);
         DEBUG_ARG("do_pty = %lx", (long)do_pty);          DEBUG_ARG("do_pty = %lx", (long)do_pty);
           
         if (do_pty == 2) {          if (do_pty == 2) {
   #if 0
                 if (slirp_openpty(&master, &s) == -1) {                  if (slirp_openpty(&master, &s) == -1) {
                         lprint("Error: openpty failed: %s\n", strerror(errno));                          lprint("Error: openpty failed: %s\n", strerror(errno));
                         return 0;                          return 0;
                 }                  }
   #else
                   return 0;
   #endif
         } else {          } else {
                 addr.sin_family = AF_INET;                  addr.sin_family = AF_INET;
                 addr.sin_port = 0;                  addr.sin_port = 0;
                 addr.sin_addr.s_addr = INADDR_ANY;                  addr.sin_addr.s_addr = INADDR_ANY;
                   
                 if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ||                  if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ||
                     bind(s, (struct sockaddr *)&addr, addrlen) < 0 ||                      bind(s, (struct sockaddr *)&addr, addrlen) < 0 ||
                     listen(s, 1) < 0) {                      listen(s, 1) < 0) {
                         lprint("Error: inet socket: %s\n", strerror(errno));                          lprint("Error: inet socket: %s\n", strerror(errno));
                         closesocket(s);                          closesocket(s);
                           
                         return 0;                          return 0;
                 }                  }
         }          }
           
         switch(fork()) {          switch(fork()) {
          case -1:           case -1:
                 lprint("Error: fork failed: %s\n", strerror(errno));                  lprint("Error: fork failed: %s\n", strerror(errno));
Line 353  fork_exec(so, ex, do_pty) Line 352  fork_exec(so, ex, do_pty)
                 if (do_pty == 2)                  if (do_pty == 2)
                    close(master);                     close(master);
                 return 0;                  return 0;
                   
          case 0:           case 0:
                 /* Set the DISPLAY */                  /* Set the DISPLAY */
                 if (do_pty == 2) {                  if (do_pty == 2) {
Line 375  fork_exec(so, ex, do_pty) Line 374  fork_exec(so, ex, do_pty)
                             ret = connect(s, (struct sockaddr *)&addr, addrlen);                              ret = connect(s, (struct sockaddr *)&addr, addrlen);
                         } while (ret < 0 && errno == EINTR);                          } while (ret < 0 && errno == EINTR);
                 }                  }
                   
 #if 0  #if 0
                 if (x_port >= 0) {                  if (x_port >= 0) {
 #ifdef HAVE_SETENV  #ifdef HAVE_SETENV
Line 386  fork_exec(so, ex, do_pty) Line 385  fork_exec(so, ex, do_pty)
                         putenv(buff);                          putenv(buff);
 #endif  #endif
                 }                  }
 #endif    #endif
                 dup2(s, 0);                  dup2(s, 0);
                 dup2(s, 1);                  dup2(s, 1);
                 dup2(s, 2);                  dup2(s, 2);
                 for (s = 3; s <= 255; s++)                  for (s = getdtablesize() - 1; s >= 3; s--)
                    close(s);                     close(s);
                   
                 i = 0;                  i = 0;
                 bptr = strdup(ex); /* No need to free() this */                  bptr = strdup(ex); /* No need to free() this */
                 if (do_pty == 1) {                  if (do_pty == 1) {
Line 410  fork_exec(so, ex, do_pty) Line 409  fork_exec(so, ex, do_pty)
                         *bptr++ = (char)0;                          *bptr++ = (char)0;
                         argv[i++] = strdup(curarg);                          argv[i++] = strdup(curarg);
                    } while (c);                     } while (c);
                   
                 argv[i] = 0;                  argv[i] = 0;
                 execvp(argv[0], argv);                  execvp(argv[0], argv);
                   
                 /* Ooops, failed, let's tell the user why */                  /* Ooops, failed, let's tell the user why */
                   {                    {
                           char buff[256];                            char buff[256];
                             
                           sprintf(buff, "Error: execvp of %s failed: %s\n",                             sprintf(buff, "Error: execvp of %s failed: %s\n",
                                   argv[0], strerror(errno));                                    argv[0], strerror(errno));
                           write(2, buff, strlen(buff)+1);                            write(2, buff, strlen(buff)+1);
                   }                    }
                 close(0); close(1); close(2); /* XXX */                  close(0); close(1); close(2); /* XXX */
                 exit(1);                  exit(1);
                   
          default:           default:
                 if (do_pty == 2) {                  if (do_pty == 2) {
                         close(s);                          close(s);
Line 447  fork_exec(so, ex, do_pty) Line 446  fork_exec(so, ex, do_pty)
                         setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));                          setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
                 }                  }
                 fd_nonblock(so->s);                  fd_nonblock(so->s);
                   
                 /* Append the telnet options now */                  /* Append the telnet options now */
                 if (so->so_m != 0 && do_pty == 1)  {                  if (so->so_m != 0 && do_pty == 1)  {
                         sbappend(so, so->so_m);                          sbappend(so, so->so_m);
                         so->so_m = 0;                          so->so_m = 0;
                 }                  }
                   
                 return 1;                  return 1;
         }          }
 }  }
Line 465  strdup(str) Line 464  strdup(str)
         const char *str;          const char *str;
 {  {
         char *bptr;          char *bptr;
           
         bptr = (char *)malloc(strlen(str)+1);          bptr = (char *)malloc(strlen(str)+1);
         strcpy(bptr, str);          strcpy(bptr, str);
           
         return bptr;          return bptr;
 }  }
 #endif  #endif
Line 484  snooze_hup(num) Line 483  snooze_hup(num)
 #endif  #endif
         struct sockaddr_in sock_in;          struct sockaddr_in sock_in;
         char buff[256];          char buff[256];
           
         ret = -1;          ret = -1;
         if (slirp_socket_passwd) {          if (slirp_socket_passwd) {
                 s = socket(AF_INET, SOCK_STREAM, 0);                  s = socket(AF_INET, SOCK_STREAM, 0);
Line 514  snooze_hup(num) Line 513  snooze_hup(num)
 #endif  #endif
         slirp_exit(0);          slirp_exit(0);
 }  }
           
           
 void  void
 snooze()  snooze()
 {  {
         sigset_t s;          sigset_t s;
         int i;          int i;
           
         /* Don't need our data anymore */          /* Don't need our data anymore */
         /* XXX This makes SunOS barf */          /* XXX This makes SunOS barf */
 /*      brk(0); */  /*      brk(0); */
           
         /* Close all fd's */          /* Close all fd's */
         for (i = 255; i >= 0; i--)          for (i = 255; i >= 0; i--)
            close(i);             close(i);
           
         signal(SIGQUIT, slirp_exit);          signal(SIGQUIT, slirp_exit);
         signal(SIGHUP, snooze_hup);          signal(SIGHUP, snooze_hup);
         sigemptyset(&s);          sigemptyset(&s);
           
         /* Wait for any signal */          /* Wait for any signal */
         sigsuspend(&s);          sigsuspend(&s);
           
         /* Just in case ... */          /* Just in case ... */
         exit(255);          exit(255);
 }  }
Line 549  relay(s) Line 548  relay(s)
         int n;          int n;
         fd_set readfds;          fd_set readfds;
         struct ttys *ttyp;          struct ttys *ttyp;
           
         /* Don't need our data anymore */          /* Don't need our data anymore */
         /* XXX This makes SunOS barf */          /* XXX This makes SunOS barf */
 /*      brk(0); */  /*      brk(0); */
           
         signal(SIGQUIT, slirp_exit);          signal(SIGQUIT, slirp_exit);
         signal(SIGHUP, slirp_exit);          signal(SIGHUP, slirp_exit);
         signal(SIGINT, slirp_exit);          signal(SIGINT, slirp_exit);
         signal(SIGTERM, slirp_exit);          signal(SIGTERM, slirp_exit);
           
         /* Fudge to get term_raw and term_restore to work */          /* Fudge to get term_raw and term_restore to work */
         if (NULL == (ttyp = tty_attach (0, slirp_tty))) {          if (NULL == (ttyp = tty_attach (0, slirp_tty))) {
          lprint ("Error: tty_attach failed in misc.c:relay()\r\n");           lprint ("Error: tty_attach failed in misc.c:relay()\r\n");
Line 567  relay(s) Line 566  relay(s)
         ttyp->fd = 0;          ttyp->fd = 0;
         ttyp->flags |= TTY_CTTY;          ttyp->flags |= TTY_CTTY;
         term_raw(ttyp);          term_raw(ttyp);
           
         while (1) {          while (1) {
                 FD_ZERO(&readfds);                  FD_ZERO(&readfds);
                   
                 FD_SET(0, &readfds);                  FD_SET(0, &readfds);
                 FD_SET(s, &readfds);                  FD_SET(s, &readfds);
                   
                 n = select(s+1, &readfds, (fd_set *)0, (fd_set *)0, (struct timeval *)0);                  n = select(s+1, &readfds, (fd_set *)0, (fd_set *)0, (struct timeval *)0);
                   
                 if (n <= 0)                  if (n <= 0)
                    slirp_exit(0);                     slirp_exit(0);
                   
                 if (FD_ISSET(0, &readfds)) {                  if (FD_ISSET(0, &readfds)) {
                         n = read(0, buf, 8192);                          n = read(0, buf, 8192);
                         if (n <= 0)                          if (n <= 0)
Line 587  relay(s) Line 586  relay(s)
                         if (n <= 0)                          if (n <= 0)
                            slirp_exit(0);                             slirp_exit(0);
                 }                  }
                   
                 if (FD_ISSET(s, &readfds)) {                  if (FD_ISSET(s, &readfds)) {
                         n = read(s, buf, 8192);                          n = read(s, buf, 8192);
                         if (n <= 0)                          if (n <= 0)
Line 597  relay(s) Line 596  relay(s)
                            slirp_exit(0);                             slirp_exit(0);
                 }                  }
         }          }
           
         /* Just in case.... */          /* Just in case.... */
         exit(1);          exit(1);
 }  }
 #endif  #endif
   
   #ifdef CONFIG_QEMU
   extern void term_vprintf(const char *fmt, va_list ap);
   
   void lprint(const char *format, ...)
   {
       va_list args;
   
       va_start(args, format);
       term_vprintf(format, args);
       va_end(args);
   }
   #else
 int (*lprint_print) _P((void *, const char *, va_list));  int (*lprint_print) _P((void *, const char *, va_list));
 char *lprint_ptr, *lprint_ptr2, **lprint_arg;  char *lprint_ptr, *lprint_ptr2, **lprint_arg;
   
Line 614  lprint(va_alist) va_dcl Line 625  lprint(va_alist) va_dcl
 #endif  #endif
 {  {
         va_list args;          va_list args;
           
 #ifdef __STDC__  #ifdef __STDC__
         va_start(args, format);          va_start(args, format);
 #else  #else
Line 631  lprint(va_alist) va_dcl Line 642  lprint(va_alist) va_dcl
                         int deltaw = lprint_sb->sb_wptr - lprint_sb->sb_data;                          int deltaw = lprint_sb->sb_wptr - lprint_sb->sb_data;
                         int deltar = lprint_sb->sb_rptr - lprint_sb->sb_data;                          int deltar = lprint_sb->sb_rptr - lprint_sb->sb_data;
                         int deltap = lprint_ptr -         lprint_sb->sb_data;                          int deltap = lprint_ptr -         lprint_sb->sb_data;
                                                   
                         lprint_sb->sb_data = (char *)realloc(lprint_sb->sb_data,                          lprint_sb->sb_data = (char *)realloc(lprint_sb->sb_data,
                                                              lprint_sb->sb_datalen + TCP_SNDSPACE);                                                               lprint_sb->sb_datalen + TCP_SNDSPACE);
                           
                         /* Adjust all values */                          /* Adjust all values */
                         lprint_sb->sb_wptr = lprint_sb->sb_data + deltaw;                          lprint_sb->sb_wptr = lprint_sb->sb_data + deltaw;
                         lprint_sb->sb_rptr = lprint_sb->sb_data + deltar;                          lprint_sb->sb_rptr = lprint_sb->sb_data + deltar;
                         lprint_ptr =         lprint_sb->sb_data + deltap;                          lprint_ptr =         lprint_sb->sb_data + deltap;
                           
                         lprint_sb->sb_datalen += TCP_SNDSPACE;                          lprint_sb->sb_datalen += TCP_SNDSPACE;
                 }                  }
         }          }
 #endif    #endif
         if (lprint_print)          if (lprint_print)
            lprint_ptr += (*lprint_print)(*lprint_arg, format, args);             lprint_ptr += (*lprint_print)(*lprint_arg, format, args);
           
         /* Check if they want output to be logged to file as well */          /* Check if they want output to be logged to file as well */
         if (lfd) {          if (lfd) {
                 /*                   /*
                  * Remove \r's                   * Remove \r's
                  * otherwise you'll get ^M all over the file                   * otherwise you'll get ^M all over the file
                  */                   */
                 int len = strlen(format);                  int len = strlen(format);
                 char *bptr1, *bptr2;                  char *bptr1, *bptr2;
                   
                 bptr1 = bptr2 = strdup(format);                  bptr1 = bptr2 = strdup(format);
                   
                 while (len--) {                  while (len--) {
                         if (*bptr1 == '\r')                          if (*bptr1 == '\r')
                            memcpy(bptr1, bptr1+1, len+1);                             memcpy(bptr1, bptr1+1, len+1);
Line 680  add_emu(buff) Line 691  add_emu(buff)
         char *buff3 = buff4;          char *buff3 = buff4;
         struct emu_t *emup;          struct emu_t *emup;
         struct socket *so;          struct socket *so;
           
         if (sscanf(buff, "%256s %256s", buff2, buff1) != 2) {          if (sscanf(buff, "%256s %256s", buff2, buff1) != 2) {
                 lprint("Error: Bad arguments\r\n");                  lprint("Error: Bad arguments\r\n");
                 return;                  return;
         }          }
           
         if (sscanf(buff1, "%d:%d", &lport, &fport) != 2) {          if (sscanf(buff1, "%d:%d", &lport, &fport) != 2) {
                 lport = 0;                  lport = 0;
                 if (sscanf(buff1, "%d", &fport) != 1) {                  if (sscanf(buff1, "%d", &fport) != 1) {
Line 693  add_emu(buff) Line 704  add_emu(buff)
                         return;                          return;
                 }                  }
         }          }
           
         if (sscanf(buff2, "%128[^:]:%128s", buff1, buff3) != 2) {          if (sscanf(buff2, "%128[^:]:%128s", buff1, buff3) != 2) {
                 buff3 = 0;                  buff3 = 0;
                 if (sscanf(buff2, "%256s", buff1) != 1) {                  if (sscanf(buff2, "%256s", buff1) != 1) {
Line 701  add_emu(buff) Line 712  add_emu(buff)
                         return;                          return;
                 }                  }
         }          }
           
         if (buff3) {          if (buff3) {
                 if (strcmp(buff3, "lowdelay") == 0)                  if (strcmp(buff3, "lowdelay") == 0)
                    tos = IPTOS_LOWDELAY;                     tos = IPTOS_LOWDELAY;
Line 712  add_emu(buff) Line 723  add_emu(buff)
                         return;                          return;
                 }                  }
         }          }
           
         if (strcmp(buff1, "ftp") == 0)          if (strcmp(buff1, "ftp") == 0)
            emu = EMU_FTP;             emu = EMU_FTP;
         else if (strcmp(buff1, "irc") == 0)          else if (strcmp(buff1, "irc") == 0)
Line 723  add_emu(buff) Line 734  add_emu(buff)
                 lprint("Error: Unknown service\r\n");                  lprint("Error: Unknown service\r\n");
                 return;                  return;
         }          }
           
         /* First, check that it isn't already emulated */          /* First, check that it isn't already emulated */
         for (emup = tcpemu; emup; emup = emup->next) {          for (emup = tcpemu; emup; emup = emup->next) {
                 if (emup->lport == lport && emup->fport == fport) {                  if (emup->lport == lport && emup->fport == fport) {
Line 731  add_emu(buff) Line 742  add_emu(buff)
                         return;                          return;
                 }                  }
         }          }
           
         /* link it */          /* link it */
         emup = (struct emu_t *)malloc(sizeof (struct emu_t));          emup = (struct emu_t *)malloc(sizeof (struct emu_t));
         emup->lport = (u_int16_t)lport;          emup->lport = (u_int16_t)lport;
Line 740  add_emu(buff) Line 751  add_emu(buff)
         emup->emu = emu;          emup->emu = emu;
         emup->next = tcpemu;          emup->next = tcpemu;
         tcpemu = emup;          tcpemu = emup;
           
         /* And finally, mark all current sessions, if any, as being emulated */          /* And finally, mark all current sessions, if any, as being emulated */
         for (so = tcb.so_next; so != &tcb; so = so->so_next) {          for (so = tcb.so_next; so != &tcb; so = so->so_next) {
                 if ((lport && lport == ntohs(so->so_lport)) ||                  if ((lport && lport == ntohs(so->so_lport)) ||
Line 751  add_emu(buff) Line 762  add_emu(buff)
                            so->so_iptos = tos;                             so->so_iptos = tos;
                 }                  }
         }          }
           
         lprint("Adding emulation for %s to port %d/%d\r\n", buff1, emup->lport, emup->fport);          lprint("Adding emulation for %s to port %d/%d\r\n", buff1, emup->lport, emup->fport);
 }  }
   #endif
   
 #ifdef BAD_SPRINTF  #ifdef BAD_SPRINTF
   
Line 803  u_sleep(usec) Line 815  u_sleep(usec)
 {  {
         struct timeval t;          struct timeval t;
         fd_set fdset;          fd_set fdset;
           
         FD_ZERO(&fdset);          FD_ZERO(&fdset);
           
         t.tv_sec = 0;          t.tv_sec = 0;
         t.tv_usec = usec * 1000;          t.tv_usec = usec * 1000;
           
         select(0, &fdset, &fdset, &fdset, &t);          select(0, &fdset, &fdset, &fdset, &t);
 }  }
   
Line 822  fd_nonblock(fd) Line 834  fd_nonblock(fd)
 {  {
 #ifdef FIONBIO  #ifdef FIONBIO
         int opt = 1;          int opt = 1;
           
         ioctlsocket(fd, FIONBIO, &opt);          ioctlsocket(fd, FIONBIO, &opt);
 #else  #else
         int opt;          int opt;
           
         opt = fcntl(fd, F_GETFL, 0);          opt = fcntl(fd, F_GETFL, 0);
         opt |= O_NONBLOCK;          opt |= O_NONBLOCK;
         fcntl(fd, F_SETFL, opt);          fcntl(fd, F_SETFL, opt);
Line 839  fd_block(fd) Line 851  fd_block(fd)
 {  {
 #ifdef FIONBIO  #ifdef FIONBIO
         int opt = 0;          int opt = 0;
           
         ioctlsocket(fd, FIONBIO, &opt);          ioctlsocket(fd, FIONBIO, &opt);
 #else  #else
         int opt;          int opt;
           
         opt = fcntl(fd, F_GETFL, 0);          opt = fcntl(fd, F_GETFL, 0);
         opt &= ~O_NONBLOCK;          opt &= ~O_NONBLOCK;
         fcntl(fd, F_SETFL, opt);          fcntl(fd, F_SETFL, opt);
Line 867  rsh_exec(so,ns, user, host, args) Line 879  rsh_exec(so,ns, user, host, args)
         int fd0[2];          int fd0[2];
         int s;          int s;
         char buff[256];          char buff[256];
           
         DEBUG_CALL("rsh_exec");          DEBUG_CALL("rsh_exec");
         DEBUG_ARG("so = %lx", (long)so);          DEBUG_ARG("so = %lx", (long)so);
           
         if (pipe(fd)<0) {          if (pipe(fd)<0) {
           lprint("Error: pipe failed: %s\n", strerror(errno));            lprint("Error: pipe failed: %s\n", strerror(errno));
           return 0;            return 0;
Line 891  rsh_exec(so,ns, user, host, args) Line 903  rsh_exec(so,ns, user, host, args)
           return 0;            return 0;
         }          }
 #endif  #endif
           
         switch(fork()) {          switch(fork()) {
          case -1:           case -1:
            lprint("Error: fork failed: %s\n", strerror(errno));             lprint("Error: fork failed: %s\n", strerror(errno));
Line 900  rsh_exec(so,ns, user, host, args) Line 912  rsh_exec(so,ns, user, host, args)
            close(fd0[0]);             close(fd0[0]);
            close(fd0[1]);             close(fd0[1]);
            return 0;             return 0;
              
          case 0:           case 0:
            close(fd[0]);             close(fd[0]);
            close(fd0[0]);             close(fd0[0]);
              
                 /* Set the DISPLAY */                  /* Set the DISPLAY */
            if (x_port >= 0) {             if (x_port >= 0) {
 #ifdef HAVE_SETENV  #ifdef HAVE_SETENV
Line 915  rsh_exec(so,ns, user, host, args) Line 927  rsh_exec(so,ns, user, host, args)
              putenv(buff);               putenv(buff);
 #endif  #endif
            }             }
              
            dup2(fd0[1], 0);             dup2(fd0[1], 0);
            dup2(fd0[1], 1);             dup2(fd0[1], 1);
            dup2(fd[1], 2);             dup2(fd[1], 2);
            for (s = 3; s <= 255; s++)             for (s = 3; s <= 255; s++)
              close(s);               close(s);
              
            execlp("rsh","rsh","-l", user, host, args, NULL);             execlp("rsh","rsh","-l", user, host, args, NULL);
              
            /* Ooops, failed, let's tell the user why */             /* Ooops, failed, let's tell the user why */
              
            sprintf(buff, "Error: execlp of %s failed: %s\n",              sprintf(buff, "Error: execlp of %s failed: %s\n",
                    "rsh", strerror(errno));                     "rsh", strerror(errno));
            write(2, buff, strlen(buff)+1);             write(2, buff, strlen(buff)+1);
            close(0); close(1); close(2); /* XXX */             close(0); close(1); close(2); /* XXX */
            exit(1);             exit(1);
              
         default:          default:
           close(fd[1]);            close(fd[1]);
           close(fd0[1]);            close(fd0[1]);
           ns->s=fd[0];            ns->s=fd[0];
           so->s=fd0[0];            so->s=fd0[0];
             
           return 1;            return 1;
         }          }
 }  }

Removed from v.1.1.1.2  
changed lines
  Added in v.1.1.1.3


unix.superglobalmegacorp.com