Esempio n. 1
0
/**
 *  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;
}
Esempio n. 2
0
LineSegment::LineSegment(class BinaryInput& b) {
	deserialize(b);
}
Esempio n. 3
0
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);
}
Esempio n. 5
0
 bool deserialize(const std::string& filename, value_type& value) {
    JsonReader reader;
    JsonNode root = reader.Parse(filename.c_str());
    return deserialize(root, value);
 }
Esempio n. 6
0
// -----------------------------------------------------------------------------
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
Esempio n. 7
0
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>();
    }
}
Esempio n. 8
0
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;
}
Esempio n. 9
0
void Property::deserializeValue(XmlDeserializer& s) {
    serializeValue_ = true;
    deserialize(s);
    serializeValue_ = false;
}
Esempio n. 10
0
void CInitMessage_Map::Deserialize(const unsigned char *p)
{
	p += header.Deserialize(p);
	p += deserialize(p, this->MapPath);
	p += deserialize32(p, &this->MapUID);
}
Esempio n. 11
0
size_t CNetworkChat::Deserialize(const unsigned char *buf)
{
	const unsigned char *p = buf;
	p += deserialize(p, this->Text);
	return p - buf;
}
Esempio n. 12
0
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);
}
Esempio n. 13
0
Box::Box(class BinaryInput& b) {
	deserialize(b);	
}
 NestedInteger deserialize(string s)
 {
     return deserialize(s, 0, s.length() - 1);
 }
Esempio n. 15
0
Vector4::Vector4(BinaryInput& b) {
    deserialize(b);
}
Esempio n. 16
0
/*
 *  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;
}
Esempio n. 19
0
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);
	}
Esempio n. 21
0
	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);
}
Esempio n. 23
0
int main(void)
{
	serialize();
	deserialize();
	return 0;
}
Esempio n. 24
0
LLGesture::LLGesture(U8 **buffer, S32 max_size)
{
	*buffer = deserialize(*buffer, max_size);
}
Esempio n. 25
0
Vector4int8::Vector4int8(class BinaryInput& b) {
    deserialize(b);
}
Esempio n. 26
0
Vector3int16::Vector3int16(class BinaryInput& bi) {
    deserialize(bi);
}
Esempio n. 27
0
ClusterState::ClusterState(vespalib::nbostream& i) {
    deserialize(i);
}
Esempio n. 28
0
uniform_value uniform_type_info::deserialize(deserializer* src) const {
  auto uval = create();
  deserialize(uval->val, src);
  return std::move(uval);
}
Esempio n. 29
0
Color3uint8::Color3uint8(class BinaryInput& bi) {
    deserialize(bi);
}
Esempio n. 30
0
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");
		}

	}

}