ref: 6d69f6fba35087686f79adb2ea0d67944a62ca7b
dir: /appl/lib/dhcpclient.b/
implement Dhcpclient;
#
# DHCP and BOOTP clients
# Copyright © 2004-2006 Vita Nuova Holdings Limited
#
include "sys.m";
sys: Sys;
include "ip.m";
ip: IP;
IPv4off, IPaddrlen, Udphdrlen, Udpraddr, Udpladdr, Udprport, Udplport: import IP;
IPaddr: import ip;
get2, get4, put2, put4: import ip;
include "keyring.m";
include "security.m"; # for Random
include "dial.m";
dial: Dial;
include "dhcpclient.m";
debug := 0;
xidgen: int;
init()
{
sys = load Sys Sys->PATH;
random := load Random Random->PATH;
if(random != nil)
xidgen = random->randomint(Random->NotQuiteRandom);
else
xidgen = sys->pctl(0, nil)*sys->millisec();
random = nil;
dial = load Dial Dial->PATH;
ip = load IP IP->PATH;
ip->init();
}
tracing(d: int)
{
debug = d;
}
Bootconf.new(): ref Bootconf
{
bc := ref Bootconf;
bc.lease = 0;
bc.options = array[256] of array of byte;
return bc;
}
Bootconf.get(c: self ref Bootconf, n: int): array of byte
{
a := c.options;
if(n & Ovendor){
a = c.vendor;
n &= ~Ovendor;
}
if(n < 0 || n >= len a)
return nil;
return a[n];
}
Bootconf.getint(c: self ref Bootconf, n: int): int
{
a := c.get(n);
v := 0;
for(i := 0; i < len a; i++)
v = (v<<8) | int a[i];
return v;
}
Bootconf.getip(c: self ref Bootconf, n: int): string
{
l := c.getips(n);
if(l == nil)
return nil;
return hd l;
}
Bootconf.getips(c: self ref Bootconf, n: int): list of string
{
a := c.get(n);
rl: list of string;
while(len a >= 4){
rl = v4text(a) :: rl;
a = a[4:];
}
l: list of string;
for(; rl != nil; rl = tl rl)
l = hd rl :: l;
return l;
}
Bootconf.gets(c: self ref Bootconf, n: int): string
{
a := c.get(n);
if(a == nil)
return nil;
for(i:=0; i<len a; i++)
if(a[i] == byte 0)
break;
return string a[0:i];
}
Bootconf.put(c: self ref Bootconf, n: int, a: array of byte)
{
if(n < 0 || n >= len c.options)
return;
ca := array[len a] of byte;
ca[0:] = a;
c.options[n] = ca;
}
Bootconf.putint(c: self ref Bootconf, n: int, v: int)
{
if(n < 0 || n >= len c.options)
return;
a := array[4] of byte;
put4(a, 0, v);
c.options[n] = a;
}
Bootconf.putips(c: self ref Bootconf, n: int, ips: list of string)
{
if(n < 0 || n >= len c.options)
return;
na := len ips;
a := array[na*4] of byte;
na = 0;
for(; ips != nil; ips = tl ips){
(nil, ipa) := IPaddr.parse(hd ips);
a[na++:] = ipa.v4();
}
c.options[n] = a;
}
Bootconf.puts(c: self ref Bootconf, n: int, s: string)
{
if(n < 0 || n >= len c.options)
return;
c.options[n] = array of byte s;
}
#
#
# DHCP
#
#
# BOOTP operations
Bootprequest, Bootpreply: con 1+iota;
# DHCP operations
NotDHCP, Discover, Offer, Request, Decline, Ack, Nak, Release, Inform: con iota;
Dhcp: adt {
udphdr: array of byte;
op: int;
htype: int;
hops: int;
xid: int;
secs: int;
flags: int;
ciaddr: IPaddr;
yiaddr: IPaddr;
siaddr: IPaddr;
giaddr: IPaddr;
chaddr: array of byte;
sname: string;
file: string;
options: list of (int, array of byte);
dhcpop: int;
};
opnames := array[] of {
Discover => "Discover",
Offer => "Offer",
Request => "Request",
Decline => "Decline",
Ack => "Ack",
Nak => "Nak",
Release => "Release",
Inform => "Inform"
};
opname(op: int): string
{
if(op >= 0 && op < len opnames)
return opnames[op];
return sys->sprint("OP%d", op);
}
stringget(buf: array of byte): string
{
for(x := 0; x < len buf; x++)
if(buf[x] == byte 0)
break;
if(x == 0)
return nil;
return string buf[0 : x];
}
eqbytes(b1: array of byte, b2: array of byte): int
{
l := len b1;
if(l != len b2)
return 0;
for(i := 0; i < l; i++)
if(b1[i] != b2[i])
return 0;
return 1;
}
magic := array[] of {byte 99, byte 130, byte 83, byte 99}; # RFC2132 (replacing RFC1048)
dhcpsend(fd: ref Sys->FD, xid: int, dhcp: ref Dhcp)
{
dhcp.xid = xid;
abuf := array[576+Udphdrlen] of {* => byte 0};
abuf[0:] = dhcp.udphdr;
buf := abuf[Udphdrlen:];
buf[0] = byte dhcp.op;
buf[1] = byte dhcp.htype;
buf[2] = byte len dhcp.chaddr;
buf[3] = byte dhcp.hops;
put4(buf, 4, xid);
put2(buf, 8, dhcp.secs);
put2(buf, 10, dhcp.flags);
buf[12:] = dhcp.ciaddr.v4();
buf[16:] = dhcp.yiaddr.v4();
buf[20:] = dhcp.siaddr.v4();
buf[24:] = dhcp.giaddr.v4();
buf[28:] = dhcp.chaddr;
buf[44:] = array of byte dhcp.sname; # [64]
buf[108:] = array of byte dhcp.file; # [128]
o := 236;
# RFC1542 suggests including magic and Oend as a minimum, even in BOOTP
buf[o:] = magic;
o += 4;
if(dhcp.dhcpop != NotDHCP){
buf[o++] = byte Otype;
buf[o++] = byte 1;
buf[o++] = byte dhcp.dhcpop;
}
for(ol := dhcp.options; ol != nil; ol = tl ol){
(opt, val) := hd ol;
buf[o++] = byte opt;
buf[o++] = byte len val;
if(len val > 0){
buf[o:] = val;
o += len val;
}
}
buf[o++] = byte Oend;
if(debug)
dumpdhcp(dhcp, "->");
sys->write(fd, abuf, len abuf);
}
kill(pid: int, grp: string)
{
fd := sys->open("#p/" + string pid + "/ctl", sys->OWRITE);
if(fd != nil)
sys->fprint(fd, "kill%s", grp);
}
v4text(a: array of byte): string
{
return sys->sprint("%ud.%ud.%ud.%ud", int a[0], int a[1], int a[2], int a[3]);
}
parseopt(a: array of byte, isdhcp: int): (int, list of (int, array of byte))
{
opts: list of (int, array of byte);
xop := NotDHCP;
for(i := 0; i < len a;){
op := int a[i++];
if(op == Opad)
continue;
if(op == Oend || i >= len a)
break;
l := int a[i++];
if(i+l > len a)
break;
if(isdhcp && op == Otype)
xop = int a[i];
else
opts = (op, a[i:i+l]) :: opts;
i += l;
}
rl := opts;
opts = nil;
for(; rl != nil; rl = tl rl)
opts = hd rl :: opts;
return (xop, opts);
}
dhcpreader(pidc: chan of int, srv: ref DhcpIO)
{
pidc <-= sys->pctl(0, nil);
for(;;){
abuf := array [576+Udphdrlen] of byte;
n := sys->read(srv.fd, abuf, len abuf);
if(n < 0){
if(debug)
sys->print("read error: %r\n");
sys->sleep(1000);
continue;
}
if(n < Udphdrlen+236){
if(debug)
sys->print("short read: %d\n", n);
continue;
}
buf := abuf[Udphdrlen:n];
n -= Udphdrlen;
dhcp := ref Dhcp;
dhcp.op = int buf[0];
if(dhcp.op != Bootpreply){
if(debug)
sys->print("bootp: not reply, discarded\n");
continue;
}
dhcp.dhcpop = NotDHCP;
if(n >= 240 && eqbytes(buf[236:240], magic)) # otherwise it's something we won't understand
(dhcp.dhcpop, dhcp.options) = parseopt(buf[240:n], 1);
case dhcp.dhcpop {
NotDHCP or Ack or Nak or Offer =>
;
* =>
if(debug)
sys->print("dhcp: ignore dhcp op %d\n", dhcp.dhcpop);
continue;
}
dhcp.udphdr = abuf[0:Udphdrlen];
dhcp.htype = int buf[1];
hlen := int buf[2];
dhcp.hops = int buf[3];
dhcp.xid = get4(buf, 4);
dhcp.secs = get2(buf, 8);
dhcp.flags = get2(buf, 10);
dhcp.ciaddr = IPaddr.newv4(buf[12:]);
dhcp.yiaddr = IPaddr.newv4(buf[16:]);
dhcp.siaddr = IPaddr.newv4(buf[20:]);
dhcp.giaddr = IPaddr.newv4(buf[24:]);
dhcp.chaddr = buf[28 : 28 + hlen];
dhcp.sname = stringget(buf[44 : 108]);
dhcp.file = stringget(buf[108 : 236]);
srv.dc <-= dhcp;
}
}
timeoutstart(msecs: int): (int, chan of int)
{
tc := chan of int;
spawn timeoutproc(tc, msecs);
return (<-tc, tc);
}
timeoutproc(c: chan of int, msecs: int)
{
c <-= sys->pctl(0, nil);
sys->sleep(msecs);
c <-= 1;
}
hex(b: int): int
{
if(b >= '0' && b <= '9')
return b-'0';
if(b >= 'A' && b <= 'F')
return b-'A' + 10;
if(b >= 'a' && b <= 'f')
return b-'a' + 10;
return -1;
}
gethaddr(device: string): (int, string, array of byte)
{
fd := sys->open(device, Sys->OREAD);
if(fd == nil)
return (-1, sys->sprint("%r"), nil);
buf := array [100] of byte;
n := sys->read(fd, buf, len buf);
if(n < 0)
return (-1, sys->sprint("%r"), nil);
if(n == 0)
return (-1, "empty address file", nil);
addr := array [n/2] of byte;
for(i := 0; i < len addr; i++){
u := hex(int buf[2*i]);
l := hex(int buf[2*i+1]);
if(u < 0 || l < 0)
return (-1, "bad address syntax", nil);
addr[i] = byte ((u<<4)|l);
}
return (1, nil, addr);
}
newrequest(dest: IPaddr, bootfile: string, htype: int, haddr: array of byte, ipaddr: IPaddr, options: array of array of byte): ref Dhcp
{
dhcp := ref Dhcp;
dhcp.op = Bootprequest;
hdr := array[Udphdrlen] of {* => byte 0};
hdr[Udpraddr:] = dest.v6();
put2(hdr, Udprport, 67);
dhcp.udphdr = hdr;
dhcp.htype = htype;
dhcp.chaddr = haddr;
dhcp.hops = 0;
dhcp.secs = 0;
dhcp.flags = 0;
dhcp.xid = 0;
dhcp.ciaddr = ipaddr;
dhcp.yiaddr = ip->v4noaddr;
dhcp.siaddr = ip->v4noaddr;
dhcp.giaddr = ip->v4noaddr;
dhcp.file = bootfile;
dhcp.dhcpop = NotDHCP;
if(options != nil){
for(i := 0; i < len options; i++)
if(options[i] != nil)
dhcp.options = (i, options[i]) :: dhcp.options;
}
clientid := array[len haddr + 1] of byte;
clientid[0] = byte htype;
clientid[1:] = haddr;
dhcp.options = (Oclientid, clientid) :: dhcp.options;
dhcp.options = (Ovendorclass, array of byte "plan9_386") :: dhcp.options; # 386 will do because type doesn't matter
return dhcp;
}
udpannounce(net: string): (ref Sys->FD, string)
{
if(net == nil)
net = "/net";
conn := dial->announce(net+"/udp!*!68");
if(conn == nil)
return (nil, sys->sprint("can't announce dhcp port: %r"));
if(sys->fprint(conn.cfd, "headers") < 0)
return (nil, sys->sprint("can't set headers mode on dhcp port: %r"));
conn.dfd = sys->open(conn.dir+"/data", Sys->ORDWR);
if(conn.dfd == nil)
return (nil, sys->sprint("can't open %s: %r", conn.dir+"/data"));
return (conn.dfd, nil);
}
ifcnoaddr(fd: ref Sys->FD, s: string)
{
if(fd != nil && sys->fprint(fd, "%s %s %s", s, (ip->noaddr).text(), (ip->noaddr).text()) < 0){
if(debug)
sys->print("dhcp: ctl %s: %r\n", s);
}
}
setup(net: string, device: string, init: ref Bootconf): (ref Dhcp, ref DhcpIO, string)
{
(htype, err, mac) := gethaddr(device);
if(htype < 0)
return (nil, nil, sys->sprint("can't get hardware MAC address: %s", err));
ciaddr := ip->v4noaddr;
if(init != nil && init.ip != nil){
valid: int;
(valid, ciaddr) = IPaddr.parse(init.ip);
if(valid < 0)
return (nil, nil, sys->sprint("invalid ip address: %s", init.ip));
}
(dfd, err2) := udpannounce(net);
if(err2 != nil)
return (nil, nil, err);
bootfile: string;
options: array of array of byte;
if(init != nil){
bootfile = init.bootf;
options = init.options;
}
return (newrequest(ip->v4bcast, bootfile, htype, mac, ciaddr, options), DhcpIO.new(dfd), nil);
}
#
# BOOTP (RFC951) is used by Inferno only during net boots, to get initial IP address and TFTP address and parameters
#
bootp(net: string, ctlifc: ref Sys->FD, device: string, init: ref Bootconf): (ref Bootconf, string)
{
(req, srv, err) := setup(net, device, init);
if(err != nil)
return (nil, err);
ifcnoaddr(ctlifc, "add");
rdhcp := exchange(srv, ++xidgen, req, 1<<NotDHCP);
srv.rstop();
ifcnoaddr(ctlifc, "remove");
if(rdhcp == nil)
return (nil, "no response to BOOTP request");
return (fillbootconf(init, rdhcp), nil);
}
defparams := array[] of {
byte Omask, byte Orouter, byte Odnsserver, byte Ohostname, byte Odomainname, byte Ontpserver,
};
#
# DHCP (RFC2131)
#
dhcp(net: string, ctlifc: ref Sys->FD, device: string, init: ref Bootconf, needparam: array of int): (ref Bootconf, ref Lease, string)
{
(req, srv, err) := setup(net, device, init);
if(err != nil)
return (nil, nil, err);
params := defparams;
if(needparam != nil){
n := len defparams;
params = array[n+len needparam] of byte;
params[0:] = defparams;
for(i := 0; i < len needparam; i++)
params[n+i] = byte needparam[i];
}
initopt := (Oparams, params) :: req.options; # RFC2131 requires parameters to be repeated each time
lease := ref Lease(0, chan[1] of (ref Bootconf, string));
spawn dhcp1(srv, lease, net, ctlifc, req, init, initopt);
bc: ref Bootconf;
(bc, err) = <-lease.configs;
return (bc, lease, err);
}
dhcp1(srv: ref DhcpIO, lease: ref Lease, net: string, ctlifc: ref Sys->FD, req: ref Dhcp, init: ref Bootconf, initopt: list of (int, array of byte))
{
cfd := -1;
if(ctlifc != nil)
cfd = ctlifc.fd;
lease.pid = sys->pctl(Sys->NEWPGRP|Sys->NEWFD, 1 :: srv.fd.fd :: cfd :: nil);
if(ctlifc != nil)
ctlifc = sys->fildes(ctlifc.fd);
srv.fd = sys->fildes(srv.fd.fd);
rep: ref Dhcp;
ifcnoaddr(ctlifc, "add");
if(req.ciaddr.isvalid())
rep = reacquire(srv, req, initopt, req.ciaddr);
if(rep == nil)
rep = askround(srv, req, initopt);
srv.rstop();
ifcnoaddr(ctlifc, "remove");
if(rep == nil){
lease.pid = 0;
lease.configs <-= (nil, "no response");
exit;
}
for(;;){
conf := fillbootconf(init, rep);
applycfg(net, ctlifc, conf);
if(conf.lease == 0){
srv.rstop();
lease.pid = 0;
flush(lease.configs);
lease.configs <-= (conf, nil);
exit;
}
flush(lease.configs);
lease.configs <-= (conf, nil);
req.ciaddr = rep.yiaddr;
while((rep = tenancy(srv, req, conf.lease)) != nil){
if(rep.dhcpop == Nak || !rep.ciaddr.eq(req.ciaddr))
break;
req.udphdr[Udpraddr:] = rep.udphdr[Udpraddr:Udpraddr+IPaddrlen];
conf = fillbootconf(init, rep);
}
removecfg(net, ctlifc, conf);
ifcnoaddr(ctlifc, "add");
while((rep = askround(srv, req, initopt)) == nil){
flush(lease.configs);
lease.configs <-= (nil, "no response");
srv.rstop();
sys->sleep(60*1000);
}
ifcnoaddr(ctlifc, "remove");
}
}
reacquire(srv: ref DhcpIO, req: ref Dhcp, initopt: list of (int, array of byte), addr: IPaddr): ref Dhcp
{
# INIT-REBOOT: know an address; try requesting it (once)
# TO DO: could use Inform when our address is static but we need a few service parameters
req.ciaddr = ip->v4noaddr;
rep := request(srv, ++xidgen, req, (Oipaddr, addr.v4()) :: initopt);
if(rep != nil && rep.dhcpop == Ack && addr.eq(rep.yiaddr)){
if(debug)
sys->print("req: server accepted\n");
req.udphdr[Udpraddr:] = rep.udphdr[Udpraddr:Udpraddr+IPaddrlen];
return rep;
}
if(debug)
sys->print("req: cannot reclaim\n");
return nil;
}
askround(srv: ref DhcpIO, req: ref Dhcp, initopt: list of (int, array of byte)): ref Dhcp
{
# INIT
req.ciaddr = ip->v4noaddr;
req.udphdr[Udpraddr:] = (ip->v4bcast).v6();
for(retries := 0; retries < 5; retries++){
# SELECTING
req.dhcpop = Discover;
req.options = initopt;
rep := exchange(srv, ++xidgen, req, 1<<Offer);
if(rep == nil)
break;
#
# could wait a little while and accumulate offers, but is it sensible?
# we do sometimes see arguments between DHCP servers that could
# only be resolved by user choice
#
if(!rep.yiaddr.isvalid())
continue; # server has no idea either
serverid := getopt(rep.options, Oserverid, 4);
if(serverid == nil)
continue; # broken server
# REQUESTING
options := (Oserverid, serverid) :: (Oipaddr, rep.yiaddr.v4()) :: initopt;
lease := getlease(rep);
if(lease != nil)
options = (Olease, lease) :: options;
rep = request(srv, rep.xid, req, options);
if(rep != nil){
# could probe with ARP here, and if found, Decline
if(debug)
sys->print("req: server accepted\n");
req.udphdr[Udpraddr:] = rep.udphdr[Udpraddr:Udpraddr+IPaddrlen];
return rep;
}
}
return nil;
}
request(srv: ref DhcpIO, xid: int, req: ref Dhcp, options: list of (int, array of byte)): ref Dhcp
{
req.dhcpop = Request; # Selecting
req.options = options;
rep := exchange(srv, xid, req, (1<<Ack)|(1<<Nak));
if(rep == nil || rep.dhcpop == Nak)
return nil;
return rep;
}
# renew
# direct to server from T1 to T2 [RENEW]
# Request must not include
# requested IP address, server identifier
# Request must include
# ciaddr set to client's address
# Request might include
# lease time
# similar, but broadcast, from T2 to T3 [REBIND]
# at T3, unbind, restart Discover
tenancy(srv: ref DhcpIO, req: ref Dhcp, leasesec: int): ref Dhcp
{
# configure address...
t3 := big leasesec * big 1000; # lease expires; restart
t2 := (big 3 * t3)/big 4; # broadcast renewal request at ¾time
t1 := t2/big 2; # renew lease with original server at ½time
srv.rstop();
thebigsleep(t1);
# RENEW
rep := renewing(srv, req, t1, t2);
if(rep != nil)
return rep;
# REBIND
req.udphdr[Udpraddr:] = (ip->v4bcast).v6(); # now try broadcast
return renewing(srv, req, t2, t3);
}
renewing(srv: ref DhcpIO, req: ref Dhcp, a: big, b: big): ref Dhcp
{
Minute: con big(60*1000);
while(a < b){
rep := exchange(srv, req.xid, req, (1<<Ack)|(1<<Nak));
if(rep != nil)
return rep;
delta := (b-a)/big 2;
if(delta < Minute)
delta = Minute;
thebigsleep(delta);
a += delta;
}
return nil;
}
thebigsleep(msec: big)
{
Day: con big (24*3600*1000); # 1 day in msec
while(msec > big 0){
n := msec;
if(n > Day)
n = Day;
sys->sleep(int n);
msec -= n;
}
}
getlease(m: ref Dhcp): array of byte
{
lease := getopt(m.options, Olease, 4);
if(lease == nil)
return nil;
if(get4(lease, 0) == 0){
lease = array[4] of byte;
put4(lease, 0, 15*60);
}
return lease;
}
fillbootconf(init: ref Bootconf, pkt: ref Dhcp): ref Bootconf
{
bc := ref Bootconf;
if(init != nil)
*bc = *init;
if(bc.options == nil)
bc.options = array[256] of array of byte;
for(l := pkt.options; l != nil; l = tl l){
(c, v) := hd l;
if(bc.options[c] == nil)
bc.options[c] = v; # give priority to first occurring
}
if((a := bc.get(Ovendorinfo)) != nil){
if(bc.vendor == nil)
bc.vendor = array[256] of array of byte;
for(l = parseopt(a, 0).t1; l != nil; l = tl l){
(c, v) := hd l;
if(bc.vendor[c] == nil)
bc.vendor[c] = v;
}
}
if(pkt.yiaddr.isvalid()){
bc.ip = pkt.yiaddr.text();
bc.ipmask = bc.getip(Omask);
if(bc.ipmask == nil)
bc.ipmask = pkt.yiaddr.classmask().masktext();
}
bc.bootf = pkt.file;
bc.dhcpip = IPaddr.newv6(pkt.udphdr[Udpraddr:]).text();
bc.siaddr = pkt.siaddr.text();
bc.lease = bc.getint(Olease);
if(bc.lease == Infinite)
bc.lease = 0;
else if(debug > 1)
bc.lease = 2*60; # shorten time, for testing
bc.dom = bc.gets(Odomainname);
s := bc.gets(Ohostname);
for(i:=0; i<len s; i++)
if(s[i] == '.'){
if(bc.dom == nil)
bc.dom = s[i+1:];
s = s[0:i];
break;
}
bc.sys = s;
bc.ipgw = bc.getip(Orouter);
bc.bootip = bc.getip(Otftpserver);
bc.serverid = bc.getip(Oserverid);
return bc;
}
Lease.release(l: self ref Lease)
{
# could send a Release message
# should unconfigure
if(l.pid){
kill(l.pid, "grp");
l.pid = 0;
}
}
flush(c: chan of (ref Bootconf, string))
{
alt{
<-c => ;
* => ;
}
}
DhcpIO: adt {
fd: ref Sys->FD;
pid: int;
dc: chan of ref Dhcp;
new: fn(fd: ref Sys->FD): ref DhcpIO;
rstart: fn(io: self ref DhcpIO);
rstop: fn(io: self ref DhcpIO);
};
DhcpIO.new(fd: ref Sys->FD): ref DhcpIO
{
return ref DhcpIO(fd, 0, chan of ref Dhcp);
}
DhcpIO.rstart(io: self ref DhcpIO)
{
if(io.pid == 0){
pids := chan of int;
spawn dhcpreader(pids, io);
io.pid = <-pids;
}
}
DhcpIO.rstop(io: self ref DhcpIO)
{
if(io.pid != 0){
kill(io.pid, "");
io.pid = 0;
}
}
getopt(options: list of (int, array of byte), op: int, minlen: int): array of byte
{
for(; options != nil; options = tl options){
(opt, val) := hd options;
if(opt == op && len val >= minlen)
return val;
}
return nil;
}
exchange(srv: ref DhcpIO, xid: int, req: ref Dhcp, accept: int): ref Dhcp
{
srv.rstart();
nsec := 3;
for(count := 0; count < 5; count++) {
(tpid, tc) := timeoutstart(nsec*1000);
dhcpsend(srv.fd, xid, req);
Wait:
for(;;){
alt {
<-tc=>
break Wait;
rep := <-srv.dc=>
if(debug)
dumpdhcp(rep, "<-");
if(rep.op == Bootpreply &&
rep.xid == req.xid &&
rep.ciaddr.eq(req.ciaddr) &&
eqbytes(rep.chaddr, req.chaddr)){
if((accept & (1<<rep.dhcpop)) == 0){
if(debug)
sys->print("req: unexpected reply %s to %s\n", opname(rep.dhcpop), opname(req.dhcpop));
continue;
}
kill(tpid, "");
return rep;
}
if(debug)
sys->print("req: mismatch\n");
}
}
req.secs += nsec;
nsec++;
}
return nil;
}
applycfg(net: string, ctlfd: ref Sys->FD, bc: ref Bootconf): string
{
# write addresses to /net/...
# local address, mask[or default], remote address [mtu]
if(net == nil)
net = "/net";
if(bc.ip == nil)
return "invalid address";
if(ctlfd != nil){
if(sys->fprint(ctlfd, "add %s %s", bc.ip, bc.ipmask) < 0) # TO DO: [raddr [mtu]]
return sys->sprint("add interface: %r");
# could use "mtu n" request to set/change mtu
}
# if primary:
# add default route if gateway valid
# put ndb entries ip=, ipmask=, ipgw=; sys= dom=; fs=; auth=; dns=; ntp=; other options from bc.options
if(bc.ipgw != nil){
fd := sys->open(net+"/iproute", Sys->OWRITE);
if(fd != nil)
sys->fprint(fd, "add 0 0 %s", bc.ipgw);
}
s := sys->sprint("ip=%s ipmask=%s", bc.ip, bc.ipmask);
if(bc.ipgw != nil)
s += sys->sprint(" ipgw=%s", bc.ipgw);
s += "\n";
if(bc.sys != nil)
s += sys->sprint(" sys=%s\n", bc.sys);
if(bc.dom != nil)
s += sys->sprint(" dom=%s.%s\n", bc.sys, bc.dom);
if((addr := bc.getip(OP9auth)) != nil)
s += sys->sprint(" auth=%s\n", addr); # TO DO: several addresses
if((addr = bc.getip(OP9fs)) != nil)
s += sys->sprint(" fs=%s\n", addr);
if((addr = bc.getip(Odnsserver)) != nil)
s += sys->sprint(" dns=%s\n", addr);
fd := sys->open(net+"/ndb", Sys->OWRITE | Sys->OTRUNC);
if(fd != nil){
a := array of byte s;
sys->write(fd, a, len a);
}
return nil;
}
removecfg(nil: string, ctlfd: ref Sys->FD, bc: ref Bootconf): string
{
# remove localaddr, localmask[or default]
if(ctlfd != nil){
if(sys->fprint(ctlfd, "remove %s %s", bc.ip, bc.ipmask) < 0)
return sys->sprint("remove address: %r");
}
bc.ip = nil;
bc.ipgw = nil;
bc.ipmask = nil;
# remote address?
# clear net+"/ndb"?
return nil;
}
#
# the following is just for debugging
#
dumpdhcp(m: ref Dhcp, dir: string)
{
s := "";
sys->print("%s %s/%ud: ", dir, IPaddr.newv6(m.udphdr[Udpraddr:]).text(), get2(m.udphdr, Udprport));
if(m.dhcpop != NotDHCP)
s = " "+opname(m.dhcpop);
sys->print("op %d%s htype %d hops %d xid %ud\n", m.op, s, m.htype, m.hops, m.xid);
sys->print("\tsecs %d flags 0x%.4ux\n", m.secs, m.flags);
sys->print("\tciaddr %s\n", m.ciaddr.text());
sys->print("\tyiaddr %s\n", m.yiaddr.text());
sys->print("\tsiaddr %s\n", m.siaddr.text());
sys->print("\tgiaddr %s\n", m.giaddr.text());
sys->print("\tchaddr ");
for(x := 0; x < len m.chaddr; x++)
sys->print("%2.2ux", int m.chaddr[x]);
sys->print("\n");
if(m.sname != nil)
sys->print("\tsname %s\n", m.sname);
if(m.file != nil)
sys->print("\tfile %s\n", m.file);
if(m.options != nil){
sys->print("\t");
printopts(m.options, opts);
sys->print("\n");
}
}
Optbytes, Optaddr, Optmask, Optint, Optstr, Optopts, Opthex: con iota;
Opt: adt
{
code: int;
name: string;
otype: int;
};
opts: array of Opt = array[] of {
(Omask, "ipmask", Optmask),
(Orouter, "ipgw", Optaddr),
(Odnsserver, "dns", Optaddr),
(Ohostname, "hostname", Optstr),
(Odomainname, "domain", Optstr),
(Ontpserver, "ntp", Optaddr),
(Oipaddr, "requestedip", Optaddr),
(Olease, "lease", Optint),
(Oserverid, "serverid", Optaddr),
(Otype, "dhcpop", Optint),
(Ovendorclass, "vendorclass", Optstr),
(Ovendorinfo, "vendorinfo", Optopts),
(Onetbiosns, "wins", Optaddr),
(Opop3server, "pop3", Optaddr),
(Osmtpserver, "smtp", Optaddr),
(Owwwserver, "www", Optaddr),
(Oparams, "params", Optbytes),
(Otftpserver, "tftp", Optaddr),
(Oclientid, "clientid", Opthex),
};
p9opts: array of Opt = array[] of {
(OP9fs, "fs", Optaddr),
(OP9auth, "auth", Optaddr),
};
lookopt(optab: array of Opt, code: int): (int, string, int)
{
for(i:=0; i<len optab; i++)
if(opts[i].code == code)
return opts[i];
return (-1, nil, 0);
}
printopts(options: list of (int, array of byte), opts: array of Opt)
{
for(; options != nil; options = tl options){
(code, val) := hd options;
sys->print("(%d %d", code, len val);
(nil, name, otype) := lookopt(opts, code);
if(name == nil){
for(v := 0; v < len val; v++)
sys->print(" %d", int val[v]);
}else{
sys->print(" %s", name);
case otype {
Optbytes =>
for(v := 0; v < len val; v++)
sys->print(" %d", int val[v]);
Opthex =>
for(v := 0; v < len val; v++)
sys->print(" %#.2ux", int val[v]);
Optaddr or Optmask =>
while(len val >= 4){
sys->print(" %s", v4text(val));
val = val[4:];
}
Optstr =>
sys->print(" \"%s\"", string val);
Optint =>
n := 0;
for(v := 0; v < len val; v++)
n = (n<<8) | int val[v];
sys->print(" %d", n);
Optopts =>
printopts(parseopt(val, 0).t1, p9opts);
}
}
sys->print(")");
}
}