]>
git.proxmox.com Git - qemu.git/blob - slirp/misc.c
2 * Copyright (c) 1995 Danny Gasparovski.
4 * Please read the file COPYRIGHT for the
5 * terms and conditions of the copyright.
13 u_int curtime
, time_fasttimo
, last_slowtimo
;
26 lprint("X Redir: X not being redirected.\r\n");
28 lprint("X Redir: In sh/bash/zsh/etc. type: DISPLAY=%s:%d.%d; export DISPLAY\r\n",
29 inet_ntoa(our_addr
), x_port
, x_screen
);
30 lprint("X Redir: In csh/tcsh/etc. type: setenv DISPLAY %s:%d.%d\r\n",
31 inet_ntoa(our_addr
), x_port
, x_screen
);
33 lprint("X Redir: Redirecting to display %d\r\n", x_display
);
41 * XXX Allow more than one X redirection?
44 redir_x(inaddr
, start_port
, display
, screen
)
53 lprint("X Redir: X already being redirected.\r\n");
56 for (i
= 6001 + (start_port
-1); i
<= 6100; i
++) {
57 if (solisten(htons(i
), inaddr
, htons(6000 + display
), 0)) {
66 lprint("X Redir: Error: Couldn't redirect a port for X. Weird.\r\n");
72 * Get our IP address and put it in our_addr
78 struct hostent
*he
= NULL
;
80 if (gethostname(buff
,256) == 0)
81 he
= gethostbyname(buff
);
83 our_addr
= *(struct in_addr
*)he
->h_addr
;
84 if (our_addr
.s_addr
== 0)
85 our_addr
.s_addr
= loopback_addr
.s_addr
;
89 struct quehead
*qh_link
;
90 struct quehead
*qh_rlink
;
94 insque(void *a
, void *b
)
96 register struct quehead
*element
= (struct quehead
*) a
;
97 register struct quehead
*head
= (struct quehead
*) b
;
98 element
->qh_link
= head
->qh_link
;
99 head
->qh_link
= (struct quehead
*)element
;
100 element
->qh_rlink
= (struct quehead
*)head
;
101 ((struct quehead
*)(element
->qh_link
))->qh_rlink
102 = (struct quehead
*)element
;
108 register struct quehead
*element
= (struct quehead
*) a
;
109 ((struct quehead
*)(element
->qh_link
))->qh_rlink
= element
->qh_rlink
;
110 ((struct quehead
*)(element
->qh_rlink
))->qh_link
= element
->qh_link
;
111 element
->qh_rlink
= NULL
;
112 /* element->qh_link = NULL; TCP FIN1 crashes if you do this. Why ? */
118 int add_exec(struct ex_list
**ex_ptr
, int do_pty
, char *exec
,
119 struct in_addr addr
, int port
)
121 struct ex_list
*tmp_ptr
;
123 /* First, check if the port is "bound" */
124 for (tmp_ptr
= *ex_ptr
; tmp_ptr
; tmp_ptr
= tmp_ptr
->ex_next
) {
125 if (port
== tmp_ptr
->ex_fport
&&
126 addr
.s_addr
== tmp_ptr
->ex_addr
.s_addr
)
131 *ex_ptr
= (struct ex_list
*)malloc(sizeof(struct ex_list
));
132 (*ex_ptr
)->ex_fport
= port
;
133 (*ex_ptr
)->ex_addr
= addr
;
134 (*ex_ptr
)->ex_pty
= do_pty
;
135 (*ex_ptr
)->ex_exec
= (do_pty
== 3) ? exec
: strdup(exec
);
136 (*ex_ptr
)->ex_next
= tmp_ptr
;
140 #ifndef HAVE_STRERROR
143 * For systems with no strerror
147 extern char *sys_errlist
[];
153 if (error
< sys_nerr
)
154 return sys_errlist
[error
];
156 return "Unknown error.";
165 fork_exec(struct socket
*so
, const char *ex
, int do_pty
)
167 /* not implemented */
175 slirp_openpty(amaster
, aslave
)
176 int *amaster
, *aslave
;
178 register int master
, slave
;
183 if ((master
= open("/dev/ptmx", O_RDWR
)) < 0 ||
184 grantpt(master
) < 0 ||
185 unlockpt(master
) < 0 ||
186 (ptr
= ptsname(master
)) == NULL
) {
191 if ((slave
= open(ptr
, O_RDWR
)) < 0 ||
192 ioctl(slave
, I_PUSH
, "ptem") < 0 ||
193 ioctl(slave
, I_PUSH
, "ldterm") < 0 ||
194 ioctl(slave
, I_PUSH
, "ttcompat") < 0) {
206 static char line
[] = "/dev/ptyXX";
207 register const char *cp1
, *cp2
;
209 for (cp1
= "pqrsPQRS"; *cp1
; cp1
++) {
211 for (cp2
= "0123456789abcdefghijklmnopqrstuv"; *cp2
; cp2
++) {
213 if ((master
= open(line
, O_RDWR
, 0)) == -1) {
215 return (-1); /* out of ptys */
218 /* These will fail */
219 (void) chown(line
, getuid(), 0);
220 (void) chmod(line
, S_IRUSR
|S_IWUSR
|S_IWGRP
);
224 if ((slave
= open(line
, O_RDWR
, 0)) != -1) {
229 (void) close(master
);
234 errno
= ENOENT
; /* out of ptys */
242 * We create and bind a socket, then fork off to another
243 * process, which connects to this socket, after which we
244 * exec the wanted program. If something (strange) happens,
245 * the accept() call could block us forever.
247 * do_pty = 0 Fork/exec inetd style
248 * do_pty = 1 Fork/exec using slirp.telnetd
249 * do_ptr = 2 Fork/exec using pty
252 fork_exec(struct socket
*so
, const char *ex
, int do_pty
)
255 struct sockaddr_in addr
;
256 socklen_t addrlen
= sizeof(addr
);
259 const char *argv
[256];
263 /* don't want to clobber the original */
268 DEBUG_CALL("fork_exec");
269 DEBUG_ARG("so = %lx", (long)so
);
270 DEBUG_ARG("ex = %lx", (long)ex
);
271 DEBUG_ARG("do_pty = %lx", (long)do_pty
);
275 if (slirp_openpty(&master
, &s
) == -1) {
276 lprint("Error: openpty failed: %s\n", strerror(errno
));
283 addr
.sin_family
= AF_INET
;
285 addr
.sin_addr
.s_addr
= INADDR_ANY
;
287 if ((s
= socket(AF_INET
, SOCK_STREAM
, 0)) < 0 ||
288 bind(s
, (struct sockaddr
*)&addr
, addrlen
) < 0 ||
290 lprint("Error: inet socket: %s\n", strerror(errno
));
299 lprint("Error: fork failed: %s\n", strerror(errno
));
306 /* Set the DISPLAY */
308 (void) close(master
);
309 #ifdef TIOCSCTTY /* XXXXX */
311 ioctl(s
, TIOCSCTTY
, (char *)NULL
);
314 getsockname(s
, (struct sockaddr
*)&addr
, &addrlen
);
317 * Connect to the socket
318 * XXX If any of these fail, we're in trouble!
320 s
= socket(AF_INET
, SOCK_STREAM
, 0);
321 addr
.sin_addr
= loopback_addr
;
323 ret
= connect(s
, (struct sockaddr
*)&addr
, addrlen
);
324 } while (ret
< 0 && errno
== EINTR
);
330 sprintf(buff
, "%s:%d.%d", inet_ntoa(our_addr
), x_port
, x_screen
);
331 setenv("DISPLAY", buff
, 1);
333 sprintf(buff
, "DISPLAY=%s:%d.%d", inet_ntoa(our_addr
), x_port
, x_screen
);
341 for (s
= getdtablesize() - 1; s
>= 3; s
--)
345 bptr
= strdup(ex
); /* No need to free() this */
347 /* Setup "slirp.telnetd -x" */
348 argv
[i
++] = "slirp.telnetd";
353 /* Change the string into argv[] */
355 while (*bptr
!= ' ' && *bptr
!= (char)0)
359 argv
[i
++] = strdup(curarg
);
363 execvp(argv
[0], (char **)argv
);
365 /* Ooops, failed, let's tell the user why */
369 snprintf(buff
, sizeof(buff
),
370 "Error: execvp of %s failed: %s\n",
371 argv
[0], strerror(errno
));
372 write(2, buff
, strlen(buff
)+1);
374 close(0); close(1); close(2); /* XXX */
383 * XXX this could block us...
384 * XXX Should set a timer here, and if accept() doesn't
385 * return after X seconds, declare it a failure
386 * The only reason this will block forever is if socket()
387 * of connect() fail in the child process
390 so
->s
= accept(s
, (struct sockaddr
*)&addr
, &addrlen
);
391 } while (so
->s
< 0 && errno
== EINTR
);
394 setsockopt(so
->s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(int));
396 setsockopt(so
->s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(int));
400 /* Append the telnet options now */
401 if (so
->so_m
!= NULL
&& do_pty
== 1) {
402 sbappend(so
, so
->so_m
);
418 bptr
= (char *)malloc(strlen(str
)+1);
431 #ifndef NO_UNIX_SOCKETS
432 struct sockaddr_un sock_un
;
434 struct sockaddr_in sock_in
;
438 if (slirp_socket_passwd
) {
439 s
= socket(AF_INET
, SOCK_STREAM
, 0);
442 sock_in
.sin_family
= AF_INET
;
443 sock_in
.sin_addr
.s_addr
= slirp_socket_addr
;
444 sock_in
.sin_port
= htons(slirp_socket_port
);
445 if (connect(s
, (struct sockaddr
*)&sock_in
, sizeof(sock_in
)) != 0)
446 slirp_exit(1); /* just exit...*/
447 sprintf(buff
, "kill %s:%d", slirp_socket_passwd
, slirp_socket_unit
);
448 write(s
, buff
, strlen(buff
)+1);
450 #ifndef NO_UNIX_SOCKETS
452 s
= socket(AF_UNIX
, SOCK_STREAM
, 0);
455 sock_un
.sun_family
= AF_UNIX
;
456 strcpy(sock_un
.sun_path
, socket_path
);
457 if (connect(s
, (struct sockaddr
*)&sock_un
,
458 sizeof(sock_un
.sun_family
) + sizeof(sock_un
.sun_path
)) != 0)
460 sprintf(buff
, "kill none:%d", slirp_socket_unit
);
461 write(s
, buff
, strlen(buff
)+1);
474 /* Don't need our data anymore */
475 /* XXX This makes SunOS barf */
479 for (i
= 255; i
>= 0; i
--)
482 signal(SIGQUIT
, slirp_exit
);
483 signal(SIGHUP
, snooze_hup
);
486 /* Wait for any signal */
489 /* Just in case ... */
502 /* Don't need our data anymore */
503 /* XXX This makes SunOS barf */
506 signal(SIGQUIT
, slirp_exit
);
507 signal(SIGHUP
, slirp_exit
);
508 signal(SIGINT
, slirp_exit
);
509 signal(SIGTERM
, slirp_exit
);
511 /* Fudge to get term_raw and term_restore to work */
512 if (NULL
== (ttyp
= tty_attach (0, slirp_tty
))) {
513 lprint ("Error: tty_attach failed in misc.c:relay()\r\n");
517 ttyp
->flags
|= TTY_CTTY
;
526 n
= select(s
+1, &readfds
, (fd_set
*)0, (fd_set
*)0, (struct timeval
*)0);
531 if (FD_ISSET(0, &readfds
)) {
532 n
= read(0, buf
, 8192);
535 n
= writen(s
, buf
, n
);
540 if (FD_ISSET(s
, &readfds
)) {
541 n
= read(s
, buf
, 8192);
544 n
= writen(0, buf
, n
);
550 /* Just in case.... */
558 void lprint(const char *format
, ...)
562 va_start(args
, format
);
563 monitor_vprintf(cur_mon
, format
, args
);
567 int (*lprint_print
) _P((void *, const char *, va_list));
568 char *lprint_ptr
, *lprint_ptr2
, **lprint_arg
;
572 lprint(const char *format
, ...)
574 lprint(va_alist
) va_dcl
580 va_start(args
, format
);
584 format
= va_arg(args
, char *);
587 /* If we're printing to an sbuf, make sure there's enough room */
590 if ((lprint_ptr
- lprint_sb
->sb_wptr
) >=
591 (lprint_sb
->sb_datalen
- (strlen(format
) + 100))) {
592 int deltaw
= lprint_sb
->sb_wptr
- lprint_sb
->sb_data
;
593 int deltar
= lprint_sb
->sb_rptr
- lprint_sb
->sb_data
;
594 int deltap
= lprint_ptr
- lprint_sb
->sb_data
;
596 lprint_sb
->sb_data
= (char *)realloc(lprint_sb
->sb_data
,
597 lprint_sb
->sb_datalen
+ TCP_SNDSPACE
);
599 /* Adjust all values */
600 lprint_sb
->sb_wptr
= lprint_sb
->sb_data
+ deltaw
;
601 lprint_sb
->sb_rptr
= lprint_sb
->sb_data
+ deltar
;
602 lprint_ptr
= lprint_sb
->sb_data
+ deltap
;
604 lprint_sb
->sb_datalen
+= TCP_SNDSPACE
;
609 lprint_ptr
+= (*lprint_print
)(*lprint_arg
, format
, args
);
611 /* Check if they want output to be logged to file as well */
615 * otherwise you'll get ^M all over the file
617 int len
= strlen(format
);
620 bptr1
= bptr2
= strdup(format
);
624 memcpy(bptr1
, bptr1
+1, len
+1);
628 vfprintf(lfd
, bptr2
, args
);
639 u_int8_t tos
= 0, emu
= 0;
640 char buff1
[256], buff2
[256], buff4
[128];
645 if (sscanf(buff
, "%256s %256s", buff2
, buff1
) != 2) {
646 lprint("Error: Bad arguments\r\n");
650 if (sscanf(buff1
, "%d:%d", &lport
, &fport
) != 2) {
652 if (sscanf(buff1
, "%d", &fport
) != 1) {
653 lprint("Error: Bad first argument\r\n");
658 if (sscanf(buff2
, "%128[^:]:%128s", buff1
, buff3
) != 2) {
660 if (sscanf(buff2
, "%256s", buff1
) != 1) {
661 lprint("Error: Bad second argument\r\n");
667 if (strcmp(buff3
, "lowdelay") == 0)
668 tos
= IPTOS_LOWDELAY
;
669 else if (strcmp(buff3
, "throughput") == 0)
670 tos
= IPTOS_THROUGHPUT
;
672 lprint("Error: Expecting \"lowdelay\"/\"throughput\"\r\n");
677 if (strcmp(buff1
, "ftp") == 0)
679 else if (strcmp(buff1
, "irc") == 0)
681 else if (strcmp(buff1
, "none") == 0)
682 emu
= EMU_NONE
; /* ie: no emulation */
684 lprint("Error: Unknown service\r\n");
688 /* First, check that it isn't already emulated */
689 for (emup
= tcpemu
; emup
; emup
= emup
->next
) {
690 if (emup
->lport
== lport
&& emup
->fport
== fport
) {
691 lprint("Error: port already emulated\r\n");
697 emup
= (struct emu_t
*)malloc(sizeof (struct emu_t
));
698 emup
->lport
= (u_int16_t
)lport
;
699 emup
->fport
= (u_int16_t
)fport
;
705 /* And finally, mark all current sessions, if any, as being emulated */
706 for (so
= tcb
.so_next
; so
!= &tcb
; so
= so
->so_next
) {
707 if ((lport
&& lport
== ntohs(so
->so_lport
)) ||
708 (fport
&& fport
== ntohs(so
->so_fport
))) {
716 lprint("Adding emulation for %s to port %d/%d\r\n", buff1
, emup
->lport
, emup
->fport
);
726 * Some BSD-derived systems have a sprintf which returns char *
730 vsprintf_len(string
, format
, args
)
735 vsprintf(string
, format
, args
);
736 return strlen(string
);
741 sprintf_len(char *string
, const char *format
, ...)
743 sprintf_len(va_alist
) va_dcl
748 va_start(args
, format
);
753 string
= va_arg(args
, char *);
754 format
= va_arg(args
, char *);
756 vsprintf(string
, format
, args
);
757 return strlen(string
);
771 t
.tv_usec
= usec
* 1000;
773 select(0, &fdset
, &fdset
, &fdset
, &t
);
777 * Set fd blocking and non-blocking
785 unsigned long opt
= 1;
790 ioctlsocket(fd
, FIONBIO
, &opt
);
794 opt
= fcntl(fd
, F_GETFL
, 0);
796 fcntl(fd
, F_SETFL
, opt
);
805 unsigned long opt
= 0;
810 ioctlsocket(fd
, FIONBIO
, &opt
);
814 opt
= fcntl(fd
, F_GETFL
, 0);
816 fcntl(fd
, F_SETFL
, opt
);
826 rsh_exec(so
,ns
, user
, host
, args
)
838 DEBUG_CALL("rsh_exec");
839 DEBUG_ARG("so = %lx", (long)so
);
842 lprint("Error: pipe failed: %s\n", strerror(errno
));
845 /* #ifdef HAVE_SOCKETPAIR */
847 if (socketpair(PF_UNIX
,SOCK_STREAM
,0, fd0
) == -1) {
850 lprint("Error: openpty failed: %s\n", strerror(errno
));
854 if (slirp_openpty(&fd0
[0], &fd0
[1]) == -1) {
857 lprint("Error: openpty failed: %s\n", strerror(errno
));
864 lprint("Error: fork failed: %s\n", strerror(errno
));
875 /* Set the DISPLAY */
878 sprintf(buff
, "%s:%d.%d", inet_ntoa(our_addr
), x_port
, x_screen
);
879 setenv("DISPLAY", buff
, 1);
881 sprintf(buff
, "DISPLAY=%s:%d.%d", inet_ntoa(our_addr
), x_port
, x_screen
);
889 for (s
= 3; s
<= 255; s
++)
892 execlp("rsh","rsh","-l", user
, host
, args
, NULL
);
894 /* Ooops, failed, let's tell the user why */
896 sprintf(buff
, "Error: execlp of %s failed: %s\n",
897 "rsh", strerror(errno
));
898 write(2, buff
, strlen(buff
)+1);
899 close(0); close(1); close(2); /* XXX */
913 void slirp_connection_info(Monitor
*mon
)
915 const char * const tcpstates
[] = {
916 [TCPS_CLOSED
] = "CLOSED",
917 [TCPS_LISTEN
] = "LISTEN",
918 [TCPS_SYN_SENT
] = "SYN_SENT",
919 [TCPS_SYN_RECEIVED
] = "SYN_RCVD",
920 [TCPS_ESTABLISHED
] = "ESTABLISHED",
921 [TCPS_CLOSE_WAIT
] = "CLOSE_WAIT",
922 [TCPS_FIN_WAIT_1
] = "FIN_WAIT_1",
923 [TCPS_CLOSING
] = "CLOSING",
924 [TCPS_LAST_ACK
] = "LAST_ACK",
925 [TCPS_FIN_WAIT_2
] = "FIN_WAIT_2",
926 [TCPS_TIME_WAIT
] = "TIME_WAIT",
928 struct in_addr dst_addr
;
929 struct sockaddr_in src
;
937 monitor_printf(mon
, " Protocol[State] FD Source Address Port "
938 "Dest. Address Port RecvQ SendQ\n");
940 for (so
= tcb
.so_next
; so
!= &tcb
; so
= so
->so_next
) {
941 if (so
->so_state
& SS_HOSTFWD
) {
942 state
= "HOST_FORWARD";
943 } else if (so
->so_tcpcb
) {
944 state
= tcpstates
[so
->so_tcpcb
->t_state
];
948 if (so
->so_state
& (SS_HOSTFWD
| SS_INCOMING
)) {
949 src_len
= sizeof(src
);
950 getsockname(so
->s
, (struct sockaddr
*)&src
, &src_len
);
951 dst_addr
= so
->so_laddr
;
952 dst_port
= so
->so_lport
;
954 src
.sin_addr
= so
->so_laddr
;
955 src
.sin_port
= so
->so_lport
;
956 dst_addr
= so
->so_faddr
;
957 dst_port
= so
->so_fport
;
959 n
= snprintf(buf
, sizeof(buf
), " TCP[%s]", state
);
960 memset(&buf
[n
], ' ', 19 - n
);
962 monitor_printf(mon
, "%s %3d %15s %5d ", buf
, so
->s
,
963 src
.sin_addr
.s_addr
? inet_ntoa(src
.sin_addr
) : "*",
964 ntohs(src
.sin_port
));
965 monitor_printf(mon
, "%15s %5d %5d %5d\n",
966 inet_ntoa(dst_addr
), ntohs(dst_port
),
967 so
->so_rcv
.sb_cc
, so
->so_snd
.sb_cc
);
970 for (so
= udb
.so_next
; so
!= &udb
; so
= so
->so_next
) {
971 if (so
->so_state
& SS_HOSTFWD
) {
972 n
= snprintf(buf
, sizeof(buf
), " UDP[HOST_FORWARD]");
973 src_len
= sizeof(src
);
974 getsockname(so
->s
, (struct sockaddr
*)&src
, &src_len
);
975 dst_addr
= so
->so_laddr
;
976 dst_port
= so
->so_lport
;
978 n
= snprintf(buf
, sizeof(buf
), " UDP[%d sec]",
979 (so
->so_expire
- curtime
) / 1000);
980 src
.sin_addr
= so
->so_laddr
;
981 src
.sin_port
= so
->so_lport
;
982 dst_addr
= so
->so_faddr
;
983 dst_port
= so
->so_fport
;
985 memset(&buf
[n
], ' ', 19 - n
);
987 monitor_printf(mon
, "%s %3d %15s %5d ", buf
, so
->s
,
988 src
.sin_addr
.s_addr
? inet_ntoa(src
.sin_addr
) : "*",
989 ntohs(src
.sin_port
));
990 monitor_printf(mon
, "%15s %5d %5d %5d\n",
991 inet_ntoa(dst_addr
), ntohs(dst_port
),
992 so
->so_rcv
.sb_cc
, so
->so_snd
.sb_cc
);