static void
capwatch(void *a)
{
Caps *c, **l;
int idletime;
USED(a);
idletime = 0;
for(;;){
osmillisleep(30*1000);
qlock(&allcaps.l);
for (l = &allcaps.caps; (c = *l) != nil;)
if(++c->time > Captimeout){
*l = c->next;
free(c);
}else
l = &c->next;
if(allcaps.caps == nil){
if(++idletime > Capidletime){
allcaps.kpstarted = 0;
qunlock(&allcaps.l);
pexit("", 0);
}
}else
idletime = 0;
qunlock(&allcaps.l);
}
}
/* currently a directory queue based interface
future plan :
use a single local proxy on same system that interfaces here with sockets
have at least a set of 2 servers, allow network rebuild
remote client interfaces to proxy at e.g. port 80
proxy on behalf of client to here, synchronously. proxy forks per request
server accepts one conn only, proxy knows list of servers and iterates
have directory-based queue for real-time status updates only
status updates synchronously, rely on having a set of servers
*/
int serverloop(void)
{
const char *querydir = globs.querydir;
struct myfile req;
int prv,rv = 1;
enum Cmds cmd = Cmd_nil;
ub4 prvseq = 0,seq = 0,useq = 0;
char c;
const char *region = "glob"; // todo
int cpid;
int do_fork;
ub4 cldcnt = 0;
info(0,"entering server loop for id %u",globs.serverid);
do {
infovrb(seq > prvseq,0,"wait for new cmd %u",seq);
rv = getqentry(querydir,&req,region,".sub");
if (rv) break;
prvseq = seq;
if (req.direxist == 0) osmillisleep(2000);
else if (req.exist == 0) {
if (cldcnt) prv = oswaitany(&cldcnt);
osmillisleep(10); // for linux only we may use inotify instead
} else {
info(0,"new client entry %s",req.name);
do_fork = 1;
c = req.name[req.basename];
switch(c) {
case 's': cmd = Cmd_stop; break;
case 'p': cmd = Cmd_plan; break;
case 'P': cmd = Cmd_plan; do_fork = 0; break;
case 'g': cmd = Cmd_geo; do_fork = 0; break;
case 'u': cmd = Cmd_upd; break;
default: info(0,"unknown command '%c'",c);
}
if (cmd == Cmd_plan) {
seq++;
if (do_fork) {
cpid = start_plan(&req,1);
if (cpid > 0) cldcnt++;
} else {
rv = start_plan(&req,do_fork);
}
if (req.alloced) afree(req.buf,"client request");
} else if (cmd == Cmd_upd) {
prv = cmd_upd(&req,useq);
if (prv) info(0,"update returned %d",prv);
if (req.alloced) afree(req.buf,"client request");
useq++;
} else if (cmd == Cmd_geo) {
prv = cmd_geo(&req);
if (req.alloced) afree(req.buf,"client request");
}
}
} while (rv == 0 && cmd != Cmd_stop && globs.sigint == 0);
info(0,"leaving server loop for id %u",globs.serverid);
return rv;
}
// parse parameters and invoke actual planning. Runs in separate process
// to be elaborated: temporary simple interface
static int cmd_plan(gnet *net,struct myfile *req,search *src)
{
struct myfile rep;
char *vp,*lp = req->buf;
ub4 n,pos = 0,len = (ub4)req->len;
ub4 ival;
ub4 varstart,varend,varlen,valstart,valend,type;
ub4 portcnt = net->portcnt;
ub4 sportcnt = net->sportcnt;
ub4 dep = 0,arr = 0,lostop = 0,histop = 3,tdep = 0,ttdep = 0,utcofs=2200;
ub4 plusday = 1,minday = 0;
ub4 costperstop = 1;
ub4 mintt = globs.mintt;
ub4 maxtt = globs.maxtt;
ub4 walklimit = globs.walklimit;
ub4 sumwalklimit = globs.sumwalklimit;
ub4 nethistop = hi32;
ub4 delay = 0;
ub4 testiter = 0;
int rv;
enum Vars {
Cnone,
Cdep,
Carr,
Ctdep,
Cttdep,
Cplusday,
Cminday,
Clostop,
Chistop,
Cmintt,
Cmaxtt,
Ccostperstop,
Cwalklimit,
Csumwalklimit,
Cnethistop,
Cutcofs,
Cdelay,
Ctestiter
} var;
ub4 *evpool;
if (len == 0) return 1;
oclear(rep);
while (pos < len && lp[pos] >= 'a' && lp[pos] <= 'z') {
ival = 0;
varstart = varend = pos;
while (varend < len && lp[varend] >= 'a' && lp[varend] <= 'z') varend++;
varlen = varend - varstart; pos = varend;
if (varlen == 0) break;
while (pos < len && lp[pos] == ' ') pos++;
if (pos == len) break;
type = lp[pos++];
if (type == '\n' || pos == len) break;
while (pos < len && lp[pos] == ' ') pos++;
lp[varend] = 0;
valstart = valend = pos;
while (valend < len && lp[valend] != '\n') valend++;
if (valend == len) break;
pos = valend;
while (pos < len && lp[pos] != '\n') pos++;
if (lp[pos] == '\n') pos++;
if (pos == len) break;
lp[valend] = 0;
if (type == 'i') {
n = str2ub4(lp + valstart,&ival);
if (n == 0) return error(0,"expected integer for %s, found '%.*s'",lp + varstart,valend - valstart,lp + valstart);
}
vp = lp + varstart;
if (varlen == 3 && memeq(vp,"dep",3)) var = Cdep;
else if (varlen == 3 && memeq(vp,"arr",3)) var = Carr;
else if (varlen == 7 && memeq(vp,"deptmin",7)) var = Ctdep;
else if (varlen == 8 && memeq(vp,"depttmin",8)) var = Cttdep;
else if (varlen == 7 && memeq(vp,"plusday",7)) var = Cplusday;
else if (varlen == 6 && memeq(vp,"minday",6)) var = Cminday;
else if (varlen == 6 && memeq(vp,"lostop",6)) var = Clostop;
else if (varlen == 6 && memeq(vp,"histop",6)) var = Chistop;
else if (varlen == 5 && memeq(vp,"mintt",5)) var = Cmintt;
else if (varlen == 5 && memeq(vp,"maxtt",5)) var = Cmaxtt;
else if (varlen == 11 && memeq(vp,"costperstop",11)) var = Ccostperstop;
else if (varlen == 9 && memeq(vp,"walklimit",9)) var = Cwalklimit;
else if (varlen == 12 && memeq(vp,"sumwalklimit",12)) var = Csumwalklimit;
else if (varlen == 9 && memeq(vp,"nethistop",9)) var = Cnethistop;
else if (varlen == 6 && memeq(vp,"utcofs",6)) var = Cutcofs;
else if (varlen == 5 && memeq(vp,"delay",5)) var = Cdelay;
else if (varlen == 8 && memeq(vp,"testiter",8)) var = Ctestiter;
else {
warn(0,"ignoring unknown var '%s'",vp);
var = Cnone;
}
switch (var) {
case Cnone: break;
case Cdep: dep = ival; break;
case Carr: arr = ival; break;
case Ctdep: tdep = ival; break;
case Cttdep: ttdep = ival; break;
case Cplusday: plusday = ival; break;
case Cminday: minday = ival; break;
case Clostop: lostop = ival; break;
case Chistop: histop = ival; break;
case Cmintt: mintt = ival; break;
case Cmaxtt: maxtt = ival; break;
case Ccostperstop: costperstop = ival; break;
case Cwalklimit: walklimit = ival; break;
case Csumwalklimit: sumwalklimit = ival; break;
case Cnethistop: nethistop = ival; break;
case Cutcofs: utcofs = ival; break;
case Cdelay: delay = ival; break;
case Ctestiter: testiter = ival; break;
}
}
if (mintt > maxtt) {
warn(0,"min transfer time %u cannot be above max %u",mintt,maxtt);
maxtt = mintt + 2;
}
if (sumwalklimit < walklimit) {
warn(0,"max distance for single go walk %u above summed max %u",walklimit,sumwalklimit);
sumwalklimit = walklimit;
}
if (dep > portcnt && dep - portcnt >= sportcnt) return error(0,"dep %u not in %u member net",dep - portcnt,sportcnt);
if (arr > portcnt && arr - portcnt >= sportcnt) return error(0,"arr %u not in %u member net",arr - portcnt,sportcnt);
if (dep == arr) warning(0,"dep %u equal to arr",dep);
evpool = src->evpool;
clear(src);
src->evpool = evpool;
src->depttmin_cd = ttdep;
src->deptmin_cd = tdep;
src->utcofs12 = utcofs;
src->plusday = plusday;
src->minday = minday;
src->nethistop = min(nethistop,histop);
src->mintt = mintt;
src->maxtt = maxtt;
src->costperstop = costperstop;
src->walklimit = m2geo(walklimit);
src->sumwalklimit = m2geo(sumwalklimit);
// invoke actual plan here
info(0,"plan %u to %u in %u to %u stop\as from %u.%u for +%u -%u days",dep,arr,lostop,histop,tdep,ttdep,plusday,minday);
info(0,"mintt %u maxtt %u maxwalk %u costperstop %u",mintt,maxtt,walklimit,costperstop);
info(0,"utcofs %u",utcofs);
rv = plantrip(src,req->name,dep,arr,lostop,histop);
// prepare reply
rep.buf = rep.localbuf;
if (rv) len = fmtstring(rep.localbuf,"reply plan %u-%u error code %d\n",dep,arr,rv);
else if (src->reslen) {
len = min(src->reslen,sizeof(rep.localbuf));
memcpy(rep.localbuf,src->resbuf,len);
} else len = fmtstring(rep.localbuf,"reply plan %u-%u : no trip found\n",dep,arr);
vrb0(0,"reply len %u",len);
rep.len = len;
if (delay) osmillisleep(delay);
rv |= setqentry(req,&rep,".rep");
if (testiter == 0 || dep == arr) return rv;
ub4 iter = 0;
while (iter < testiter) {
if (++arr == portcnt) {
arr = 0;
if (++dep == portcnt) dep = 0;
}
if (dep == arr) continue;
iter++;
rv = plantrip(src,req->name,dep,arr,lostop,histop);
if (rv) return rv;
}
ub4 iv,cnt,cumcnt = 0;
cnt = src->notrips;
infocc(cnt,0,"%u of %u trips not found",cnt,testiter);
info(0,"max dur %lu msec for dep %u arr %u",src->querymaxdur / 1000,src->querymaxdep,src->querymaxarr);
info(0,"query times in msec for %u iters",testiter);
for (iv = 0; iv < Elemcnt(src->querydurs); iv++) {
cnt = src->querydurs[iv];
cumcnt += cnt;
infocc(cnt,0,"%02u: %u %u",iv,cnt,cumcnt);
}
return 0;
}
int
limbosleep(ulong milsec)
{
return osmillisleep(milsec);
}
long
audio_file_write(Chan *c, void *va, long count, vlong offset)
{
MMRESULT status;
WAVEHDR *hHdr = (WAVEHDR *) NULL;
char *hData = NULL;
char *p = (char *) va;
long ba;
long bufsz;
long chunk;
long total;
qlock(&flag_lock);
if(waserror()) {
qunlock(&flag_lock);
nexterror();
}
if(!(audio_flags & OUTISOPEN))
error(Eperm);
/* check for block alignment */
ba = av.out.bits * av.out.chan / Bits_Per_Byte;
if(count % ba)
error(Ebadarg);
bufsz = av.out.buf * Audio_Max_Buf / Audio_Max_Val;
if(bufsz < 1)
error(Ebadarg);
total = 0;
while(total < count) {
Again:
chunk = min(bufsz, count - total);
Drain:
WaitForSingleObject(outlock, INFINITE);
while(out_buf_count > bufsz) {
ReleaseMutex(outlock);
sleep(0);
goto Drain;
}
if(out_buf_count == 0)
audioerror(waveOutReset(audio_file_out), AUDIOOUT, "wave out reset");
ReleaseMutex(outlock);
/*
* allocate and lock the memory for the wave header
* and data blocks
*/
hHdr = (WAVEHDR *) malloc(sizeof(WAVEHDR));
if (!hHdr)
error(Enomem);
hData = malloc(chunk);
if (!hData) {
free(hHdr);
error(Enomem);
}
/*
* initialize the wave header struct
*/
/*
* copy user data into write Q
*/
memmove(hData, p+total, chunk);
hHdr->lpData = hData;
hHdr->dwBufferLength = chunk;
hHdr->dwBytesRecorded = 0;
hHdr->dwUser = chunk;
hHdr->dwFlags = 0;
hHdr->dwLoops = 0;
hHdr->lpNext = 0;
hHdr->reserved = 0;
status = waveOutPrepareHeader(audio_file_out, hHdr, sizeof(WAVEHDR));
if (audioerror(status, AUDIOOUT, "out prepare header") == -1) {
free(hHdr);
free(hData);
error(Eio);
}
status =
waveOutWrite(audio_file_out, hHdr, sizeof(WAVEHDR));
if (audioerror(status, AUDIOOUT, "out write data") == -1) {
waveOutUnprepareHeader(audio_file_out, hHdr, sizeof(WAVEHDR));
free(hHdr);
free(hData);
error(Eio);
}
WaitForSingleObject(outlock, INFINITE);
out_buf_count += chunk;
ReleaseMutex(outlock);
total += chunk;
}
poperror();
qunlock(&flag_lock);
osmillisleep(1); /* hack to get around thread scheduler */
return count;
}
