blob: 337f8a857472131eb9269129880deebf5f8eb3e2 [file] [log] [blame]
bellardf0cbd3e2004-04-22 00:10:48 +00001/*
2 * Copyright (c) 1995 Danny Gasparovski.
ths5fafdf22007-09-16 21:08:06 +00003 *
bellardf0cbd3e2004-04-22 00:10:48 +00004 * 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
blueswir19634d902007-10-26 19:01:16 +000011u_int curtime, time_fasttimo, last_slowtimo;
bellardf0cbd3e2004-04-22 00:10:48 +000012
13#if 0
14int x_port = -1;
15int x_display = 0;
16int x_screen = 0;
17
18int
19show_x(buff, inso)
20 char *buff;
21 struct socket *inso;
22{
23 if (x_port < 0) {
24 lprint("X Redir: X not being redirected.\r\n");
25 } else {
26 lprint("X Redir: In sh/bash/zsh/etc. type: DISPLAY=%s:%d.%d; export DISPLAY\r\n",
27 inet_ntoa(our_addr), x_port, x_screen);
28 lprint("X Redir: In csh/tcsh/etc. type: setenv DISPLAY %s:%d.%d\r\n",
29 inet_ntoa(our_addr), x_port, x_screen);
30 if (x_display)
31 lprint("X Redir: Redirecting to display %d\r\n", x_display);
32 }
ths5fafdf22007-09-16 21:08:06 +000033
bellardf0cbd3e2004-04-22 00:10:48 +000034 return CFG_OK;
35}
36
37
38/*
39 * XXX Allow more than one X redirection?
40 */
41void
42redir_x(inaddr, start_port, display, screen)
43 u_int32_t inaddr;
44 int start_port;
45 int display;
46 int screen;
47{
48 int i;
ths5fafdf22007-09-16 21:08:06 +000049
bellardf0cbd3e2004-04-22 00:10:48 +000050 if (x_port >= 0) {
51 lprint("X Redir: X already being redirected.\r\n");
52 show_x(0, 0);
53 } else {
54 for (i = 6001 + (start_port-1); i <= 6100; i++) {
55 if (solisten(htons(i), inaddr, htons(6000 + display), 0)) {
56 /* Success */
57 x_port = i - 6000;
58 x_display = display;
59 x_screen = screen;
60 show_x(0, 0);
61 return;
62 }
63 }
64 lprint("X Redir: Error: Couldn't redirect a port for X. Weird.\r\n");
65 }
66}
67#endif
68
69#ifndef HAVE_INET_ATON
70int
71inet_aton(cp, ia)
72 const char *cp;
73 struct in_addr *ia;
74{
75 u_int32_t addr = inet_addr(cp);
76 if (addr == 0xffffffff)
77 return 0;
78 ia->s_addr = addr;
79 return 1;
80}
81#endif
82
83/*
84 * Get our IP address and put it in our_addr
85 */
86void
87getouraddr()
88{
89 char buff[256];
pbrookf4e15b42006-04-23 19:41:17 +000090 struct hostent *he = NULL;
ths5fafdf22007-09-16 21:08:06 +000091
pbrookf4e15b42006-04-23 19:41:17 +000092 if (gethostname(buff,256) == 0)
93 he = gethostbyname(buff);
94 if (he)
95 our_addr = *(struct in_addr *)he->h_addr;
bellard8dbca8d2006-05-03 19:58:17 +000096 if (our_addr.s_addr == 0)
97 our_addr.s_addr = loopback_addr.s_addr;
bellardf0cbd3e2004-04-22 00:10:48 +000098}
99
100#if SIZEOF_CHAR_P == 8
101
102struct quehead_32 {
103 u_int32_t qh_link;
104 u_int32_t qh_rlink;
105};
106
107inline void
108insque_32(a, b)
109 void *a;
110 void *b;
111{
112 register struct quehead_32 *element = (struct quehead_32 *) a;
113 register struct quehead_32 *head = (struct quehead_32 *) b;
114 element->qh_link = head->qh_link;
115 head->qh_link = (u_int32_t)element;
116 element->qh_rlink = (u_int32_t)head;
117 ((struct quehead_32 *)(element->qh_link))->qh_rlink
118 = (u_int32_t)element;
119}
120
121inline void
122remque_32(a)
123 void *a;
124{
125 register struct quehead_32 *element = (struct quehead_32 *) a;
126 ((struct quehead_32 *)(element->qh_link))->qh_rlink = element->qh_rlink;
127 ((struct quehead_32 *)(element->qh_rlink))->qh_link = element->qh_link;
128 element->qh_rlink = 0;
129}
130
131#endif /* SIZEOF_CHAR_P == 8 */
132
133struct quehead {
134 struct quehead *qh_link;
135 struct quehead *qh_rlink;
136};
137
138inline void
139insque(a, b)
140 void *a, *b;
141{
142 register struct quehead *element = (struct quehead *) a;
143 register struct quehead *head = (struct quehead *) b;
144 element->qh_link = head->qh_link;
145 head->qh_link = (struct quehead *)element;
146 element->qh_rlink = (struct quehead *)head;
147 ((struct quehead *)(element->qh_link))->qh_rlink
148 = (struct quehead *)element;
149}
150
151inline void
152remque(a)
153 void *a;
154{
155 register struct quehead *element = (struct quehead *) a;
156 ((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink;
157 ((struct quehead *)(element->qh_rlink))->qh_link = element->qh_link;
158 element->qh_rlink = NULL;
159 /* element->qh_link = NULL; TCP FIN1 crashes if you do this. Why ? */
160}
161
162/* #endif */
163
164
165int
166add_exec(ex_ptr, do_pty, exec, addr, port)
167 struct ex_list **ex_ptr;
168 int do_pty;
169 char *exec;
170 int addr;
171 int port;
172{
173 struct ex_list *tmp_ptr;
ths5fafdf22007-09-16 21:08:06 +0000174
bellardf0cbd3e2004-04-22 00:10:48 +0000175 /* First, check if the port is "bound" */
176 for (tmp_ptr = *ex_ptr; tmp_ptr; tmp_ptr = tmp_ptr->ex_next) {
177 if (port == tmp_ptr->ex_fport && addr == tmp_ptr->ex_addr)
178 return -1;
179 }
ths5fafdf22007-09-16 21:08:06 +0000180
bellardf0cbd3e2004-04-22 00:10:48 +0000181 tmp_ptr = *ex_ptr;
182 *ex_ptr = (struct ex_list *)malloc(sizeof(struct ex_list));
183 (*ex_ptr)->ex_fport = port;
184 (*ex_ptr)->ex_addr = addr;
185 (*ex_ptr)->ex_pty = do_pty;
186 (*ex_ptr)->ex_exec = strdup(exec);
187 (*ex_ptr)->ex_next = tmp_ptr;
188 return 0;
189}
190
191#ifndef HAVE_STRERROR
192
193/*
194 * For systems with no strerror
195 */
196
197extern int sys_nerr;
198extern char *sys_errlist[];
199
200char *
201strerror(error)
202 int error;
203{
204 if (error < sys_nerr)
205 return sys_errlist[error];
206 else
207 return "Unknown error.";
208}
209
210#endif
211
212
bellarda3d4af02004-09-05 23:10:26 +0000213#ifdef _WIN32
214
215int
blueswir19634d902007-10-26 19:01:16 +0000216fork_exec(struct socket *so, const char *ex, int do_pty)
bellarda3d4af02004-09-05 23:10:26 +0000217{
218 /* not implemented */
219 return 0;
220}
221
222#else
223
blueswir19634d902007-10-26 19:01:16 +0000224#ifndef CONFIG_QEMU
bellardf0cbd3e2004-04-22 00:10:48 +0000225int
bellardf3ff6492004-10-10 18:00:00 +0000226slirp_openpty(amaster, aslave)
227 int *amaster, *aslave;
bellardf0cbd3e2004-04-22 00:10:48 +0000228{
229 register int master, slave;
230
231#ifdef HAVE_GRANTPT
232 char *ptr;
ths5fafdf22007-09-16 21:08:06 +0000233
bellardf0cbd3e2004-04-22 00:10:48 +0000234 if ((master = open("/dev/ptmx", O_RDWR)) < 0 ||
235 grantpt(master) < 0 ||
236 unlockpt(master) < 0 ||
237 (ptr = ptsname(master)) == NULL) {
238 close(master);
239 return -1;
240 }
ths5fafdf22007-09-16 21:08:06 +0000241
bellardf0cbd3e2004-04-22 00:10:48 +0000242 if ((slave = open(ptr, O_RDWR)) < 0 ||
243 ioctl(slave, I_PUSH, "ptem") < 0 ||
244 ioctl(slave, I_PUSH, "ldterm") < 0 ||
245 ioctl(slave, I_PUSH, "ttcompat") < 0) {
246 close(master);
247 close(slave);
248 return -1;
249 }
ths5fafdf22007-09-16 21:08:06 +0000250
bellardf0cbd3e2004-04-22 00:10:48 +0000251 *amaster = master;
252 *aslave = slave;
253 return 0;
ths5fafdf22007-09-16 21:08:06 +0000254
bellardf0cbd3e2004-04-22 00:10:48 +0000255#else
ths5fafdf22007-09-16 21:08:06 +0000256
bellardf0cbd3e2004-04-22 00:10:48 +0000257 static char line[] = "/dev/ptyXX";
258 register const char *cp1, *cp2;
ths5fafdf22007-09-16 21:08:06 +0000259
bellardf0cbd3e2004-04-22 00:10:48 +0000260 for (cp1 = "pqrsPQRS"; *cp1; cp1++) {
261 line[8] = *cp1;
262 for (cp2 = "0123456789abcdefghijklmnopqrstuv"; *cp2; cp2++) {
263 line[9] = *cp2;
264 if ((master = open(line, O_RDWR, 0)) == -1) {
265 if (errno == ENOENT)
266 return (-1); /* out of ptys */
267 } else {
268 line[5] = 't';
269 /* These will fail */
270 (void) chown(line, getuid(), 0);
271 (void) chmod(line, S_IRUSR|S_IWUSR|S_IWGRP);
272#ifdef HAVE_REVOKE
273 (void) revoke(line);
274#endif
275 if ((slave = open(line, O_RDWR, 0)) != -1) {
276 *amaster = master;
277 *aslave = slave;
278 return 0;
279 }
280 (void) close(master);
281 line[5] = 'p';
282 }
283 }
284 }
285 errno = ENOENT; /* out of ptys */
286 return (-1);
287#endif
288}
blueswir19634d902007-10-26 19:01:16 +0000289#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000290
291/*
292 * XXX This is ugly
293 * We create and bind a socket, then fork off to another
294 * process, which connects to this socket, after which we
295 * exec the wanted program. If something (strange) happens,
296 * the accept() call could block us forever.
ths5fafdf22007-09-16 21:08:06 +0000297 *
bellardf0cbd3e2004-04-22 00:10:48 +0000298 * do_pty = 0 Fork/exec inetd style
299 * do_pty = 1 Fork/exec using slirp.telnetd
300 * do_ptr = 2 Fork/exec using pty
301 */
302int
blueswir19634d902007-10-26 19:01:16 +0000303fork_exec(struct socket *so, const char *ex, int do_pty)
bellardf0cbd3e2004-04-22 00:10:48 +0000304{
305 int s;
306 struct sockaddr_in addr;
balrog242acf32008-05-10 01:49:53 +0000307 socklen_t addrlen = sizeof(addr);
bellardf0cbd3e2004-04-22 00:10:48 +0000308 int opt;
blueswir19634d902007-10-26 19:01:16 +0000309 int master = -1;
bellardf0cbd3e2004-04-22 00:10:48 +0000310 char *argv[256];
bellarda3d4af02004-09-05 23:10:26 +0000311#if 0
bellardf0cbd3e2004-04-22 00:10:48 +0000312 char buff[256];
bellarda3d4af02004-09-05 23:10:26 +0000313#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000314 /* don't want to clobber the original */
315 char *bptr;
blueswir19634d902007-10-26 19:01:16 +0000316 const char *curarg;
bellard7b91a172004-12-12 11:45:10 +0000317 int c, i, ret;
ths5fafdf22007-09-16 21:08:06 +0000318
bellardf0cbd3e2004-04-22 00:10:48 +0000319 DEBUG_CALL("fork_exec");
320 DEBUG_ARG("so = %lx", (long)so);
321 DEBUG_ARG("ex = %lx", (long)ex);
322 DEBUG_ARG("do_pty = %lx", (long)do_pty);
ths5fafdf22007-09-16 21:08:06 +0000323
bellardf0cbd3e2004-04-22 00:10:48 +0000324 if (do_pty == 2) {
blueswir19634d902007-10-26 19:01:16 +0000325#if 0
bellardf3ff6492004-10-10 18:00:00 +0000326 if (slirp_openpty(&master, &s) == -1) {
bellardf0cbd3e2004-04-22 00:10:48 +0000327 lprint("Error: openpty failed: %s\n", strerror(errno));
328 return 0;
329 }
balrog3f9b2b12007-11-13 01:56:12 +0000330#else
331 return 0;
blueswir19634d902007-10-26 19:01:16 +0000332#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000333 } else {
334 addr.sin_family = AF_INET;
335 addr.sin_port = 0;
336 addr.sin_addr.s_addr = INADDR_ANY;
ths3b46e622007-09-17 08:09:54 +0000337
bellardf0cbd3e2004-04-22 00:10:48 +0000338 if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ||
339 bind(s, (struct sockaddr *)&addr, addrlen) < 0 ||
340 listen(s, 1) < 0) {
341 lprint("Error: inet socket: %s\n", strerror(errno));
bellard379ff532004-07-12 22:33:07 +0000342 closesocket(s);
ths3b46e622007-09-17 08:09:54 +0000343
bellardf0cbd3e2004-04-22 00:10:48 +0000344 return 0;
345 }
346 }
ths5fafdf22007-09-16 21:08:06 +0000347
bellardf0cbd3e2004-04-22 00:10:48 +0000348 switch(fork()) {
349 case -1:
350 lprint("Error: fork failed: %s\n", strerror(errno));
351 close(s);
352 if (do_pty == 2)
353 close(master);
354 return 0;
ths3b46e622007-09-17 08:09:54 +0000355
bellardf0cbd3e2004-04-22 00:10:48 +0000356 case 0:
357 /* Set the DISPLAY */
358 if (do_pty == 2) {
359 (void) close(master);
360#ifdef TIOCSCTTY /* XXXXX */
361 (void) setsid();
362 ioctl(s, TIOCSCTTY, (char *)NULL);
363#endif
364 } else {
365 getsockname(s, (struct sockaddr *)&addr, &addrlen);
366 close(s);
367 /*
368 * Connect to the socket
369 * XXX If any of these fail, we're in trouble!
370 */
371 s = socket(AF_INET, SOCK_STREAM, 0);
372 addr.sin_addr = loopback_addr;
bellard7b91a172004-12-12 11:45:10 +0000373 do {
374 ret = connect(s, (struct sockaddr *)&addr, addrlen);
375 } while (ret < 0 && errno == EINTR);
bellardf0cbd3e2004-04-22 00:10:48 +0000376 }
ths3b46e622007-09-17 08:09:54 +0000377
bellarda3d4af02004-09-05 23:10:26 +0000378#if 0
bellardf0cbd3e2004-04-22 00:10:48 +0000379 if (x_port >= 0) {
380#ifdef HAVE_SETENV
381 sprintf(buff, "%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
382 setenv("DISPLAY", buff, 1);
383#else
384 sprintf(buff, "DISPLAY=%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
385 putenv(buff);
386#endif
387 }
ths5fafdf22007-09-16 21:08:06 +0000388#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000389 dup2(s, 0);
390 dup2(s, 1);
391 dup2(s, 2);
blueswir19634d902007-10-26 19:01:16 +0000392 for (s = getdtablesize() - 1; s >= 3; s--)
bellardf0cbd3e2004-04-22 00:10:48 +0000393 close(s);
ths3b46e622007-09-17 08:09:54 +0000394
bellardf0cbd3e2004-04-22 00:10:48 +0000395 i = 0;
396 bptr = strdup(ex); /* No need to free() this */
397 if (do_pty == 1) {
398 /* Setup "slirp.telnetd -x" */
399 argv[i++] = "slirp.telnetd";
400 argv[i++] = "-x";
401 argv[i++] = bptr;
402 } else
403 do {
404 /* Change the string into argv[] */
405 curarg = bptr;
406 while (*bptr != ' ' && *bptr != (char)0)
407 bptr++;
408 c = *bptr;
409 *bptr++ = (char)0;
410 argv[i++] = strdup(curarg);
411 } while (c);
ths3b46e622007-09-17 08:09:54 +0000412
bellardf0cbd3e2004-04-22 00:10:48 +0000413 argv[i] = 0;
414 execvp(argv[0], argv);
ths3b46e622007-09-17 08:09:54 +0000415
bellardf0cbd3e2004-04-22 00:10:48 +0000416 /* Ooops, failed, let's tell the user why */
417 {
418 char buff[256];
ths3b46e622007-09-17 08:09:54 +0000419
ths5fafdf22007-09-16 21:08:06 +0000420 sprintf(buff, "Error: execvp of %s failed: %s\n",
bellardf0cbd3e2004-04-22 00:10:48 +0000421 argv[0], strerror(errno));
422 write(2, buff, strlen(buff)+1);
423 }
424 close(0); close(1); close(2); /* XXX */
425 exit(1);
ths3b46e622007-09-17 08:09:54 +0000426
bellardf0cbd3e2004-04-22 00:10:48 +0000427 default:
428 if (do_pty == 2) {
429 close(s);
430 so->s = master;
431 } else {
432 /*
433 * XXX this could block us...
434 * XXX Should set a timer here, and if accept() doesn't
435 * return after X seconds, declare it a failure
436 * The only reason this will block forever is if socket()
437 * of connect() fail in the child process
438 */
bellard7b91a172004-12-12 11:45:10 +0000439 do {
440 so->s = accept(s, (struct sockaddr *)&addr, &addrlen);
441 } while (so->s < 0 && errno == EINTR);
442 closesocket(s);
bellardf0cbd3e2004-04-22 00:10:48 +0000443 opt = 1;
444 setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
445 opt = 1;
446 setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
447 }
448 fd_nonblock(so->s);
ths3b46e622007-09-17 08:09:54 +0000449
bellardf0cbd3e2004-04-22 00:10:48 +0000450 /* Append the telnet options now */
451 if (so->so_m != 0 && do_pty == 1) {
452 sbappend(so, so->so_m);
453 so->so_m = 0;
454 }
ths3b46e622007-09-17 08:09:54 +0000455
bellardf0cbd3e2004-04-22 00:10:48 +0000456 return 1;
457 }
458}
459#endif
460
461#ifndef HAVE_STRDUP
462char *
463strdup(str)
464 const char *str;
465{
466 char *bptr;
ths5fafdf22007-09-16 21:08:06 +0000467
bellardf0cbd3e2004-04-22 00:10:48 +0000468 bptr = (char *)malloc(strlen(str)+1);
469 strcpy(bptr, str);
ths5fafdf22007-09-16 21:08:06 +0000470
bellardf0cbd3e2004-04-22 00:10:48 +0000471 return bptr;
472}
473#endif
474
475#if 0
476void
477snooze_hup(num)
478 int num;
479{
480 int s, ret;
481#ifndef NO_UNIX_SOCKETS
482 struct sockaddr_un sock_un;
483#endif
484 struct sockaddr_in sock_in;
485 char buff[256];
ths5fafdf22007-09-16 21:08:06 +0000486
bellardf0cbd3e2004-04-22 00:10:48 +0000487 ret = -1;
488 if (slirp_socket_passwd) {
489 s = socket(AF_INET, SOCK_STREAM, 0);
490 if (s < 0)
491 slirp_exit(1);
492 sock_in.sin_family = AF_INET;
493 sock_in.sin_addr.s_addr = slirp_socket_addr;
494 sock_in.sin_port = htons(slirp_socket_port);
495 if (connect(s, (struct sockaddr *)&sock_in, sizeof(sock_in)) != 0)
496 slirp_exit(1); /* just exit...*/
497 sprintf(buff, "kill %s:%d", slirp_socket_passwd, slirp_socket_unit);
498 write(s, buff, strlen(buff)+1);
499 }
500#ifndef NO_UNIX_SOCKETS
501 else {
502 s = socket(AF_UNIX, SOCK_STREAM, 0);
503 if (s < 0)
504 slirp_exit(1);
505 sock_un.sun_family = AF_UNIX;
506 strcpy(sock_un.sun_path, socket_path);
507 if (connect(s, (struct sockaddr *)&sock_un,
508 sizeof(sock_un.sun_family) + sizeof(sock_un.sun_path)) != 0)
509 slirp_exit(1);
510 sprintf(buff, "kill none:%d", slirp_socket_unit);
511 write(s, buff, strlen(buff)+1);
512 }
513#endif
514 slirp_exit(0);
515}
ths5fafdf22007-09-16 21:08:06 +0000516
517
bellardf0cbd3e2004-04-22 00:10:48 +0000518void
519snooze()
520{
521 sigset_t s;
522 int i;
ths5fafdf22007-09-16 21:08:06 +0000523
bellardf0cbd3e2004-04-22 00:10:48 +0000524 /* Don't need our data anymore */
525 /* XXX This makes SunOS barf */
526/* brk(0); */
ths5fafdf22007-09-16 21:08:06 +0000527
bellardf0cbd3e2004-04-22 00:10:48 +0000528 /* Close all fd's */
529 for (i = 255; i >= 0; i--)
530 close(i);
ths5fafdf22007-09-16 21:08:06 +0000531
bellardf0cbd3e2004-04-22 00:10:48 +0000532 signal(SIGQUIT, slirp_exit);
533 signal(SIGHUP, snooze_hup);
534 sigemptyset(&s);
ths5fafdf22007-09-16 21:08:06 +0000535
bellardf0cbd3e2004-04-22 00:10:48 +0000536 /* Wait for any signal */
537 sigsuspend(&s);
ths5fafdf22007-09-16 21:08:06 +0000538
bellardf0cbd3e2004-04-22 00:10:48 +0000539 /* Just in case ... */
540 exit(255);
541}
542
543void
544relay(s)
545 int s;
546{
547 char buf[8192];
548 int n;
549 fd_set readfds;
550 struct ttys *ttyp;
ths5fafdf22007-09-16 21:08:06 +0000551
bellardf0cbd3e2004-04-22 00:10:48 +0000552 /* Don't need our data anymore */
553 /* XXX This makes SunOS barf */
554/* brk(0); */
ths5fafdf22007-09-16 21:08:06 +0000555
bellardf0cbd3e2004-04-22 00:10:48 +0000556 signal(SIGQUIT, slirp_exit);
557 signal(SIGHUP, slirp_exit);
558 signal(SIGINT, slirp_exit);
559 signal(SIGTERM, slirp_exit);
ths5fafdf22007-09-16 21:08:06 +0000560
bellardf0cbd3e2004-04-22 00:10:48 +0000561 /* Fudge to get term_raw and term_restore to work */
562 if (NULL == (ttyp = tty_attach (0, slirp_tty))) {
563 lprint ("Error: tty_attach failed in misc.c:relay()\r\n");
564 slirp_exit (1);
565 }
566 ttyp->fd = 0;
567 ttyp->flags |= TTY_CTTY;
568 term_raw(ttyp);
ths5fafdf22007-09-16 21:08:06 +0000569
bellardf0cbd3e2004-04-22 00:10:48 +0000570 while (1) {
571 FD_ZERO(&readfds);
ths3b46e622007-09-17 08:09:54 +0000572
bellardf0cbd3e2004-04-22 00:10:48 +0000573 FD_SET(0, &readfds);
574 FD_SET(s, &readfds);
ths3b46e622007-09-17 08:09:54 +0000575
bellardf0cbd3e2004-04-22 00:10:48 +0000576 n = select(s+1, &readfds, (fd_set *)0, (fd_set *)0, (struct timeval *)0);
ths3b46e622007-09-17 08:09:54 +0000577
bellardf0cbd3e2004-04-22 00:10:48 +0000578 if (n <= 0)
579 slirp_exit(0);
ths3b46e622007-09-17 08:09:54 +0000580
bellardf0cbd3e2004-04-22 00:10:48 +0000581 if (FD_ISSET(0, &readfds)) {
582 n = read(0, buf, 8192);
583 if (n <= 0)
584 slirp_exit(0);
585 n = writen(s, buf, n);
586 if (n <= 0)
587 slirp_exit(0);
588 }
ths3b46e622007-09-17 08:09:54 +0000589
bellardf0cbd3e2004-04-22 00:10:48 +0000590 if (FD_ISSET(s, &readfds)) {
591 n = read(s, buf, 8192);
592 if (n <= 0)
593 slirp_exit(0);
594 n = writen(0, buf, n);
595 if (n <= 0)
596 slirp_exit(0);
597 }
598 }
ths5fafdf22007-09-16 21:08:06 +0000599
bellardf0cbd3e2004-04-22 00:10:48 +0000600 /* Just in case.... */
601 exit(1);
602}
603#endif
604
blueswir131a60e22007-10-26 18:42:59 +0000605#ifdef CONFIG_QEMU
thsc9f10302007-10-30 23:19:52 +0000606extern void term_vprintf(const char *fmt, va_list ap);
607
blueswir131a60e22007-10-26 18:42:59 +0000608void lprint(const char *format, ...)
609{
610 va_list args;
611
612 va_start(args, format);
613 term_vprintf(format, args);
614 va_end(args);
615}
616#else
bellardf0cbd3e2004-04-22 00:10:48 +0000617int (*lprint_print) _P((void *, const char *, va_list));
618char *lprint_ptr, *lprint_ptr2, **lprint_arg;
619
620void
621#ifdef __STDC__
622lprint(const char *format, ...)
623#else
624lprint(va_alist) va_dcl
625#endif
626{
627 va_list args;
ths3b46e622007-09-17 08:09:54 +0000628
bellardf0cbd3e2004-04-22 00:10:48 +0000629#ifdef __STDC__
630 va_start(args, format);
631#else
632 char *format;
633 va_start(args);
634 format = va_arg(args, char *);
635#endif
636#if 0
637 /* If we're printing to an sbuf, make sure there's enough room */
638 /* XXX +100? */
639 if (lprint_sb) {
640 if ((lprint_ptr - lprint_sb->sb_wptr) >=
641 (lprint_sb->sb_datalen - (strlen(format) + 100))) {
642 int deltaw = lprint_sb->sb_wptr - lprint_sb->sb_data;
643 int deltar = lprint_sb->sb_rptr - lprint_sb->sb_data;
644 int deltap = lprint_ptr - lprint_sb->sb_data;
ths3b46e622007-09-17 08:09:54 +0000645
bellardf0cbd3e2004-04-22 00:10:48 +0000646 lprint_sb->sb_data = (char *)realloc(lprint_sb->sb_data,
647 lprint_sb->sb_datalen + TCP_SNDSPACE);
ths3b46e622007-09-17 08:09:54 +0000648
bellardf0cbd3e2004-04-22 00:10:48 +0000649 /* Adjust all values */
650 lprint_sb->sb_wptr = lprint_sb->sb_data + deltaw;
651 lprint_sb->sb_rptr = lprint_sb->sb_data + deltar;
652 lprint_ptr = lprint_sb->sb_data + deltap;
ths3b46e622007-09-17 08:09:54 +0000653
bellardf0cbd3e2004-04-22 00:10:48 +0000654 lprint_sb->sb_datalen += TCP_SNDSPACE;
655 }
656 }
ths5fafdf22007-09-16 21:08:06 +0000657#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000658 if (lprint_print)
659 lprint_ptr += (*lprint_print)(*lprint_arg, format, args);
ths5fafdf22007-09-16 21:08:06 +0000660
bellardf0cbd3e2004-04-22 00:10:48 +0000661 /* Check if they want output to be logged to file as well */
662 if (lfd) {
ths5fafdf22007-09-16 21:08:06 +0000663 /*
bellardf0cbd3e2004-04-22 00:10:48 +0000664 * Remove \r's
665 * otherwise you'll get ^M all over the file
666 */
667 int len = strlen(format);
668 char *bptr1, *bptr2;
ths3b46e622007-09-17 08:09:54 +0000669
bellardf0cbd3e2004-04-22 00:10:48 +0000670 bptr1 = bptr2 = strdup(format);
ths3b46e622007-09-17 08:09:54 +0000671
bellardf0cbd3e2004-04-22 00:10:48 +0000672 while (len--) {
673 if (*bptr1 == '\r')
674 memcpy(bptr1, bptr1+1, len+1);
675 else
676 bptr1++;
677 }
678 vfprintf(lfd, bptr2, args);
679 free(bptr2);
680 }
681 va_end(args);
682}
683
684void
685add_emu(buff)
686 char *buff;
687{
688 u_int lport, fport;
689 u_int8_t tos = 0, emu = 0;
690 char buff1[256], buff2[256], buff4[128];
691 char *buff3 = buff4;
692 struct emu_t *emup;
693 struct socket *so;
ths5fafdf22007-09-16 21:08:06 +0000694
bellardf0cbd3e2004-04-22 00:10:48 +0000695 if (sscanf(buff, "%256s %256s", buff2, buff1) != 2) {
696 lprint("Error: Bad arguments\r\n");
697 return;
698 }
ths5fafdf22007-09-16 21:08:06 +0000699
bellardf0cbd3e2004-04-22 00:10:48 +0000700 if (sscanf(buff1, "%d:%d", &lport, &fport) != 2) {
701 lport = 0;
702 if (sscanf(buff1, "%d", &fport) != 1) {
703 lprint("Error: Bad first argument\r\n");
704 return;
705 }
706 }
ths5fafdf22007-09-16 21:08:06 +0000707
bellardf0cbd3e2004-04-22 00:10:48 +0000708 if (sscanf(buff2, "%128[^:]:%128s", buff1, buff3) != 2) {
709 buff3 = 0;
710 if (sscanf(buff2, "%256s", buff1) != 1) {
711 lprint("Error: Bad second argument\r\n");
712 return;
713 }
714 }
ths5fafdf22007-09-16 21:08:06 +0000715
bellardf0cbd3e2004-04-22 00:10:48 +0000716 if (buff3) {
717 if (strcmp(buff3, "lowdelay") == 0)
718 tos = IPTOS_LOWDELAY;
719 else if (strcmp(buff3, "throughput") == 0)
720 tos = IPTOS_THROUGHPUT;
721 else {
722 lprint("Error: Expecting \"lowdelay\"/\"throughput\"\r\n");
723 return;
724 }
725 }
ths5fafdf22007-09-16 21:08:06 +0000726
bellardf0cbd3e2004-04-22 00:10:48 +0000727 if (strcmp(buff1, "ftp") == 0)
728 emu = EMU_FTP;
729 else if (strcmp(buff1, "irc") == 0)
730 emu = EMU_IRC;
731 else if (strcmp(buff1, "none") == 0)
732 emu = EMU_NONE; /* ie: no emulation */
733 else {
734 lprint("Error: Unknown service\r\n");
735 return;
736 }
ths5fafdf22007-09-16 21:08:06 +0000737
bellardf0cbd3e2004-04-22 00:10:48 +0000738 /* First, check that it isn't already emulated */
739 for (emup = tcpemu; emup; emup = emup->next) {
740 if (emup->lport == lport && emup->fport == fport) {
741 lprint("Error: port already emulated\r\n");
742 return;
743 }
744 }
ths5fafdf22007-09-16 21:08:06 +0000745
bellardf0cbd3e2004-04-22 00:10:48 +0000746 /* link it */
747 emup = (struct emu_t *)malloc(sizeof (struct emu_t));
748 emup->lport = (u_int16_t)lport;
749 emup->fport = (u_int16_t)fport;
750 emup->tos = tos;
751 emup->emu = emu;
752 emup->next = tcpemu;
753 tcpemu = emup;
ths5fafdf22007-09-16 21:08:06 +0000754
bellardf0cbd3e2004-04-22 00:10:48 +0000755 /* And finally, mark all current sessions, if any, as being emulated */
756 for (so = tcb.so_next; so != &tcb; so = so->so_next) {
757 if ((lport && lport == ntohs(so->so_lport)) ||
758 (fport && fport == ntohs(so->so_fport))) {
759 if (emu)
760 so->so_emu = emu;
761 if (tos)
762 so->so_iptos = tos;
763 }
764 }
ths5fafdf22007-09-16 21:08:06 +0000765
bellardf0cbd3e2004-04-22 00:10:48 +0000766 lprint("Adding emulation for %s to port %d/%d\r\n", buff1, emup->lport, emup->fport);
767}
blueswir131a60e22007-10-26 18:42:59 +0000768#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000769
770#ifdef BAD_SPRINTF
771
772#undef vsprintf
773#undef sprintf
774
775/*
776 * Some BSD-derived systems have a sprintf which returns char *
777 */
778
779int
780vsprintf_len(string, format, args)
781 char *string;
782 const char *format;
783 va_list args;
784{
785 vsprintf(string, format, args);
786 return strlen(string);
787}
788
789int
790#ifdef __STDC__
791sprintf_len(char *string, const char *format, ...)
792#else
793sprintf_len(va_alist) va_dcl
794#endif
795{
796 va_list args;
797#ifdef __STDC__
798 va_start(args, format);
799#else
800 char *string;
801 char *format;
802 va_start(args);
803 string = va_arg(args, char *);
804 format = va_arg(args, char *);
805#endif
806 vsprintf(string, format, args);
807 return strlen(string);
808}
809
810#endif
811
812void
813u_sleep(usec)
814 int usec;
815{
816 struct timeval t;
817 fd_set fdset;
ths5fafdf22007-09-16 21:08:06 +0000818
bellardf0cbd3e2004-04-22 00:10:48 +0000819 FD_ZERO(&fdset);
ths5fafdf22007-09-16 21:08:06 +0000820
bellardf0cbd3e2004-04-22 00:10:48 +0000821 t.tv_sec = 0;
822 t.tv_usec = usec * 1000;
ths5fafdf22007-09-16 21:08:06 +0000823
bellardf0cbd3e2004-04-22 00:10:48 +0000824 select(0, &fdset, &fdset, &fdset, &t);
825}
826
827/*
828 * Set fd blocking and non-blocking
829 */
830
831void
832fd_nonblock(fd)
833 int fd;
834{
835#ifdef FIONBIO
836 int opt = 1;
ths5fafdf22007-09-16 21:08:06 +0000837
bellard379ff532004-07-12 22:33:07 +0000838 ioctlsocket(fd, FIONBIO, &opt);
bellardf0cbd3e2004-04-22 00:10:48 +0000839#else
840 int opt;
ths5fafdf22007-09-16 21:08:06 +0000841
bellardf0cbd3e2004-04-22 00:10:48 +0000842 opt = fcntl(fd, F_GETFL, 0);
843 opt |= O_NONBLOCK;
844 fcntl(fd, F_SETFL, opt);
845#endif
846}
847
848void
849fd_block(fd)
850 int fd;
851{
852#ifdef FIONBIO
853 int opt = 0;
ths5fafdf22007-09-16 21:08:06 +0000854
bellard379ff532004-07-12 22:33:07 +0000855 ioctlsocket(fd, FIONBIO, &opt);
bellardf0cbd3e2004-04-22 00:10:48 +0000856#else
857 int opt;
ths5fafdf22007-09-16 21:08:06 +0000858
bellardf0cbd3e2004-04-22 00:10:48 +0000859 opt = fcntl(fd, F_GETFL, 0);
860 opt &= ~O_NONBLOCK;
861 fcntl(fd, F_SETFL, opt);
862#endif
863}
864
865
866#if 0
867/*
868 * invoke RSH
869 */
870int
871rsh_exec(so,ns, user, host, args)
872 struct socket *so;
873 struct socket *ns;
874 char *user;
875 char *host;
876 char *args;
877{
878 int fd[2];
879 int fd0[2];
880 int s;
881 char buff[256];
ths5fafdf22007-09-16 21:08:06 +0000882
bellardf0cbd3e2004-04-22 00:10:48 +0000883 DEBUG_CALL("rsh_exec");
884 DEBUG_ARG("so = %lx", (long)so);
ths5fafdf22007-09-16 21:08:06 +0000885
bellardf0cbd3e2004-04-22 00:10:48 +0000886 if (pipe(fd)<0) {
887 lprint("Error: pipe failed: %s\n", strerror(errno));
888 return 0;
889 }
890/* #ifdef HAVE_SOCKETPAIR */
891#if 1
892 if (socketpair(PF_UNIX,SOCK_STREAM,0, fd0) == -1) {
893 close(fd[0]);
894 close(fd[1]);
895 lprint("Error: openpty failed: %s\n", strerror(errno));
896 return 0;
897 }
898#else
bellardf3ff6492004-10-10 18:00:00 +0000899 if (slirp_openpty(&fd0[0], &fd0[1]) == -1) {
bellardf0cbd3e2004-04-22 00:10:48 +0000900 close(fd[0]);
901 close(fd[1]);
902 lprint("Error: openpty failed: %s\n", strerror(errno));
903 return 0;
904 }
905#endif
ths5fafdf22007-09-16 21:08:06 +0000906
bellardf0cbd3e2004-04-22 00:10:48 +0000907 switch(fork()) {
908 case -1:
909 lprint("Error: fork failed: %s\n", strerror(errno));
910 close(fd[0]);
911 close(fd[1]);
912 close(fd0[0]);
913 close(fd0[1]);
914 return 0;
ths3b46e622007-09-17 08:09:54 +0000915
bellardf0cbd3e2004-04-22 00:10:48 +0000916 case 0:
917 close(fd[0]);
918 close(fd0[0]);
ths3b46e622007-09-17 08:09:54 +0000919
bellardf0cbd3e2004-04-22 00:10:48 +0000920 /* Set the DISPLAY */
921 if (x_port >= 0) {
922#ifdef HAVE_SETENV
923 sprintf(buff, "%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
924 setenv("DISPLAY", buff, 1);
925#else
926 sprintf(buff, "DISPLAY=%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
927 putenv(buff);
928#endif
929 }
ths3b46e622007-09-17 08:09:54 +0000930
bellardf0cbd3e2004-04-22 00:10:48 +0000931 dup2(fd0[1], 0);
932 dup2(fd0[1], 1);
933 dup2(fd[1], 2);
934 for (s = 3; s <= 255; s++)
935 close(s);
ths3b46e622007-09-17 08:09:54 +0000936
bellardf0cbd3e2004-04-22 00:10:48 +0000937 execlp("rsh","rsh","-l", user, host, args, NULL);
ths3b46e622007-09-17 08:09:54 +0000938
bellardf0cbd3e2004-04-22 00:10:48 +0000939 /* Ooops, failed, let's tell the user why */
ths3b46e622007-09-17 08:09:54 +0000940
ths5fafdf22007-09-16 21:08:06 +0000941 sprintf(buff, "Error: execlp of %s failed: %s\n",
bellardf0cbd3e2004-04-22 00:10:48 +0000942 "rsh", strerror(errno));
943 write(2, buff, strlen(buff)+1);
944 close(0); close(1); close(2); /* XXX */
945 exit(1);
ths3b46e622007-09-17 08:09:54 +0000946
bellardf0cbd3e2004-04-22 00:10:48 +0000947 default:
948 close(fd[1]);
949 close(fd0[1]);
950 ns->s=fd[0];
951 so->s=fd0[0];
ths3b46e622007-09-17 08:09:54 +0000952
bellardf0cbd3e2004-04-22 00:10:48 +0000953 return 1;
954 }
955}
956#endif