int server::client_do_packet(packet &pk) { int rp=pk.get_read_position(); int er=0; while (!pk.eop() && !er) { uint8_t cmd; if (pk.read(&cmd,1)!=1) er=1; else { view *f=NULL; int fail=0; if (cmd!=SCMD_ADD_VIEW && cmd!=SCMD_SYNC) { uint16_t player; if (pk.read((uint8_t *)&player,2)!=2) er=1; player=lstl(player); for (f=player_list; f && f->player_number!=player; f=f->next); if (!f) fail=1; } if (!fail) { if (!process_command(f,cmd,pk)) er=1; } else er=1; } } pk.set_read_position(rp); return !er; }
void client_impl::on_decode(packet const& p) { switch(p.get_frame()) { case packet::frame_message: { socket::ptr so_ptr = get_socket_locked(p.get_nsp()); if(so_ptr)so_ptr->on_message_packet(p); break; } case packet::frame_open: this->on_handshake(p.get_message()); break; case packet::frame_close: //FIXME how to deal? this->close_impl(close::status::abnormal_close, "End by server"); break; case packet::frame_pong: this->on_pong(); break; default: break; } }
string palringoPacket::generate_payload(string password, packet data) { engine.pl("palPacket-> Generating AUTH", 1); //use this instead of the RNG string payload = cipher.hexDec(data.getPayload()); //string rnd = data.getHeader(1).value.erase(10,1); string rnd = data.search_headers("TIMESTAMP").erase(10,1); //create the IV char* IV = new char[9]; for(int i=16; i<24; i++) { IV[i-16] = payload.c_str()[i]; } IV[8] = '\0'; //create some final keys for the salsa string authKey = cipher.dbMD5(password, IV); //string sessionKey = cipher.dbMD5(password, rnd); //finally create our data block to be hashed by salsa //this information get's hashed char* dte = new char[33]; for(int i=0; i<16; i++) { dte[i] = payload.c_str()[i]; dte[i+16] = rnd.c_str()[i]; } dte[32] = '\0'; //string dataToEncrypt = dte; //generate final output for the packet //string result = cipher.salsa20enc(IV, authKey, dte); //return cipher.salsa20(IV, authKey, dte); string result = cipher.salsa20(IV, authKey, dte); if(engine.DEBUG) { cout << "------------------------------------" << endl; cout << "IV" << endl << cipher.hexEnc(IV) << endl << endl; cout << "AK" << endl << cipher.hexEnc(authKey) << endl << endl; cout << "DE" << endl << cipher.hexEnc(dte) << endl << endl; cout << "Auth inPacket" << endl << data.getPayload() << endl << endl; cout << "Auth outPacket" << endl << cipher.hexEnc(result) << endl; cout << "------------------------------------" << endl; } return result; }
void connection::do_byte_calculation(packet p) { assert(this->check_packet(p)); this->byte_total += p.data_size(); if (this->src_to_dst(p)) { this->byte_src_to_dst_num += p.data_size(); return; } if (this->dst_to_src(p)) { this->byte_dst_to_src_num += p.data_size(); return; } assert(false); }
void packet_manager::encode(packet& pack,encode_callback_function const& override_encode_callback) const { shared_ptr<string> ptr = make_shared<string>(); vector<shared_ptr<const string> > buffers; const encode_callback_function *cb_ptr = &m_encode_callback; if(override_encode_callback) { cb_ptr = &override_encode_callback; } if(pack.accept(*ptr,buffers)) { if((*cb_ptr)) { (*cb_ptr)(false,ptr); } for(auto it = buffers.begin();it!=buffers.end();++it) { if((*cb_ptr)) { (*cb_ptr)(true,*it); } } } else { if((*cb_ptr)) { (*cb_ptr)(false,ptr); } } }
void static_net_config::print_brief(const boost::asio::ip::udp::endpoint& /*sender*/, const packet& response) const { BOOST_FOREACH(const field& f, response.fields()) if(f.type() == field::FT_RESULT_MSG) { std::cout << f.value<std::string>() << std::endl; break; } }
void connection::recv_packet(packet p) { using namespace std; assert(this->check_packet(p)); this->window_sizes.push_back(p.window_size()); this->do_packet_calculation(p); this->do_byte_calculation(p); this->do_rtt_calculation(p); if (p.rst()) { this->connection_reset = true; this->change_state(std::shared_ptr<reset>(new reset)); } this->state->recv_packet(p, this); }
connection::connection(packet p) { this->src_addr = p.src_addr(); this->dst_addr = p.dst_addr(); this->src_port = p.src_port(); this->dst_port = p.dst_port(); this->connection_reset = p.rst(); this->start_time = p.ts_milli() + p.ts_sec()*1000000; this->change_state(std::shared_ptr<s0f0>(new s0f0)); //this->recv_packet(p); }
void_result remote_node::send(const packet &p) { // Do not send packets marked as local_only if(p.local_only()) return success(); // Check to see if anyone is actually listening // for this on this branch of the network. auto it = _parent->_subscription_count.find(p.meta().topic); const bool internal_check = _mode == remote_node::allow_internal && p.meta().topic == topic::internal.name(); if(!internal_check && it == _parent->_subscription_count.end()) return success(); packet mod = p; mod.meta().path.push_back(_parent->id()); mod.meta().id = _parent->id(); mod.build(); bool should_send = true; #ifdef SPLAT_ENABLED bool splattable = p.meta().droppable && p.meta().origin_id == _parent->_id; // cout << "REMOTE NODE SEND " << p.meta().topic << ": " << p.packed()->len << " (splat: " << splattable << ")" << endl; if(splattable) { auto ret = _parent->push_splat(mod); if(!ret) { cout << "Warning: Failed to push splat: " << ret.message() << endl; } } // FIXME: This is not the correct condition. // We still want to send to *truly* remote clients // over TCP, but there is currently no way to // identify unique systems on the network to // generate disconnected splat neighborhoods. should_send = !splattable; #endif return should_send ? _parent->_thread.send(_link.get(), mod) : success(); }
int unix_out_socket::get(packet &pk) { pk.ro=pk.wo=2; ushort size=0; if (pk_buffer_last==pk_buffer_ro) fill_buffer(); if (pk_buffer_last-pk_buffer_ro<2) // make sure the two byte for the size are in the same packet { uchar two[2]; two[0]=pk_buffer[pk_buffer_ro]; fill_buffer(); if (pk_buffer_last-pk_buffer_ro<2) // if still not enough info, something is screwy { printf("Incomplete packet\n"); return 0; } two[1]=pk_buffer[pk_buffer_ro]; pk_buffer_ro++; size=lstl((*((ushort *)two))); } else { memcpy(&size,pk_buffer+pk_buffer_ro,2); pk_buffer_ro+=2; size=lstl(size); } pk.rend=size+2; pk.make_bigger(pk.rend); uchar *pk_off=pk.buf+2; int rs; while (size) { if (pk_buffer_last==pk_buffer_ro) fill_buffer(); if (pk_buffer_last-pk_buffer_ro>size) rs=size; else rs=pk_buffer_last-pk_buffer_ro; memcpy(pk_off,pk_buffer+pk_buffer_ro,rs); pk_buffer_ro+=rs; size-=rs; pk_off+=rs; } return 1; }
virtual void receive(packet payload) { m_last_packet = payload; m_new_packet = true; if (m_decoder->is_complete()) { std::string counter_id = node_id()+"_waste_from_"+payload.get_sender(); ++m_counter[counter_id]; } else { std::copy(payload.data_begin(), payload.data_end(), &m_decode_buffer[0]); uint32_t rank = m_decoder->rank(); m_decoder->read_payload(&m_decode_buffer[0]); if (rank < m_decoder->rank()) { std::string counter_id = node_id()+"_innovative_from_"+payload.get_sender(); ++m_counter[counter_id]; } else { std::string counter_id = node_id()+"_linear_dept_from_"+payload.get_sender(); ++m_counter[counter_id]; } } }
/// Receives a payload virtual void receive(packet payload) { for(uint32_t j = 0; j < receiver_count(); ++j) { std::string recv_id = get_receiver(j)->node_id(); std::string src_id = payload.get_sender(); // If true we drop if(m_channel_condition->generate()) { ++m_counter[node_id()+"_"+src_id+"_to_"+recv_id+"_dropped"]; } else { ++m_counter[node_id()+"_"+src_id+"_to_"+recv_id+"_ok"]; // Deliver packet to receiver j forward(j, payload); } } }
void server::add_change_log(view *f, packet &pk, int number) { if (f->view_changed()) { uint8_t cmd=SCMD_VIEW_RESIZE; pk.write(&cmd,1); if (number) { uint16_t pn=lstl(f->player_number); pk.write((uint8_t *)&pn,2); dprintf("Server : %s resized view %d %d %d %d\n",f->name, f->suggest.cx1,f->suggest.cy1,f->suggest.cx2,f->suggest.cy2); f->resize_view(f->suggest.cx1,f->suggest.cy1,f->suggest.cx2,f->suggest.cy2); f->suggest.send_view=0; } else dprintf("sending resize to server\n"); uint32_t view_size[8]; view_size[0]=lltl(f->suggest.cx1); view_size[1]=lltl(f->suggest.cy1); view_size[2]=lltl(f->suggest.cx2); view_size[3]=lltl(f->suggest.cy2); view_size[4]=lltl(f->suggest.pan_x); view_size[5]=lltl(f->suggest.pan_y); view_size[6]=lltl(f->suggest.shift_down); view_size[7]=lltl(f->suggest.shift_right); pk.write((uint8_t *)view_size,8*4); } if (f->weapon_changed()) { uint8_t cmd=SCMD_WEAPON_CHANGE; pk.write(&cmd,1); if (number) { uint16_t pn=lstl(f->player_number); pk.write((uint8_t *)&pn,2); dprintf("Server : %s change weapon to %d\n",f->name,f->suggest.new_weapon); f->current_weapon=f->suggest.new_weapon; f->suggest.send_weapon_change=0; } else dprintf("sending resize to server\n"); uint32_t nw=lltl(f->suggest.new_weapon); pk.write((uint8_t *)&nw,4); } }
int server::process_command(view *f, uint8_t command, packet &pk) { switch (command) { case SCMD_QUIT : // delete player { dprintf("Player %d has quit\n",f->player_number); return 0; } break; case SCMD_VIEW_RESIZE : // change view area { uint32_t view_size[8]; if (pk.read((uint8_t *)view_size,8*4)!=8*4) return 0; else { f->resize_view(lltl(view_size[0]),lltl(view_size[1]),lltl(view_size[2]),lltl(view_size[3])); f->pan_x=lltl(view_size[4]); f->pan_y=lltl(view_size[5]); f->shift_down=lltl(view_size[6]); f->shift_right=lltl(view_size[7]); f->suggest.send_view=0; if (is_server) // if we are a server, tell everybody about this. { uint8_t cmd=SCMD_VIEW_RESIZE; next_out.write((uint8_t *)&cmd,1); uint16_t pn=lstl(f->player_number); next_out.write((uint8_t *)&pn,2); next_out.write((uint8_t *)view_size,8*4); } } } break; case SCMD_WEAPON_CHANGE : // change weapon { uint32_t new_weap; if (pk.read((uint8_t *)&new_weap,4)!=4) return 0; else { f->current_weapon=lltl(new_weap); f->suggest.send_weapon_change=0; if (is_server) // if we are a server, tell everybody about this. { uint8_t cmd=SCMD_WEAPON_CHANGE; next_out.write((uint8_t *)&cmd,1); uint16_t pn=lstl(f->player_number); next_out.write((uint8_t *)&pn,2); next_out.write((uint8_t *)&new_weap,4); } } } break; case SCMD_SET_INPUT : // set the input from this player { signed char inp[5]; if (pk.read((uint8_t *)inp,5)!=5) return 0; else f->set_input(inp[0],inp[1],inp[2],inp[3],inp[4]); } break; case SCMD_ADD_VIEW : { view *v=add_view(pk); if (v) { for (view *f=player_list; f && f->next; f=f->next); if (f) f->next=v; else player_list=f; } } break; case SCMD_SYNC : { uint32_t x; if (pk.read((uint8_t *)&x,4)!=4) return 0; else { uint32_t s=make_sync_uint32(); if (lltl(x)!=s) printf("Out of sync, %x!=%x\n",lltl(x),s); return 1; } } break; default : return 0; } return 1; }
bool connection::dst_to_src(packet p) { bool addr = (p.dst_addr() == this->src_addr) && (p.src_addr() == this->dst_addr); bool port = (p.dst_port() == this->src_port) && (p.src_port() == this->dst_port); return addr && port; }
bool operator>(const packet& arg) const { return A > arg.comp(); }
bool operator<(const packet& arg) const { return A < arg.comp(); }
void connection::do_rtt_calculation(packet p) { assert(this->check_packet(p)); if (this->src_to_dst(p)) { if (p.syn() && !p.ack()) { this->seq_num = p.seq_number(); auto it = dst_packets.find(p.seq_number()); if (it != dst_packets.end()) { dst_packets.erase(it); this->rtts.push_back(p.ts() - it->second.ts()); } this->nxt_ack = p.seq_number() + 1; src_packets[this->nxt_ack] = p; } if (p.ack() && !p.syn()) { this->seq_num = p.seq_number(); auto it = dst_packets.find(p.seq_number()); if (it != dst_packets.end()) { dst_packets.erase(it); this->rtts.push_back(p.ts() - it->second.ts()); } this->nxt_ack = p.seq_number() + p.data_size(); src_packets[this->nxt_ack] = p; } if (p.fin()) { this->fin_set = true; this->rtt_t0 = p.ts(); } } if (this->dst_to_src(p)) { if (p.ack() && p.fin()) { if (this->fin_set) { this->rtts.push_back(p.ts() - this->rtt_t0); } } if (p.syn() && p.ack()) { auto it = src_packets.find(p.ack_number()); if (it != src_packets.end()) { src_packets.erase(it); this->rtts.push_back(p.ts() - it->second.ts()); } dst_packets[p.ack_number()] = p; } if (p.ack() && !p.syn()) { auto it = src_packets.find(p.ack_number()); if (it != src_packets.end()) { src_packets.erase(it); this->rtts.push_back(p.ts() - it->second.ts()); } dst_packets[p.ack_number()] = p; } } }