Statistics
| Branch: | Revision:

root / slirp / misc.c @ eb6a0540

History | View | Annotate | Download (19.2 kB)

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;
12

    
13
#if 0
14
int x_port = -1;
15
int x_display = 0;
16
int x_screen = 0;
17

18
int
19
show_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
        }
33

34
        return CFG_OK;
35
}
36

37

38
/*
39
 * XXX Allow more than one X redirection?
40
 */
41
void
42
redir_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;
49

50
        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
70
int
71
inet_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
 */
86
void
87
getouraddr()
88
{
89
        char buff[256];
90
        struct hostent *he = NULL;
91

    
92
        if (gethostname(buff,256) == 0)
93
            he = gethostbyname(buff);
94
        if (he)
95
            our_addr = *(struct in_addr *)he->h_addr;
96
        if (our_addr.s_addr == 0)
97
            our_addr.s_addr = loopback_addr.s_addr;
98
}
99

    
100
#if SIZEOF_CHAR_P == 8
101

    
102
struct quehead_32 {
103
        u_int32_t qh_link;
104
        u_int32_t qh_rlink;
105
};
106

    
107
inline void
108
insque_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

    
121
inline void
122
remque_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

    
133
struct quehead {
134
        struct quehead *qh_link;
135
        struct quehead *qh_rlink;
136
};
137

    
138
inline void
139
insque(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

    
151
inline void
152
remque(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

    
165
int
166
add_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;
174

    
175
        /* 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
        }
180

    
181
        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

    
197
extern int sys_nerr;
198
extern char *sys_errlist[];
199

    
200
char *
201
strerror(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

    
213
#ifdef _WIN32
214

    
215
int
216
fork_exec(struct socket *so, const char *ex, int do_pty)
217
{
218
    /* not implemented */
219
    return 0;
220
}
221

    
222
#else
223

    
224
#ifndef CONFIG_QEMU
225
int
226
slirp_openpty(amaster, aslave)
227
     int *amaster, *aslave;
228
{
229
        register int master, slave;
230

    
231
#ifdef HAVE_GRANTPT
232
        char *ptr;
233

    
234
        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
        }
241

    
242
        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
        }
250

    
251
        *amaster = master;
252
        *aslave = slave;
253
        return 0;
254

    
255
#else
256

    
257
        static char line[] = "/dev/ptyXX";
258
        register const char *cp1, *cp2;
259

    
260
        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
}
289
#endif
290

    
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.
297
 *
298
 * 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
 */
302
int
303
fork_exec(struct socket *so, const char *ex, int do_pty)
304
{
305
        int s;
306
        struct sockaddr_in addr;
307
        int addrlen = sizeof(addr);
308
        int opt;
309
        int master = -1;
310
        char *argv[256];
311
#if 0
312
        char buff[256];
313
#endif
314
        /* don't want to clobber the original */
315
        char *bptr;
316
        const char *curarg;
317
        int c, i, ret;
318

    
319
        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);
323

    
324
        if (do_pty == 2) {
325
#if 0
326
                if (slirp_openpty(&master, &s) == -1) {
327
                        lprint("Error: openpty failed: %s\n", strerror(errno));
328
                        return 0;
329
                }
330
#else
331
                return 0;
332
#endif
333
        } else {
334
                addr.sin_family = AF_INET;
335
                addr.sin_port = 0;
336
                addr.sin_addr.s_addr = INADDR_ANY;
337

    
338
                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));
342
                        closesocket(s);
343

    
344
                        return 0;
345
                }
346
        }
347

    
348
        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;
355

    
356
         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;
373
                        do {
374
                            ret = connect(s, (struct sockaddr *)&addr, addrlen);
375
                        } while (ret < 0 && errno == EINTR);
376
                }
377

    
378
#if 0
379
                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
                }
388
#endif
389
                dup2(s, 0);
390
                dup2(s, 1);
391
                dup2(s, 2);
392
                for (s = getdtablesize() - 1; s >= 3; s--)
393
                   close(s);
394

    
395
                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);
412

    
413
                argv[i] = 0;
414
                execvp(argv[0], argv);
415

    
416
                /* Ooops, failed, let's tell the user why */
417
                  {
418
                          char buff[256];
419

    
420
                          sprintf(buff, "Error: execvp of %s failed: %s\n",
421
                                  argv[0], strerror(errno));
422
                          write(2, buff, strlen(buff)+1);
423
                  }
424
                close(0); close(1); close(2); /* XXX */
425
                exit(1);
426

    
427
         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
                          */
439
                        do {
440
                            so->s = accept(s, (struct sockaddr *)&addr, &addrlen);
441
                        } while (so->s < 0 && errno == EINTR);
442
                        closesocket(s);
443
                        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);
449

    
450
                /* 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
                }
455

    
456
                return 1;
457
        }
458
}
459
#endif
460

    
461
#ifndef HAVE_STRDUP
462
char *
463
strdup(str)
464
        const char *str;
465
{
466
        char *bptr;
467

    
468
        bptr = (char *)malloc(strlen(str)+1);
469
        strcpy(bptr, str);
470

    
471
        return bptr;
472
}
473
#endif
474

    
475
#if 0
476
void
477
snooze_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];
486

    
487
        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
}
516

    
517

    
518
void
519
snooze()
520
{
521
        sigset_t s;
522
        int i;
523

    
524
        /* Don't need our data anymore */
525
        /* XXX This makes SunOS barf */
526
/*        brk(0); */
527

    
528
        /* Close all fd's */
529
        for (i = 255; i >= 0; i--)
530
           close(i);
531

    
532
        signal(SIGQUIT, slirp_exit);
533
        signal(SIGHUP, snooze_hup);
534
        sigemptyset(&s);
535

    
536
        /* Wait for any signal */
537
        sigsuspend(&s);
538

    
539
        /* Just in case ... */
540
        exit(255);
541
}
542

    
543
void
544
relay(s)
545
        int s;
546
{
547
        char buf[8192];
548
        int n;
549
        fd_set readfds;
550
        struct ttys *ttyp;
551

    
552
        /* Don't need our data anymore */
553
        /* XXX This makes SunOS barf */
554
/*        brk(0); */
555

    
556
        signal(SIGQUIT, slirp_exit);
557
        signal(SIGHUP, slirp_exit);
558
        signal(SIGINT, slirp_exit);
559
        signal(SIGTERM, slirp_exit);
560

    
561
        /* 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);
569

    
570
        while (1) {
571
                FD_ZERO(&readfds);
572

    
573
                FD_SET(0, &readfds);
574
                FD_SET(s, &readfds);
575

    
576
                n = select(s+1, &readfds, (fd_set *)0, (fd_set *)0, (struct timeval *)0);
577

    
578
                if (n <= 0)
579
                   slirp_exit(0);
580

    
581
                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
                }
589

    
590
                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
        }
599

    
600
        /* Just in case.... */
601
        exit(1);
602
}
603
#endif
604

    
605
#ifdef CONFIG_QEMU
606
extern void term_vprintf(const char *fmt, va_list ap);
607

    
608
void 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
617
int (*lprint_print) _P((void *, const char *, va_list));
618
char *lprint_ptr, *lprint_ptr2, **lprint_arg;
619

    
620
void
621
#ifdef __STDC__
622
lprint(const char *format, ...)
623
#else
624
lprint(va_alist) va_dcl
625
#endif
626
{
627
        va_list args;
628

    
629
#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;
645

646
                        lprint_sb->sb_data = (char *)realloc(lprint_sb->sb_data,
647
                                                             lprint_sb->sb_datalen + TCP_SNDSPACE);
648

649
                        /* 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;
653

654
                        lprint_sb->sb_datalen += TCP_SNDSPACE;
655
                }
656
        }
657
#endif
658
        if (lprint_print)
659
           lprint_ptr += (*lprint_print)(*lprint_arg, format, args);
660

    
661
        /* Check if they want output to be logged to file as well */
662
        if (lfd) {
663
                /*
664
                 * Remove \r's
665
                 * otherwise you'll get ^M all over the file
666
                 */
667
                int len = strlen(format);
668
                char *bptr1, *bptr2;
669

    
670
                bptr1 = bptr2 = strdup(format);
671

    
672
                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

    
684
void
685
add_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;
694

    
695
        if (sscanf(buff, "%256s %256s", buff2, buff1) != 2) {
696
                lprint("Error: Bad arguments\r\n");
697
                return;
698
        }
699

    
700
        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
        }
707

    
708
        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
        }
715

    
716
        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
        }
726

    
727
        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
        }
737

    
738
        /* 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
        }
745

    
746
        /* 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;
754

    
755
        /* 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
        }
765

    
766
        lprint("Adding emulation for %s to port %d/%d\r\n", buff1, emup->lport, emup->fport);
767
}
768
#endif
769

    
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

    
779
int
780
vsprintf_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

    
789
int
790
#ifdef __STDC__
791
sprintf_len(char *string, const char *format, ...)
792
#else
793
sprintf_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

    
812
void
813
u_sleep(usec)
814
        int usec;
815
{
816
        struct timeval t;
817
        fd_set fdset;
818

    
819
        FD_ZERO(&fdset);
820

    
821
        t.tv_sec = 0;
822
        t.tv_usec = usec * 1000;
823

    
824
        select(0, &fdset, &fdset, &fdset, &t);
825
}
826

    
827
/*
828
 * Set fd blocking and non-blocking
829
 */
830

    
831
void
832
fd_nonblock(fd)
833
        int fd;
834
{
835
#ifdef FIONBIO
836
        int opt = 1;
837

    
838
        ioctlsocket(fd, FIONBIO, &opt);
839
#else
840
        int opt;
841

    
842
        opt = fcntl(fd, F_GETFL, 0);
843
        opt |= O_NONBLOCK;
844
        fcntl(fd, F_SETFL, opt);
845
#endif
846
}
847

    
848
void
849
fd_block(fd)
850
        int fd;
851
{
852
#ifdef FIONBIO
853
        int opt = 0;
854

    
855
        ioctlsocket(fd, FIONBIO, &opt);
856
#else
857
        int opt;
858

    
859
        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
 */
870
int
871
rsh_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];
882

883
        DEBUG_CALL("rsh_exec");
884
        DEBUG_ARG("so = %lx", (long)so);
885

886
        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
899
        if (slirp_openpty(&fd0[0], &fd0[1]) == -1) {
900
          close(fd[0]);
901
          close(fd[1]);
902
          lprint("Error: openpty failed: %s\n", strerror(errno));
903
          return 0;
904
        }
905
#endif
906

    
907
        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;
915

    
916
         case 0:
917
           close(fd[0]);
918
           close(fd0[0]);
919

    
920
                /* 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
           }
930

    
931
           dup2(fd0[1], 0);
932
           dup2(fd0[1], 1);
933
           dup2(fd[1], 2);
934
           for (s = 3; s <= 255; s++)
935
             close(s);
936

    
937
           execlp("rsh","rsh","-l", user, host, args, NULL);
938

    
939
           /* Ooops, failed, let's tell the user why */
940

    
941
           sprintf(buff, "Error: execlp of %s failed: %s\n",
942
                   "rsh", strerror(errno));
943
           write(2, buff, strlen(buff)+1);
944
           close(0); close(1); close(2); /* XXX */
945
           exit(1);
946

    
947
        default:
948
          close(fd[1]);
949
          close(fd0[1]);
950
          ns->s=fd[0];
951
          so->s=fd0[0];
952

    
953
          return 1;
954
        }
955
}
956
#endif