Diff for /qemu/slirp/misc.c between versions 1.1.1.6 and 1.1.1.12

version 1.1.1.6, 2018/04/24 17:41:11 version 1.1.1.12, 2018/04/24 19:51:41
Line 113  fork_exec(struct socket *so, const char  Line 113  fork_exec(struct socket *so, const char 
         struct sockaddr_in addr;          struct sockaddr_in addr;
         socklen_t addrlen = sizeof(addr);          socklen_t addrlen = sizeof(addr);
         int opt;          int opt;
         int master = -1;  
         const char *argv[256];          const char *argv[256];
         /* don't want to clobber the original */          /* don't want to clobber the original */
         char *bptr;          char *bptr;
         const char *curarg;          const char *curarg;
         int c, i, ret;          int c, i, ret;
           pid_t pid;
   
         DEBUG_CALL("fork_exec");          DEBUG_CALL("fork_exec");
         DEBUG_ARG("so = %lx", (long)so);          DEBUG_ARG("so = %lx", (long)so);
Line 142  fork_exec(struct socket *so, const char  Line 142  fork_exec(struct socket *so, const char 
                 }                  }
         }          }
   
         switch(fork()) {          pid = fork();
           switch(pid) {
          case -1:           case -1:
                 lprint("Error: fork failed: %s\n", strerror(errno));                  lprint("Error: fork failed: %s\n", strerror(errno));
                 close(s);                  close(s);
                 if (do_pty == 2)  
                    close(master);  
                 return 0;                  return 0;
   
          case 0:           case 0:
                   setsid();
   
                 /* Set the DISPLAY */                  /* Set the DISPLAY */
                 if (do_pty == 2) {                  getsockname(s, (struct sockaddr *)&addr, &addrlen);
                         (void) close(master);                  close(s);
 #ifdef TIOCSCTTY /* XXXXX */                  /*
                         (void) setsid();                   * Connect to the socket
                         ioctl(s, TIOCSCTTY, (char *)NULL);                   * XXX If any of these fail, we're in trouble!
 #endif                   */
                 } else {                  s = qemu_socket(AF_INET, SOCK_STREAM, 0);
                         getsockname(s, (struct sockaddr *)&addr, &addrlen);                  addr.sin_addr = loopback_addr;
                         close(s);                  do {
                         /*                      ret = connect(s, (struct sockaddr *)&addr, addrlen);
                          * Connect to the socket                  } while (ret < 0 && errno == EINTR);
                          * XXX If any of these fail, we're in trouble!  
                          */  
                         s = qemu_socket(AF_INET, SOCK_STREAM, 0);  
                         addr.sin_addr = loopback_addr;  
                         do {  
                             ret = connect(s, (struct sockaddr *)&addr, addrlen);  
                         } while (ret < 0 && errno == EINTR);  
                 }  
   
                 dup2(s, 0);                  dup2(s, 0);
                 dup2(s, 1);                  dup2(s, 1);
Line 179  fork_exec(struct socket *so, const char  Line 172  fork_exec(struct socket *so, const char 
                    close(s);                     close(s);
   
                 i = 0;                  i = 0;
                 bptr = strdup(ex); /* No need to free() this */                  bptr = g_strdup(ex); /* No need to free() this */
                 if (do_pty == 1) {                  if (do_pty == 1) {
                         /* Setup "slirp.telnetd -x" */                          /* Setup "slirp.telnetd -x" */
                         argv[i++] = "slirp.telnetd";                          argv[i++] = "slirp.telnetd";
Line 200  fork_exec(struct socket *so, const char  Line 193  fork_exec(struct socket *so, const char 
                 execvp(argv[0], (char **)argv);                  execvp(argv[0], (char **)argv);
   
                 /* Ooops, failed, let's tell the user why */                  /* Ooops, failed, let's tell the user why */
                   {          fprintf(stderr, "Error: execvp of %s failed: %s\n",
                           char buff[256];                  argv[0], strerror(errno));
   
                           snprintf(buff, sizeof(buff),  
                                    "Error: execvp of %s failed: %s\n",  
                                    argv[0], strerror(errno));  
                           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) {                  qemu_add_child_watch(pid);
                         close(s);                  /*
                         so->s = master;                   * XXX this could block us...
                 } else {                   * XXX Should set a timer here, and if accept() doesn't
                         /*                   * return after X seconds, declare it a failure
                          * XXX this could block us...                   * The only reason this will block forever is if socket()
                          * XXX Should set a timer here, and if accept() doesn't                   * of connect() fail in the child process
                          * return after X seconds, declare it a failure                   */
                          * The only reason this will block forever is if socket()                  do {
                          * of connect() fail in the child process                      so->s = accept(s, (struct sockaddr *)&addr, &addrlen);
                          */                  } while (so->s < 0 && errno == EINTR);
                         do {                  closesocket(s);
                             so->s = accept(s, (struct sockaddr *)&addr, &addrlen);                  opt = 1;
                         } while (so->s < 0 && errno == EINTR);                  setsockopt(so->s, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(int));
                         closesocket(s);                  opt = 1;
                         opt = 1;                  setsockopt(so->s, SOL_SOCKET, SO_OOBINLINE, (char *)&opt, sizeof(int));
                         setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));                  socket_set_nonblock(so->s);
                         opt = 1;  
                         setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));  
                 }  
                 fd_nonblock(so->s);  
   
                 /* Append the telnet options now */                  /* Append the telnet options now */
                 if (so->so_m != NULL && do_pty == 1)  {                  if (so->so_m != NULL && do_pty == 1)  {
Line 266  void lprint(const char *format, ...) Line 249  void lprint(const char *format, ...)
     va_list args;      va_list args;
   
     va_start(args, format);      va_start(args, format);
     monitor_vprintf(cur_mon, format, args);      monitor_vprintf(default_mon, format, args);
     va_end(args);      va_end(args);
 }  }
   
 #ifdef BAD_SPRINTF  
   
 #undef vsprintf  
 #undef sprintf  
   
 /*  
  * Some BSD-derived systems have a sprintf which returns char *  
  */  
   
 int  
 vsprintf_len(string, format, args)  
         char *string;  
         const char *format;  
         va_list args;  
 {  
         vsprintf(string, format, args);  
         return strlen(string);  
 }  
   
 int  
 #ifdef __STDC__  
 sprintf_len(char *string, const char *format, ...)  
 #else  
 sprintf_len(va_alist) va_dcl  
 #endif  
 {  
         va_list args;  
 #ifdef __STDC__  
         va_start(args, format);  
 #else  
         char *string;  
         char *format;  
         va_start(args);  
         string = va_arg(args, char *);  
         format = va_arg(args, char *);  
 #endif  
         vsprintf(string, format, args);  
         return strlen(string);  
 }  
   
 #endif  
   
 void  void
 u_sleep(int usec)  u_sleep(int usec)
 {  {
Line 326  u_sleep(int usec) Line 267  u_sleep(int usec)
         select(0, &fdset, &fdset, &fdset, &t);          select(0, &fdset, &fdset, &fdset, &t);
 }  }
   
 /*  
  * Set fd blocking and non-blocking  
  */  
   
 void  
 fd_nonblock(int fd)  
 {  
 #ifdef FIONBIO  
 #ifdef _WIN32  
         unsigned long opt = 1;  
 #else  
         int opt = 1;  
 #endif  
   
         ioctlsocket(fd, FIONBIO, &opt);  
 #else  
         int opt;  
   
         opt = fcntl(fd, F_GETFL, 0);  
         opt |= O_NONBLOCK;  
         fcntl(fd, F_SETFL, opt);  
 #endif  
 }  
   
 void  
 fd_block(int fd)  
 {  
 #ifdef FIONBIO  
 #ifdef _WIN32  
         unsigned long opt = 0;  
 #else  
         int opt = 0;  
 #endif  
   
         ioctlsocket(fd, FIONBIO, &opt);  
 #else  
         int opt;  
   
         opt = fcntl(fd, F_GETFL, 0);  
         opt &= ~O_NONBLOCK;  
         fcntl(fd, F_SETFL, opt);  
 #endif  
 }  
   
 void slirp_connection_info(Slirp *slirp, Monitor *mon)  void slirp_connection_info(Slirp *slirp, Monitor *mon)
 {  {
     const char * const tcpstates[] = {      const char * const tcpstates[] = {
Line 392  void slirp_connection_info(Slirp *slirp, Line 289  void slirp_connection_info(Slirp *slirp,
     struct socket *so;      struct socket *so;
     const char *state;      const char *state;
     char buf[20];      char buf[20];
     int n;  
   
     monitor_printf(mon, "  Protocol[State]    FD  Source Address  Port   "      monitor_printf(mon, "  Protocol[State]    FD  Source Address  Port   "
                         "Dest. Address  Port RecvQ SendQ\n");                          "Dest. Address  Port RecvQ SendQ\n");
Line 416  void slirp_connection_info(Slirp *slirp, Line 312  void slirp_connection_info(Slirp *slirp,
             dst_addr = so->so_faddr;              dst_addr = so->so_faddr;
             dst_port = so->so_fport;              dst_port = so->so_fport;
         }          }
         n = snprintf(buf, sizeof(buf), "  TCP[%s]", state);          snprintf(buf, sizeof(buf), "  TCP[%s]", state);
         memset(&buf[n], ' ', 19 - n);          monitor_printf(mon, "%-19s %3d %15s %5d ", buf, so->s,
         buf[19] = 0;  
         monitor_printf(mon, "%s %3d %15s %5d ", buf, so->s,  
                        src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*",                         src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*",
                        ntohs(src.sin_port));                         ntohs(src.sin_port));
         monitor_printf(mon, "%15s %5d %5d %5d\n",          monitor_printf(mon, "%15s %5d %5d %5d\n",
Line 429  void slirp_connection_info(Slirp *slirp, Line 323  void slirp_connection_info(Slirp *slirp,
   
     for (so = slirp->udb.so_next; so != &slirp->udb; so = so->so_next) {      for (so = slirp->udb.so_next; so != &slirp->udb; so = so->so_next) {
         if (so->so_state & SS_HOSTFWD) {          if (so->so_state & SS_HOSTFWD) {
             n = snprintf(buf, sizeof(buf), "  UDP[HOST_FORWARD]");              snprintf(buf, sizeof(buf), "  UDP[HOST_FORWARD]");
             src_len = sizeof(src);              src_len = sizeof(src);
             getsockname(so->s, (struct sockaddr *)&src, &src_len);              getsockname(so->s, (struct sockaddr *)&src, &src_len);
             dst_addr = so->so_laddr;              dst_addr = so->so_laddr;
             dst_port = so->so_lport;              dst_port = so->so_lport;
         } else {          } else {
             n = snprintf(buf, sizeof(buf), "  UDP[%d sec]",              snprintf(buf, sizeof(buf), "  UDP[%d sec]",
                          (so->so_expire - curtime) / 1000);                           (so->so_expire - curtime) / 1000);
             src.sin_addr = so->so_laddr;              src.sin_addr = so->so_laddr;
             src.sin_port = so->so_lport;              src.sin_port = so->so_lport;
             dst_addr = so->so_faddr;              dst_addr = so->so_faddr;
             dst_port = so->so_fport;              dst_port = so->so_fport;
         }          }
         memset(&buf[n], ' ', 19 - n);          monitor_printf(mon, "%-19s %3d %15s %5d ", buf, so->s,
         buf[19] = 0;  
         monitor_printf(mon, "%s %3d %15s %5d ", buf, so->s,  
                        src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*",                         src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*",
                        ntohs(src.sin_port));                         ntohs(src.sin_port));
         monitor_printf(mon, "%15s %5d %5d %5d\n",          monitor_printf(mon, "%15s %5d %5d %5d\n",
                        inet_ntoa(dst_addr), ntohs(dst_port),                         inet_ntoa(dst_addr), ntohs(dst_port),
                        so->so_rcv.sb_cc, so->so_snd.sb_cc);                         so->so_rcv.sb_cc, so->so_snd.sb_cc);
     }      }
   
       for (so = slirp->icmp.so_next; so != &slirp->icmp; so = so->so_next) {
           snprintf(buf, sizeof(buf), "  ICMP[%d sec]",
                        (so->so_expire - curtime) / 1000);
           src.sin_addr = so->so_laddr;
           dst_addr = so->so_faddr;
           monitor_printf(mon, "%-19s %3d %15s  -    ", buf, so->s,
                          src.sin_addr.s_addr ? inet_ntoa(src.sin_addr) : "*");
           monitor_printf(mon, "%15s  -    %5d %5d\n", inet_ntoa(dst_addr),
                          so->so_rcv.sb_cc, so->so_snd.sb_cc);
       }
 }  }

Removed from v.1.1.1.6  
changed lines
  Added in v.1.1.1.12


unix.superglobalmegacorp.com