Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <ip.h>
#include <thread.h>
#include "netbios.h"

static struct {
        int thread;
        QLock;
        int fd;
} udp = { -1 };

typedef struct Listen Listen;

struct Listen {
        NbName to;
        int (*deliver)(void *magic, NbDgram *s);
        void *magic;
        Listen *next;
};

static struct {
        QLock;
        Listen *head;
} listens;

static void
udplistener(void *)
{
//print("udplistener - starting\n");
        for (;;) {
                uchar msg[Udphdrsize + 576];
                int len = read(udp.fd, msg, sizeof(msg));
                if (len < 0)
                        break;
                if (len >= nbudphdrsize) {
                        NbDgram s;
//                      Udphdr *uh;
                        uchar *p;
                        int n;

//                      uh = (Udphdr*)msg;
                        p = msg + nbudphdrsize;
                        len -= nbudphdrsize;
                        n = nbdgramconvM2S(&s, p, p + len);
                        if (n) {
                                switch (s.type) {
                                case NbDgramError:
                                        print("nbdgramlisten: error: ip %I port %d code 0x%.2ux\n", s.srcip, s.srcport, s.error.code);
                                        break;
                                case NbDgramDirectUnique:
                                case NbDgramDirectGroup:
                                case NbDgramBroadcast: {
                                        int delivered = 0;
                                        Listen **lp, *l;
                                        if ((s.flags & NbDgramMore) || s.datagram.offset != 0)
                                                break;
                                        if (!nbnameisany(s.datagram.dstname)
                                                && !nbnametablefind(s.datagram.dstname, 0)) {
/* - only do this if a broadcast node, and can tell when packets are broadcast...
                                                s.flags &= 3;
                                                ipmove(s.srcip, nbglobals.myipaddr);
                                                s.srcport = NbDgramPort;
                                                s.type = NbDgramError;  
                                                s.error.code = NbDgramErrorDestinationNameNotPresent;
                                                nbdgramsendto(uh->raddr, nhgets(uh->rport), &s);
*/
                                                break;
                                        }
                                        qlock(&listens);
                                        for (lp = &listens.head; (l = *lp) != nil;) {
                                                if (nbnameisany(l->to) || nbnameequal(l->to, s.datagram.dstname)) {
                                                        switch ((*l->deliver)(l->magic, &s)) {
                                                        case 0:
                                                                delivered = 1;
                                                                /* fall through */
                                                        case -1:
                                                                *lp = l->next;
                                                                free(l);
                                                                continue;
                                                        default:
                                                                delivered = 1;
                                                                break;
                                                        }
                                                }
                                                lp = &l->next;
                                        }
                                        qunlock(&listens);
                                        USED(delivered);
                                }
                                default:
                                        ;
                                }
                        }
                }
        }
print("udplistener - exiting\n");
        qlock(&udp);
        udp.thread = -1;
        qunlock(&udp);
}

static char *
startlistener(void)
{
        qlock(&udp);
        if (udp.thread < 0) {
                char *e;
                e = nbudpannounce(NbDgramPort, &udp.fd);
                if (e) {
                        qunlock(&udp);
                        return e;
                }
                udp.thread = proccreate(udplistener, nil, 16384);
        }
        qunlock(&udp);
        return nil;
}

char *
nbdgramlisten(NbName to, int (*deliver)(void *magic, NbDgram *s), void *magic)
{
        Listen *l;
        char *e;
        nbnametablefind(to, 1);
        e = startlistener();
        if (e)
                return e;
        l = nbemalloc(sizeof(Listen));
        nbnamecpy(l->to, to);
        l->deliver = deliver;
        l->magic = magic;
        qlock(&listens);
        l->next = listens.head;
        listens.head = l;
        qunlock(&listens);
        return 0;
}

int
nbdgramsendto(uchar *ipaddr, ushort port, NbDgram *s)
{
        Udphdr *u;
        uchar msg[NbDgramMaxPacket + Udphdrsize];
        int l;
        int rv;
        char *e;

        e = startlistener();
        if (e != nil)
                return 0;

        l = nbdgramconvS2M(msg + nbudphdrsize, msg + sizeof(msg), s);
        if (l == 0) {
                print("conv failed\n");
                return 0;
        }
        u = (Udphdr *)msg;
        ipmove(u->laddr, nbglobals.myipaddr);
        hnputs(u->lport, NbDgramPort);
        ipmove(u->raddr, ipaddr);
        hnputs(u->rport, port);
//nbdumpdata(msg, l + nbudphdrsize);
//print("transmitting\n");
        rv = write(udp.fd, msg, l + nbudphdrsize);
//print("rv %d l %d hdrsize %d error %r\n", rv, l, nbudphdrsize);
        return rv == l + nbudphdrsize;
}

static struct {
        Lock;
        ushort id;
} id;

static ushort
nextdgramid(void)
{
        ushort v;
        lock(&id);
        v = id.id++;
        unlock(&id);
        return v;
}

int
nbdgramsend(NbDgramSendParameters *p, uchar *data, long datalen)
{
        NbDgram s;
        uchar dstip[IPaddrlen];
        s.type = p->type;
        switch (p->type) {
        case NbDgramBroadcast:
        case NbDgramDirectGroup:
                ipmove(dstip, nbglobals.bcastaddr);
                break;
        case NbDgramDirectUnique:
                if (!nbnameresolve(p->to, dstip)) {
                        werrstr("nbdgramsend: name resolution failed");
                        return 0;
                }
                break;
        default:
                werrstr("nbdgramsend: illegal datagram type");
                return 0;
        }
        s.flags = NbDgramFirst;
        s.id = nextdgramid();
        ipmove(s.srcip, nbglobals.myipaddr);
        s.srcport = NbDgramPort;
        s.datagram.offset = 0;
        s.datagram.data = data;
        s.datagram.length = datalen;
        nbnamecpy(s.datagram.dstname, p->to);
        nbnamecpy(s.datagram.srcname, nbglobals.myname);
        return nbdgramsendto(dstip, NbDgramPort, &s);
}