[governance] The C02 LAN-Link Prefix for Uni.X to Uni.X .NETworking

Jim Fleming JimFleming at ameritech.net
Thu Dec 15 21:26:39 EST 2005


The 12-bit C02 value comes from the UDP port field for LAN to LAN bridging.
When considered as the left-most 12 bits of the 64-bit Uni.X to Uni.X
addressing
the C02 shows up as 11.00.0000.001.0.

11 - #define YOU_11  3
00 - #define EARTH_00 0
0000 - tos field
001 - gov field
0* - ida field

That can be viewed as user-to-user connections on Earth, with some spare
bits for "governance".

The C02 is hard-wired into the video game console. It could be mapped, but
there does
not seem to be much concern as long as the various vendors do not collide.
Computer
Professionals for Social Responsibility may want to consider helping to make
sure the
vendors do not collide. The software can only do so much, and it generally
allows all
values. Consumers will benefit from things just working, out of the box,
without a lot of
configuration. There are tens of millions of devices out there with C02
wired into them.
That more or less sets a marketplace standard, a defacto value.

Saddr_set(msg,addr)
 unsigned char *msg;
 U64 addr;
{
 //printk("Saddr_set addr=%016.llX\n",addr);
 SET_V16_verSS(msg,(addr&0xC000000000000000)>>62);
 SET_V16_hlnSS(msg,(addr&0x3000000000000000)>>60);
 SET_V16_tosSSSS(msg,(addr&0x0F00000000000000)>>56);
 SET_V16_govSSS(msg,(addr&0x00E0000000000000)>>53);
 SET_V16_idaSSSSSSS(msg,(addr&0x001FC00000000000)>>46);
 SET_V16_idbS(msg,(addr&0x0000200000000000)>>45);
 SET_V16_pivS(msg,(addr&0x0000100000000000)>>44);
 msg[12]=(addr&0x00000FF000000000)>>36;
 msg[13]=(addr&0x0000000FF0000000)>>28;
 msg[14]=(addr&0x000000000FF00000)>>20;
 msg[15]=(addr&0x00000000000FF000)>>12;
 SET_V16_dmzS(msg,(addr&0x0000000000000800)>>11);
 SET_V16_frgSSSSSS(msg,(addr&0x00000000000007E0)>>5);
 SET_V16_ttaS(msg,(addr&0x0000000000000010)>>4);
 SET_V16_ttbS(msg,(addr&0x0000000000000008)>>3);
 SET_V16_proSSS(msg,(addr&0x0000000000000007)>>0);
}

 U64
Saddr_get(msg)
 unsigned char *msg;
{
 U64 r;

 r=(U64)GET_V16_verSS(msg)<<62;
 r=((r&~0x3000000000000000)|((U64)GET_V16_hlnSS(msg)<<60));
 r=((r&~0x0F00000000000000)|((U64)GET_V16_tosSSSS(msg)<<56));
 r=((r&~0x00E0000000000000)|((U64)GET_V16_govSSS(msg)<<53));
 r=((r&~0x001FC00000000000)|((U64)GET_V16_idaSSSSSSS(msg)<<46));
 r=((r&~0x0000200000000000)|((U64)GET_V16_idbS(msg)<<45));
 r=((r&~0x0000100000000000)|((U64)GET_V16_pivS(msg)<<44));
 r=((r&~0x00000FF000000000)|((U64)msg[12]<<36));
 r=((r&~0x0000000FF0000000)|((U64)msg[13]<<28));
 r=((r&~0x000000000FF00000)|((U64)msg[14]<<20));
 r=((r&~0x00000000000FF000)|((U64)msg[15]<<12));
 r=((r&~0x0000000000000800)|((U64)GET_V16_dmzS(msg)<<11));
 r=((r&~0x00000000000007E0)|((U64)GET_V16_frgSSSSSS(msg)<<5));
 r=((r&~0x0000000000000010)|((U64)GET_V16_ttaS(msg)<<4));
 r=((r&~0x0000000000000008)|((U64)GET_V16_ttbS(msg)<<3));
 r=((r&~0x0000000000000007)|((U64)GET_V16_proSSS(msg)<<0));
 //printk("Saddr_get addr=%016.llX\n",r);
 return r;
}

Daddr_set(msg,addr)
 unsigned char *msg;
 U64 addr;
{
 //printk("Daddr_set addr=%016.llX\n",addr);
 SET_V16_verDD(msg,(addr&0xC000000000000000)>>62);
 SET_V16_hlnDD(msg,(addr&0x3000000000000000)>>60);
 SET_V16_tosDDDD(msg,(addr&0x0F00000000000000)>>56);
 SET_V16_govDDD(msg,(addr&0x00E0000000000000)>>53);
 SET_V16_idaDDDDDDD(msg,(addr&0x001FC00000000000)>>46);
 SET_V16_idbD(msg,(addr&0x0000200000000000)>>45);
 SET_V16_pivD(msg,(addr&0x0000100000000000)>>44);
 msg[16]=(addr&0x00000FF000000000)>>36;
 msg[17]=(addr&0x0000000FF0000000)>>28;
 msg[18]=(addr&0x000000000FF00000)>>20;
 msg[19]=(addr&0x00000000000FF000)>>12;
 SET_V16_dmzD(msg,(addr&0x0000000000000800)>>11);
 SET_V16_frgDDDDDD(msg,(addr&0x00000000000007E0)>>5);
 SET_V16_ttaD(msg,(addr&0x0000000000000010)>>4);
 SET_V16_ttbD(msg,(addr&0x0000000000000008)>>3);
 SET_V16_proDDD(msg,(addr&0x0000000000000007)>>0);
}

 U64
Daddr_get(msg)
 unsigned char *msg;
{
 U64 r;

 r=(U64)GET_V16_verDD(msg)<<62;
 r=((r&~0x3000000000000000)|((U64)GET_V16_hlnDD(msg)<<60));
 r=((r&~0x0F00000000000000)|((U64)GET_V16_tosDDDD(msg)<<56));
 r=((r&~0x00E0000000000000)|((U64)GET_V16_govDDD(msg)<<53));
 r=((r&~0x001FC00000000000)|((U64)GET_V16_idaDDDDDDD(msg)<<46));
 r=((r&~0x0000200000000000)|((U64)GET_V16_idbD(msg)<<45));
 r=((r&~0x0000100000000000)|((U64)GET_V16_pivD(msg)<<44));
 r=((r&~0x00000FF000000000)|((U64)msg[16]<<36));
 r=((r&~0x0000000FF0000000)|((U64)msg[17]<<28));
 r=((r&~0x000000000FF00000)|((U64)msg[18]<<20));
 r=((r&~0x00000000000FF000)|((U64)msg[19]<<12));
 r=((r&~0x0000000000000800)|((U64)GET_V16_dmzD(msg)<<11));
 r=((r&~0x00000000000007E0)|((U64)GET_V16_frgDDDDDD(msg)<<5));
 r=((r&~0x0000000000000010)|((U64)GET_V16_ttaD(msg)<<4));
 r=((r&~0x0000000000000008)|((U64)GET_V16_ttbD(msg)<<3));
 r=((r&~0x0000000000000007)|((U64)GET_V16_proDDD(msg)<<0));
 return r;
}

Msg_print(msg)
 unsigned char *msg;
{

printk("%1X.%1X.%X:%X{%02o{%03X}}%02X:%02X.%1X.%1X.[%d.%d.%d.%d].%1X.%04o.%1
X.%1X((%d)%d)<%d>%02o.%04X[%d.%d.%d.%d]\n",
  GET_V16_verSSDD(msg),
  GET_V16_hlnSSDD(msg),
  GET_V16_tosSSSS(msg),
  GET_V16_tosDDDD(msg),
  GET_V16_govSSSDDD(msg),
  GET_V16_length(msg),
  GET_V16_idaSSSSSSS(msg),
  GET_V16_idaDDDDDDD(msg),
  GET_V16_idbSD(msg),
  GET_V16_pivSD(msg),
  msg[12],msg[13],msg[14],msg[15],
  GET_V16_dmzSD(msg),
  GET_V16_frgSSSSSSDDDDDD(msg),
  GET_V16_ttaSD(msg),
  GET_V16_ttbSD(msg),
  GET_V16_global(msg),
  GET_V16_hops(msg),
  GET_V16_protocol(msg),
  GET_V16_proSSSDDD(msg),
  GET_V16_checksum(msg),
  msg[16],msg[17],msg[18],msg[19]);
}


Byte_set(m,c)
 char *m;
 int c;
{
 SET_V16_protocol(m,NOP_00);
 SET_V16_byte(m,c);
 SET_V16_checksum(m,0);
 SET_V16_checksum(m,Checksum_of(m,LENGTH_160));
}

 int
Byte_get(m)
 char *m;
{
 int r;
 int cs;

 if(GET_V16_protocol(m) != NOP_00){
  r = -1;
 }
 else{
  cs = GET_V16_checksum(m);
  SET_V16_checksum(m,0);
  if(cs != Checksum_of(m,LENGTH_160)){
   r = -2;
  }
  else{
   r = GET_V16_byte(m);
  }
  SET_V16_checksum(m,cs);
 }
 return r;
}

/*
* Encode 16 bits of data in the checksum bits and xor+parity in length
*/

Short_set(m,c)
 char *m;
 int c;
{
 unsigned char xor;

 SET_V16_protocol(m,NOP_00);
 xor = ((c>>8)&0xFF)^(c&0xFF);
 if (bitcnt[xor] & 0x01){
  SET_V16_blength(m,SHORT_E_01);
 }
 else{
  SET_V16_blength(m,SHORT_O_10);
 }
 SET_V16_byte(m,xor);
 SET_V16_checksum(m,c);
}

 int
Short_get(m)
 char *m;
{
 int r;
 unsigned char xor;

 r=0;
 if(GET_V16_protocol(m) != NOP_00){
  r = -1;
 }
 else{
  xor = GET_V16_byte(m);
  if(bitcnt[xor] & 0x01){
   if(GET_V16_blength(m) != SHORT_E_01){
    r = -3;
   }
  }
  else{
   if(GET_V16_blength(m) != SHORT_O_10){
    r = -4;
   }
  }
  if(r == 0){
   r = GET_V16_checksum(m);
   if(xor != ((r>>8)&0xFF)^(r&0xFF)){
    r = -5;
   }
  }
 }
 return r;
}

/*
* Encode 24-bits of data into the length and checksum bits
*/

Pipe_set(m,c)
 char *m;
 int c;
{
 SET_V16_protocol(m,NOP_00);
 SET_V16_blength(m,PIPE_11);
 SET_V16_byte(m,c>>16);
 SET_V16_checksum(m,c);
}

 int
Pipe_get(m)
 char *m;
{
 int r;

 if(GET_V16_protocol(m) != NOP_00){
  r =  -1;
 }
 else{
  if(GET_V16_blength(m) != PIPE_11){
   r = -2;
  }
  else{
   r = (GET_V16_byte(m)<<16)+GET_V16_checksum(m);
  }
 }
 return r;
}

/*
*
* Simple checksum computation
*
*/

 int
Checksum_of(m,length,pseudo)
 unsigned short *m;
 int length;
 unsigned short *pseudo;
{
 int sum=0;

 if(length>1024){
  printk("RAWE: panic in Checkum length=%d\n",length);
  return 0;
 }

 if(pseudo){
  sum += *pseudo++;
  sum += *pseudo++;
  sum += *pseudo++;
  sum += *pseudo++;
  sum += *pseudo++;
  sum += *pseudo++;
 }

 while(length > 1){
  sum += *m++;
  if(sum & 0x80000000){
   sum = (sum & 0xFFFF) + (sum>>16);
  }
  length -= 2;
 }
 if(length){
  sum += (unsigned short) *(unsigned char *)m;
 }
 while(sum >> 16){
  sum = (sum & 0xFFFF) + (sum >> 16);
 }

 return ~sum;
}

_______________________________________________
governance mailing list
governance at lists.cpsr.org
https://ssl.cpsr.org/mailman/listinfo/governance



More information about the Governance mailing list