/** * Wątek obsługujący pojedynczą wiadomość przesłaną do serwera. */ void Server::handleMessage(tcp::socket* socket){ boost::array<char, 8192> messageBuffer; boost::system::error_code error; ioService.run(); socket->read_some(boost::asio::buffer(messageBuffer), error); if (error){ cerr<<error<<endl; socket->close(); delete socket; return; } Message message; deserialize(message, messageBuffer.data()); cout<<"Otrzymano wiadomość: "<<endl; cout<<message.toString()<<endl; int result; string response; string sessionId; History emptyHistory; vector<string> mismatchingParameters; History* history; if(message.getAction()!=REGISTER && message.getAction()!=LOGIN && message.getAction()!=UNREGISTER && (serverStore.getSessionId(message.getUserId())!=message.getSessionId() || serverStore.getSessionId(message.getUserId())=="")) { response = createResponse(NOT_LOGGED_IN); socket->write_some(boost::asio::buffer(response), error); socket->close(); delete socket; return; } switch(message.getAction()){ case REGISTER: { // muszą być dwa parametry if (message.getParameters().size() != 2) { response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); } else { // tworzymy użyszkodnika result = serverStore.registerUser(message.getParameters()[0], message.getParameters()[1]); switch (result) { case 0: // użytkownik dodany poprawnie response = createResponse(OK); break; case -1: // login zajęty response = createResponse(INCORRECT_LOGIN); break; } socket->write_some(boost::asio::buffer(response), error); } break; } case LOGIN: { // muszą być dwa parametry if (message.getParameters().size() != 2) { response = createResponse(WRONG_SYNTAX, "", &emptyHistory); socket->write_some(boost::asio::buffer(response), error); } else { // logowanie użyszkodnika result = serverStore.loginUser(message.getParameters()[0], message.getParameters()[1]); switch (result) { case 0: // użytkownik zalogowany poprawnie history = serverStore.getHistory(message.getUserId()); if(history==NULL){ history = &emptyHistory; } sessionId = generateSessionId(); serverStore.setSessionId(message.getUserId(), sessionId); response = createResponse(OK, sessionId, history); serverStore.clearHistory(message.getUserId()); break; case -1: // niepoprawny login response = createResponse(INCORRECT_LOGIN, "", &emptyHistory); break; case -2: // niepoprawne haslo response = createResponse(INCORRECT_PASSWORD, "", &emptyHistory); break; } socket->write_some(boost::asio::buffer(response), error); } break; } case LOGOUT: { serverStore.setSessionId(message.getUserId(), ""); response = createResponse(OK); socket->write_some(boost::asio::buffer(response), error); break; } case UNREGISTER: { // muszą być dwa parametry if (message.getParameters().size() != 2) { response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); } else { // usuwamy użyszkodnika result = serverStore.unregisterUser(message.getParameters()[0], message.getParameters()[1]); switch (result) { case 0: // użytkownik usunięty poprawnie response = createResponse(OK); break; case -1: // login błędny response = createResponse(INCORRECT_LOGIN); break; case -2: // hasło błędne response = createResponse(INCORRECT_PASSWORD); break; } socket->write_some(boost::asio::buffer(response), error); } break; } case LIST: { //jeśli podano parametry - błąd if(message.getParameters().size()!=0){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } vector<string> filenames = serverStore.list(message.getUserId()); response = createResponse(OK, filenames); socket->write_some(boost::asio::buffer(response), error); filenames.clear(); break; } case LIST_SHARED: { //jeśli podano parametry - błąd if(message.getParameters().size()!=0){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } vector<string> names = serverStore.listShared(message.getUserId()); response = createResponse(OK, names); socket->write_some(boost::asio::buffer(response), error); names.clear(); break; } case UPLOAD: //jeśli nie podano parametrów - błąd if(message.getParameters().size()==0){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } //żądanie poprawne, rozpocznij transfer dataPortAccessMutex.lock(); response = createResponse(OK); socket->write_some(boost::asio::buffer(response), error); for(unsigned int i=0; i<message.getParameters().size(); ++i){ cout<<"Użytkownik "<<message.getUserId()<<" przesyła plik "<<message.getParameters()[i]<<endl; result = fileTransferManager.receiveFile(message.getSource(), createFilePath(message.getUserId(), message.getParameters()[i]), i!=0); if(!result){ cerr<<"Nie przesłano pliku"<<endl; break; } serverStore.add(message.getUserId(), message.getParameters()[i]); if(serverStore.fileExists(message.getUserId(), message.getParameters()[i])){ serverStore.updateHistory(FILE_MODIFIED, message.getUserId(), message.getParameters()[i]); } cout<<"Gotowe."<<endl; } dataPortAccessMutex.unlock(); break; case DOWNLOAD: //jeśli nie podano parametrów - błąd if(message.getParameters().size()==0){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } //jeśli któreś z podanych plików nie istnieją - błąd. //zwróć nazwy nieistniejących plików. for(unsigned int i=0; i<message.getParameters().size(); ++i){ if(!serverStore.fileExists(message.getUserId(), message.getParameters()[i])){ mismatchingParameters.push_back(message.getParameters()[i]); } } if(mismatchingParameters.size()>0){ response = createResponse(NO_SUCH_FILE, mismatchingParameters); socket->write_some(boost::asio::buffer(response), error); break; } //żądanie poprawne, rozpocznij transfer dataPortAccessMutex.lock(); response = createResponse(OK); socket->write_some(boost::asio::buffer(response), error); for(unsigned int i=0; i<message.getParameters().size(); ++i){ cout<<"Użytkownik "<<message.getUserId()<<" pobiera plik "<<message.getParameters()[i]<<endl; result = fileTransferManager.sendFile(message.getSource(), createFilePath(message.getUserId(), message.getParameters()[i]), true); if(!result){ cerr<<"Nie przesłano pliku"<<endl; break; } cout<<"Gotowe."<<endl; } dataPortAccessMutex.unlock(); break; case DOWNLOAD_SHARED: //musi być podany użytkownik oraz min. 1 plik, jeśli nie jest - błąd if(message.getParameters().size()<2){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } //jeśli nie ma takiego użytkownika - błąd if(!serverStore.userExists(message.getParameters()[0])){ response = createResponse(NO_SUCH_USER); socket->write_some(boost::asio::buffer(response), error); break; } //jeśli któreś z podanych plików nie istnieją - błąd. //zwróć nazwy nieistniejących plików. for(unsigned int i=1; i<message.getParameters().size(); ++i){ if(!serverStore.fileExists(message.getParameters()[0], message.getParameters()[i])){ mismatchingParameters.push_back(message.getParameters()[i]); } } if(mismatchingParameters.size()>0){ response = createResponse(NO_SUCH_FILE, mismatchingParameters); socket->write_some(boost::asio::buffer(response), error); break; } //jeśli użytkownik nie ma dostępu do któregoś z plików - błąd. //zwróć nazwy tychże plików. for(unsigned int i=1; i<message.getParameters().size(); ++i){ if(!serverStore.hasAccess(message.getUserId(), message.getParameters()[0], message.getParameters()[i])){ mismatchingParameters.push_back(message.getParameters()[i]); } } if(mismatchingParameters.size()>0){ response = createResponse(ACCESS_DENIED, mismatchingParameters); socket->write_some(boost::asio::buffer(response), error); break; } //żądanie poprawne, rozpocznij transfer dataPortAccessMutex.lock(); response = createResponse(OK); socket->write_some(boost::asio::buffer(response), error); for(unsigned int i=1; i<message.getParameters().size(); ++i){ cout<<"Użytkownik "<<message.getUserId()<<" pobiera plik "<<message.getParameters()[i]<<" należący do użytkownika "<<message.getParameters()[0]<<endl; result = fileTransferManager.sendFile(message.getSource(), createFilePath(message.getParameters()[0], message.getParameters()[i]), true); if(!result){ cerr<<"Nie przesłano pliku"<<endl; break; } cout<<"Gotowe."<<endl; } dataPortAccessMutex.unlock(); break; case REMOVE: //jeśli nie podano parametrów - błąd if(message.getParameters().size()==0){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } //usuń pliki, jeśli istnieją, zapisz nazwy tych, które nie istnieją int result; for(unsigned int i=0; i<message.getParameters().size(); ++i){ serverStore.updateHistory(FILE_REMOVED, message.getUserId(), message.getParameters()[i]); result = serverStore.remove(message.getUserId(), message.getParameters()[i]); if(result==0){ remove(createFilePath(message.getUserId(), message.getParameters()[i]).c_str()); }else{ mismatchingParameters.push_back(message.getParameters()[i]); } } //wyślij zwrotny komunikat if(mismatchingParameters.size()>0){ response = createResponse(NO_SUCH_FILE, mismatchingParameters); }else{ response = createResponse(OK); } socket->write_some(boost::asio::buffer(response), error); break; case RENAME: //jeśli liczba parametrów różna od 2 - błąd if(message.getParameters().size()!=2){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } result = serverStore.rename(message.getUserId(), message.getParameters()[0], message.getParameters()[1]); switch(result){ case 0: serverStore.updateHistory(FILE_RENAMED, message.getUserId(), message.getParameters()[1], message.getParameters()[0]); rename(createFilePath(message.getUserId(), message.getParameters()[0]).c_str(), createFilePath(message.getUserId(), message.getParameters()[1]).c_str()); response = createResponse(OK); break; case -2: mismatchingParameters.push_back(message.getParameters()[0]); response = createResponse(NO_SUCH_FILE, mismatchingParameters); break; case -3: mismatchingParameters.push_back(message.getParameters()[1]); response = createResponse(FILE_EXISTS, mismatchingParameters); break; } socket->write_some(boost::asio::buffer(response), error); break; case GIVE_ACCESS: if(message.getParameters().size()<2){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } for(unsigned int i=1; i<message.getParameters().size(); ++i){ result = serverStore.giveAccess(message.getUserId().c_str(), message.getParameters()[0].c_str(), message.getParameters()[i].c_str()); switch(result){ case 0: serverStore.updateHistory(ACCESS_GRANTED, message.getUserId(), message.getParameters()[i], message.getParameters()[0]); response = createResponse(OK); break; case -1: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(NO_SUCH_USER, mismatchingParameters); break; case -2: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(NO_SUCH_FILE, mismatchingParameters); break; case -3: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(NO_SUCH_USER, mismatchingParameters); break; case -4: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(ALREADY_HAVE_ACCESS, mismatchingParameters); break; case -5: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(OWN_FILE, mismatchingParameters); break; } if(result!=0){ break; } } socket->write_some(boost::asio::buffer(response), error); break; case REVOKE_ACCESS: if(message.getParameters().size()<2){ response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); break; } for(unsigned int i=1; i<message.getParameters().size(); ++i){ result = serverStore.revokeAccess(message.getUserId().c_str(), message.getParameters()[0].c_str(), message.getParameters()[i].c_str()); switch(result){ case 0: serverStore.updateHistory(ACCESS_REVOKED, message.getUserId(), message.getParameters()[i], message.getParameters()[0]); response = createResponse(OK); break; case -1: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(NO_SUCH_USER, mismatchingParameters); break; case -2: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(NO_SUCH_FILE, mismatchingParameters); break; case -3: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(NO_SUCH_USER, mismatchingParameters); break; case -4: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(ALREADY_NO_ACCESS, mismatchingParameters); break; case -5: mismatchingParameters.push_back(message.getParameters()[i]); response = createResponse(OWN_FILE, mismatchingParameters); break; } if(result!=0){ break; } } socket->write_some(boost::asio::buffer(response), error); break; default: response = createResponse(WRONG_SYNTAX); socket->write_some(boost::asio::buffer(response), error); } socket->close(); delete socket; }
LineSegment::LineSegment(class BinaryInput& b) { deserialize(b); }
ClusterState::ClusterState(const ClusterState& other) { vespalib::nbostream o; other.serialize(o); deserialize(o); }
void PrimitiveDeserializer::deserialize(GAFStream* in, cocos2d::Rect* out) { deserialize(in, &out->origin); deserialize(in, &out->size); }
bool deserialize(const std::string& filename, value_type& value) { JsonReader reader; JsonNode root = reader.Parse(filename.c_str()); return deserialize(root, value); }
// ----------------------------------------------------------------------------- bool DeviceManager::initialize() { GamepadConfig *gamepadConfig = NULL; GamePadDevice *gamepadDevice = NULL; m_map_fire_to_select = false; bool created = false; // Shutdown in case the device manager is being re-initialized shutdown(); if(UserConfigParams::logMisc()) { Log::info("Device manager","Initializing Device Manager"); Log::info("-","---------------------------"); } deserialize(); // Assign a configuration to the keyboard, or create one if we haven't yet if(UserConfigParams::logMisc()) Log::info("Device manager","Initializing keyboard support."); if (m_keyboard_configs.size() == 0) { if(UserConfigParams::logMisc()) Log::info("Device manager","No keyboard configuration exists, creating one."); m_keyboard_configs.push_back(new KeyboardConfig()); created = true; } const int keyboard_amount = m_keyboard_configs.size(); for (int n=0; n<keyboard_amount; n++) { m_keyboards.push_back(new KeyboardDevice(m_keyboard_configs.get(n))); } if(UserConfigParams::logMisc()) Log::info("Device manager","Initializing gamepad support."); irr_driver->getDevice()->activateJoysticks(m_irrlicht_gamepads); int num_gamepads = m_irrlicht_gamepads.size(); if(UserConfigParams::logMisc()) { Log::info("Device manager","Irrlicht reports %d gamepads are attached to the system.", num_gamepads); } // Create GamePadDevice for each physical gamepad and find a GamepadConfig to match for (int id = 0; id < num_gamepads; id++) { core::stringc name = m_irrlicht_gamepads[id].Name; // Some linux systems report a disk accelerometer as a gamepad, skip that if (name.find("LIS3LV02DL") != -1) continue; #ifdef WIN32 // On Windows, unless we use DirectInput, all gamepads are given the // same name ('microsoft pc-joystick driver'). This makes configuration // totally useless, so append an ID to the name. We can't test for the // name, since the name is even translated. name = name + " " + StringUtils::toString(id).c_str(); #endif if (UserConfigParams::logMisc()) { Log::info("Device manager","#%d: %s detected...", id, name.c_str()); } // Returns true if new configuration was created if (getConfigForGamepad(id, name, &gamepadConfig) == true) { if(UserConfigParams::logMisc()) Log::info("Device manager","creating new configuration."); created = true; } else { if(UserConfigParams::logMisc()) Log::info("Device manager","using existing configuration."); } gamepadConfig->setPlugged(); gamepadDevice = new GamePadDevice(id, name.c_str(), m_irrlicht_gamepads[id].Axes, m_irrlicht_gamepads[id].Buttons, gamepadConfig ); addGamepad(gamepadDevice); } // end for if (created) serialize(); return created; } // initialize
inline void from_json (const nlohmann::json& j, object& o) { JSON_VALIDATE_REQUIRED(j, id, is_number); JSON_VALIDATE_REQUIRED(j, name, is_string); JSON_VALIDATE_REQUIRED(j, type, is_string); JSON_VALIDATE_REQUIRED(j, x, is_number); JSON_VALIDATE_REQUIRED(j, y, is_number); JSON_VALIDATE_REQUIRED(j, width, is_number); JSON_VALIDATE_REQUIRED(j, height, is_number); JSON_VALIDATE_REQUIRED(j, visible, is_boolean); JSON_VALIDATE_REQUIRED(j, rotation, is_number_float); JSON_VALIDATE_OPTIONAL(j, properties, is_object); JSON_VALIDATE_OPTIONAL(j, propertytypes, is_object); JSON_VALIDATE_OPTIONAL(j, gid, is_number); JSON_VALIDATE_OPTIONAL(j, point, is_boolean); JSON_VALIDATE_OPTIONAL(j, ellipse, is_boolean); JSON_VALIDATE_OPTIONAL(j, polygon, is_array); JSON_VALIDATE_OPTIONAL(j, polyline, is_array); JSON_VALIDATE_OPTIONAL(j, text, is_string); o.id = j["id"].get<int32>(); o.name = j["name"].get<std::string>(); o.type = j["type"].get<std::string>(); o.x = j["x"].get<int32>(); o.y = j["y"].get<int32>(); o.width = j["width"].get<int32>(); o.height = j["height"].get<int32>(); o.visible = j["visible"].get<bool>(); o.rotation = j["rotation"].get<float>(); deserialize(j, o.properties); if (j.count("gid")) { o.gid = j["gid"].get<int32>(); if (o.gid <= 0) { throw std::invalid_argument("object has invalid gid"); } o.otype = object_type::sprite; return; } o.otype = object_type::rect; if (j.count("point") && j["point"].get<bool>()) { o.otype = object_type::point; } if (j.count("ellipse") && j["ellipse"].get<bool>()) { o.otype = object_type::ellipse; } if (j.count("polygon")) { o.otype = object_type::polygon; o.coords = j["polygon"].get<std::vector<coordinate>>(); } if (j.count("polyline")) { o.otype = object_type::polyline; o.coords = j["polyline"].get<std::vector<coordinate>>(); } if (j.count("text")) { o.otype = object_type::text; o.text = j["text"].get<object_text>(); } }
void TransferServer::deserializeAction(MemoryBuffer & msg, unsigned action) { SocketEndpoint ep; ep.deserialize(msg); if (!ep.isLocal()) { StringBuffer host, expected; queryHostIP().getIpText(host); ep.getIpText(expected); throwError2(DFTERR_WrongComputer, expected.str(), host.str()); } srcFormat.deserialize(msg); tgtFormat.deserialize(msg); msg.read(calcInputCRC); msg.read(calcOutputCRC); deserialize(partition, msg); msg.read(numParallelSlaves); msg.read(updateFrequency); msg.read(replicate); msg.read(mirror); msg.read(isSafeMode); srand((unsigned)get_cycles_now()); int adjust = (rand() * rand() * rand()) % updateFrequency - (updateFrequency/2); lastTick = msTick() + adjust; StringBuffer localFilename; if (action == FTactionpull) { partition.item(0).outputName.getPath(localFilename); LOG(MCdebugProgress, unknownJob, "Process Pull Command: %s", localFilename.str()); } else { partition.item(0).inputName.getPath(localFilename); LOG(MCdebugProgress, unknownJob, "Process Push Command: %s", localFilename.str()); } LOG(MCdebugProgress, unknownJob, "Num Parallel Slaves=%d Adjust=%d/%d", numParallelSlaves, adjust, updateFrequency); LOG(MCdebugProgress, unknownJob, "replicate(%d) mirror(%d) safe(%d) incrc(%d) outcrc(%d)", replicate, mirror, isSafeMode, calcInputCRC, calcOutputCRC); displayPartition(partition); unsigned numProgress; msg.read(numProgress); for (unsigned i = 0; i < numProgress; i++) { OutputProgress & next = *new OutputProgress; next.deserialize(msg); progress.append(next); } if (msg.remaining()) msg.read(throttleNicSpeed); if (msg.remaining()) msg.read(compressedInput).read(compressOutput); if (msg.remaining()) msg.read(copyCompressed); if (msg.remaining()) msg.read(transferBufferSize); if (msg.remaining()) msg.read(encryptKey).read(decryptKey); if (msg.remaining()) { srcFormat.deserializeExtra(msg, 1); tgtFormat.deserializeExtra(msg, 1); } LOG(MCdebugProgress, unknownJob, "throttle(%d), transferBufferSize(%d)", throttleNicSpeed, transferBufferSize); PROGLOG("compressedInput(%d), compressedOutput(%d), copyCompressed(%d)", compressedInput?1:0, compressOutput?1:0, copyCompressed?1:0); PROGLOG("encrypt(%d), decrypt(%d)", encryptKey.isEmpty()?0:1, decryptKey.isEmpty()?0:1); //---Finished deserializing --- displayProgress(progress); totalLengthRead = 0; totalLengthToRead = 0; ForEachItemIn(idx, partition) totalLengthToRead += partition.item(idx).inputLength; }
void Property::deserializeValue(XmlDeserializer& s) { serializeValue_ = true; deserialize(s); serializeValue_ = false; }
void CInitMessage_Map::Deserialize(const unsigned char *p) { p += header.Deserialize(p); p += deserialize(p, this->MapPath); p += deserialize32(p, &this->MapUID); }
size_t CNetworkChat::Deserialize(const unsigned char *buf) { const unsigned char *p = buf; p += deserialize(p, this->Text); return p - buf; }
TEST(DictionaryDeserialization, EmptyDictionary) { deserialize(AmfDictionary(false, false), v8 { 0x11, 0x01, 0x00 }); deserialize(AmfDictionary(false, true), v8 { 0x11, 0x01, 0x01 }); deserialize(AmfDictionary(false, true), v8 { 0x11, 0x01, 0x01, 0x01 }, 1); }
Box::Box(class BinaryInput& b) { deserialize(b); }
NestedInteger deserialize(string s) { return deserialize(s, 0, s.length() - 1); }
Vector4::Vector4(BinaryInput& b) { deserialize(b); }
/* * Deserialisierungs-Konstruktor von @p LobbyPlayerInfo. * * @author FloSoft */ LobbyPlayerInfo::LobbyPlayerInfo(const unsigned playerid, Serializer* ser) { deserialize(ser); }
block_header_type block_result::header() const { BITCOIN_ASSERT(slab_); return deserialize(slab_); }
STATIC int process_request(fqueue_element_t *qe_l) { int rv; const char *name; int name_len; const char *uri; int uri_len; const char *hdrdata; int hdrdata_len; const char *nstokendata; int nstokendata_len; namespace_token_t nstoken; const namespace_config_t *nsc = 0; pseudo_con_t *pcon = 0; const char *http_flag; int http_flag_len; pcon = alloc_pseudo_con_t(); if (!pcon) { DBG("alloc_pseudo_con_t() failed, rv=%d", rv); rv = 1; goto exit; } rv = get_attr_fqueue_element(qe_l, T_ATTR_URI, 0, &name, &name_len, &uri, &uri_len); if (rv) { DBG("get_attr_fqueue_element(T_ATTR_URI) failed, rv=%d", rv); rv = 2; goto exit; } if (uri_len >= (MAX_URI_SIZE - MAX_URI_HDR_SIZE)) { DBG("uri_len(%d) >= (MAX_URI_SIZE-MAX_URI_HDR_SIZE)(%d)", uri_len, MAX_URI_SIZE-MAX_URI_HDR_SIZE); rv = 3; goto exit; } rv = get_nvattr_fqueue_element_by_name(qe_l, "http_header", 11, &hdrdata, &hdrdata_len); if (!rv) { rv = deserialize(hdrdata, hdrdata_len, &pcon->con.con.http.hdr, 0, 0); if (rv) { DBG("deserialize() failed, rv=%d", rv); rv = 4; goto exit; } } else { DBG("get_nvattr_fqueue_element_by_name() " "for \"http_header\" failed, rv=%d", rv); } nstokendata = 0; rv = get_nvattr_fqueue_element_by_name(qe_l, "namespace_token", 15, &nstokendata, &nstokendata_len); if (nstokendata) { nstoken.u.token = (uint64_t)atol_len(nstokendata, nstokendata_len); nsc = namespace_to_config(nstoken); } if (!nsc) { TSTR(uri, uri_len, p_uri); DBG("Invalid namespace token(gen=%d val=%d) " "for URI=%s, request dropped", nstoken.u.token_data.gen, nstoken.u.token_data.val, p_uri); rv = 5; goto exit; } pcon->con.con.http.ns_token = nstoken; http_flag = 0; rv = get_nvattr_fqueue_element_by_name(qe_l, "http_flag", 9, &http_flag, &http_flag_len); if (http_flag) { if (!strncasecmp(http_flag, "FORWARD_PROXY", http_flag_len)) { pcon->con.con.http.flag |= HRF_FORWARD_PROXY; } else if (!strncasecmp(http_flag, "VIRTUAL_DOMAIN_REVERSE_PROXY", http_flag_len)) { pcon->flags |= PC_FL_VIRTUAL_DOMAIN_REVERSE_PROXY; } else if (!strncasecmp(http_flag, "TRASPARENT_REVERSE_PROXY", http_flag_len)) { pcon->flags |= PC_FL_TRANSPARENT_REVERSE_PROXY; } } rv = start_http_get_task(uri, uri_len, pcon); if (rv) { TSTR(uri, uri_len, p_uri); DBG("send_http_request() failed uri=%s, rv=%d", p_uri, rv); rv = 6; goto exit; } { TSTR(uri, uri_len, p_uri); DBG("Scheduled GET for URI=%s", p_uri); } return 0; exit: if (pcon) { free_pseudo_con_t(pcon); } if (nsc) { release_namespace_token_t(nstoken); } return rv; }
void item::load_info( const std::string &data ) { std::istringstream dump(data); char check=dump.peek(); if ( check == ' ' ) { // sigh.. check=data[1]; } if ( check == '{' ) { JsonIn jsin(dump); try { deserialize(jsin); } catch( const JsonError &jsonerr ) { debugmsg("Bad item json\n%s", jsonerr.c_str() ); } return; } unset_flags(); clear_vars(); std::string idtmp, ammotmp, item_tag, mode; int lettmp, damtmp, acttmp, corp, tag_count; int owned; // Ignoring an obsolete member. dump >> lettmp >> idtmp >> charges >> damtmp >> tag_count; for( int i = 0; i < tag_count; ++i ) { dump >> item_tag; if( itag2ivar(item_tag, item_vars ) == false ) { item_tags.insert( item_tag ); } } dump >> burnt >> poison >> ammotmp >> owned >> bday >> mode >> acttmp >> corp >> mission_id >> player_id; corpse = NULL; getline(dump, corpse_name); if( corpse_name == " ''" ) { corpse_name = ""; } else { size_t pos = corpse_name.find_first_of( "@@" ); while (pos != std::string::npos) { corpse_name.replace( pos, 2, "\n" ); pos = corpse_name.find_first_of( "@@" ); } corpse_name = corpse_name.substr( 2, corpse_name.size() - 3 ); // s/^ '(.*)'$/\1/ } gun_set_mode( mode ); if( idtmp == "UPS_on" ) { idtmp = "UPS_off"; } else if( idtmp == "adv_UPS_on" ) { idtmp = "adv_UPS_off" ; } convert( idtmp ); invlet = char(lettmp); set_damage( damtmp ); active = false; if (acttmp == 1) { active = true; } }
CertificateOfMembership(const Buffer<C> &b,unsigned int startAt = 0) throw(std::out_of_range,std::invalid_argument) { deserialize(b,startAt); }
Any::Any(TextInput& t) : m_type(NONE), m_data(NULL) { deserialize(t); }
java::lang::Object* org::mpisws::p2p::transport::simpleidentity::InetSocketAddressSerializer::deserialize(::rice::p2p::commonapi::rawserialization::InputBuffer* b, ::java::lang::Object* i, ::java::util::Map* options) { return deserialize(b, dynamic_cast< ::java::net::InetSocketAddress* >(i), options); }
int main(void) { serialize(); deserialize(); return 0; }
LLGesture::LLGesture(U8 **buffer, S32 max_size) { *buffer = deserialize(*buffer, max_size); }
Vector4int8::Vector4int8(class BinaryInput& b) { deserialize(b); }
Vector3int16::Vector3int16(class BinaryInput& bi) { deserialize(bi); }
ClusterState::ClusterState(vespalib::nbostream& i) { deserialize(i); }
uniform_value uniform_type_info::deserialize(deserializer* src) const { auto uval = create(); deserialize(uval->val, src); return std::move(uval); }
Color3uint8::Color3uint8(class BinaryInput& bi) { deserialize(bi); }
static void do_mysql_comms(int to_server, int from_server) { struct sql_request req; static char *buffer = 0; static int buflen = 0; static char *serial; Timer_ID id; Var args; Var result; set_server_cmdline("(MOO mysql-client slave)"); my_handle = moomysql_open_connection(SQLHOST, SQLUSER, SQLPASS, SQLDB, SQLPORT, 0); for (;;) { oklog("MYSQL CHILD: ready to read!\n"); if (robust_read(from_server, &req, sizeof(req)) != sizeof(req)) end_sql(); oklog("MYSQL CHILD read!\n"); if (req.length) { ensure_buffer(&buffer, &buflen, req.length + 1); if (robust_read(from_server, buffer, req.length) != req.length) end_sql(); buffer[req.length] = '\0'; oklog("MYSQL CHILD got stuff!\n"); args = deserialize(buffer); } id = set_timer(req.timeout, timeout_proc, 0); if (req.kind == SQLREQ_DO_QUERY) { oklog("MYSQL CHILD: doing query '%s'\n", args.v.list[1].v.str); result = moomysql_send_query(my_handle, args.v.list[1].v.str); oklog("got result: %s\n", value2str(result)); serial = serialize(result); oklog("MYSQL CHILD: serialized!\n"); req.length = strlen(serial); oklog("MYSQL CHILD: strlenned!\n"); } else if (req.kind == SQLREQ_GET_ROW) { result = moomysql_next_row(my_handle); serial = serialize(result); req.length = strlen(serial); } else { req.kind = SQLREQ_ERROR; req.length = 0; } oklog("MYSQL CHILD: writing..\n"); write(to_server, &req, sizeof(req)); oklog("MYSQL CHILD: wrote req..\n"); if (req.length) { write(to_server, serial, req.length); oklog("MYSQL CHILD: wrote serial..\n"); free(serial); oklog("MYSQL CHILD: freed serial!\n"); } } }