|
|
|
@ -9,7 +9,7 @@ |
|
|
|
#define MAXMSG 4096 |
|
|
|
|
|
|
|
int udpsocket; |
|
|
|
const unsigned char gameversion[4]={0xda,0x01,0x00,0x04}; |
|
|
|
const unsigned char gameversion[4]={0xda,0x01,0x00,0x05}; |
|
|
|
|
|
|
|
struct netnode netnodes[64]; |
|
|
|
|
|
|
|
@ -36,6 +36,84 @@ unsigned char actions[MAXNETNODES]; |
|
|
|
unsigned char latestactions[MAXNETNODES]; |
|
|
|
long latestcounts[MAXNETNODES]; |
|
|
|
|
|
|
|
enum network_packet_types { |
|
|
|
PKT_ACK, /* perfect copy of packet received */ |
|
|
|
/* join / host game */ |
|
|
|
/* slave -> master packets */ |
|
|
|
PKT_JOIN, /* 4 bytes version #, 4 bytes joinunique #, 16 bytes name */ |
|
|
|
PKT_QUIT, /* 4 bytes unique # */ |
|
|
|
/* master -> slave packets */ |
|
|
|
PKT_INVITE, /* 4 bytes unique #, 1 byte your slot (0xff for kick, no data following it) #, any # of 1:slot,16:name sets (-1 end) */ |
|
|
|
PKT_BEGIN, /* clone of INVITE */ |
|
|
|
PKT_CONFIG, /* 4 bytes unique #, config */ |
|
|
|
PKT_ACCEPT, /* 4 bytes join unique #, 132 bytes seed + unique #, config, slot info (see invite) */ |
|
|
|
PKT_REJECT, /* 4 bytes join unique #, 4 bytes version #, 1: reason */ |
|
|
|
/* ingame actions */ |
|
|
|
/* slave -> master packets */ |
|
|
|
PKT_MYDATA, /* 4 bytes unique #,4 bytes frame #, 1 byte data */ |
|
|
|
/* master -> slave packets */ |
|
|
|
PKT_STEP, /* 4 bytes unique #, 4 bytes frame #, 8 bytes ACT_* */ |
|
|
|
|
|
|
|
PKT_INVALID = 0xff |
|
|
|
}; |
|
|
|
|
|
|
|
enum reject_reason { |
|
|
|
REJECT_FULL, |
|
|
|
REJECT_VERSION |
|
|
|
/* TODO: password? */ |
|
|
|
}; |
|
|
|
|
|
|
|
/* all bytes stored MSB first */ |
|
|
|
|
|
|
|
/* |
|
|
|
game startup: |
|
|
|
<master and matcher> |
|
|
|
Master: send REGISTER to matcher with optional password, wait for ack. If |
|
|
|
timout, resend. |
|
|
|
matcher: Wait for REGISTER packet, when received maintain database. respond |
|
|
|
to sender with ACK. REGISTER packet can close a game also. The REGISTER |
|
|
|
packet sent by the master has a unique word to be used to avoid confusion. |
|
|
|
REGISTER packet also contains a game version # |
|
|
|
|
|
|
|
After master registers game and receives ACK, just waits for slaves to contact. |
|
|
|
|
|
|
|
<slave and matcher> |
|
|
|
slave: send QUERY to matcher with optional password, wait for INFO, if timeout, |
|
|
|
resend. |
|
|
|
matcher: respond to QUERY with INFO packet. matcher need not maintain any |
|
|
|
database for slave requests. INFO packet contains IP addr and port for each |
|
|
|
master machine that matches the QUERY spec (ALL or password). Only a |
|
|
|
certain MAX # of entries are sent if there are too many to choose from. |
|
|
|
|
|
|
|
<slave and master> |
|
|
|
slave: send JOIN to master, wait for INVITE. If timeout, resend. JOIN packet |
|
|
|
contains the unique word the master created. JOIN also contains username. |
|
|
|
master: Respond to JOIN with INVITE. INVITE contains unique word from JOIN |
|
|
|
packet. INVITE either contains NO meaning game no longer exists or is closed |
|
|
|
or player is not invited. IF yes, INVITE contains info on other players |
|
|
|
already in the game (username and slot # for each). Master allocates the |
|
|
|
slots and avoids confusion based on IP addr and port #. INVITE also contains |
|
|
|
game options structure. Whenever a new player JOINS and is admitted, master |
|
|
|
sends updated INVITE packets to everyone already in the JOIN list. Whenever |
|
|
|
master changes game options, master sends out another set of INVITES |
|
|
|
|
|
|
|
Duplicate JOINS are answered with updated INVITE but nothing changes as far |
|
|
|
as allocation. |
|
|
|
|
|
|
|
Master player launches game after he's satisfied everyone has joined. |
|
|
|
|
|
|
|
Master sends BEGIN packet to everyone. BEGIN is identical to INVITE except |
|
|
|
that the data is final. Slave must respond with its first MYDATA packet with |
|
|
|
frame # of 0. If master times out waiting, master sends duplicate BEGIN to |
|
|
|
wayward slaves. Once master has received MYDATA from everyone, game starts. |
|
|
|
|
|
|
|
Within game slave sends MYDATA to master and waits for STEP packet. If |
|
|
|
timeout, slave sends duplicate MYDATA. |
|
|
|
|
|
|
|
If master times out waiting for a slave's MYDATA, slave gets dropped. MYDATAs |
|
|
|
received will be answered with PKT_QUIT. |
|
|
|
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
/* Network I/O, building/checking packets */ |
|
|
|
@ -132,17 +210,17 @@ static Uint32 readuint32(unsigned char *p) { |
|
|
|
return (p[0]<<24L) | (p[1]<<16L) | (p[2]<<8) | p[3]; |
|
|
|
} |
|
|
|
|
|
|
|
static unsigned char* writeunique(unsigned char *p) { |
|
|
|
static unsigned char* write_unique(unsigned char *p) { |
|
|
|
memcpy(p, &network_unique, 4); |
|
|
|
return p + 4; |
|
|
|
} |
|
|
|
|
|
|
|
static unsigned char* writeversion(unsigned char *p) { |
|
|
|
static unsigned char* write_version(unsigned char *p) { |
|
|
|
memcpy(p, &gameversion, 4); |
|
|
|
return p + 4; |
|
|
|
} |
|
|
|
|
|
|
|
static int isvalidmsg() { |
|
|
|
static int isvalidmsg_from_slave() { |
|
|
|
int i; |
|
|
|
void *host; |
|
|
|
void *port; |
|
|
|
@ -158,6 +236,13 @@ static int isvalidmsg() { |
|
|
|
return -1; |
|
|
|
} |
|
|
|
|
|
|
|
static int isvalidmsg_from_master() { |
|
|
|
if (sender.sin_family != mastername.sin_family |
|
|
|
|| sender.sin_addr.s_addr != mastername.sin_addr.s_addr |
|
|
|
|| sender.sin_port != mastername.sin_port) return 0; |
|
|
|
return 1; |
|
|
|
} |
|
|
|
|
|
|
|
/* Handling game actions */ |
|
|
|
|
|
|
|
static void addactions(void) { |
|
|
|
@ -190,7 +275,7 @@ static void sendactions(int which) { |
|
|
|
unsigned char msg[512]; |
|
|
|
|
|
|
|
msg[0] = PKT_STEP; |
|
|
|
writeunique(msg+1); |
|
|
|
write_unique(msg+1); |
|
|
|
writeuint32(msg+5, actioncount); |
|
|
|
memcpy(msg+9,actionblock,MAXNETNODES*ACTIONHIST); |
|
|
|
putmsg(&netnodes[which].netname,msg,MAXNETNODES*ACTIONHIST+9); |
|
|
|
@ -200,7 +285,7 @@ static void sendmine(int frame) { |
|
|
|
unsigned char msg[64]; |
|
|
|
|
|
|
|
msg[0] = PKT_MYDATA; |
|
|
|
writeunique(msg+1); |
|
|
|
write_unique(msg+1); |
|
|
|
writeuint32(msg+5, frame); |
|
|
|
msg[9]=myaction; |
|
|
|
putmsg(&mastername,msg,10); |
|
|
|
@ -229,7 +314,7 @@ int networktraffic(void) { |
|
|
|
// for example JOIN on frame 0, respond with BEGIN if player already in game |
|
|
|
// respond with uninvite INVITE on JOIN from others |
|
|
|
if(length<10) continue; |
|
|
|
whosent=isvalidmsg(); |
|
|
|
whosent = isvalidmsg_from_slave(); |
|
|
|
if(whosent<=0) continue; |
|
|
|
count=readuint32(mesg+5); |
|
|
|
if(count>latestcounts[whosent]) { |
|
|
|
@ -333,120 +418,86 @@ void freesocket(void) { |
|
|
|
|
|
|
|
/* Join / Host Games */ |
|
|
|
|
|
|
|
static void buildinform(unsigned char type) { |
|
|
|
unsigned char *put; |
|
|
|
/* Master side */ |
|
|
|
|
|
|
|
static unsigned char* write_inform(unsigned char* put) { |
|
|
|
int i; |
|
|
|
|
|
|
|
put=mesg; |
|
|
|
*put++=type; |
|
|
|
put = writeunique(put); |
|
|
|
++put; // slot specific for each slave |
|
|
|
*put++ = 0xff; /* slot specific for each slave */ |
|
|
|
for (i = 0; i < MAXNETNODES; ++i) { |
|
|
|
if(!netnodes[i].used) continue; |
|
|
|
*put++=i; |
|
|
|
memmove(put,netnodes[i].name,16); |
|
|
|
put+=16; |
|
|
|
*put++ = i; |
|
|
|
memmove(put, netnodes[i].name, 16); |
|
|
|
put += 16; |
|
|
|
} |
|
|
|
*put++=0xff; |
|
|
|
memcpy(put, configopts, sizeof(configopts)); |
|
|
|
put += sizeof(configopts); |
|
|
|
informsize=put-mesg; |
|
|
|
} |
|
|
|
|
|
|
|
static void inform1(int which) { |
|
|
|
mesg[5]=which; |
|
|
|
putmsg(&netnodes[which].netname,mesg,informsize); |
|
|
|
*put++ = 0xff; |
|
|
|
return put; |
|
|
|
} |
|
|
|
|
|
|
|
static void inform(unsigned char type) { |
|
|
|
static void send_inform_all(unsigned char type) { |
|
|
|
int i; |
|
|
|
buildinform(type); |
|
|
|
for(i=1;i<MAXNETNODES;++i) |
|
|
|
if(netnodes[i].used) |
|
|
|
inform1(i); |
|
|
|
} |
|
|
|
|
|
|
|
//returns 0=ignore packet,1=we're rejected,2=INVITE,3=BEGIN |
|
|
|
int scaninvite(int msec) { |
|
|
|
int i, size; |
|
|
|
unsigned char *take; |
|
|
|
Uint32 unique = 0; |
|
|
|
|
|
|
|
size = getmsg(msec); |
|
|
|
|
|
|
|
if (size < 6) return 0; |
|
|
|
if (*mesg!=PKT_INVITE && *mesg!=PKT_BEGIN) return 0; |
|
|
|
if (sender.sin_family != mastername.sin_family |
|
|
|
|| sender.sin_addr.s_addr != mastername.sin_addr.s_addr |
|
|
|
|| sender.sin_port != mastername.sin_port) return 0; |
|
|
|
|
|
|
|
myslot=mesg[5]; |
|
|
|
if (6 == size || 0xff == mesg[5] || 0xff == mesg[6]) return 1; |
|
|
|
unsigned char *put = mesg; |
|
|
|
|
|
|
|
/* update unique */ |
|
|
|
memcpy(&unique, mesg+1, 4); |
|
|
|
if (unique != network_unique) |
|
|
|
set_unique(ntohl(unique)); |
|
|
|
*put++ = type; |
|
|
|
put = write_unique(put); |
|
|
|
put = write_inform(put); |
|
|
|
informsize = put-mesg; |
|
|
|
|
|
|
|
memset(netnodes,0,sizeof(netnodes)); |
|
|
|
size-=6; |
|
|
|
take=mesg+6; |
|
|
|
while(*take!=0xff && size>=17) { |
|
|
|
if((i=*take)<MAXNETNODES) { |
|
|
|
netnodes[i].used=1; |
|
|
|
memmove(netnodes[i].name,take+1,16); |
|
|
|
for(i=1;i<MAXNETNODES;++i) { |
|
|
|
if(netnodes[i].used) { |
|
|
|
mesg[5] = i; |
|
|
|
putmsg(&netnodes[i].netname, mesg, informsize); |
|
|
|
} |
|
|
|
take+=17; |
|
|
|
size-=17; |
|
|
|
} |
|
|
|
take++; size--; /* read 0xff */ |
|
|
|
} |
|
|
|
|
|
|
|
if(*mesg==PKT_INVITE) { |
|
|
|
return 2; |
|
|
|
} else { /* BEGIN */ |
|
|
|
if (size != sizeof(configopts)) { |
|
|
|
fprintf(stderr, "PKT_BEGIN has wrong size: %i != %i\n", size, (int) sizeof(configopts)); |
|
|
|
return 1; /* broken packet */ |
|
|
|
} |
|
|
|
set_game_options(take); |
|
|
|
return 3; |
|
|
|
} |
|
|
|
static unsigned char* write_config(unsigned char* put) { |
|
|
|
*put++ = configopts.density; |
|
|
|
*put++ = configopts.flames; |
|
|
|
*put++ = configopts.bombs; |
|
|
|
*put++ = configopts.generosity; |
|
|
|
return put; |
|
|
|
} |
|
|
|
|
|
|
|
int send_join(struct sockaddr_in *netname, char playername[16]) { |
|
|
|
int res = 0; |
|
|
|
long now; |
|
|
|
static void build_config() { |
|
|
|
unsigned char *put; |
|
|
|
|
|
|
|
set_unique(-1); /* reset unique and random */ |
|
|
|
put=mesg; |
|
|
|
*put++=PKT_CONFIG; |
|
|
|
put = write_config(put); |
|
|
|
informsize=put-mesg; |
|
|
|
} |
|
|
|
|
|
|
|
mastername = *netname; |
|
|
|
*regpacket=PKT_JOIN; |
|
|
|
writeversion(regpacket + 1); |
|
|
|
memmove(regpacket+5, playername, 16); |
|
|
|
now=longtime(); |
|
|
|
while(longtime()-now<10) { |
|
|
|
putmsg(&mastername,regpacket,1+4+16); |
|
|
|
if (0 == (res=scaninvite(1000))) continue; |
|
|
|
return res; |
|
|
|
} |
|
|
|
return 0; |
|
|
|
static void send_config1(int which) { |
|
|
|
putmsg(&netnodes[which].netname,mesg,informsize); |
|
|
|
} |
|
|
|
|
|
|
|
void send_quit() { |
|
|
|
long now; |
|
|
|
int size; |
|
|
|
void send_config() { |
|
|
|
int i; |
|
|
|
build_config(); |
|
|
|
for (i = 1; i < MAXNETNODES; ++i) |
|
|
|
if (netnodes[i].used) |
|
|
|
send_config1(i); |
|
|
|
} |
|
|
|
|
|
|
|
*regpacket = PKT_QUIT; |
|
|
|
writeunique(regpacket+1); |
|
|
|
now=longtime(); |
|
|
|
while(longtime()-now<10) { |
|
|
|
putmsg(&mastername,regpacket,5); |
|
|
|
size=getmsg(1000); |
|
|
|
if(size<6) continue; |
|
|
|
if(mesg[0] != PKT_ACK || mesg[1] != PKT_QUIT) continue; |
|
|
|
if (isvalidunique(mesg+2)) |
|
|
|
break; |
|
|
|
} |
|
|
|
static void send_reject(struct sockaddr_in *toname, Uint32 network_join_unique, unsigned char reason) { |
|
|
|
mesg[0] = PKT_REJECT; |
|
|
|
memcpy(mesg+1, &network_join_unique, sizeof(network_join_unique)); |
|
|
|
write_version(mesg+5); |
|
|
|
mesg[9] = reason; |
|
|
|
putmsg(&sender,mesg,10); |
|
|
|
} |
|
|
|
|
|
|
|
static void send_accept(Uint32 network_join_unique) { |
|
|
|
unsigned char *put = mesg; |
|
|
|
|
|
|
|
*put++ = PKT_ACCEPT; |
|
|
|
memcpy(put, &network_join_unique, sizeof(network_join_unique)); |
|
|
|
put += sizeof(network_join_unique); |
|
|
|
put = write_seed_unique(put); |
|
|
|
put = write_config(put); |
|
|
|
put = write_inform(put); |
|
|
|
putmsg(&sender,mesg,put-mesg); |
|
|
|
} |
|
|
|
|
|
|
|
int start_network_game() { |
|
|
|
@ -459,21 +510,21 @@ int start_network_game() { |
|
|
|
} |
|
|
|
|
|
|
|
int begin_network_game() { |
|
|
|
inform(PKT_BEGIN); |
|
|
|
send_inform_all(PKT_BEGIN); |
|
|
|
network = NETWORK_MASTER; |
|
|
|
/* TODO: wait for ack */ |
|
|
|
return 1; |
|
|
|
} |
|
|
|
|
|
|
|
void send_invites() { |
|
|
|
inform(PKT_INVITE); |
|
|
|
send_inform_all(PKT_INVITE); |
|
|
|
} |
|
|
|
|
|
|
|
void cancel_network_game() { |
|
|
|
int i; |
|
|
|
|
|
|
|
mesg[0] = PKT_INVITE; |
|
|
|
writeunique(mesg+1); |
|
|
|
write_unique(mesg+1); |
|
|
|
mesg[5] = 0xff; |
|
|
|
|
|
|
|
for(i=1;i<MAXNETNODES;++i) { |
|
|
|
@ -487,11 +538,17 @@ int handle_joins() { |
|
|
|
int size; |
|
|
|
int i, j; |
|
|
|
unsigned char temp[64]; |
|
|
|
Uint32 network_join_unique; |
|
|
|
|
|
|
|
size=getmsg(40); |
|
|
|
switch (*mesg) { |
|
|
|
case PKT_JOIN: |
|
|
|
if (size < 21 || !isvalidversion(mesg+1)) return 0; |
|
|
|
if (size < 25) return 0; |
|
|
|
memcpy(&network_join_unique, mesg+5, sizeof(network_join_unique)); |
|
|
|
if (!isvalidversion(mesg+1)) { |
|
|
|
send_reject(&sender, network_join_unique, REJECT_VERSION); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
break; |
|
|
|
case PKT_QUIT: |
|
|
|
if (size < 5 || !isvalidunique(mesg+1)) return 0; |
|
|
|
@ -519,23 +576,21 @@ int handle_joins() { |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
if(*mesg==PKT_QUIT) { |
|
|
|
switch (*mesg) { |
|
|
|
case PKT_QUIT: |
|
|
|
if(i < MAXNETNODES) /* if host found, reset entry */ |
|
|
|
memset(netnodes+i,0,sizeof(struct netnode)); |
|
|
|
/* send always ACK for QUITs */ |
|
|
|
*temp=PKT_ACK; |
|
|
|
memmove(temp+1,mesg,5); |
|
|
|
putmsg(&sender,temp,6); |
|
|
|
} else { |
|
|
|
break; |
|
|
|
case PKT_JOIN: |
|
|
|
if (i==MAXNETNODES && j==-1) { /* reject */ |
|
|
|
*mesg=PKT_INVITE; |
|
|
|
writeunique(mesg+1); |
|
|
|
mesg[5]=0xff; |
|
|
|
putmsg(&sender,mesg,6); |
|
|
|
send_reject(&sender, network_join_unique, REJECT_FULL); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
/* no explicit ack, send invites to all later */ |
|
|
|
if(i==MAXNETNODES) i=j; |
|
|
|
memmove(&netnodes[i].netname.sin_addr.s_addr, |
|
|
|
&sender.sin_addr.s_addr,4); |
|
|
|
@ -543,8 +598,138 @@ int handle_joins() { |
|
|
|
&sender.sin_port,2); |
|
|
|
netnodes[i].netname.sin_family=AF_INET; |
|
|
|
netnodes[i].used=1; |
|
|
|
memmove(netnodes[i].name,mesg+5,16); |
|
|
|
memcpy(netnodes[i].name,mesg+9,16); |
|
|
|
netnodes[i].name[15] = '\0'; |
|
|
|
|
|
|
|
send_accept(network_join_unique); |
|
|
|
break; |
|
|
|
} |
|
|
|
return 1; |
|
|
|
} |
|
|
|
|
|
|
|
/* Client side */ |
|
|
|
|
|
|
|
static int read_inform(unsigned char** pbuf, int *psize) { |
|
|
|
unsigned char *buf = *pbuf; |
|
|
|
int size = *psize; |
|
|
|
int i; |
|
|
|
|
|
|
|
if (size < 1) return 0; |
|
|
|
myslot = *buf++; size--; |
|
|
|
if (0xff == myslot) return 1; |
|
|
|
|
|
|
|
if (size < 1) return 0; |
|
|
|
while (0xff != *buf) { |
|
|
|
i = *buf++; size--; |
|
|
|
if (size < 17 || i >= MAXNETNODES) return 0; |
|
|
|
netnodes[i].used = 1; |
|
|
|
memcpy(netnodes[i].name, buf, 16); |
|
|
|
buf += 16; |
|
|
|
size -= 16; |
|
|
|
} |
|
|
|
|
|
|
|
*psize = size; |
|
|
|
*pbuf = buf; |
|
|
|
return 1; |
|
|
|
} |
|
|
|
|
|
|
|
static void read_config(unsigned char* buf) { |
|
|
|
GameOptions opts; |
|
|
|
memset(&opts, 0, sizeof(opts)); |
|
|
|
opts.density = *buf++; |
|
|
|
opts.flames = *buf++; |
|
|
|
opts.bombs = *buf++; |
|
|
|
opts.generosity = *buf++; |
|
|
|
set_game_options(&opts); |
|
|
|
} |
|
|
|
|
|
|
|
/* returns 0=ignore packet,1=we're rejected,2=INVITE/CONFIG,3=BEGIN */ |
|
|
|
int scaninvite(int msec) { |
|
|
|
int size; |
|
|
|
unsigned char *take; |
|
|
|
|
|
|
|
size = getmsg(msec); |
|
|
|
|
|
|
|
if (size < 6) return 0; |
|
|
|
if (*mesg!=PKT_INVITE && *mesg!=PKT_BEGIN && *mesg!=PKT_CONFIG) return 0; |
|
|
|
if (!isvalidmsg_from_master()) return 0; |
|
|
|
if (!isvalidunique(mesg+1)) return 0; |
|
|
|
|
|
|
|
take = mesg+5; |
|
|
|
size -= 5; |
|
|
|
|
|
|
|
switch (*mesg) { |
|
|
|
case PKT_INVITE: |
|
|
|
case PKT_BEGIN: |
|
|
|
if (!read_inform(&take, &size)) return 0; |
|
|
|
if (0xff == myslot) return 1; /* master closed game */ |
|
|
|
break; |
|
|
|
case PKT_CONFIG: |
|
|
|
if (size < 4) return 0; |
|
|
|
read_config(take); |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
if (*mesg == PKT_BEGIN) { |
|
|
|
return 3; |
|
|
|
} else { |
|
|
|
return 2; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
int send_join(struct sockaddr_in *netname, char playername[16]) { |
|
|
|
int size; |
|
|
|
long now; |
|
|
|
Uint32 join_unique = gtime(); |
|
|
|
unsigned char *buf; |
|
|
|
|
|
|
|
mastername = *netname; |
|
|
|
*regpacket=PKT_JOIN; |
|
|
|
write_version(regpacket + 1); |
|
|
|
writeuint32(regpacket+5, join_unique); |
|
|
|
memcpy(regpacket+9, playername, 16); |
|
|
|
now=longtime(); |
|
|
|
putmsg(&mastername,regpacket,1+4+4+16); |
|
|
|
while(longtime()-now < 3) { |
|
|
|
if (0 == (size = getmsg(1000))) { |
|
|
|
/* got no message, send join again */ |
|
|
|
putmsg(&mastername,regpacket,1+4+4+16); |
|
|
|
continue; |
|
|
|
} |
|
|
|
if (size < 5) continue; |
|
|
|
if (readuint32(mesg+1) != join_unique) continue; |
|
|
|
switch (*mesg) { |
|
|
|
case PKT_ACCEPT: |
|
|
|
if (size < 1+4+132+4+2) continue; |
|
|
|
read_seed_unique(mesg + 5); |
|
|
|
read_config(mesg+137); |
|
|
|
buf = mesg+141; |
|
|
|
size -= 141; |
|
|
|
if (!read_inform(&buf,&size)) return 0; |
|
|
|
return 2; |
|
|
|
case PKT_REJECT: |
|
|
|
/* TODO: print reject message */ |
|
|
|
return 0; |
|
|
|
default: |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
void send_quit() { |
|
|
|
long now; |
|
|
|
int size; |
|
|
|
|
|
|
|
*regpacket = PKT_QUIT; |
|
|
|
write_unique(regpacket+1); |
|
|
|
now=longtime(); |
|
|
|
while(longtime()-now<10) { |
|
|
|
putmsg(&mastername,regpacket,5); |
|
|
|
size=getmsg(1000); |
|
|
|
if(size<6) continue; |
|
|
|
if(mesg[0] != PKT_ACK || mesg[1] != PKT_QUIT) continue; |
|
|
|
if (isvalidunique(mesg+2)) |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
Stefan Bühler
11 years ago