misc.c@ 1

Last change on this file since 1 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native`
File size: 19.4 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Network/slirp/misc.c@ 1

Download in other formats: