ref: 3efb5bbb4061056e523858b134c555949591efe2
dir: /appl/cmd/ip/nppp/ppplink.b/
implement PPPlink;
#
# Copyright © 2001 Vita Nuova Holdings Limited. All rights reserved.
#
include "sys.m";
sys: Sys;
include "draw.m";
include "arg.m";
include "cfgfile.m";
cfg: CfgFile;
ConfigFile: import cfg;
include "lock.m";
include "modem.m";
include "script.m";
include "sh.m";
include "translate.m";
translate: Translate;
Dict: import translate;
dict: ref Dict;
PPPlink: module
{
init: fn(nil: ref Draw->Context, nil: list of string);
};
PPPInfo: adt {
ipaddr: string;
ipmask: string;
peeraddr: string;
maxmtu: string;
username: string;
password: string;
};
modeminfo: ref Modem->ModemInfo;
context: ref Draw->Context;
pppinfo: ref PPPInfo;
scriptinfo: ref Script->ScriptInfo;
isp_number: string;
lastCdir: ref Sys->Dir; # state of file when last read
netdir := "/net";
Packet: adt {
src: array of byte;
dst: array of byte;
data: array of byte;
};
DEFAULT_ISP_DB_PATH: con "/services/ppp/isp.cfg"; # contains pppinfo & scriptinfo
DEFAULT_MODEM_DB_PATH: con "/services/ppp/modem.cfg"; # contains modeminfo
MODEM_DB_PATH: con "modem.cfg"; # contains modeminfo
ISP_DB_PATH: con "isp.cfg"; # contains pppinfo & scriptinfo
primary := 0;
framing := 1;
Disconnected, Modeminit, Dialling, Modemup, Scriptstart, Scriptdone, Startingppp, Startedppp, Login, Linkup: con iota;
Error: con -1;
Ignorems: con 10*1000; # time to ignore outgoing packets between dial attempts
statustext := array[] of {
Disconnected => "Disconnected",
Modeminit => "Initializing Modem",
Dialling => "Dialling Service Provider",
Modemup => "Logging Into Network",
Scriptstart => "Executing Login Script",
Scriptdone => "Script Execution Complete",
Startingppp => "Logging Into Network",
Startedppp => "Logging Into Network",
Login => "Verifying Password",
Linkup => "Connected",
};
usage()
{
sys->fprint(sys->fildes(2), "usage: ppplink [-P] [-f] [-m mtu] [local [remote]]\n");
raise "fail:usage";
}
init(ctxt: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
translate = load Translate Translate->PATH;
if(translate != nil) {
translate->init();
dictname := translate->mkdictname("", "pppclient");
(dict, nil) = translate->opendict(dictname);
}
mtu := 1450;
arg := load Arg Arg->PATH;
if(arg == nil)
error(0, sys->sprint("can't load %s: %r", Arg->PATH));
arg->init(args);
while((c := arg->opt()) != 0)
case c {
'm' =>
if((s := arg->arg()) == nil || !(s[0]>='0' && s[0]<='9'))
usage();
mtu = int s;
'P' =>
primary = 1;
'f' =>
framing = 0;
* =>
usage();
}
args = arg->argv();
arg = nil;
localip := "10.9.8.7"; # should be something locally unique
fake := 1;
if(args != nil){
fake = 0;
localip = hd args;
args = tl args;
}
cerr := configinit();
if(cerr != nil)
error(0, sys->sprint("can't configure: %s", cerr));
context = ctxt;
# make default (for now)
# if packet appears, start ppp and reset routing until it stops
(cfd, dir, err) := getifc();
if(err != nil)
error(0, err);
if(sys->fprint(cfd, "bind pkt") < 0)
error(0, sys->sprint("can't bind pkt: %r"));
if(sys->fprint(cfd, "add %s 255.255.255.0 10.9.8.0 %d", localip, mtu) < 0)
error(0, sys->sprint("can't add ppp addresses: %r"));
if(primary && addroute("0", "0", localip) < 0)
error(0, sys->sprint("can't add default route: %r"));
dfd := sys->open(dir+"/data", Sys->ORDWR);
if(dfd == nil)
error(0, sys->sprint("can't open %s: %r", dir));
sys->pctl(Sys->NEWPGRP, nil);
packets := chan of ref Packet;
spawn netreader(dfd, dir, localip, fake, packets);
logger := chan of (int, string);
iocmd := sys->file2chan("/chan", "pppctl");
if(iocmd == nil)
error(0, sys->sprint("can't create /chan/pppctl: %r"));
spawn servestatus(iocmd.read, logger);
starteduser := 0;
lasttime := 0;
for(;;) alt{
(nil, data, nil, wc) := <-iocmd.write => # remote io control
if(wc == nil)
break;
(nil, flds) := sys->tokenize(string data, " \t");
if(len flds > 1){
case hd flds {
"cancel" or "disconnect" or "hangup" =>
; # ignore it
"connect" =>
# start connection ...
;
* =>
wreply(wc, (0, "illegal request"));
continue;
}
}
wreply(wc, (len data, nil));
pkt := <-packets =>
sys->print("ppplink: received packet %s->%s: %d bytes\n", ipa(pkt.src), ipa(pkt.dst), len pkt.data);
if(abs(sys->millisec()-lasttime) < Ignorems){
sys->print("ppplink: ignored, not enough time elapsed yet between dial attempts\n");
break;
}
(ok, stat) := sys->stat(ISP_DB_PATH);
if(ok < 0 || lastCdir == nil || !samefile(*lastCdir, stat)){
cerr = configinit();
if(cerr != nil){
sys->print("ppplink: can't reconfigure: %s\n", cerr);
# use existing configuration
}
}
if(!starteduser){
sync := chan of int;
spawn userinterface(sync);
starteduser = <-sync;
}
(ppperr, pppdir) := makeconnection(packets, logger, iocmd.write);
lasttime = sys->millisec();
if(ppperr == nil){
sys->print("ppplink: connected on %s\n", pppdir);
# converse ...
sys->sleep(120*1000);
}else{
sys->print("ppplink: ppp connect error: %s\n", ppperr);
hangup(pppdir);
}
}
}
servestatus(reader: chan of (int, int, int, Sys->Rread), updates: chan of (int, string))
{
statuspending := 0;
statusreq: (int, int, Sys->Rread);
step := Disconnected;
statuslist := statusline(step, step, nil) :: nil;
for(;;) alt{
(off, nbytes, fid, rc) := <-reader=>
if(rc == nil){
statuspending = 0;
if(step == Disconnected)
statuslist = nil;
break;
}
if(statuslist == nil){
if(statuspending){
alt{
rc <-= (nil, "pppctl file already in use") => ;
* => ;
}
break;
}
statusreq = (nbytes, fid, rc);
statuspending = 1;
break;
}
alt{
rc <-= reads(hd statuslist, 0, nbytes) =>
statuslist = tl statuslist;
* => ;
}
(code, arg) := <-updates =>
# convert to string
if(code != Error)
step = code;
status := statusline(step, code, arg);
if(code == Error)
step = Disconnected;
statuslist = appends(statuslist, status);
sys->print("status: %d %d %s\n", step, code, status);
if(statuspending){
(nbytes, nil, rc) := statusreq;
statuspending = 0;
alt{
rc <-= reads(hd statuslist, 0, nbytes) =>
statuslist = tl statuslist;
* =>
;
}
}
}
}
makeconnection(packets: chan of ref Packet, logger: chan of (int, string), writer: chan of (int, array of byte, int, Sys->Rwrite)): (string, string)
{
result := chan of (string, string);
sync := chan of int;
spawn pppconnect(result, sync, logger);
pid := <-sync;
for(;;) alt{
(err, pppdir) := <-result =>
# pppconnect finished
return (err, pppdir);
pkt := <-packets =>
# ignore packets whilst connecting
sys->print("ppplink: ignored packet %s->%s: %d byten", ipa(pkt.src), ipa(pkt.dst), len pkt.data);
(nil, data, nil, wc) := <-writer => # user control
if(wc == nil)
break;
(nil, flds) := sys->tokenize(string data, " \t");
if(len flds > 1){
case hd flds {
"connect" =>
; # ignore it
"cancel" or "disconnect" or "hangup"=>
kill(pid, "killgrp");
wreply(wc, (len data, nil));
return ("cancelled", nil);
* =>
wreply(wc, (0, "illegal request"));
continue;
}
}
wreply(wc, (len data, nil));
}
}
wreply(wc: chan of (int, string), v: (int, string))
{
alt{
wc <-= v => ;
* => ;
}
}
appends(l: list of string, s: string): list of string
{
if(l == nil)
return s :: nil;
return hd l :: appends(tl l, s);
}
statusline(step: int, code: int, arg: string): string
{
s: string;
if(code >= 0 && code < len statustext){
n := "step";
if(code == Linkup)
n = "connect";
s = sys->sprint("%d %d %s %s", step, len statustext, n, X(statustext[code]));
}else
s = sys->sprint("%d %d error", step, len statustext);
if(arg != nil)
s += sys->sprint(": %s", arg);
return s;
}
getifc(): (ref Sys->FD, string, string)
{
clonefile := netdir+"/ipifc/clone";
cfd := sys->open(clonefile, Sys->ORDWR);
if(cfd == nil)
return (nil, nil, sys->sprint("can't open %s: %r", clonefile));
buf := array[32] of byte;
n := sys->read(cfd, buf, len buf);
if(n <= 0)
return (nil, nil, sys->sprint("can't read %s: %r", clonefile));
return (cfd, netdir+"/ipifc/" + string buf[0:n], nil);
}
addroute(addr, mask, gate: string): int
{
fd := sys->open(netdir+"/iproute", Sys->OWRITE);
if(fd == nil)
return -1;
return sys->fprint(fd, "add %s %s %s", addr, mask, gate);
}
# uchar vihl; /* Version and header length */
# uchar tos; /* Type of service */
# uchar length[2]; /* packet length */
# uchar id[2]; /* ip->identification */
# uchar frag[2]; /* Fragment information */
# uchar ttl; /* Time to live */
# uchar proto; /* Protocol */
# uchar cksum[2]; /* Header checksum */
# uchar src[4]; /* IP source */
# uchar dst[4]; /* IP destination */
IPhdrlen: con 20;
netreader(dfd: ref Sys->FD, dir: string, localip: string, fake: int, outc: chan of ref Packet)
{
buf := array [32*1024] of byte;
while((n := sys->read(dfd, buf, len buf)) > 0){
if(n < IPhdrlen){
sys->print("ppplink: received short packet: %d bytes\n", n);
continue;
}
pkt := ref Packet;
if(n < 9*1024){
pkt.data = array[n] of byte;
pkt.data[0:] = buf[0:n];
}else{
pkt.data = buf[0:n];
buf = array[32*1024] of byte;
}
pkt.src = pkt.data[12:];
pkt.dst = pkt.data[16:];
outc <-= pkt;
}
if(n < 0)
error(1, sys->sprint("packet interface read error: %r"));
else if(n == 0)
error(1, "packet interface: end of file");
}
ipa(a: array of byte): string
{
if(len a < 4)
return "???";
return sys->sprint("%d.%d.%d.%d", int a[0], int a[1], int a[2], int a[3]);
}
reads(str: string, off, nbytes: int): (array of byte, string)
{
bstr := array of byte str;
slen := len bstr;
if(off < 0 || off >= slen)
return (nil, nil);
if(off + nbytes > slen)
nbytes = slen - off;
if(nbytes <= 0)
return (nil, nil);
return (bstr[off:off+nbytes], nil);
}
readppplog(log: chan of (int, string), errfile: string, pidc: chan of int)
{
pidc <-= sys->pctl(0, nil);
src := sys->open(errfile, Sys->OREAD);
if(src == nil)
log <-= (Error, sys->sprint("can't open %s: %r", errfile));
buf := array[1024] of byte;
connected := 0;
lasterror := "";
while((count := sys->read(src, buf, len buf)) > 0) {
(nil, tokens) := sys->tokenize(string buf[:count],"\n");
for(; tokens != nil; tokens = tl tokens) {
case hd tokens {
"no error" =>
log <-= (Linkup, nil);
lasterror = nil;
connected = 1;
"permission denied" =>
lasterror = X("Username or Password Incorrect");
log <-= (Error, lasterror);
"write to hungup channel" =>
lasterror = X("Remote Host Hung Up");
log <-= (Error, lasterror);
* =>
lasterror = X(hd tokens);
log <-= (Error, lasterror);
}
}
}
if(count == 0 && connected && lasterror == nil){ # should change ip/pppmedium.c instead?
#hangup(nil);
log <-= (Error, X("Lost Connection"));
}
}
dialup(mi: ref Modem->ModemInfo, number: string, scriptinfo: ref Script->ScriptInfo, logchan: chan of (int, string)): (string, ref Sys->Connection)
{
logchan <-= (Modeminit, nil);
# open & init the modem
modeminfo = mi;
modem := load Modem Modem->PATH;
if(modem == nil)
return (sys->sprint("can't load %s: %r", Modem->PATH), nil);
err := modem->init();
if(err != nil)
return (sys->sprint("couldn't init modem: %s", err), nil);
Device: import modem;
d := Device.new(modeminfo, 1);
logchan <-= (Dialling, number);
err = d.dial(number);
if(err != nil){
d.close();
return (err, nil);
}
logchan <-= (Modemup, nil);
# login script
if(scriptinfo != nil) {
logchan <-= (Scriptstart, nil);
err = runscript(modem, d, scriptinfo);
if(err != nil){
d.close();
return (err, nil);
}
logchan <-= (Scriptdone, nil);
}
mc := d.close();
return (nil, mc);
}
startppp(logchan: chan of (int, string), pppinfo: ref PPPInfo): (string, string)
{
(ifd, dir, err) := getifc();
if(ifd == nil)
return (err, nil);
sync := chan of int;
spawn readppplog(logchan, dir + "/err", sync); # unbind gives eof on err
<-sync;
if(pppinfo.ipaddr == nil)
pppinfo.ipaddr = "-";
# if(pppinfo.ipmask == nil)
# pppinfo.ipmask = "255.255.255.255";
if(pppinfo.peeraddr == nil)
pppinfo.peeraddr = "-";
if(pppinfo.maxmtu == nil)
pppinfo.maxmtu = "-";
# if(pppinfo.maxmtu <= 0)
# pppinfo.maxmtu = mtu;
# if(pppinfo.maxmtu < 576)
# pppinfo.maxmtu = 576;
if(pppinfo.username == nil)
pppinfo.username = "-";
if(pppinfo.password == nil)
pppinfo.password = "-";
ifc := "bind ppp "+modeminfo.path+" "+ pppinfo.ipaddr+" "+pppinfo.peeraddr+" "+pppinfo.maxmtu
+" "+string framing+" "+pppinfo.username+" "+pppinfo.password;
if(sys->fprint(ifd, "%s", ifc) < 0)
return (sys->sprint("can't bind ppp to %s: %r", dir), nil);
sys->print("ppplink: %s\n", ifc);
return (nil, dir);
}
runscript(modem: Modem, dev: ref Modem->Device, scriptinfo: ref Script->ScriptInfo): string
{
script := load Script Script->PATH;
if(script == nil)
return sys->sprint("can't load %s: %r", Script->PATH);
err := script->init(modem);
if(err != nil)
return err;
return script->execute(dev, scriptinfo);
}
hangup(pppdir: string)
{
sys->print("ppplink: hangup...\n");
if(pppdir != nil){ # shut down the PPP link
fd := sys->open(pppdir + "/ctl", Sys->OWRITE);
if(fd == nil || sys->fprint(fd, "unbind") < 0)
sys->print("ppplink: hangup: can't unbind ppp on %s: %r\n", pppdir);
fd = nil;
}
modem := load Modem Modem->PATH;
if(modem == nil) {
sys->print("ppplink: hangup: can't load %s: %r", Modem->PATH);
return;
}
err := modem->init();
if(err != nil){
sys->print("ppplink: hangup: couldn't init modem: %s", err);
return;
}
Device: import modem;
d := Device.new(modeminfo, 1);
if(d != nil){
d.onhook();
d.close();
}
}
kill(pid: int, msg: string)
{
fd := sys->open("/prog/"+string pid+"/ctl", Sys->OWRITE);
if(fd == nil || sys->fprint(fd, "%s", msg) < 0)
sys->print("pppclient: can't %s %d: %r\n", msg, pid);
}
error(dokill: int, s: string)
{
sys->fprint(sys->fildes(2), "ppplink: %s\n", s);
if(dokill)
kill(sys->pctl(0, nil), "killgrp");
raise "fail:error";
}
X(s : string) : string
{
if(dict != nil)
return dict.xlate(s);
return s;
}
cfile(file: string): string
{
if(len file > 0 && file[0] == '/')
return file;
return "/usr/"+user()+"/config/"+file;
}
user(): string
{
fd := sys->open("/dev/user", Sys->OREAD);
buf := array[64] of byte;
if(fd != nil && (n := sys->read(fd, buf, len buf)) > 0)
return string buf[0:n];
return "inferno"; # hmmm.
}
cfvalue(c: ref ConfigFile, key: string) :string
{
s := "";
for(values := c.getcfg(key); values != nil; values = tl values){
if(s != "")
s[len s] = ' ';
s += hd values;
}
return s;
}
configinit(): string
{
cfg = load CfgFile CfgFile->PATH;
if(cfg == nil)
return sys->sprint("can't load %s: %r", CfgFile->PATH);
# Modem Configuration
modemdb := cfile(MODEM_DB_PATH);
cfg->verify(DEFAULT_MODEM_DB_PATH, modemdb);
modemcfg := cfg->init(modemdb);
if(modemcfg == nil)
return sys->sprint("can't open %s: %r", modemdb);
modeminfo = ref Modem->ModemInfo;
modeminfo.path = cfvalue(modemcfg, "PATH");
modeminfo.init = cfvalue(modemcfg, "INIT");
modeminfo.country = cfvalue(modemcfg, "COUNTRY");
modeminfo.other = cfvalue(modemcfg, "OTHER");
modeminfo.errorcorrection = cfvalue(modemcfg,"CORRECT");
modeminfo.compression = cfvalue(modemcfg,"COMPRESS");
modeminfo.flowctl = cfvalue(modemcfg,"FLOWCTL");
modeminfo.rateadjust = cfvalue(modemcfg,"RATEADJ");
modeminfo.mnponly = cfvalue(modemcfg,"MNPONLY");
modeminfo.dialtype = cfvalue(modemcfg,"DIALING");
if(modeminfo.dialtype!="ATDP")
modeminfo.dialtype="ATDT";
ispdb := cfile(ISP_DB_PATH);
cfg->verify(DEFAULT_ISP_DB_PATH, ispdb);
sys->print("cfg->init(%s)\n", ispdb);
# ISP Configuration
pppcfg := cfg->init(ispdb);
if(pppcfg == nil)
return sys->sprint("can't read or create ISP configuration file %s: %r", ispdb);
(ok, stat) := sys->stat(ispdb);
if(ok >= 0)
lastCdir = ref stat;
pppinfo = ref PPPInfo;
isp_number = cfvalue(pppcfg, "NUMBER");
pppinfo.ipaddr = cfvalue(pppcfg,"IPADDR");
pppinfo.ipmask = cfvalue(pppcfg,"IPMASK");
pppinfo.peeraddr = cfvalue(pppcfg,"PEERADDR");
pppinfo.maxmtu = cfvalue(pppcfg,"MAXMTU");
pppinfo.username = cfvalue(pppcfg,"USERNAME");
pppinfo.password = cfvalue(pppcfg,"PASSWORD");
info := pppcfg.getcfg("SCRIPT");
if(info != nil) {
scriptinfo = ref Script->ScriptInfo;
scriptinfo.path = hd info;
scriptinfo.username = pppinfo.username;
scriptinfo.password = pppinfo.password;
} else
scriptinfo = nil;
info = pppcfg.getcfg("TIMEOUT");
if(info != nil)
scriptinfo.timeout = int (hd info);
cfg = nil; # unload it
if(modeminfo.path == nil)
return "no modem device configured";
if(isp_number == nil)
return "no telephone number configured for ISP";
return nil;
}
isipaddr(a: string): int
{
i, c, ac, np : int = 0;
for(i = 0; i < len a; i++) {
c = a[i];
if(c >= '0' && c <= '9') {
np = 10*np + c - '0';
continue;
}
if(c == '.' && np) {
ac++;
if(np > 255)
return 0;
np = 0;
continue;
}
return 0;
}
return np && np < 256 && ac == 3;
}
userinterface(sync: chan of int)
{
pppgui := load Command "pppchat.dis";
if(pppgui == nil){
sys->fprint(sys->fildes(2), "ppplink: can't load %s: %r\n", "/dis/svc/nppp/pppchat.dis");
# TO DO: should be optional
sync <-= 0;
}
sys->pctl(Sys->NEWPGRP|Sys->NEWFD, list of {0, 1, 2});
sync <-= sys->pctl(0, nil);
pppgui->init(context, "pppchat" :: nil);
}
pppconnect(result: chan of (string, string), sync: chan of int, status: chan of (int, string))
{
sys->pctl(Sys->NEWPGRP|Sys->NEWFD, list of {0, 1, 2});
sync <-= sys->pctl(0, nil);
pppdir: string;
(err, mc) := dialup(modeminfo, isp_number, scriptinfo, status); # mc keeps connection open until startppp binds it to ppp
if(err == nil){
if(0 && (cfd := mc.cfd) != nil){
sys->fprint(cfd, "m1"); # cts/rts flow control/fifo's on
sys->fprint(cfd, "q64000"); # increase queue size to 64k
sys->fprint(cfd, "n1"); # nonblocking writes on
sys->fprint(cfd, "r1"); # rts on
sys->fprint(cfd, "d1"); # dtr on
}
status <-= (Startingppp, nil);
(err, pppdir) = startppp(status, pppinfo);
if(err == nil){
status <-= (Startedppp, nil);
result <-= (nil, pppdir);
return;
}
}
status <-= (Error, err);
result <-= (err, nil);
}
getspeed(file: string): string
{
return findrate("/dev/modemstat", "rcvrate" :: "baud" :: nil);
}
findrate(file: string, opt: list of string): string
{
fd := sys->open(file, sys->OREAD);
if(fd == nil)
return nil;
buf := array [1024] of byte;
n := sys->read(fd, buf, len buf);
if(n <= 1)
return nil;
(nil, flds) := sys->tokenize(string buf[0:n], " \t\r\n");
for(; flds != nil; flds = tl flds)
for(l := opt; l != nil; l = tl l)
if(hd flds == hd l)
return hd tl flds;
return nil;
}
samefile(d1, d2: Sys->Dir): int
{
return d1.dev==d2.dev && d1.dtype==d2.dtype &&
d1.qid.path==d2.qid.path && d1.qid.vers==d2.qid.vers &&
d1.mtime==d2.mtime;
}
abs(n: int): int
{
if(n < 0)
return -n;
return n;
}