bool make_and_append_chain(ClientObject* client){
std::vector<RSSObject*> route;
RSSObject* client_obj=new RSSObject(getDefinedStructs(),"address_t");
client_obj->setUintObjectByName("type",ADDR_TYPE_LOCALHASH);
client_obj->dynObjectByName("address")->append(client->local_unique_identifier->data(),client->local_unique_identifier->length());
route.push_back(client_obj);
route.push_back(my_address);
for(int i=0;i<2;i++){
RSSObject* random_address=devices[rand()%(devices.size()-1)];
route.push_back(random_address);
}
//printf
printf("CHAIN: ");
for(int i=route.size()-1;i>-1;i--){
printf("%s",(i==route.size()-1)?"":" => ");
if(i==0){
print_ip4( client->local_addr );
}else{
print_ip4( *(in_addr*)(route[i]->dynObjectByName("address")->data() ) );
}
}
printf("\n");
//end printf
RSSObject* o=NULL;
RSSObject* o2=NULL;
for(int i=0;i<route.size();i++){
encryption_method_t em;
if( (!o)||(i==(route.size()-1))){ //first and last dont encrypt (first - on device. crypted by second. )
em=RS_ENCRYPTION_NOTENCRYPT;
}else{
em=RS_ENCRYPTION_BLOWFISH;
}
o2 = encrypt_chain_element(route[i],o,em);
if(o){delete o;}
o=o2;
}
delete client_obj;
client->chains->arrayObjectByName("chain")->push_back(o2);
return true;
}
static void parse_descriptor(struct qeth_qoat_hdr *oat_hdr,
struct qeth_print_hdr *phdr, char *buf, int *processed)
{
int i;
char *ptr;
*processed += oat_hdr->len;
for (i = 0; i < oat_hdr->type.descriptor.reply_entry_count; i++) {
ptr = buf + *processed;
switch (oat_hdr->type.descriptor.des_type) {
case OAT_DES_TYPE_IP4:
print_ip4((struct qeth_qoat_des_ip4 *)ptr, phdr->ip4_h);
phdr->ip4_h = 0;
break;
case OAT_DES_TYPE_IP4MC:
print_ip4mc((struct qeth_qoat_des_ip4mc *)ptr,
phdr->ip4mc_h);
phdr->ip4mc_h = 0;
break;
case OAT_DES_TYPE_IP6:
print_ip6((struct qeth_qoat_des_ip6 *)ptr, phdr->ip6_h);
phdr->ip6_h = 0;
break;
case OAT_DES_TYPE_IP6MC:
print_ip6mc((struct qeth_qoat_des_ip6mc *)ptr,
phdr->ip6mc_h);
phdr->ip6mc_h = 0;
break;
case OAT_DES_TYPE_VMAC:
print_vmac((struct qeth_qoat_des_vmac *)ptr,
phdr->vmac_h);
phdr->vmac_h = 0;
break;
case OAT_DES_TYPE_VLAN:
print_vlan((struct qeth_qoat_des_vlan *)ptr,
phdr->vlan_h);
phdr->vlan_h = 0;
break;
case OAT_DES_TYPE_GMAC:
print_gmac((struct qeth_qoat_des_gmac *)ptr,
phdr->gmac_h);
phdr->gmac_h = 0;
break;
case OAT_DES_TYPE_AIQ:
print_aiq((struct qeth_qoat_des_aiq *)ptr,
phdr->aiq_h);
phdr->aiq_h = 0;
break;
default:
printf("Unknown descriptor (0x%x)\n",
oat_hdr->type.descriptor.des_type);
hex_dump(ptr,
oat_hdr->type.descriptor.reply_entry_len);
}
*processed += oat_hdr->type.descriptor.reply_entry_len;
}
}
static void debug( const struct sockaddr* before, struct sockaddr* after ) {
printf("bind_public: ");
switch( before->sa_family ) {
case AF_INET:
print_ip4( ((struct sockaddr_in*)before)->sin_addr.s_addr );
printf(" --> ");
print_ip4( ((struct sockaddr_in*)after)->sin_addr.s_addr );
printf("\n");
break;
case AF_INET6:
print_ip6( ((struct sockaddr_in6*)before)->sin6_addr.s6_addr );
printf(" --> " );
print_ip6( ((struct sockaddr_in6*)after)->sin6_addr.s6_addr );
printf("\n");
break;
default:
printf("UNKNOWN --> UNKNOWN\n");
break;
}
fflush( stdout );
}
ClientObject* getClientInfoById(unsigned int ip_ident){
if(ip_ident>=registred_clients.size()){return NULL;}
ClientObject* co = registred_clients[ip_ident];
if(co->state==CLIENT_STATE_REGISTRED){
co->lastActivityTime=time(NULL);
return registred_clients[ip_ident];
}
if(co->state==CLIENT_STATE_USED){return NULL;}
if(co->state==CLIENT_STATE_WAIT_RESPONSE){return NULL;}
if(co->state==CLIENT_STATE_UNUSED){
if(!devices.size()){return NULL;}
co->state=CLIENT_STATE_WAIT_RESPONSE;
randomize();
int it=18+(getRandomChar()%16);
char cd[128];
sprintf(cd,"%x.ll",rand()%255);
co->local_domain->append(cd);
for(int i=0;i<it;i++){
unsigned char c=getRandomChar();
co->local_unique_identifier->append((char*)&c,1);
}
//generating chains
printf("=================== \nNEW USER %s LOCAL IP: ",cd); print_ip4(co->local_addr); printf("\n");
for(int i=0;i<5;i++){
make_and_append_chain(co);
}
printf("=================== \n");
RSSObject* setChainRequest=new RSSObject(getDefinedStructs(),"setChainsRequest");
setChainRequest->objectByName("address")->setUintObjectByName("type",ADDR_TYPE_DOMAIN);
setChainRequest->setUintObjectByName("encryption_method",RS_ENCRYPTION_BLOWFISH);
setChainRequest->objectByName("address")->dynObjectByName("address")->append(co->local_domain->data(),co->local_domain->length());
setChainRequest->dynObjectByName("traffic_key")->append(co->traffic_key->data(),co->traffic_key->length());
setChainRequest->objectByName("chains")->assign(co->chains);
rsock->sendToRouteServer(RS_CMD_SETCHAINS_REQUEST,setChainRequest);
delete setChainRequest;
return NULL;
}
return NULL;
}
void receiver(){
while(rsock->receivePacket()){
RSSObject* o=NULL;
rs_cmd_t cmd_id=rsock->getLastCmd();
if(rsock->isLastPackedFromRouteServer()){
if((cmd_id==RS_CMD_GETCHAINS_RESPONSE)&&(o=rsock->getLastPackedDataAsType("getChainsResponse"))){
printf("getChainsResponse\n");
RSSObject* addr_o=o->objectByName("address");
std::string* addr=addr_o->dynObjectByName("address");
uint addr_crc=get_crc(addr->data(),addr->length());
BindedChain* bc=NULL;
if(o->uintObjectByName("status")==RS_GETCHAINS_RESPONSE_OK){
inc_binded();
printf("RS_GETCHAINS_RESPONSE_OK. RA=");print_ip4(*(in_addr*)&binded_ip);printf(" \n");
bc=new BindedChain;
bc->getChainsResponse=new RSSObject(getDefinedStructs(),"getChainsResponse");
memcpy(&bc->local_addr,&binded_ip[0],4);
bc->domain_address_crc=addr_crc;
bc->getChainsResponse->assign(o);
binded_chains.push_back(bc);
}
for(int i=0;i<dns_requests.size();i++){
dns_requests_t* rt=dns_requests[i];
if(rt->domain_address_crc==addr_crc){
if(rt->address->compare(addr_o)){
if(bc && o->uintObjectByName("status")==RS_GETCHAINS_RESPONSE_OK){
sendDNSResponse(rt,&bc->local_addr);
}else{
sendDNSResponse(rt,NULL);
}
free_dns_requests_t(rt);
dns_requests.erase(dns_requests.begin()+i);
break;
}
}
}
}else if((cmd_id==RS_CMD_SETCHAINS_RESPONSE)&&(o=rsock->getLastPackedDataAsType("setChainsResponse"))){
printf("setChainsResponse\n");
if(o->objectByName("address")->uintObjectByName("type")==ADDR_TYPE_DOMAIN){
std::string *sstr=o->objectByName("address")->dynObjectByName("address");
for(int i=0;i<registred_clients.size();i++){
if(*(registred_clients.at(i)->local_domain)==*sstr){
registred_clients.at(i)->state=CLIENT_STATE_REGISTRED;
break;
}
}
}
}else if((cmd_id==RS_CMD_ONDEVICECONNECT_RESPONSE)&&(o=rsock->getLastPackedDataAsType("onDeviceConnectResponse"))){
printf("onDeviceConnectResponse\n");
if(o->uintObjectByName("status")==RS_ONDEVICECONNECT_RESPONSE_OK){
printf("RS Register Success\n");
if(my_address){delete my_address;}
my_address=o->objectByName("you_address")->copy();
RSSObject* os = new RSSObject(getDefinedStructs(),"getDevicesRequest");
os->setUintObjectByName("max_count",10);
rsock->sendToRouteServer(RS_CMD_GETDEVICES_REQUEST,os);
}else{
printf("RS Register Error\n");
}
}else if((cmd_id==RS_CMD_GETDEVICES_RESPONSE)&&(o=rsock->getLastPackedDataAsType("getDevicesResponse"))){
printf("getDevicesResponse\n");
//clearing old device list
for(int i=0;i<devices.size();i++){
delete devices[i];
}
devices.clear();
//adding new device list
std::vector<RSSObject*> * rd;
rd=o->arrayObjectByName("devices");
if(rd){
for(int i=0;i<rd->size();i++){
RSSObject* no=(*rd)[i]->copy();
if(no){
devices.push_back(no);
}
}
}
}
}else{ //end of from RouteServer.
//then from devices
if((cmd_id==RS_CMD_SEND_PACKET)&&(o=rsock->getLastPackedDataAsType("data_packet_t"))){
//o->printDump("");
apply_and_route_rss_packet(o,true);
}
}//end of from devices
done:
if(o){
delete o;
}
}//while receive packet
}
