ref: 1216c06c3bdf3f3fb953ec96de99e026ef318360
dir: /sys/src/cmd/telco/telco.c/
#include <u.h>
#include <libc.h>
#include <auth.h>
#include <fcall.h>
#define LOGFILE "telco"
/*
* Rather than reading /adm/users, which is a lot of work for
* a toy progdev, we assume all groups have the form
* NNN:user:user:
* meaning that each user is the leader of his own group.
*/
enum
{
OPERM = 0x3, /* mask of all permission types in open mode */
Ndev = 8,
Nreq = (Ndev*3)/2,
Nrbuf = 32*1024,
};
typedef struct Fid Fid;
typedef struct Dev Dev;
typedef struct Request Request;
typedef struct Type Type;
struct Fid
{
Qid qid;
short busy;
short open;
int fid;
Fid *next;
char *user;
};
struct Request
{
Request *next;
Fid *fid;
ulong tag;
int count;
int flushed;
};
struct Dev
{
Lock;
/* device state */
int ctl; /* control fd */
int data; /* data fd */
char *path; /* to device */
Type *t;
Type *baset;
int speed;
int fclass;
/* fs emulation */
int open;
long perm;
char *name;
char *user;
char msgbuf[128];
Request *r;
Request *rlast;
/* input reader */
int monitoring; /* monitor pid */
char rbuf[Nrbuf];
char *rp;
char *wp;
long pid;
};
enum
{
Devmask= (Ndev-1)<<8,
Qlvl1= 0,
Qlvl2= 1,
Qclone= 2,
Qlvl3= 3,
Qdata= 4,
Qctl= 5,
Pexec = 1,
Pwrite = 2,
Pread = 4,
Pother = 1,
Pgroup = 8,
Powner = 64,
};
char *names[] =
{
[Qlvl1] "/",
[Qlvl2] "telco",
[Qclone] "clone",
[Qlvl3] "",
[Qdata] "data",
[Qctl] "ctl",
};
#define DEV(q) ((((ulong)(q).path)&Devmask)>>8)
#define TYPE(q) (((ulong)(q).path)&((1<<8)-1))
#define MKQID(t, i) ((((i)<<8)&Devmask) | (t))
enum
{
/*
* modem specific commands
*/
Cerrorcorrection = 0, /* error correction */
Ccompression, /* compression */
Cflowctl, /* CTS/RTS */
Crateadjust, /* follow line speed */
Cfclass2, /* set up for fax */
Cfclass0, /* set up for data */
Ncommand,
};
struct Type
{
char *name;
char *ident; /* inquire request */
char *response; /* inquire response (strstr) */
char *basetype; /* name of base type */
char *commands[Ncommand];
};
/*
* Fax setup summary
*
* FCLASS=2 - set to service class 2, i.e., one where the fax handles timing
* FTBC=0 - ???
* FREL=1 - ???
* FCQ=1 - receive copy quality checking enabled
* FBOR=1 - set reversed bit order for phase C data
* FCR=1 - the DCE can receive message data, bit 10 in the DIS or
* DTC frame will be set
* FDIS=,3 - limit com speed to 9600 baud
*/
Type typetab[] =
{
{ "Rockwell", 0, 0, 0,
"AT\\N7", /* auto reliable (V.42, fall back to MNP, to none) */
"AT%C1\\J0", /* negotiate for compression, don't change port baud rate */
"AT\\Q3", /* CTS/RTS flow control */
"AT\\J1",
"AT+FCLASS=2\rAT+FCR=1\r",
"AT+FCLASS=0",
},
{ "ATT2400", "ATI9", "E2400", "Rockwell",
"AT\\N3", /* auto reliable (MNP, fall back to none) */
0,
0,
0,
0,
0,
},
{ "ATT14400", "ATI9", "E14400", "Rockwell",
0,
0,
0,
0,
0,
0,
},
{ "MT1432", "ATI2", "MT1432", 0,
"AT&E1", /* auto reliable (V.42, fall back to none) */
"AT&E15$BA0", /* negotiate for compression */
"AT&E4", /* CTS/RTS flow control */
"AT$BA1", /* don't change port baud rate */
"AT+FCLASS=2\rAT+FTBC=0\rAT+FREL=1\rAT+FCQ=1\rAT+FBOR=1\rAT+FCR=1\rAT+FDIS=,3",
"AT+FCLASS=0",
},
{ "MT2834", "ATI2", "MT2834", "MT1432",
0,
0,
0,
0,
"AT+FCLASS=2\rAT+FTBC=0\rAT+FREL=1\rAT+FCQ=1\rAT+FBOR=1\rAT+FCR=1",
0,
},
{ "VOCAL", "ATI6", "144DPL+FAX", "Rockwell",
"AT\\N3", /* auto reliable (V.42, fall back to MNP, fall back to none) */
"AT%C3\\J0", /* negotiate for compression, don't change port baud rate */
0,
0,
"AT+FCLASS=2\rAT+FTBC=0\rAT+FREL=1\rAT+FCQ=1\rAT+FBOR=1\rAT+FCR=1",
"AT+FCLASS=0",
},
{ 0, },
};
/*
* modem return codes
*/
enum
{
Ok,
Success,
Failure,
Noise,
Found,
};
/*
* modem return messages
*/
typedef struct Msg Msg;
struct Msg
{
char *text;
int type;
};
Msg msgs[] =
{
{ "OK", Ok, },
{ "NO CARRIER", Failure, },
{ "ERROR", Failure, },
{ "NO DIALTONE", Failure, },
{ "BUSY", Failure, },
{ "NO ANSWER", Failure, },
{ "CONNECT", Success, },
{ 0, 0 },
};
Fid *fids;
Dev *dev;
int ndev;
int mfd[2];
char *user;
uchar mdata[8192+IOHDRSZ];
int messagesize = sizeof mdata;
Fcall thdr;
Fcall rhdr;
char errbuf[ERRMAX];
uchar statbuf[STATMAX];
int pulsed;
int verbose;
int maxspeed = 56000;
char *srcid = "plan9";
int answer = 1;
Fid *newfid(int);
int devstat(Dir*, uchar*, int);
int devgen(Qid, int, Dir*, uchar*, int);
void error(char*);
void io(void);
void *erealloc(void*, ulong);
void *emalloc(ulong);
void usage(void);
int perm(Fid*, Dev*, int);
void setspeed(Dev*, int);
int getspeed(char*, int);
char *dialout(Dev*, char*);
void onhook(Dev*);
int readmsg(Dev*, int, char*);
void monitor(Dev*);
int getinput(Dev*, char*, int);
void serve(Dev*);
void receiver(Dev*);
char* modemtype(Dev*, int, int);
char *rflush(Fid*), *rversion(Fid*),
*rattach(Fid*), *rauth(Fid*), *rwalk(Fid*),
*ropen(Fid*), *rcreate(Fid*),
*rread(Fid*), *rwrite(Fid*), *rclunk(Fid*),
*rremove(Fid*), *rstat(Fid*), *rwstat(Fid*);
char *(*fcalls[])(Fid*) = {
[Tflush] rflush,
[Tversion] rversion,
[Tattach] rattach,
[Tauth] rauth,
[Twalk] rwalk,
[Topen] ropen,
[Tcreate] rcreate,
[Tread] rread,
[Twrite] rwrite,
[Tclunk] rclunk,
[Tremove] rremove,
[Tstat] rstat,
[Twstat] rwstat,
};
char Eperm[] = "permission denied";
char Enotdir[] = "not a directory";
char Enotexist[] = "file does not exist";
char Ebadaddr[] = "bad address";
char Eattn[] = "can't get modem's attention";
char Edial[] = "can't dial";
char Enoauth[] = "telco: authentication not required";
char Eisopen[] = "file already open for I/O";
char Enodev[] = "no free modems";
char Enostream[] = "stream closed prematurely";
void
usage(void)
{
fprint(2, "usage: %s [-vp] [-i srcid] dev ...\n", argv0);
exits("usage");
}
void
notifyf(void *a, char *s)
{
USED(a);
if(strncmp(s, "interrupt", 9) == 0)
noted(NCONT);
noted(NDFLT);
}
void
main(int argc, char *argv[])
{
int p[2];
int fd;
char buf[10];
Dev *d;
ARGBEGIN{
case 'p':
pulsed = 1;
break;
case 'v':
verbose = 1;
break;
case 'i':
srcid = ARGF();
break;
case 's':
maxspeed = atoi(ARGF());
break;
case 'n':
answer = 0;
break;
default:
usage();
}ARGEND
if(argc == 0)
usage();
if(argc > Ndev)
argc = Ndev;
if(pipe(p) < 0)
error("pipe failed");
notify(notifyf);
fmtinstall('F', fcallfmt);
user = getuser();
switch(rfork(RFFDG|RFPROC|RFREND|RFNOTEG)){
case -1:
error("fork");
case 0:
close(p[1]);
mfd[0] = mfd[1] = p[0];
break;
default:
close(p[0]);
fd = create("/srv/telco", OWRITE, 0666);
if(fd < 0)
error("create of /srv/telco failed");
sprint(buf, "%d", p[1]);
if(write(fd, buf, strlen(buf)) < 0)
error("writing /srv/telco");
close(fd);
if(mount(p[1], -1, "/net", MBEFORE, "") < 0)
error("mount failed");
exits(0);
}
dev = mallocz(argc*sizeof(Dev), 1);
for(ndev = 0; ndev < argc; ndev++){
d = &dev[ndev];
d->path = argv[ndev];
d->rp = d->wp = d->rbuf;
monitor(d);
d->open++;
onhook(d);
d->open--;
}
io();
}
/*
* generate a stat structure for a qid
*/
int
devstat(Dir *dir, uchar *buf, int nbuf)
{
Dev *d;
int t;
static char tmp[10][32];
static int ntmp;
t = TYPE(dir->qid);
if(t != Qlvl3)
dir->name = names[t];
else{
dir->name = tmp[ntmp % nelem(tmp)];
sprint(dir->name, "%lud", DEV(dir->qid));
ntmp++;
}
dir->mode = 0755;
dir->uid = user;
dir->gid = user;
dir->muid = user;
if(t >= Qlvl3){
d = &dev[DEV(dir->qid)];
if(d->open){
dir->mode = d->perm;
dir->uid = d->user;
}
}
if(dir->qid.type & QTDIR)
dir->mode |= DMDIR;
if(t == Qdata){
d = &dev[DEV(dir->qid)];
dir->length = d->wp - d->rp;
if(dir->length < 0)
dir->length += Nrbuf;
} else
dir->length = 0;
dir->atime = time(0);
dir->mtime = dir->atime;
if(buf)
return convD2M(dir, buf, nbuf);
return 0;
}
/*
* enumerate file's we can walk to from q
*/
int
devgen(Qid q, int i, Dir *d, uchar *buf, int nbuf)
{
static ulong v;
d->qid.vers = v++;
switch(TYPE(q)){
case Qlvl1:
if(i != 0)
return -1;
d->qid.type = QTDIR;
d->qid.path = Qlvl2;
break;
case Qlvl2:
switch(i){
case -1:
d->qid.type = QTDIR;
d->qid.path = Qlvl1;
break;
case 0:
d->qid.type = QTFILE;
d->qid.path = Qclone;
break;
default:
if(i > ndev)
return -1;
d->qid.type = QTDIR;
d->qid.path = MKQID(Qlvl3, i-1);
break;
}
break;
case Qlvl3:
switch(i){
case -1:
d->qid.type = QTDIR;
d->qid.path = Qlvl2;
break;
case 0:
d->qid.type = QTFILE;
d->qid.path = MKQID(Qdata, DEV(q));
break;
case 1:
d->qid.type = QTFILE;
d->qid.path = MKQID(Qctl, DEV(q));
break;
default:
return -1;
}
break;
default:
return -1;
}
return devstat(d, buf, nbuf);
}
char*
rversion(Fid *)
{
Fid *f;
for(f = fids; f; f = f->next)
if(f->busy)
rclunk(f);
if(thdr.msize < 256)
return "version: message size too small";
messagesize = thdr.msize;
if(messagesize > sizeof mdata)
messagesize = sizeof mdata;
rhdr.msize = messagesize;
if(strncmp(thdr.version, "9P2000", 6) != 0)
return "unrecognized 9P version";
rhdr.version = "9P2000";
return 0;
}
char*
rflush(Fid *f)
{
Request *r, **l;
Dev *d;
USED(f);
for(d = dev; d < &dev[ndev]; d++){
lock(d);
for(l = &d->r; r = *l; l = &r->next)
if(r->tag == thdr.oldtag){
*l = r->next;
free(r);
break;
}
unlock(d);
}
return 0;
}
char *
rauth(Fid *f)
{
USED(f);
return Enoauth;
}
char*
rattach(Fid *f)
{
f->busy = 1;
f->qid.type = QTDIR;
f->qid.path = Qlvl1;
f->qid.vers = 0;
rhdr.qid = f->qid;
if(thdr.uname[0])
f->user = strdup(thdr.uname);
else
f->user = "none";
return 0;
}
char*
rwalk(Fid *f)
{
Fid *nf;
int i, nqid;
char *name, *err;
Dir dir;
Qid q;
nf = nil;
if(thdr.fid != thdr.newfid){
if(f->open)
return Eisopen;
if(f->busy == 0)
return Enotexist;
nf = newfid(thdr.newfid);
nf->busy = 1;
nf->open = 0;
nf->qid = f->qid;
nf->user = strdup(f->user);
f = nf; /* walk f */
}
err = nil;
dir.qid = f->qid;
nqid = 0;
if(thdr.nwname > 0){
for(; nqid < thdr.nwname; nqid++) {
if((dir.qid.type & QTDIR) == 0){
err = Enotdir;
break;
}
name = thdr.wname[nqid];
if(strcmp(name, ".") == 0){
/* nothing to do */
}else if(strcmp(name, "..") == 0) {
if(devgen(f->qid, -1, &dir, 0, 0) < 0)
break;
}
else{
q = dir.qid;
for(i = 0;; i++){
if(devgen(q, i, &dir, 0, 0) < 0)
goto Out;
if(strcmp(name, dir.name) == 0)
break;
}
}
rhdr.wqid[nqid] = dir.qid;
}
Out:
if(nqid == 0 && err == nil)
err = Enotexist;
if(nf != nil && thdr.fid != thdr.newfid && nqid < thdr.nwname)
rclunk(nf);
}
rhdr.nwqid = nqid;
if(nqid > 0 && nqid == thdr.nwname)
f->qid = dir.qid;
return err;
}
char *
ropen(Fid *f)
{
Dev *d;
int mode, t;
if(f->open)
return Eisopen;
mode = thdr.mode;
mode &= OPERM;
if(f->qid.type & QTDIR){
if(mode != OREAD)
return Eperm;
rhdr.qid = f->qid;
return 0;
}
if(mode==OEXEC)
return Eperm;
t = TYPE(f->qid);
if(t == Qclone){
for(d = dev; d < &dev[ndev]; d++)
if(d->open == 0)
break;
if(d == &dev[ndev])
return Enodev;
f->qid.path = MKQID(Qctl, d-dev);
t = Qctl;
}
switch(t){
case Qdata:
case Qctl:
d = &dev[DEV(f->qid)];
if(d->open == 0){
d->user = strdup(f->user);
d->perm = 0660;
}else {
if(mode==OWRITE || mode==ORDWR)
if(!perm(f, d, Pwrite))
return Eperm;
if(mode==OREAD || mode==ORDWR)
if(!perm(f, d, Pread))
return Eperm;
}
d->open++;
break;
}
rhdr.qid = f->qid;
rhdr.iounit = messagesize - IOHDRSZ;
f->open = 1;
return 0;
}
char *
rcreate(Fid *f)
{
USED(f);
return Eperm;
}
/*
* intercept a note
*/
void
takeanote(void *u, char *note)
{
USED(u);
if(strstr(note, "interrupted"))
noted(NCONT);
noted(NDFLT);
}
char*
rread(Fid *f)
{
char *buf;
long off, start;
int i, m, n, cnt, t;
Dir dir;
char num[32];
Dev *d;
Request *r;
n = 0;
rhdr.count = 0;
off = thdr.offset;
cnt = thdr.count;
buf = rhdr.data;
t = TYPE(f->qid);
switch(t){
default:
start = 0;
for(i = 0; n < cnt; i++){
m = devgen(f->qid, i, &dir, (uchar*)buf+n, cnt-n);
if(m <= BIT16SZ)
break;
if(start >= off)
n += m;
start += m;
}
break;
case Qctl:
i = sprint(num, "%lud", DEV(f->qid));
if(off < i){
n = cnt;
if(off + n > i)
n = i - off;
memmove(buf, num + off, n);
} else
n = 0;
break;
case Qdata:
d = &dev[DEV(f->qid)];
r = mallocz(sizeof(Request), 1);
r->tag = thdr.tag;
r->count = thdr.count;
r->fid = f;
r->flushed = 0;
lock(d);
if(d->r)
d->rlast->next = r;
else
d->r = r;
d->rlast = r;
serve(d);
unlock(d);
return "";
}
rhdr.count = n;
return 0;
}
char *cmsg = "connect ";
int clen;
char*
rwrite(Fid *f)
{
Dev *d;
ulong off;
int cnt;
char *cp;
char buf[64];
off = thdr.offset;
cnt = thdr.count;
switch(TYPE(f->qid)){
default:
return "file is a directory";
case Qctl:
d = &dev[DEV(f->qid)];
clen = strlen(cmsg);
if(cnt < clen || strncmp(thdr.data, cmsg, clen) != 0){
/*
* send control message to real control file
*/
if(seek(d->ctl, off, 0) < 0 || write(d->ctl, thdr.data, cnt) < 0){
errstr(errbuf, sizeof errbuf);
return errbuf;
}
} else {
/*
* connect
*/
cnt -= clen;
if(cnt >= sizeof(buf))
cnt = sizeof(buf) - 1;
if(cnt < 0)
return Ebadaddr;
strncpy(buf, &thdr.data[clen], cnt);
buf[cnt] = 0;
cp = dialout(d, buf);
if(cp)
return cp;
}
rhdr.count = cnt;
break;
case Qdata:
d = &dev[DEV(f->qid)];
if(write(d->data, thdr.data, cnt) < 0){
errstr(errbuf, sizeof errbuf);
return errbuf;
}
rhdr.count = cnt;
break;
}
return 0;
}
char *
rclunk(Fid *f)
{
Dev *d;
if(f->open)
switch(TYPE(f->qid)){
case Qdata:
case Qctl:
d = &dev[DEV(f->qid)];
if(d->open == 1)
onhook(d);
d->open--;
break;
}
free(f->user);
f->busy = 0;
f->open = 0;
return 0;
}
char *
rremove(Fid *f)
{
USED(f);
return Eperm;
}
char *
rstat(Fid *f)
{
Dir d;
d.qid = f->qid;
rhdr.stat = statbuf;
rhdr.nstat = devstat(&d, statbuf, sizeof statbuf);
return 0;
}
char *
rwstat(Fid *f)
{
Dev *d;
Dir dir;
if(TYPE(f->qid) < Qlvl3)
return Eperm;
convM2D(thdr.stat, thdr.nstat, &dir, rhdr.data); /* rhdr.data is a known place to scribble */
d = &dev[DEV(f->qid)];
/*
* To change mode, must be owner
*/
if(d->perm != dir.mode){
if(strcmp(f->user, d->user) != 0)
if(strcmp(f->user, user) != 0)
return Eperm;
}
/* all ok; do it */
d->perm = dir.mode & ~DMDIR;
return 0;
}
Fid *
newfid(int fid)
{
Fid *f, *ff;
ff = 0;
for(f = fids; f; f = f->next)
if(f->fid == fid)
return f;
else if(!ff && !f->busy)
ff = f;
if(ff){
ff->fid = fid;
return ff;
}
f = emalloc(sizeof *f);
f->fid = fid;
f->next = fids;
fids = f;
return f;
}
/*
* read fs requests and dispatch them
*/
void
io(void)
{
char *err;
int n;
for(;;){
/*
* reading from a pipe or a network device
* will give an error after a few eof reads
* however, we cannot tell the difference
* between a zero-length read and an interrupt
* on the processes writing to us,
* so we wait for the error
*/
n = read9pmsg(mfd[0], mdata, messagesize);
if(n == 0)
continue;
if(n < 0)
error("mount read");
if(convM2S(mdata, n, &thdr) != n)
error("convM2S error");
rhdr.data = (char*)mdata + IOHDRSZ;
if(!fcalls[thdr.type])
err = "bad fcall type";
else
err = (*fcalls[thdr.type])(newfid(thdr.fid));
if(err){
if(*err == 0)
continue; /* assigned to a slave */
rhdr.type = Rerror;
rhdr.ename = err;
}else{
rhdr.type = thdr.type + 1;
rhdr.fid = thdr.fid;
}
rhdr.tag = thdr.tag;
n = convS2M(&rhdr, mdata, messagesize);
if(write(mfd[1], mdata, n) != n)
error("mount write");
}
}
int
perm(Fid *f, Dev *d, int p)
{
if((p*Pother) & d->perm)
return 1;
if(strcmp(f->user, user)==0 && ((p*Pgroup) & d->perm))
return 1;
if(strcmp(f->user, d->user)==0 && ((p*Powner) & d->perm))
return 1;
return 0;
}
void
error(char *s)
{
fprint(2, "%s: %s: %r\n", argv0, s);
syslog(0, LOGFILE, "%s: %r", s);
remove("/srv/telco");
postnote(PNGROUP, getpid(), "exit");
exits(s);
}
void *
emalloc(ulong n)
{
void *p;
p = mallocz(n, 1);
if(!p)
error("out of memory");
return p;
}
void *
erealloc(void *p, ulong n)
{
p = realloc(p, n);
if(!p)
error("out of memory");
return p;
}
/*
* send bytes to modem
*/
int
send(Dev *d, char *x)
{
if(verbose)
syslog(0, LOGFILE, "->%s", x);
return write(d->data, x, strlen(x));
}
/*
* apply a string of commands to modem
*/
int
apply(Dev *d, char *s, char *substr, int secs)
{
char buf[128];
char *p;
int c, m;
p = buf;
m = Ok;
while(*s){
c = *p++ = *s++;
if(c == '\r' || *s == 0){
if(c != '\r')
*p++ = '\r';
*p = 0;
if(send(d, buf) < 0)
return Failure;
m = readmsg(d, secs, substr);
p = buf;
}
}
return m;
}
/*
* apply a command type
*/
int
applyspecial(Dev *d, int index)
{
char *cmd;
cmd = d->t->commands[index];
if(cmd == 0 && d->baset)
cmd = d->baset->commands[index];
if(cmd == 0)
return Failure;
return apply(d, cmd, 0, 2);
}
/*
* get modem into command mode if it isn't already
*/
int
attention(Dev *d)
{
int i;
for(i = 0; i < 2; i++){
sleep(250);
if(send(d, "+") < 0)
continue;
sleep(250);
if(send(d, "+") < 0)
continue;
sleep(250);
if(send(d, "+") < 0)
continue;
sleep(250);
readmsg(d, 0, 0);
if(apply(d, "ATZH0", 0, 2) == Ok)
return Ok;
}
return Failure;
}
int portspeed[] = { 56000, 38400, 19200, 14400, 9600, 4800, 2400, 1200, 600, 300, 0 };
/*
* get the modem's type and speed
*/
char*
modemtype(Dev *d, int limit, int fax)
{
int *p;
Type *t, *bt;
char buf[28];
d->t = typetab;
d->baset = 0;
/* assume we're at a good speed, try getting attention a few times */
attention(d);
/* find a common port rate */
for(p = portspeed; *p; p++){
if(*p > limit)
continue;
setspeed(d, *p);
if(attention(d) == Ok)
break;
}
if(*p == 0)
return Eattn;
d->speed = *p;
if(verbose)
syslog(0, LOGFILE, "port speed %d", *p);
/*
* basic Hayes commands everyone implements (we hope)
* Q0 = report result codes
* V1 = full word result codes
* E0 = don't echo commands
* M1 = speaker on until on-line
* S0=0 = autoanswer off
*/
if(apply(d, "ATQ0V1E0M1S0=0", 0, 2) != Ok)
return Eattn;
/* find modem type */
for(t = typetab; t->name; t++){
if(t->ident == 0 || t->response == 0)
continue;
if(apply(d, t->ident, t->response, 2) == Found)
break;
readmsg(d, 0, 0);
}
readmsg(d, 0, 0);
if(t->name){
d->t = t;
if(t->basetype){
for(bt = typetab; bt->name; bt++)
if(strcmp(bt->name, t->basetype) == 0)
break;
if(bt->name)
d->baset = bt;
}
}
if(verbose)
syslog(0, LOGFILE, "modem %s", d->t->name);
/* try setting fax modes */
d->fclass = 0;
if(fax){
/* set up fax parameters */
if(applyspecial(d, Cfclass2) != Failure)
d->fclass = 2;
/* setup a source id */
if(srcid){
sprint(buf, "AT+FLID=\"%s\"", srcid);
apply(d, buf, 0, 2);
}
/* allow both data and fax calls in */
apply(d, "AT+FAA=1", 0, 2);
} else
applyspecial(d, Cfclass0);
return 0;
}
/*
* a process to read input from a modem.
*/
void
monitor(Dev *d)
{
int n;
char *p;
char file[256];
int background;
background = 0;
d->ctl = d->data = -1;
for(;;){
lock(d);
sprint(file, "%sctl", d->path);
d->ctl = open(file, ORDWR);
if(d->ctl < 0)
error("opening ctl");
d->data = open(d->path, ORDWR);
if(d->data < 0)
error("opening data");
d->wp = d->rp = d->rbuf;
unlock(d);
if(!background){
background = 1;
switch(d->pid = rfork(RFPROC|RFMEM)){
case -1:
error("out of processes");
case 0:
break;
default:
return;
}
}
/* wait for ring or off hook */
while(d->open == 0){
d->rp = d->rbuf;
p = d->wp;
n = read(d->data, p, 1);
if(n < 1)
continue;
if(p < &d->rbuf[Nrbuf] - 2)
d->wp++;
if(*p == '\r' || *p == '\n'){
*(p+1) = 0;
if(verbose)
syslog(0, LOGFILE, "<:-%s", d->rp);
if(answer && strncmp(d->rp, "RING", 4) == 0){
receiver(d);
continue;
}
if(d->open == 0)
d->wp = d->rbuf;
}
}
/* shuttle bytes till on hook */
while(d->open){
if(d->wp >= d->rp)
n = &d->rbuf[Nrbuf] - d->wp;
else
n = d->rp - d->wp - 1;
if(n > 0)
n = read(d->data, d->wp, n);
else {
read(d->data, file, sizeof(file));
continue;
}
if(n < 0)
break;
lock(d);
if(d->wp + n >= &d->rbuf[Nrbuf])
d->wp = d->rbuf;
else
d->wp += n;
serve(d);
unlock(d);
}
close(d->ctl);
close(d->data);
}
}
/*
* get bytes input by monitor() (only routine that changes d->rp)
*/
int
getinput(Dev *d, char *buf, int n)
{
char *p;
int i;
p = buf;
while(n > 0){
if(d->wp == d->rp)
break;
if(d->wp < d->rp)
i = &d->rbuf[Nrbuf] - d->rp;
else
i = d->wp - d->rp;
if(i > n)
i = n;
memmove(p, d->rp, i);
if(d->rp + i == &d->rbuf[Nrbuf])
d->rp = d->rbuf;
else
d->rp += i;
n -= i;
p += i;
}
return p - buf;
}
/*
* fulfill a read request (we assume d is locked)
*/
void
serve(Dev *d)
{
Request *r;
int n;
Fcall rhdr;
uchar *mdata;
char *buf;
mdata = malloc(messagesize);
buf = malloc(messagesize-IOHDRSZ);
for(;;){
if(d->r == 0 || d->rp == d->wp)
break;
r = d->r;
if(r->count > sizeof(buf))
r->count = sizeof(buf);
n = getinput(d, buf, r->count);
if(n == 0)
break;
d->r = r->next;
rhdr.type = Rread;
rhdr.fid = r->fid->fid;
rhdr.tag = r->tag;
rhdr.data = buf;
rhdr.count = n;
n = convS2M(&rhdr, mdata, messagesize);
if(write(mfd[1], mdata, n) != n)
fprint(2, "telco: error writing\n");
free(r);
}
free(mdata);
free(buf);
}
/*
* dial a number
*/
char*
dialout(Dev *d, char *number)
{
int i, m, compress, rateadjust, speed, fax;
char *err;
char *field[5];
char dialstr[128];
compress = Ok;
rateadjust = Failure;
speed = maxspeed;
fax = Failure;
m = getfields(number, field, 5, 1, "!");
for(i = 1; i < m; i++){
if(field[i][0] >= '0' && field[i][0] <= '9')
speed = atoi(field[i]);
else if(strcmp(field[i], "nocompress") == 0)
compress = Failure;
else if(strcmp(field[i], "fax") == 0)
fax = Ok;
}
syslog(0, LOGFILE, "dialing %s speed=%d %s", number, speed, fax==Ok?"fax":"");
err = modemtype(d, speed, fax == Ok);
if(err)
return err;
/*
* extented Hayes commands, meaning depends on modem (VGA all over again)
*/
if(fax != Ok){
if(d->fclass != 0)
applyspecial(d, Cfclass0);
applyspecial(d, Cerrorcorrection);
if(compress == Ok)
compress = applyspecial(d, Ccompression);
if(compress != Ok)
rateadjust = applyspecial(d, Crateadjust);
}
applyspecial(d, Cflowctl);
/* dialout */
sprint(dialstr, "ATD%c%s\r", pulsed ? 'P' : 'T', number);
if(send(d, dialstr) < 0)
return Edial;
if(fax == Ok)
return 0; /* fax sender worries about the rest */
switch(readmsg(d, 120, 0)){
case Success:
break;
default:
return d->msgbuf;
}
/* change line rate if not compressing */
if(rateadjust == Ok)
setspeed(d, getspeed(d->msgbuf, d->speed));
return 0;
}
/*
* start a receiving process
*/
void
receiver(Dev *d)
{
int fd;
char file[256];
char *argv[8];
int argc;
int pfd[2];
char *prog;
pipe(pfd);
switch(rfork(RFPROC|RFMEM|RFFDG|RFNAMEG)){
case -1:
return;
case 0:
fd = open("/srv/telco", ORDWR);
if(fd < 0){
syslog(0, LOGFILE, "can't open telco: %r");
exits(0);
}
if(mount(fd, -1, "/net", MAFTER, "") < 0){
syslog(0, LOGFILE, "can't mount: %r");
exits(0);
}
close(fd);
/* open connection through the file system interface */
sprint(file, "/net/telco/%zd/data", d - dev);
fd = open(file, ORDWR);
if(fd < 0){
syslog(0, LOGFILE, "can't open %s: %r", file);
exits(0);
}
/* let parent continue */
close(pfd[0]);
close(pfd[1]);
/* answer the phone and see what flavor call this is */
prog = "/bin/service/telcodata";
switch(apply(d, "ATA", "+FCON", 30)){
case Success:
break;
case Found:
prog = "/bin/service/telcofax";
break;
default:
syslog(0, LOGFILE, "bad ATA response");
exits(0);
}
/* fork a receiving process */
dup(fd, 0);
dup(fd, 1);
close(fd);
argc = 0;
argv[argc++] = strrchr(prog, '/')+1;
argv[argc++] = file;
argv[argc++] = dev->t->name;
argv[argc] = 0;
exec(prog, argv);
syslog(0, LOGFILE, "can't exec %s: %r", prog);
exits(0);
default:
/* wait till child gets the device open */
close(pfd[1]);
read(pfd[0], file, 1);
close(pfd[0]);
break;
}
}
/*
* hang up an connections in progress
*/
void
onhook(Dev *d)
{
write(d->ctl, "d0", 2);
write(d->ctl, "r0", 2);
sleep(250);
write(d->ctl, "r1", 2);
write(d->ctl, "d1", 2);
modemtype(d, maxspeed, 1);
}
/*
* read till we see a message or we time out
*/
int
readmsg(Dev *d, int secs, char *substr)
{
ulong start;
char *p;
int i, len;
Msg *pp;
int found = 0;
p = d->msgbuf;
len = sizeof(d->msgbuf) - 1;
for(start = time(0); time(0) <= start+secs;){
if(len && d->rp == d->wp){
sleep(100);
continue;
}
i = getinput(d, p, 1);
if(i == 0)
continue;
if(*p == '\n' || *p == '\r' || len == 0){
*p = 0;
if(verbose && p != d->msgbuf)
syslog(0, LOGFILE, "<-%s", d->msgbuf);
if(substr && strstr(d->msgbuf, substr))
found = 1;
for(pp = msgs; pp->text; pp++)
if(strncmp(pp->text, d->msgbuf, strlen(pp->text))==0)
return found ? Found : pp->type;
start = time(0);
p = d->msgbuf;
len = sizeof(d->msgbuf) - 1;
continue;
}
len--;
p++;
}
strcpy(d->msgbuf, "No response from modem");
return found ? Found : Noise;
}
/*
* get baud rate from a connect message
*/
int
getspeed(char *msg, int speed)
{
char *p;
int s;
p = msg + sizeof("CONNECT") - 1;
while(*p == ' ' || *p == '\t')
p++;
s = atoi(p);
if(s <= 0)
return speed;
else
return s;
}
/*
* set speed and RTS/CTS modem flow control
*/
void
setspeed(Dev *d, int baud)
{
char buf[32];
if(d->ctl < 0)
return;
sprint(buf, "b%d", baud);
write(d->ctl, buf, strlen(buf));
write(d->ctl, "m1", 2);
}