---------------------------------------*/ int setbcorbit(int tag) {
int rc;
char buffer[50];
printf("setting ttcmi clock:%d\n", tag);
if(micratepresent()==0) {
#define MAXdbhns 40
char dbhns[MAXdbhns]; int ldbhns;
ldbhns= readclockshift(dbhns, MAXdbhns);
printf("mi crate not present. readclockshift:%d:%s:\n", ldbhns,dbhns);
if(tag==1) {bcmvme=3; omvme=0;
} else if(tag==2) {bcmvme=2; omvme=1;
} else if(tag==3) {bcmvme=1; omvme=2;
} else if(tag==4) {bcmvme=0; omvme=2;
} else {
printf("novme setbcorbit: bad tag:%d bcmvme:%x omvme:%x\n", tag, bcmvme, omvme);
return(0);
};
} else {
setbcorbitMain(tag);
};
rc= dis_update_service(SHIFTid);
printf("TTCMI/SHIFT updated for %d clients\n", rc);
sprintf(buffer, "mon ds005 N:%d", tag);
rc= udpsend(udpsock, (unsigned char *)buffer, strlen(buffer)+1);
getclocknow();
return(tag);
}
int main() {
udpsock s1 = udplisten(iplocal(NULL, 5555, 0));
udpsock s2 = udplisten(iplocal(NULL, 5556, 0));
ipaddr addr = ipremote("127.0.0.1", 5556, 0, -1);
while(1) {
udpsend(s1, addr, "ABC", 3);
assert(errno == 0);
char buf[3];
size_t sz = udprecv(s2, &addr, buf, sizeof(buf), now() + 100);
if(errno == ETIMEDOUT)
continue;
assert(errno == 0);
assert(sz == 3);
break;
}
while(1) {
udpsend(s2, addr, "DEF", 3);
assert(errno == 0);
char buf[3];
size_t sz = udprecv(s1, &addr, buf, sizeof(buf), now() + 100);
if(errno == ETIMEDOUT)
continue;
assert(errno == 0);
assert(sz == 3);
break;
}
udpclose(s2);
udpclose(s1);
return 0;
}
/*------------------------------------------------------------------------
* snd - send datagram just for kicks
*------------------------------------------------------------------------
*/
snd()
{
char *ch;
int i, r;
struct epacket *packet;
sleep10(50);
kprintf("Sending a datagram\n");
packet = (struct epacket *) getbuf(netpool);
ch = (char *) ( (struct udpip *)packet->ep_data)->u_data;
for (i=0 ; i<10; i++)
*ch++ = 'D';
r = udpsend(netgate, 7/*ECHO*/, 50, packet, 10);
kprintf("udpsend returns %d\n",r);
}
void QCOMM::timerEvent(QTimerEvent *event)
{
if(event->timerId()==timerid){
HEARTBEAT heart;
heart.header.sizeofpack = sizeof heart;
heart.header.magic[0] ='M';
heart.header.magic[1] ='D';
heart.header.seq = heartbeatnum++;
heart.customerID = 0xaa;
heart.fileterminal = hasterminalfile();
heart.licensetimeout = islicensetimeout();
heart.netinvade = isnetinvade();
heart.numofpack = numberofudppack;
heart.header.crc = qChecksum((char *)(&heart+sizeof (heart.header)),sizeof heart-sizeof (heart.header));
udpsend((char*)&heart,sizeof(heart));
}
}
int main(int argc, char **argv)
{
Uint16 port;
char *host,*fname,*fbasename;
Sint32 flen,pos,p2;
int len,blocks,i,err=0;
Uint32 ack;
IPaddress ip;
UDPsocket sock;
UDPpacket *in, *out;
FILE *f;
/* check our commandline */
if(argc<4)
{
printf("%s host port file\n",argv[0]);
exit(0);
}
/* initialize SDL */
if(SDL_Init(0)==-1)
{
printf("SDL_Init: %s\n",SDL_GetError());
exit(1);
}
/* initialize SDL_net */
if(SDLNet_Init()==-1)
{
printf("SDLNet_Init: %s\n",SDLNet_GetError());
exit(2);
}
/* get the host from the commandline */
host=argv[1];
/* get the port from the commandline */
port=(Uint16) strtol(argv[2],NULL,0);
if(!port)
{
printf("a server port cannot be 0.\n");
exit(3);
}
/* get filename to get from server from commandline */
fname=argv[3];
if(SDLNet_ResolveHost(&ip,host,port)==-1)
{
printf("SDLNet_ResolveHost: %s\n",SDLNet_GetError());
exit(4);
}
/* open udp client socket */
if(!(sock=SDLNet_UDP_Open(0)))
{
printf("SDLNet_UDP_Open: %s\n",SDLNet_GetError());
exit(5);
}
/* allocate max packet */
if(!(out=SDLNet_AllocPacket(65535)))
{
printf("SDLNet_AllocPacket: %s\n",SDLNet_GetError());
exit(6);
}
if(!(in=SDLNet_AllocPacket(65535)))
{
printf("SDLNet_AllocPacket: %s\n",SDLNet_GetError());
exit(6);
}
/* bind server address to channel 0 */
if(SDLNet_UDP_Bind(sock, 0, &ip)==-1)
{
printf("SDLNet_UDP_Bind: %s\n",SDLNet_GetError());
exit(7);
}
/* open output file */
fbasename=strrchr(fname,'/');
if(!fbasename)
fbasename=fname;
else
fbasename++;
printf("writting file: %s\n",fbasename);
if(!(f=fopen(fbasename,"wb")))
{
perror("fopen");
exit(8);
}
/* request file / expect filesize */
printf("requesting file=%s\n",fname);
out->data[0]=1<<4;
strcpy((char*)out->data+1,fname);
out->len=strlen(fname)+2;
if(udpsend(sock,0,out,in,200,1,TIMEOUT)<1)
exit(9);
flen=SDLNet_Read32(in->data+1);
len=SDLNet_Read32(in->data+5);
blocks=(flen+len-1)/len;
printf("flen=%d blocksize=%d blocks=%d\n",flen,len,blocks);
/* send ready / expect file */
printf("starting transfer\n");
out->data[0]=2<<4;
out->len=1;
if(udpsend(sock,0,out,in,10,2,TIMEOUT)<1)
exit(10);
if(flen<0)
{
printf("file not available...\n");
exit(11);
}
pos=0; /* count per 32 blocks */
while(pos*32<blocks && !err)
{
/*printf("pos=%d\n",pos); */
ack=0;
if((pos+1)*32>=blocks)
{
for(i=blocks%32;i<32;i++)
ack|=1<<i;
}
printf("\r "
"\r%3d%% %08x: ",(pos*3200)/blocks,pos*32*len);
while(ack!=0xffffffff && !err)
{
i=in->data[1];
p2=SDLNet_Read32(in->data+2);
/*printf("received %d,%d\n",i,p2); */
if(!(ack&1<<i) && p2>=pos*32*len)
{
fseek(f,p2,SEEK_SET);
fwrite(in->data+6,in->len-6,1,f);
ack|=1<<i;
printf(".");
fflush(stdout);
}
if(ack!=0xffffffff)
err=udprecv(sock,in,10,2,500);
if(err<0)
continue; /* error... */
if(!err)
{
/*printf("sending ack 0x%0X\n",ack); */
out->data[0]=3<<4;
SDLNet_Write32(pos*32*len,out->data+1);
SDLNet_Write32(ack,out->data+5);
out->len=9;
SDLNet_UDP_Send(sock,0,out);
}
err=0;
}
pos++;
}
printf("\ndone.\n");
fclose(f);
/* close the socket */
SDLNet_UDP_Close(sock);
/* free packets */
SDLNet_FreePacket(out);
SDLNet_FreePacket(in);
/* shutdown SDL_net */
SDLNet_Quit();
/* shutdown SDL */
SDL_Quit();
return(0);
}
static void video_encoded_toudp(omxcam_buffer_t buff)
{
extern void udpsend(int, const unsigned char*, int);
udpsend(udpsock, buff.data, buff.length);
}
/*------------------------------------------------------------------------
* rwhod - Periodically clean cache and (optionally) send rwho packets
*------------------------------------------------------------------------
*/
PROCESS
rwhod(void)
{
STATWORD ps;
char *p;
int i, j;
struct rwent *rwptr;
struct rwent *myptr;
struct rwhopac *rpacptr;
struct rw_who *rwwptr;
struct ep *pep;
u_long now;
int len;
/* Initialize rwho information */
Rwho.rwnent = 1;
Rwho.rwsend = TRUE;
getutim(&Rwho.rwbtime);
myptr = &Rwho.rwcache[0];
myptr->rwboot = myptr->rwlast = myptr->rwslast = Rwho.rwbtime;
for (i=0 ; i<3 ; i++)
myptr->rwload[i] = 0L;
myptr->rwusers = 1;
for( ; TRUE ; sleep(RWDELAY) ) {
if (getname(myptr->rwmach) == SYSERR)
continue;
if (p = index(myptr->rwmach, '.'))
*p = '\0';
getutim(&now);
myptr->rwlast = myptr->rwslast = now;
disable(ps);
for (i=0 ; i<Rwho.rwnent ; i++) {
rwptr = &Rwho.rwcache[i];
if (now - rwptr->rwlast > RWMAXDT) {
Rwho.rwnent--;
for (j=i-- ; j<Rwho.rwnent ; j++)
Rwho.rwcache[j] = Rwho.rwcache[j+1];
}
}
restore(ps);
if (!Rwho.rwsend)
continue;
pep = (struct ep *)getbuf(Net.netpool);
rpacptr = (struct rwhopac *)
((struct udp *)
(((struct ip *)pep->ep_data)->ip_data))->u_data;
rpacptr->rw_vers = RWVERSION;
rpacptr->rw_type= RWSTATUS;
rpacptr->rw_sndtim = hl2net(now);
rpacptr->rw_rtim = 0L;
getname(rpacptr->rw_host);
if (p = index(rpacptr->rw_host, '.'))
*p = '\0';
for (j=0 ; j<RWNLOAD ; j++)
rpacptr->rw_load[j] = 0L;
rpacptr->rw_btim = hl2net(Rwho.rwbtime);
len = RWMINP;
if ( marked(Shl.shmark) && Shl.shused ) {
rwwptr = &rpacptr->rw_rww[0];
strcpy (rwwptr->rw_tty, "Console");
strncpy(rwwptr->rw_nam, Shl.shuser, RWNLEN);
rwwptr->rw_ton = hl2net(Shl.shlogon);
rwwptr->rw_idle = hl2net(now - Shl.shlast);
len += sizeof(struct rw_who);
}
for (i=0; i<(Net.nif-1); ++i) {
struct ep *pep2;
if (i == NI_LOCAL)
continue;
if (nif[i].ni_state != NIS_UP)
continue;
pep2 = (struct ep *)getbuf(Net.netpool);
if (pep2 == (struct ep *)SYSERR)
break;
memcpy(pep2, pep, EP_HLEN+IP_ALEN+len);
udpsend(nif[i].ni_brc, UP_RWHO, UP_RWHO,
pep2, len, 1);
}
udpsend(nif[i].ni_brc, UP_RWHO, UP_RWHO, pep,
len, 1);
}
}
//------------------------------------------------------------------------
// rwhod - Periodically clean cache and (optionally) send rwho packets
//------------------------------------------------------------------------
PROCESS
rwhod(void)
{
int i, j;
struct rwent *rwptr;
struct rwent *myptr;
struct rwhopac *rpacptr;
struct rw_who *rwwptr;
struct epacket *packet;
IPaddr mynet;
long now;
int len;
int ps;
// Initialize rwho information
Rwho.rwnent = 1;
Rwho.rwsend = TRUE;
getutime(&Rwho.rwbtime);
myptr = &Rwho.rwcache[0];
getname(myptr->rwmach, RMACLEN);
myptr->rwboot = myptr->rwlast = myptr->rwslast = Rwho.rwbtime;
for (i = 0; i < 3; i++)
myptr->rwload[i] = 0L;
myptr->rwusers = 1;
getnet(mynet);
for (; TRUE; sleep(RWDELAY)) {
getutime(&now);
myptr->rwlast = myptr->rwslast = now;
ps = disable();
for (i = 0; i < Rwho.rwnent; i++) {
rwptr = &Rwho.rwcache[i];
if (now - rwptr->rwlast > RWMAXDT) {
Rwho.rwnent--;
for (j = i--; j < Rwho.rwnent; j++)
Rwho.rwcache[j] =
Rwho.rwcache[j + 1];
}
}
restore(ps);
if (!Rwho.rwsend)
continue;
packet = (struct epacket *)getbuf(Net.netpool);
rpacptr = (struct rwhopac *)
((struct udp *)
(((struct ip *)packet->ep_data)->i_data))->u_data;
rpacptr->rw_vers = RWVERSION;
rpacptr->rw_type = RWSTATUS;
rpacptr->rw_sndtim = hl2net(now);
rpacptr->rw_rtim = 0L;
getname(rpacptr->rw_host, sizeof(rpacptr->rw_host));
for (j = 0; j < RWNLOAD; j++)
rpacptr->rw_load[j] = 0L;
rpacptr->rw_btim = hl2net(Rwho.rwbtime);
len = RWMINP;
if (marked(Shl.shmark) && Shl.shused) {
rwwptr = &rpacptr->rw_rww[0];
strlcpy(rwwptr->rw_tty, "Console", RWNLEN);
strncpy(rwwptr->rw_nam, Shl.shuser, RWNLEN);
rwwptr->rw_ton = hl2net(Shl.shlogon);
rwwptr->rw_idle = hl2net(now - Shl.shlast);
len += sizeof(struct rw_who);
}
udpsend(mynet, URWHO, URWHO, packet, len);
}
}
