ref: 87952fb18827d804a53fe8c12562a0444e4f59dd
dir: /muswd.c/
#include <u.h>
#include <libc.h>
#include <ip.h>
#include <mp.h>
#include <libsec.h>
#include <thread.h>
#include <draw.h>
#include <geometry.h>
#include "dat.h"
#include "fns.h"
int debug;
int mainstacksize = 24*1024;
Party theparty;
Playerq players;
NetConn **conns;
usize nconns;
usize maxconns;
Channel *ingress;
Channel *egress;
void
putconn(NetConn *nc)
{
if(++nconns > maxconns){
conns = erealloc(conns, sizeof(NetConn*)*nconns);
maxconns = nconns;
}
conns[nconns-1] = nc;
}
NetConn *
getconn(Frame *f)
{
NetConn **nc;
for(nc = conns; nc < conns+nconns; nc++)
if(memcmp(&(*nc)->udp, &f->udp, Udphdrsize) == 0)
return *nc;
return nil;
}
void
dissolveparty(Player *player)
{
int i;
Party *p;
Player *adv;
Frame *f;
/*
* kick the player and put their adversary back in the
* queue, then dissolve the party
*/
for(p = theparty.next; p != &theparty; p = p->next)
for(i = 0; i < nelem(p->players); i++)
if(p->players[i] == player){
adv = p->players[i^1];
players.put(&players, adv);
delparty(p);
/* notify the adversary */
f = newframe(&adv->conn->udp, NSawol, 0, 0, 0, nil);
signframe(f, adv->conn->dh.priv);
sendp(egress, f);
goto kickplayer;
}
kickplayer:
/*
* make sure to free the player even if there's no
* party going on.
*/
players.del(&players, player);
delplayer(player);
}
int
popconn(NetConn *nc)
{
NetConn **ncp, **ncpe;
ncpe = conns+nconns;
for(ncp = conns; ncp < ncpe; ncp++)
if(*ncp == nc){
memmove(ncp, ncp+1, sizeof(NetConn*)*(ncpe-ncp-1));
nconns--;
dissolveparty(nc->player);
delnetconn(nc);
return 0;
}
return -1;
}
void
nudgeconns(ulong curts)
{
NetConn **ncp, **ncpe;
Frame *f;
ulong elapsed, elapsednudge;
ncpe = conns+nconns;
for(ncp = conns; ncp < ncpe; ncp++){
elapsed = curts - (*ncp)->lastrecvts;
elapsednudge = curts - (*ncp)->lastnudgets;
switch((*ncp)->state){
case NCSConnected:
if(elapsed > ConnTimeout)
popconn(*ncp);
else if(elapsednudge > 1000){ /* every second */
f = newframe(&(*ncp)->udp, NSnudge, (*ncp)->lastseq+1, 0, 0, nil);
signframe(f, (*ncp)->dh.priv);
sendp(egress, f);
(*ncp)->lastnudgets = curts;
}
break;
case NCSConnecting:
if(elapsed > ConnTimeout)
popconn(*ncp);
break;
}
}
}
void
threadnetrecv(void *arg)
{
uchar buf[MTU];
int fd, n;
ushort rport, lport;
Ioproc *io;
Frame *frame;
threadsetname("threadnetrecv");
fd = *(int*)arg;
io = ioproc();
while((n = ioread(io, fd, buf, sizeof buf)) > 0){
frame = newframe(nil, 0, 0, 0, n-Udphdrsize-Framehdrsize, nil);
unpack(buf, n, "F", frame);
sendp(ingress, frame);
if(debug){
rport = frame->udp.rport[0]<<8 | frame->udp.rport[1];
lport = frame->udp.lport[0]<<8 | frame->udp.lport[1];
fprint(2, "%I!%ud ← %I!%ud | rcvd %Φ\n",
frame->udp.laddr, lport, frame->udp.raddr, rport, frame);
}
}
closeioproc(io);
}
void
threadnetppu(void *)
{
ulong kdown;
Frame *frame, *newf;
NetConn *nc;
threadsetname("threadnetppu");
while((frame = recvp(ingress)) != nil){
if(frame->id != ProtocolID)
goto discard;
nc = getconn(frame);
if(nc == nil){
if(frame->type == NChi){
nc = newnetconn(NCSConnecting, &frame->udp);
putconn(nc);
newf = newframe(&frame->udp, NShi, frame->seq+1, frame->seq, 2*sizeof(ulong), nil);
dhgenpg(&nc->dh.p, &nc->dh.g);
pack(newf->data, newf->len, "kk", nc->dh.p, nc->dh.g);
sendp(egress, newf);
if(debug)
fprint(2, "\tsent p %ld g %ld\n", nc->dh.p, nc->dh.g);
}else
goto discard;
}
switch(nc->state){
case NCSConnecting:
if(frame->seq != nc->lastseq + 1 &&
frame->ack != nc->lastseq)
goto discard;
switch(frame->type){
case NCdhx:
unpack(frame->data, frame->len, "k", &nc->dh.pub);
nc->state = NCSConnected;
players.put(&players, newplayer(nil, nc));
nc->player = players.tail;
if(debug)
fprint(2, "\trcvd pubkey %ld\n", nc->dh.pub);
newf = newframe(&frame->udp, NSdhx, frame->seq+1, frame->seq, sizeof(ulong), nil);
nc->dh.sec = truerand();
nc->dh.priv = dhgenkey(nc->dh.pub, nc->dh.sec, nc->dh.p);
pack(newf->data, newf->len, "k", dhgenkey(nc->dh.g, nc->dh.sec, nc->dh.p));
sendp(egress, newf);
if(debug)
fprint(2, "\tsent pubkey %ld\n", dhgenkey(nc->dh.g, nc->dh.sec, nc->dh.p));
break;
}
break;
case NCSConnected:
if(!verifyframe(frame, nc->dh.priv)){
if(debug)
fprint(2, "\tbad signature\n");
goto discard;
}
switch(frame->type){
case NCinput:
unpack(frame->data, frame->len, "k", &kdown);
if(debug)
fprint(2, "\t%.*lub\n", sizeof(kdown)*8, kdown);
nbsendul(nc->player->inputq, kdown);
break;
case NCbuhbye:
popconn(nc);
break;
}
break;
}
nc->lastrecvts = nanosec()/1e6;
nc->lastseq = frame->seq;
nc->lastack = frame->ack;
discard:
delframe(frame);
}
}
void
threadnetsend(void *arg)
{
uchar buf[MTU];
int fd, n;
ushort rport, lport;
Frame *frame;
NetConn *nc;
threadsetname("threadnetsend");
fd = *(int*)arg;
while((frame = recvp(egress)) != nil){
n = pack(buf, sizeof buf, "F", frame);
if(write(fd, buf, n) != n)
sysfatal("write: %r");
if(debug){
rport = frame->udp.rport[0]<<8 | frame->udp.rport[1];
lport = frame->udp.lport[0]<<8 | frame->udp.lport[1];
fprint(2, "%I!%ud → %I!%ud | sent %Φ\n",
frame->udp.laddr, lport, frame->udp.raddr, rport, frame);
}
nc = getconn(frame);
if(nc != nil){
nc->lastseq = frame->seq;
nc->lastack = frame->ack;
}
delframe(frame);
}
}
void
broadcaststate(void)
{
int i, j, k;
int nfired[2];
uchar *bufp;
Frame *frame;
NetConn *pnc;
Party *p;
for(p = theparty.next; p != &theparty; p = p->next)
for(i = 0; i < nelem(p->players); i++){
pnc = p->players[i]->conn;
frame = newframe(&pnc->udp, NSsimstate, pnc->lastseq+1, 0, 2*(3*8+8)+3*8+20*(3*8+8), nil);
bufp = frame->data;
bufp += pack(bufp, frame->len, "PdPdP",
p->u->ships[0].p, p->u->ships[0].θ,
p->u->ships[1].p, p->u->ships[1].θ,
p->u->star.p);
nfired[0] = nfired[1] = 0;
for(j = 0; j < nelem(p->u->ships); j++)
for(k = 0; k < nelem(p->u->ships[j].rounds); k++)
if(p->u->ships[j].rounds[k].fired)
nfired[j]++;
bufp += pack(bufp, frame->len - (bufp-frame->data), "bb", nfired[0], nfired[1]);
for(j = 0; j < nelem(p->u->ships); j++)
for(k = 0; k < nelem(p->u->ships[j].rounds); k++)
if(p->u->ships[j].rounds[k].fired)
bufp += pack(bufp, frame->len - (bufp-frame->data), "bPd",
k, p->u->ships[j].rounds[k].p, p->u->ships[j].rounds[k].θ);
signframe(frame, pnc->dh.priv);
sendp(egress, frame);
}
}
void
runsim(void)
{
int i;
ulong kdown;
uvlong then, now;
double frametime, Δt;
Ioproc *io;
Party *p, *np;
Player *player;
Ship *ship;
Δt = 0.01;
then = nanosec();
io = ioproc();
for(;;){
now = nanosec();
frametime = now - then;
then = now;
if(players.len >= 2)
newparty(&theparty, players.get(&players), players.get(&players));
for(p = theparty.next; p != &theparty; p = np){
p->u->timeacc += frametime/1e9;
for(i = 0; i < nelem(p->players); i++){
player = p->players[i];
ship = &p->u->ships[i];
if(nbrecv(player->inputq, &kdown) != 0)
player->kdown = kdown;
if((player->kdown & 1<<Kquit) != 0){
np = p->next;
popconn(player->conn);
goto partydone;
}
if((player->kdown & 1<<K↑) != 0)
ship->forward(ship, Δt);
if((player->kdown & 1<<K↺) != 0)
ship->rotate(ship, 1, Δt);
if((player->kdown & 1<<K↻) != 0)
ship->rotate(ship, -1, Δt);
if(player->oldkdown != player->kdown &&
(player->kdown & 1<<Khyper) != 0)
ship->hyperjump(ship);
if(player->oldkdown != player->kdown &&
(player->kdown & 1<<Kfire) != 0)
ship->fire(ship);
player->oldkdown = player->kdown;
}
while(p->u->timeacc >= Δt){
p->u->step(p->u, Δt);
p->u->collide(p->u);
}
np = p->next;
partydone:;
}
broadcaststate();
nudgeconns(now/1e6);
iosleep(io, HZ2MS(70));
}
}
void
fprintstats(int fd)
{
usize nparties = 0;
Party *p;
for(p = theparty.next; p != &theparty; p = p->next)
nparties++;
fprint(fd, "curconns %lld\n"
"maxconns %lld\n"
"nplayers %lld\n"
"nparties %lld\n",
nconns, maxconns, players.len, nparties);
}
void
fprintstates(int fd)
{
ulong i = 0;
Party *p;
Ship *s;
for(p = theparty.next; p != &theparty; p = p->next, i++){
for(s = &p->u->ships[0]; s-p->u->ships < nelem(p->u->ships); s++){
fprint(fd, "%ld s%lld p %v v %v θ %g ω %g m %g f %d\n",
i, s-p->u->ships, s->p, s->v, s->θ, s->ω, s->mass, s->fuel);
}
fprint(fd, "%ld S p %v m %g\n", i, p->u->star.p, p->u->star.mass);
}
}
/*
* Command & Control
*
* - show stats: prints some server stats
* - show states: prints the state of running simulations
* - debug [on|off]: toggles debug mode
*/
void
threadC2(void *)
{
int fd, pfd[2], n, ncmdargs;
char buf[256], *usr, *cmdargs[2];
Ioproc *io;
if(pipe(pfd) < 0)
sysfatal("pipe: %r");
usr = getenv("user");
snprint(buf, sizeof buf, "/srv/muswctl.%s.%d", usr, getpid());
free(usr);
fd = create(buf, OWRITE|ORCLOSE|OCEXEC, 0600);
if(fd < 0)
sysfatal("open: %r");
fprint(fd, "%d", pfd[0]);
close(pfd[0]);
io = ioproc();
while((n = ioread(io, pfd[1], buf, sizeof(buf)-1)) > 0){
buf[n] = 0;
ncmdargs = tokenize(buf, cmdargs, 2);
if(ncmdargs == 2){
if(strcmp(cmdargs[0], "show") == 0){
if(strcmp(cmdargs[1], "stats") == 0)
fprintstats(pfd[1]);
else if(strcmp(cmdargs[1], "states") == 0)
fprintstates(pfd[1]);
}else if(strcmp(cmdargs[0], "debug") == 0){
if(strcmp(cmdargs[1], "on") == 0)
debug = 1;
else if(strcmp(cmdargs[1], "off") == 0)
debug = 0;
}
}
}
closeioproc(io);
}
void
usage(void)
{
fprint(2, "usage: %s [-d] [-a addr]\n", argv0);
threadexitsall("usage");
}
void
threadmain(int argc, char *argv[])
{
int acfd, adfd;
char adir[40], *addr, aux[64];
GEOMfmtinstall();
fmtinstall('I', eipfmt);
fmtinstall(L'Φ', Φfmt);
addr = "udp!*!112";
ARGBEGIN{
case 'd':
debug++;
break;
case 'a':
addr = EARGF(usage());
break;
default:
usage();
}ARGEND;
if(argc != 0)
usage();
acfd = announce(addr, adir);
if(acfd < 0)
sysfatal("announce: %r");
/* we don't want a line per client. we want it RAW */
if(fprint(acfd, "headers") < 0)
sysfatal("couldn't set udp headers option: %r");
snprint(aux, sizeof aux, "%s/data", adir);
adfd = open(aux, ORDWR);
if(adfd < 0)
sysfatal("open: %r");
if(debug)
fprint(2, "listening on %s\n", addr);
initparty(&theparty);
initplayerq(&players);
ingress = chancreate(sizeof(Frame*), 32);
egress = chancreate(sizeof(Frame*), 32);
threadcreate(threadC2, nil, mainstacksize);
threadcreate(threadnetrecv, &adfd, mainstacksize);
threadcreate(threadnetppu, nil, mainstacksize);
threadcreate(threadnetsend, &adfd, mainstacksize);
runsim();
}