← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/virtualbox-ose/gutsy

« back to all changes in this revision

Viewing changes to src/VBox/Devices/Network/slirp/udp.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2007-09-08 16:44:58 UTC
  • Revision ID: james.westby@ubuntu.com-20070908164458-wao29470vqtr8ksy
Tags: upstream-1.5.0-dfsg2
Import upstream version 1.5.0-dfsg2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Devices/Network/slirp/udp.c
 
1
/*
 
2
 * Copyright (c) 1982, 1986, 1988, 1990, 1993
 
3
 *      The Regents of the University of California.  All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer.
 
10
 * 2. Redistributions in binary form must reproduce the above copyright
 
11
 *    notice, this list of conditions and the following disclaimer in the
 
12
 *    documentation and/or other materials provided with the distribution.
 
13
 * 3. All advertising materials mentioning features or use of this software
 
14
 *    must display the following acknowledgement:
 
15
 *      This product includes software developed by the University of
 
16
 *      California, Berkeley and its contributors.
 
17
 * 4. Neither the name of the University nor the names of its contributors
 
18
 *    may be used to endorse or promote products derived from this software
 
19
 *    without specific prior written permission.
 
20
 *
 
21
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 
22
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
23
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
24
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 
25
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
26
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
27
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
28
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
29
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 
30
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 
31
 * SUCH DAMAGE.
 
32
 *
 
33
 *      @(#)udp_usrreq.c        8.4 (Berkeley) 1/21/94
 
34
 * udp_usrreq.c,v 1.4 1994/10/02 17:48:45 phk Exp
 
35
 */
 
36
 
 
37
/*
 
38
 * Changes and additions relating to SLiRP
 
39
 * Copyright (c) 1995 Danny Gasparovski.
 
40
 *
 
41
 * Please read the file COPYRIGHT for the
 
42
 * terms and conditions of the copyright.
 
43
 */
 
44
 
 
45
#include <slirp.h>
 
46
#include "ip_icmp.h"
 
47
 
 
48
 
 
49
/*
 
50
 * UDP protocol implementation.
 
51
 * Per RFC 768, August, 1980.
 
52
 */
 
53
#define udpcksum 1
 
54
 
 
55
void
 
56
udp_init(PNATState pData)
 
57
{
 
58
        udp_last_so = &udb;
 
59
        udb.so_next = udb.so_prev = &udb;
 
60
}
 
61
 
 
62
/* m->m_data  points at ip packet header
 
63
 * m->m_len   length ip packet
 
64
 * ip->ip_len length data (IPDU)
 
65
 */
 
66
void
 
67
udp_input(PNATState pData, register struct mbuf *m, int iphlen)
 
68
{
 
69
        register struct ip *ip;
 
70
        register struct udphdr *uh;
 
71
/*      struct mbuf *opts = 0;*/
 
72
        int len;
 
73
        struct ip save_ip;
 
74
        struct socket *so;
 
75
 
 
76
        DEBUG_CALL("udp_input");
 
77
        DEBUG_ARG("m = %lx", (long)m);
 
78
        DEBUG_ARG("iphlen = %d", iphlen);
 
79
 
 
80
        udpstat.udps_ipackets++;
 
81
 
 
82
        /*
 
83
         * Strip IP options, if any; should skip this,
 
84
         * make available to user, and use on returned packets,
 
85
         * but we don't yet have a way to check the checksum
 
86
         * with options still present.
 
87
         */
 
88
        if(iphlen > sizeof(struct ip)) {
 
89
                ip_stripoptions(m, (struct mbuf *)0);
 
90
                iphlen = sizeof(struct ip);
 
91
        }
 
92
 
 
93
        /*
 
94
         * Get IP and UDP header together in first mbuf.
 
95
         */
 
96
        ip = mtod(m, struct ip *);
 
97
        uh = (struct udphdr *)((caddr_t)ip + iphlen);
 
98
 
 
99
        /*
 
100
         * Make mbuf data length reflect UDP length.
 
101
         * If not enough data to reflect UDP length, drop.
 
102
         */
 
103
        len = ntohs((u_int16_t)uh->uh_ulen);
 
104
 
 
105
        if (ip->ip_len != len) {
 
106
                if (len > ip->ip_len) {
 
107
                        udpstat.udps_badlen++;
 
108
                        goto bad;
 
109
                }
 
110
                m_adj(m, len - ip->ip_len);
 
111
                ip->ip_len = len;
 
112
        }
 
113
 
 
114
        /*
 
115
         * Save a copy of the IP header in case we want restore it
 
116
         * for sending an ICMP error message in response.
 
117
         */
 
118
        save_ip = *ip;
 
119
        save_ip.ip_len+= iphlen;         /* tcp_input subtracts this */
 
120
 
 
121
        /*
 
122
         * Checksum extended UDP header and data.
 
123
         */
 
124
        if (udpcksum && uh->uh_sum) {
 
125
          ((struct ipovly *)ip)->ih_next = 0;
 
126
          ((struct ipovly *)ip)->ih_prev = 0;
 
127
          ((struct ipovly *)ip)->ih_x1 = 0;
 
128
          ((struct ipovly *)ip)->ih_len = uh->uh_ulen;
 
129
          /* keep uh_sum for ICMP reply
 
130
           * uh->uh_sum = cksum(m, len + sizeof (struct ip));
 
131
           * if (uh->uh_sum) {
 
132
           */
 
133
          if(cksum(m, len + sizeof(struct ip))) {
 
134
            udpstat.udps_badsum++;
 
135
            goto bad;
 
136
          }
 
137
        }
 
138
 
 
139
        /*
 
140
         *  handle DHCP/BOOTP
 
141
         */
 
142
        if (ntohs(uh->uh_dport) == BOOTP_SERVER) {
 
143
            bootp_input(pData, m);
 
144
            goto bad;
 
145
        }
 
146
 
 
147
        /*
 
148
         *  handle TFTP
 
149
         */
 
150
        if (ntohs(uh->uh_dport) == TFTP_SERVER) {
 
151
            tftp_input(pData, m);
 
152
            goto bad;
 
153
        }
 
154
 
 
155
        /*
 
156
         * Locate pcb for datagram.
 
157
         */
 
158
        so = udp_last_so;
 
159
        if (so->so_lport != uh->uh_sport ||
 
160
            so->so_laddr.s_addr != ip->ip_src.s_addr) {
 
161
                struct socket *tmp;
 
162
 
 
163
                for (tmp = udb.so_next; tmp != &udb; tmp = tmp->so_next) {
 
164
                        if (tmp->so_lport == uh->uh_sport &&
 
165
                            tmp->so_laddr.s_addr == ip->ip_src.s_addr) {
 
166
                                so = tmp;
 
167
                                break;
 
168
                        }
 
169
                }
 
170
                if (tmp == &udb) {
 
171
                  so = NULL;
 
172
                } else {
 
173
                  udpstat.udpps_pcbcachemiss++;
 
174
                  udp_last_so = so;
 
175
                }
 
176
        }
 
177
 
 
178
        if (so == NULL) {
 
179
          /*
 
180
           * If there's no socket for this packet,
 
181
           * create one
 
182
           */
 
183
          if ((so = socreate()) == NULL) goto bad;
 
184
          if(udp_attach(pData, so) == -1) {
 
185
            DEBUG_MISC((dfd," udp_attach errno = %d-%s\n",
 
186
                        errno,strerror(errno)));
 
187
            sofree(pData, so);
 
188
            goto bad;
 
189
          }
 
190
 
 
191
          /*
 
192
           * Setup fields
 
193
           */
 
194
          /* udp_last_so = so; */
 
195
          so->so_laddr = ip->ip_src;
 
196
          so->so_lport = uh->uh_sport;
 
197
 
 
198
          if ((so->so_iptos = udp_tos(so)) == 0)
 
199
            so->so_iptos = ip->ip_tos;
 
200
 
 
201
          /*
 
202
           * XXXXX Here, check if it's in udpexec_list,
 
203
           * and if it is, do the fork_exec() etc.
 
204
           */
 
205
        }
 
206
 
 
207
        so->so_faddr = ip->ip_dst; /* XXX */
 
208
        so->so_fport = uh->uh_dport; /* XXX */
 
209
 
 
210
        iphlen += sizeof(struct udphdr);
 
211
        m->m_len -= iphlen;
 
212
        m->m_data += iphlen;
 
213
 
 
214
        /*
 
215
         * Now we sendto() the packet.
 
216
         */
 
217
        if (so->so_emu)
 
218
           udp_emu(pData, so, m);
 
219
 
 
220
        if(sosendto(pData, so,m) == -1) {
 
221
          m->m_len += iphlen;
 
222
          m->m_data -= iphlen;
 
223
          *ip=save_ip;
 
224
          DEBUG_MISC((dfd,"udp tx errno = %d-%s\n",errno,strerror(errno)));
 
225
          icmp_error(pData, m, ICMP_UNREACH,ICMP_UNREACH_NET, 0,strerror(errno));
 
226
        }
 
227
 
 
228
        m_free(pData, so->so_m);   /* used for ICMP if error on sorecvfrom */
 
229
 
 
230
        /* restore the orig mbuf packet */
 
231
        m->m_len += iphlen;
 
232
        m->m_data -= iphlen;
 
233
        *ip=save_ip;
 
234
        so->so_m=m;         /* ICMP backup */
 
235
 
 
236
        return;
 
237
bad:
 
238
        m_freem(pData, m);
 
239
        /* if (opts) m_freem(opts); */
 
240
        return;
 
241
}
 
242
 
 
243
int udp_output2(PNATState pData, struct socket *so, struct mbuf *m,
 
244
                struct sockaddr_in *saddr, struct sockaddr_in *daddr,
 
245
                int iptos)
 
246
{
 
247
        register struct udpiphdr *ui;
 
248
        int error = 0;
 
249
 
 
250
        DEBUG_CALL("udp_output");
 
251
        DEBUG_ARG("so = %lx", (long)so);
 
252
        DEBUG_ARG("m = %lx", (long)m);
 
253
        DEBUG_ARG("saddr = %lx", (long)saddr->sin_addr.s_addr);
 
254
        DEBUG_ARG("daddr = %lx", (long)daddr->sin_addr.s_addr);
 
255
 
 
256
        /*
 
257
         * Adjust for header
 
258
         */
 
259
        m->m_data -= sizeof(struct udpiphdr);
 
260
        m->m_len += sizeof(struct udpiphdr);
 
261
 
 
262
        /*
 
263
         * Fill in mbuf with extended UDP header
 
264
         * and addresses and length put into network format.
 
265
         */
 
266
        ui = mtod(m, struct udpiphdr *);
 
267
        ui->ui_next = ui->ui_prev = 0;
 
268
        ui->ui_x1 = 0;
 
269
        ui->ui_pr = IPPROTO_UDP;
 
270
        ui->ui_len = htons(m->m_len - sizeof(struct ip)); /* + sizeof (struct udphdr)); */
 
271
        /* XXXXX Check for from-one-location sockets, or from-any-location sockets */
 
272
        ui->ui_src = saddr->sin_addr;
 
273
        ui->ui_dst = daddr->sin_addr;
 
274
        ui->ui_sport = saddr->sin_port;
 
275
        ui->ui_dport = daddr->sin_port;
 
276
        ui->ui_ulen = ui->ui_len;
 
277
 
 
278
        /*
 
279
         * Stuff checksum and output datagram.
 
280
         */
 
281
        ui->ui_sum = 0;
 
282
        if (udpcksum) {
 
283
            if ((ui->ui_sum = cksum(m, /* sizeof (struct udpiphdr) + */ m->m_len)) == 0)
 
284
                ui->ui_sum = 0xffff;
 
285
        }
 
286
        ((struct ip *)ui)->ip_len = m->m_len;
 
287
 
 
288
        ((struct ip *)ui)->ip_ttl = ip_defttl;
 
289
        ((struct ip *)ui)->ip_tos = iptos;
 
290
 
 
291
        udpstat.udps_opackets++;
 
292
 
 
293
        error = ip_output(pData, so, m);
 
294
 
 
295
        return (error);
 
296
}
 
297
 
 
298
int udp_output(PNATState pData, struct socket *so, struct mbuf *m,
 
299
               struct sockaddr_in *addr)
 
300
{
 
301
    struct sockaddr_in saddr, daddr;
 
302
 
 
303
    saddr = *addr;
 
304
    if ((so->so_faddr.s_addr & htonl(0xffffff00)) == special_addr.s_addr) {
 
305
        saddr.sin_addr.s_addr = so->so_faddr.s_addr;
 
306
        if ((so->so_faddr.s_addr & htonl(0x000000ff)) == htonl(0xff))
 
307
            saddr.sin_addr.s_addr = alias_addr.s_addr;
 
308
    }
 
309
    daddr.sin_addr = so->so_laddr;
 
310
    daddr.sin_port = so->so_lport;
 
311
 
 
312
    return udp_output2(pData, so, m, &saddr, &daddr, so->so_iptos);
 
313
}
 
314
 
 
315
int
 
316
udp_attach(PNATState pData, struct socket *so)
 
317
{
 
318
  struct sockaddr_in addr;
 
319
 
 
320
  if((so->s = socket(AF_INET,SOCK_DGRAM,0)) != -1) {
 
321
    /*
 
322
     * Here, we bind() the socket.  Although not really needed
 
323
     * (sendto() on an unbound socket will bind it), it's done
 
324
     * here so that emulation of ytalk etc. don't have to do it
 
325
     */
 
326
    addr.sin_family = AF_INET;
 
327
    addr.sin_port = 0;
 
328
    addr.sin_addr.s_addr = INADDR_ANY;
 
329
    if(bind(so->s, (struct sockaddr *)&addr, sizeof(addr))<0) {
 
330
      int lasterrno=errno;
 
331
      closesocket(so->s);
 
332
      so->s=-1;
 
333
#ifdef _WIN32
 
334
      WSASetLastError(lasterrno);
 
335
#else
 
336
      errno=lasterrno;
 
337
#endif
 
338
    } else {
 
339
      int opt = 1;
 
340
      /* success, insert in queue */
 
341
      so->so_expire = curtime + SO_EXPIRE;
 
342
      /* enable broadcast for later use */
 
343
      setsockopt(so->s, SOL_SOCKET, SO_BROADCAST, (const char *)&opt, sizeof(opt));
 
344
      insque(pData, so,&udb);
 
345
    }
 
346
  }
 
347
  return(so->s);
 
348
}
 
349
 
 
350
void
 
351
udp_detach(PNATState pData, struct socket *so)
 
352
{
 
353
        /* Correctly update list if detaching last socket in list. */
 
354
        if (so == udp_last_so) udp_last_so = &udb;
 
355
        closesocket(so->s);
 
356
        /* if (so->so_m) m_free(so->so_m);    done by sofree */
 
357
 
 
358
        sofree(pData, so);
 
359
}
 
360
 
 
361
static const struct tos_t udptos[] = {
 
362
        {0, 53, IPTOS_LOWDELAY, 0},                     /* DNS */
 
363
        {517, 517, IPTOS_LOWDELAY, EMU_TALK},   /* talk */
 
364
        {518, 518, IPTOS_LOWDELAY, EMU_NTALK},  /* ntalk */
 
365
        {0, 7648, IPTOS_LOWDELAY, EMU_CUSEEME}, /* Cu-Seeme */
 
366
        {0, 0, 0, 0}
 
367
};
 
368
 
 
369
u_int8_t
 
370
udp_tos(so)
 
371
        struct socket *so;
 
372
{
 
373
        int i = 0;
 
374
 
 
375
        while(udptos[i].tos) {
 
376
                if ((udptos[i].fport && ntohs(so->so_fport) == udptos[i].fport) ||
 
377
                    (udptos[i].lport && ntohs(so->so_lport) == udptos[i].lport)) {
 
378
                        so->so_emu = udptos[i].emu;
 
379
                        return udptos[i].tos;
 
380
                }
 
381
                i++;
 
382
        }
 
383
 
 
384
        return 0;
 
385
}
 
386
 
 
387
#ifdef EMULATE_TALK
 
388
#include "talkd.h"
 
389
#endif
 
390
 
 
391
/*
 
392
 * Here, talk/ytalk/ntalk requests must be emulated
 
393
 */
 
394
void
 
395
udp_emu(PNATState pData, struct socket *so, struct mbuf *m)
 
396
{
 
397
        struct sockaddr_in addr;
 
398
        socklen_t addrlen = sizeof(addr);
 
399
#ifdef EMULATE_TALK
 
400
        CTL_MSG_OLD *omsg;
 
401
        CTL_MSG *nmsg;
 
402
        char buff[sizeof(CTL_MSG)];
 
403
        u_char type;
 
404
 
 
405
struct talk_request {
 
406
        struct talk_request *next;
 
407
        struct socket *udp_so;
 
408
        struct socket *tcp_so;
 
409
} *req;
 
410
 
 
411
        static struct talk_request *req_tbl = 0;
 
412
 
 
413
#endif
 
414
 
 
415
struct cu_header {
 
416
        uint16_t        d_family;               /* destination family */
 
417
        uint16_t        d_port;                 /* destination port */
 
418
        uint32_t        d_addr;                 /* destination address */
 
419
        uint16_t        s_family;               /* source family */
 
420
        uint16_t        s_port;                 /* source port */
 
421
        uint32_t        so_addr;                /* source address */
 
422
        uint32_t        seqn;                   /* sequence number */
 
423
        uint16_t        message;                /* message */
 
424
        uint16_t        data_type;              /* data type */
 
425
        uint16_t        pkt_len;                /* packet length */
 
426
} *cu_head;
 
427
 
 
428
        switch(so->so_emu) {
 
429
 
 
430
#ifdef EMULATE_TALK
 
431
         case EMU_TALK:
 
432
         case EMU_NTALK:
 
433
                /*
 
434
                 * Talk emulation. We always change the ctl_addr to get
 
435
                 * some answers from the daemon. When an ANNOUNCE comes,
 
436
                 * we send LEAVE_INVITE to the local daemons. Also when a
 
437
                 * DELETE comes, we send copies to the local daemons.
 
438
                 */
 
439
                if (getsockname(so->s, (struct sockaddr *)&addr, &addrlen) < 0)
 
440
                        return;
 
441
 
 
442
#define IS_OLD  (so->so_emu == EMU_TALK)
 
443
 
 
444
#define COPY_MSG(dest, src) { dest->type = src->type; \
 
445
                              dest->id_num = src->id_num; \
 
446
                              dest->pid = src->pid; \
 
447
                              dest->addr = src->addr; \
 
448
                              dest->ctl_addr = src->ctl_addr; \
 
449
                              memcpy(&dest->l_name, &src->l_name, NAME_SIZE_OLD); \
 
450
                              memcpy(&dest->r_name, &src->r_name, NAME_SIZE_OLD); \
 
451
                              memcpy(&dest->r_tty, &src->r_tty, TTY_SIZE); }
 
452
 
 
453
#define OTOSIN(ptr, field) ((struct sockaddr_in *)&ptr->field)
 
454
/* old_sockaddr to sockaddr_in */
 
455
 
 
456
 
 
457
                if (IS_OLD) {           /* old talk */
 
458
                        omsg = mtod(m, CTL_MSG_OLD*);
 
459
                        nmsg = (CTL_MSG *) buff;
 
460
                        type = omsg->type;
 
461
                        OTOSIN(omsg, ctl_addr)->sin_port = addr.sin_port;
 
462
                        OTOSIN(omsg, ctl_addr)->sin_addr = our_addr;
 
463
                        strncpy(omsg->l_name, getlogin(), NAME_SIZE_OLD);
 
464
                } else {                /* new talk */
 
465
                        omsg = (CTL_MSG_OLD *) buff;
 
466
                        nmsg = mtod(m, CTL_MSG *);
 
467
                        type = nmsg->type;
 
468
                        OTOSIN(nmsg, ctl_addr)->sin_port = addr.sin_port;
 
469
                        OTOSIN(nmsg, ctl_addr)->sin_addr = our_addr;
 
470
                        strncpy(nmsg->l_name, getlogin(), NAME_SIZE_OLD);
 
471
                }
 
472
 
 
473
                if (type == LOOK_UP)
 
474
                        return;         /* for LOOK_UP this is enough */
 
475
 
 
476
                if (IS_OLD) {           /* make a copy of the message */
 
477
                        COPY_MSG(nmsg, omsg);
 
478
                        nmsg->vers = 1;
 
479
                        nmsg->answer = 0;
 
480
                } else
 
481
                        COPY_MSG(omsg, nmsg);
 
482
 
 
483
                /*
 
484
                 * If if is an ANNOUNCE message, we go through the
 
485
                 * request table to see if a tcp port has already
 
486
                 * been redirected for this socket. If not, we solisten()
 
487
                 * a new socket and add this entry to the table.
 
488
                 * The port number of the tcp socket and our IP
 
489
                 * are put to the addr field of the message structures.
 
490
                 * Then a LEAVE_INVITE is sent to both local daemon
 
491
                 * ports, 517 and 518. This is why we have two copies
 
492
                 * of the message, one in old talk and one in new talk
 
493
                 * format.
 
494
                 */
 
495
 
 
496
                if (type == ANNOUNCE) {
 
497
                        int s;
 
498
                        u_short temp_port;
 
499
 
 
500
                        for(req = req_tbl; req; req = req->next)
 
501
                                if (so == req->udp_so)
 
502
                                        break;          /* found it */
 
503
 
 
504
                        if (!req) {     /* no entry for so, create new */
 
505
                                req = (struct talk_request *)
 
506
                                        malloc(sizeof(struct talk_request));
 
507
                                req->udp_so = so;
 
508
                                req->tcp_so = solisten(0,
 
509
                                        OTOSIN(omsg, addr)->sin_addr.s_addr,
 
510
                                        OTOSIN(omsg, addr)->sin_port,
 
511
                                        SS_FACCEPTONCE);
 
512
                                req->next = req_tbl;
 
513
                                req_tbl = req;
 
514
                        }
 
515
 
 
516
                        /* replace port number in addr field */
 
517
                        addrlen = sizeof(addr);
 
518
                        getsockname(req->tcp_so->s,
 
519
                                        (struct sockaddr *) &addr,
 
520
                                        &addrlen);
 
521
                        OTOSIN(omsg, addr)->sin_port = addr.sin_port;
 
522
                        OTOSIN(omsg, addr)->sin_addr = our_addr;
 
523
                        OTOSIN(nmsg, addr)->sin_port = addr.sin_port;
 
524
                        OTOSIN(nmsg, addr)->sin_addr = our_addr;
 
525
 
 
526
                        /* send LEAVE_INVITEs */
 
527
                        temp_port = OTOSIN(omsg, ctl_addr)->sin_port;
 
528
                        OTOSIN(omsg, ctl_addr)->sin_port = 0;
 
529
                        OTOSIN(nmsg, ctl_addr)->sin_port = 0;
 
530
                        omsg->type = nmsg->type = LEAVE_INVITE;
 
531
 
 
532
                        s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
 
533
                        addr.sin_addr = our_addr;
 
534
                        addr.sin_family = AF_INET;
 
535
                        addr.sin_port = htons(517);
 
536
                        sendto(s, (char *)omsg, sizeof(*omsg), 0,
 
537
                                (struct sockaddr *)&addr, sizeof(addr));
 
538
                        addr.sin_port = htons(518);
 
539
                        sendto(s, (char *)nmsg, sizeof(*nmsg), 0,
 
540
                                (struct sockaddr *) &addr, sizeof(addr));
 
541
                        closesocket(s) ;
 
542
 
 
543
                        omsg->type = nmsg->type = ANNOUNCE;
 
544
                        OTOSIN(omsg, ctl_addr)->sin_port = temp_port;
 
545
                        OTOSIN(nmsg, ctl_addr)->sin_port = temp_port;
 
546
                }
 
547
 
 
548
                /*
 
549
                 * If it is a DELETE message, we send a copy to the
 
550
                 * local daemons. Then we delete the entry corresponding
 
551
                 * to our socket from the request table.
 
552
                 */
 
553
 
 
554
                if (type == DELETE) {
 
555
                        struct talk_request *temp_req, *req_next;
 
556
                        int s;
 
557
                        u_short temp_port;
 
558
 
 
559
                        temp_port = OTOSIN(omsg, ctl_addr)->sin_port;
 
560
                        OTOSIN(omsg, ctl_addr)->sin_port = 0;
 
561
                        OTOSIN(nmsg, ctl_addr)->sin_port = 0;
 
562
 
 
563
                        s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
 
564
                        addr.sin_addr = our_addr;
 
565
                        addr.sin_family = AF_INET;
 
566
                        addr.sin_port = htons(517);
 
567
                        sendto(s, (char *)omsg, sizeof(*omsg), 0,
 
568
                                (struct sockaddr *)&addr, sizeof(addr));
 
569
                        addr.sin_port = htons(518);
 
570
                        sendto(s, (char *)nmsg, sizeof(*nmsg), 0,
 
571
                                (struct sockaddr *)&addr, sizeof(addr));
 
572
                        closesocket(s);
 
573
 
 
574
                        OTOSIN(omsg, ctl_addr)->sin_port = temp_port;
 
575
                        OTOSIN(nmsg, ctl_addr)->sin_port = temp_port;
 
576
 
 
577
                        /* delete table entry */
 
578
                        if (so == req_tbl->udp_so) {
 
579
                                temp_req = req_tbl;
 
580
                                req_tbl = req_tbl->next;
 
581
                                free(temp_req);
 
582
                        } else {
 
583
                                temp_req = req_tbl;
 
584
                                for(req = req_tbl->next; req; req = req_next) {
 
585
                                        req_next = req->next;
 
586
                                        if (so == req->udp_so) {
 
587
                                                temp_req->next = req_next;
 
588
                                                free(req);
 
589
                                                break;
 
590
                                        } else {
 
591
                                                temp_req = req;
 
592
                                        }
 
593
                                }
 
594
                        }
 
595
                }
 
596
 
 
597
                return;
 
598
#endif
 
599
 
 
600
        case EMU_CUSEEME:
 
601
 
 
602
                /*
 
603
                 * Cu-SeeMe emulation.
 
604
                 * Hopefully the packet is more that 16 bytes long. We don't
 
605
                 * do any other tests, just replace the address and port
 
606
                 * fields.
 
607
                 */
 
608
                if (m->m_len >= sizeof (*cu_head)) {
 
609
                        if (getsockname(so->s, (struct sockaddr *)&addr, &addrlen) < 0)
 
610
                                return;
 
611
                        cu_head = mtod(m, struct cu_header *);
 
612
                        cu_head->s_port = addr.sin_port;
 
613
                        cu_head->so_addr = our_addr.s_addr;
 
614
                }
 
615
 
 
616
                return;
 
617
        }
 
618
}
 
619
 
 
620
struct socket *
 
621
udp_listen(PNATState pData, u_int port, u_int32_t laddr, u_int lport, int flags)
 
622
{
 
623
        struct sockaddr_in addr;
 
624
        struct socket *so;
 
625
        socklen_t addrlen = sizeof(struct sockaddr_in);
 
626
        int opt = 1;
 
627
 
 
628
        if ((so = socreate()) == NULL) {
 
629
                free(so);
 
630
                return NULL;
 
631
        }
 
632
        so->s = socket(AF_INET,SOCK_DGRAM,0);
 
633
        so->so_expire = curtime + SO_EXPIRE;
 
634
        insque(pData, so,&udb);
 
635
 
 
636
        addr.sin_family = AF_INET;
 
637
        addr.sin_addr.s_addr = INADDR_ANY;
 
638
        addr.sin_port = port;
 
639
 
 
640
        if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
 
641
                udp_detach(pData, so);
 
642
                return NULL;
 
643
        }
 
644
        setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
 
645
/*      setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int)); */
 
646
 
 
647
        getsockname(so->s,(struct sockaddr *)&addr,&addrlen);
 
648
        so->so_fport = addr.sin_port;
 
649
        if (addr.sin_addr.s_addr == 0 || addr.sin_addr.s_addr == loopback_addr.s_addr)
 
650
           so->so_faddr = alias_addr;
 
651
        else
 
652
           so->so_faddr = addr.sin_addr;
 
653
 
 
654
        so->so_lport = lport;
 
655
        so->so_laddr.s_addr = laddr;
 
656
        if (flags != SS_FACCEPTONCE)
 
657
           so->so_expire = 0;
 
658
 
 
659
        so->so_state = SS_ISFCONNECTED;
 
660
 
 
661
        return so;
 
662
}