ref: fc4bfd57d261e5c99c5d4367adf5c72e8c7e6496
dir: /sys/src/cmd/ip/dhcpclient.c/
#include <u.h> #include <libc.h> #include <ip.h> #include "dhcp.h" void bootpdump(uchar *p, int n); void dhcpinit(void); void dhcprecv(void); void dhcpsend(int); void myfatal(char *fmt, ...); int openlisten(char*); uchar *optaddaddr(uchar*, int, uchar*); uchar *optaddbyte(uchar*, int, int); uchar *optadd(uchar*, int, void*, int); uchar *optaddulong(uchar*, int, ulong); uchar *optget(Bootp*, int, int); int optgetaddr(Bootp*, int, uchar*); int optgetbyte(Bootp*, int); ulong optgetulong(Bootp*, int); Bootp *parse(uchar*, int); void stdinthread(void*); ulong thread(void(*f)(void*), void *a); void timerthread(void*); void usage(void); struct { QLock lk; int state; int fd; ulong xid; ulong starttime; char cid[100]; char sname[64]; uchar server[IPaddrlen]; /* server IP address */ uchar client[IPaddrlen]; /* client IP address */ uchar mask[IPaddrlen]; /* client mask */ ulong lease; /* lease time */ ulong resend; /* number of resends for current state */ ulong timeout; /* time to timeout - seconds */ } dhcp; char net[64]; char optmagic[4] = { 0x63, 0x82, 0x53, 0x63 }; void main(int argc, char *argv[]) { char *p; setnetmtpt(net, sizeof(net), nil); ARGBEGIN{ case 'x': p = ARGF(); if(p == nil) usage(); setnetmtpt(net, sizeof(net), p); }ARGEND; fmtinstall('E', eipfmt); fmtinstall('I', eipfmt); fmtinstall('V', eipfmt); dhcpinit(); rfork(RFNOTEG|RFREND); thread(timerthread, 0); thread(stdinthread, 0); qlock(&dhcp.lk); dhcp.starttime = time(0); dhcp.fd = openlisten(net); dhcpsend(Discover); dhcp.state = Sselecting; dhcp.resend = 0; dhcp.timeout = 4; while(dhcp.state != Sbound) dhcprecv(); /* allows other clients on this machine */ close(dhcp.fd); dhcp.fd = -1; print("ip=%I\n", dhcp.client); print("mask=%I\n", dhcp.mask); print("end\n"); /* keep lease alive */ for(;;) { //fprint(2, "got lease for %d\n", dhcp.lease); qunlock(&dhcp.lk); sleep(dhcp.lease*500); /* wait half of lease time */ qlock(&dhcp.lk); //fprint(2, "try renue\n", dhcp.lease); dhcp.starttime = time(0); dhcp.fd = openlisten(net); dhcp.xid = time(0)*getpid(); dhcpsend(Request); dhcp.state = Srenewing; dhcp.resend = 0; dhcp.timeout = 1; while(dhcp.state != Sbound) dhcprecv(); /* allows other clients on this machine */ close(dhcp.fd); dhcp.fd = -1; } } void usage(void) { fprint(2, "usage: %s [-x netextension]\n", argv0); exits("usage"); } void timerthread(void*) { for(;;) { sleep(1000); qlock(&dhcp.lk); if(--dhcp.timeout > 0) { qunlock(&dhcp.lk); continue; } switch(dhcp.state) { default: myfatal("timerthread: unknown state %d", dhcp.state); case Sinit: break; case Sselecting: dhcpsend(Discover); dhcp.timeout = 4; dhcp.resend++; if(dhcp.resend>5) myfatal("dhcp: giving up: selecting"); break; case Srequesting: dhcpsend(Request); dhcp.timeout = 4; dhcp.resend++; if(dhcp.resend>5) myfatal("dhcp: giving up: requesting"); break; case Srenewing: dhcpsend(Request); dhcp.timeout = 1; dhcp.resend++; if(dhcp.resend>3) { dhcp.state = Srebinding; dhcp.resend = 0; } break; case Srebinding: dhcpsend(Request); dhcp.timeout = 4; dhcp.resend++; if(dhcp.resend>5) myfatal("dhcp: giving up: rebinding"); break; case Sbound: break; } qunlock(&dhcp.lk); } } void stdinthread(void*) { uchar buf[100]; int n; for(;;) { n = read(0, buf, sizeof(buf)); if(n <= 0) break; } /* shutdown cleanly */ qlock(&dhcp.lk); if(dhcp.client) { if(dhcp.fd < 0) dhcp.fd = openlisten(net); dhcpsend(Release); } qunlock(&dhcp.lk); postnote(PNGROUP, getpid(), "die"); exits(0); } void dhcpinit(void) { int fd; dhcp.state = Sinit; dhcp.timeout = 4; fd = open("/dev/random", 0); if(fd >= 0) { read(fd, &dhcp.xid, sizeof(dhcp.xid)); close(fd); } else dhcp.xid = time(0)*getpid(); srand(dhcp.xid); sprint(dhcp.cid, "%s.%d", getenv("sysname"), getpid()); } void dhcpsend(int type) { int n; uchar *p; Bootp bp; Udphdr *up; memset(&bp, 0, sizeof bp); up = (Udphdr*)bp.udphdr; hnputs(up->rport, 67); bp.op = Bootrequest; hnputl(bp.xid, dhcp.xid); hnputs(bp.secs, time(0) - dhcp.starttime); hnputs(bp.flags, Fbroadcast); /* reply must be broadcast */ memmove(bp.optmagic, optmagic, 4); p = bp.optdata; p = optaddbyte(p, ODtype, type); p = optadd(p, ODclientid, dhcp.cid, strlen(dhcp.cid)); switch(type) { default: myfatal("dhcpsend: unknown message type: %d", type); case Discover: ipmove(up->raddr, IPv4bcast); /* broadcast */ break; case Request: if(dhcp.state == Sbound || dhcp.state == Srenewing) ipmove(up->raddr, dhcp.server); else ipmove(up->raddr, IPv4bcast); /* broadcast */ p = optaddulong(p, ODlease, dhcp.lease); if(dhcp.state == Sselecting || dhcp.state == Srequesting) { p = optaddaddr(p, ODipaddr, dhcp.client); /* mistake?? */ p = optaddaddr(p, ODserverid, dhcp.server); } else v6tov4(bp.ciaddr, dhcp.client); break; case Release: ipmove(up->raddr, dhcp.server); v6tov4(bp.ciaddr, dhcp.client); p = optaddaddr(p, ODipaddr, dhcp.client); p = optaddaddr(p, ODserverid, dhcp.server); break; } *p++ = OBend; n = p - (uchar*)&bp; if(write(dhcp.fd, &bp, n) != n) myfatal("dhcpsend: write failed: %r"); } void dhcprecv(void) { uchar buf[2000]; Bootp *bp; int n, type; ulong lease; uchar mask[IPaddrlen]; qunlock(&dhcp.lk); n = read(dhcp.fd, buf, sizeof(buf)); qlock(&dhcp.lk); if(n <= 0) myfatal("dhcprecv: bad read: %r"); bp = parse(buf, n); if(bp == 0) return; if(1) { fprint(2, "recved\n"); bootpdump(buf, n); } type = optgetbyte(bp, ODtype); switch(type) { default: fprint(2, "dhcprecv: unknown type: %d\n", type); break; case Offer: if(dhcp.state != Sselecting) break; lease = optgetulong(bp, ODlease); if(lease == 0) myfatal("bad lease"); if(!optgetaddr(bp, OBmask, mask)) memset(mask, 0xff, sizeof(mask)); v4tov6(dhcp.client, bp->yiaddr); if(!optgetaddr(bp, ODserverid, dhcp.server)) { fprint(2, "dhcprecv: Offer from server with invalid serverid\n"); break; } dhcp.lease = lease; ipmove(dhcp.mask, mask); memmove(dhcp.sname, bp->sname, sizeof(dhcp.sname)); dhcp.sname[sizeof(dhcp.sname)-1] = 0; dhcpsend(Request); dhcp.state = Srequesting; dhcp.resend = 0; dhcp.timeout = 4; break; case Ack: if(dhcp.state != Srequesting) if(dhcp.state != Srenewing) if(dhcp.state != Srebinding) break; lease = optgetulong(bp, ODlease); if(lease == 0) myfatal("bad lease"); if(!optgetaddr(bp, OBmask, mask)) memset(mask, 0xff, sizeof(mask)); v4tov6(dhcp.client, bp->yiaddr); dhcp.lease = lease; ipmove(dhcp.mask, mask); dhcp.state = Sbound; break; case Nak: myfatal("recved nak"); break; } } int openlisten(char *net) { int n, fd, cfd; char data[128], devdir[40]; // sprint(data, "%s/udp!*!bootpc", net); sprint(data, "%s/udp!*!68", net); for(n = 0; ; n++) { cfd = announce(data, devdir); if(cfd >= 0) break; /* might be another client - wait and try again */ fprint(2, "dhcpclient: can't announce %s: %r", data); sleep(1000); if(n > 10) myfatal("can't announce: giving up: %r"); } if(fprint(cfd, "headers") < 0) myfatal("can't set header mode: %r"); sprint(data, "%s/data", devdir); fd = open(data, ORDWR); if(fd < 0) myfatal("open %s: %r", data); close(cfd); return fd; } uchar* optadd(uchar *p, int op, void *d, int n) { p[0] = op; p[1] = n; memmove(p+2, d, n); return p+n+2; } uchar* optaddbyte(uchar *p, int op, int b) { p[0] = op; p[1] = 1; p[2] = b; return p+3; } uchar* optaddulong(uchar *p, int op, ulong x) { p[0] = op; p[1] = 4; hnputl(p+2, x); return p+6; } uchar * optaddaddr(uchar *p, int op, uchar *ip) { p[0] = op; p[1] = 4; v6tov4(p+2, ip); return p+6; } uchar* optget(Bootp *bp, int op, int n) { int len, code; uchar *p; p = bp->optdata; for(;;) { code = *p++; if(code == OBpad) continue; if(code == OBend) return 0; len = *p++; if(code != op) { p += len; continue; } if(n && n != len) return 0; return p; } } int optgetbyte(Bootp *bp, int op) { uchar *p; p = optget(bp, op, 1); if(p == 0) return 0; return *p; } ulong optgetulong(Bootp *bp, int op) { uchar *p; p = optget(bp, op, 4); if(p == 0) return 0; return nhgetl(p); } int optgetaddr(Bootp *bp, int op, uchar *ip) { uchar *p; p = optget(bp, op, 4); if(p == 0) return 0; v4tov6(ip, p); return 1; } /* make sure packet looks ok */ Bootp * parse(uchar *p, int n) { int len, code; Bootp *bp; bp = (Bootp*)p; if(n < bp->optmagic - p) { fprint(2, "dhcpclient: parse: short bootp packet"); return 0; } if(dhcp.xid != nhgetl(bp->xid)) { fprint(2, "dhcpclient: parse: bad xid: got %ux expected %lux\n", nhgetl(bp->xid), dhcp.xid); return 0; } if(bp->op != Bootreply) { fprint(2, "dhcpclient: parse: bad op\n"); return 0; } n -= bp->optmagic - p; p = bp->optmagic; if(n < 4) { fprint(2, "dhcpclient: parse: not option data"); return 0; } if(memcmp(optmagic, p, 4) != 0) { fprint(2, "dhcpclient: parse: bad opt magic %ux %ux %ux %ux\n", p[0], p[1], p[2], p[3]); return 0; } p += 4; n -= 4; while(n>0) { code = *p++; n--; if(code == OBpad) continue; if(code == OBend) return bp; if(n == 0) { fprint(2, "dhcpclient: parse: bad option: %d", code); return 0; } len = *p++; n--; if(len > n) { fprint(2, "dhcpclient: parse: bad option: %d", code); return 0; } p += len; n -= len; } /* fix up nonstandard packets */ /* assume there is space */ *p = OBend; return bp; } void bootpdump(uchar *p, int n) { int len, i, code; Bootp *bp; Udphdr *up; bp = (Bootp*)p; up = (Udphdr*)bp->udphdr; if(n < bp->optmagic - p) { fprint(2, "dhcpclient: short bootp packet"); return; } fprint(2, "laddr=%I lport=%d raddr=%I rport=%d\n", up->laddr, nhgets(up->lport), up->raddr, nhgets(up->rport)); fprint(2, "op=%d htype=%d hlen=%d hops=%d\n", bp->op, bp->htype, bp->hlen, bp->hops); fprint(2, "xid=%ux secs=%d flags=%ux\n", nhgetl(bp->xid), nhgets(bp->secs), nhgets(bp->flags)); fprint(2, "ciaddr=%V yiaddr=%V siaddr=%V giaddr=%V\n", bp->ciaddr, bp->yiaddr, bp->siaddr, bp->giaddr); fprint(2, "chaddr="); for(i=0; i<16; i++) fprint(2, "%ux ", bp->chaddr[i]); fprint(2, "\n"); fprint(2, "sname=%s\n", bp->sname); fprint(2, "file = %s\n", bp->file); n -= bp->optmagic - p; p = bp->optmagic; if(n < 4) return; if(memcmp(optmagic, p, 4) != 0) fprint(2, "dhcpclient: bad opt magic %ux %ux %ux %ux\n", p[0], p[1], p[2], p[3]); p += 4; n -= 4; while(n>0) { code = *p++; n--; if(code == OBpad) continue; if(code == OBend) break; if(n == 0) { fprint(2, " bad option: %d", code); return; } len = *p++; n--; if(len > n) { fprint(2, " bad option: %d", code); return; } switch(code) { default: fprint(2, "unknown option %d\n", code); for(i = 0; i<len; i++) fprint(2, "%ux ", p[i]); case ODtype: fprint(2, "DHCP type %d\n", p[0]); break; case ODclientid: fprint(2, "client id="); for(i = 0; i<len; i++) fprint(2, "%ux ", p[i]); fprint(2, "\n"); break; case ODlease: fprint(2, "lease=%d\n", nhgetl(p)); break; case ODserverid: fprint(2, "server id=%V\n", p); break; case OBmask: fprint(2, "mask=%V\n", p); break; case OBrouter: fprint(2, "router=%V\n", p); break; } p += len; n -= len; } } ulong thread(void(*f)(void*), void *a) { int pid; pid = rfork(RFNOWAIT|RFMEM|RFPROC); if(pid < 0) myfatal("rfork failed: %r"); if(pid != 0) return pid; (*f)(a); return 0; /* never reaches here */ } void myfatal(char *fmt, ...) { char buf[1024]; va_list arg; va_start(arg, fmt); vseprint(buf, buf+sizeof(buf), fmt, arg); va_end(arg); fprint(2, "%s: %s\n", argv0, buf); postnote(PNGROUP, getpid(), "die"); exits(buf); }