std::string Platform::getResourceString(Resource resource) { size_t size = Resources::getResourceSize(resource); char * data = new char[size]; Resources::getResourceData(resource, data); std::string dataStr(data, size); delete[] data; return dataStr; }
NS_IMETHODIMP AutoMounterSetting::Observe(nsISupports* aSubject, const char* aTopic, const PRUnichar* aData) { if (strcmp(aTopic, MOZSETTINGS_CHANGED) != 0) { return NS_OK; } // Note that this function gets called for any and all settings changes, // so we need to carefully check if we have the one we're interested in. // // The string that we're interested in will be a JSON string that looks like: // {"key":"ums.autoMount","value":true} nsCOMPtr<nsIThreadJSContextStack> stack = do_GetService("@mozilla.org/js/xpc/ContextStack;1"); if (!stack) { ERR("Failed to get JSContextStack"); return NS_OK; } JSContext* cx = stack->GetSafeJSContext(); if (!cx) { ERR("Failed to GetSafeJSContext"); return NS_OK; } nsDependentString dataStr(aData); JS::Value val; if (!JS_ParseJSON(cx, dataStr.get(), dataStr.Length(), &val) || !val.isObject()) { return NS_OK; } JSObject& obj(val.toObject()); JS::Value key; if (!JS_GetProperty(cx, &obj, "key", &key) || !key.isString()) { return NS_OK; } JSBool match; if (!JS_StringEqualsAscii(cx, key.toString(), UMS_MODE, &match) || (match != JS_TRUE)) { return NS_OK; } JS::Value value; if (!JS_GetProperty(cx, &obj, "value", &value) || !value.isInt32()) { return NS_OK; } int32_t mode = value.toInt32(); SetAutoMounterMode(mode); return NS_OK; }
bool DDGNode::findDataLinkDest(DDGNode*& ptr, const std::string& path, const BaseLink* link) { std::string pathStr, dataStr(" "); // non-empty data to specify that a data name is optionnal for DDGNode (as it can be a DataEngine) if (link) { if (!link->parseString(path, &pathStr, &dataStr)) return false; } else { if (!BaseLink::ParseString(path, &pathStr, &dataStr, this->getOwner())) return false; } bool self = (pathStr.empty() || pathStr == "[]"); if (dataStr == "") // no Data -> we look for a DataEngine { if (self) { ptr = this; return true; } else { Base* owner = this->getOwner(); DataEngine* obj = NULL; if (!owner) return false; if (!owner->findLinkDest(obj, path, link)) return false; ptr = obj; return true; } } Base* owner = this->getOwner(); if (!owner) return false; if (self) { ptr = owner->findData(dataStr); return (ptr != NULL); } else { Base* obj = NULL; if (!owner->findLinkDest(obj, BaseLink::CreateString(pathStr), link)) return false; if (!obj) return false; ptr = obj->findData(dataStr); return (ptr != NULL); } return false; }
size_t RESTHttpClient::processResponseHeader( void *buffer, size_t size, size_t nmemb, void *userp ) { RESTHttpClient *client = (RESTHttpClient *) userp; size_t length = size * nmemb; RESTRepresentation &dataRep = client->getInboundRepresentation(); std::string dataStr( (const char *)buffer, length ); boost::regex headerRE("([A-Za-z0-9]*): (.*)"); boost::cmatch match; if( boost::regex_match( dataStr.c_str(), match, headerRE ) ) { dataRep.addHTTPHeader( match[1].str(), match[2].str() ); } return length; }
bool Infogrames::load(Common::SeekableReadStream &dum) { int subSong = 0; int i; uint32 size; size = dum.size(); if (size < 20) return false; _data = new uint8[size]; dum.seek(0); dum.read(_data, size); Common::MemoryReadStream dataStr(_data, size); dataStr.seek(subSong * 2); dataStr.seek(dataStr.readUint16BE()); _subSong = _data + dataStr.pos(); if (_subSong > (_data + size)) return false; _speedCounter = dataStr.readUint16BE(); _speed = _speedCounter; _volSlideBlocks = _subSong + dataStr.readUint16BE(); _periodSlideBlocks = _subSong + dataStr.readUint16BE(); for (i = 0; i < 4; i++) { _chn[i].cmdBlockIndices = _subSong + dataStr.readUint16BE(); _chn[i].flags = 0x81; } _cmdBlocks = _data + dataStr.pos() + 2; if ((_volSlideBlocks > (_data + size)) || (_periodSlideBlocks > (_data + size)) || (_chn[0].cmdBlockIndices > (_data + size)) || (_chn[1].cmdBlockIndices > (_data + size)) || (_chn[2].cmdBlockIndices > (_data + size)) || (_chn[3].cmdBlockIndices > (_data + size)) || (_cmdBlocks > (_data + size))) return false; startPaula(); return true; }
void TCPSocket::_Write(const ValueList& args, KValueRef result) { args.VerifyException("write", "s|o"); BytesRef data; if (args.at(0)->IsString()) { std::string dataStr(args.GetString(0)); data = new Bytes(dataStr); } else { data = args.GetObject(0).cast<Bytes>(); if (data.isNull()) { throw ValueException::FromString("Argument is not Bytes object"); } } Write(data); }
/** * @brief RequestHandler::handlePost * @param uri * @param p_data * @return */ void RequestHandler::handleRequest(ConnectionInfo &conInfo) { vector<string> parsedURI = parseURI(conInfo.url); string p_image[] = {"index", "images", "IDENTIFIER", ""}; string p_searchImage[] = {"index", "searcher", ""}; string p_ioIndex[] = {"index", "io", ""}; Json::Value ret; conInfo.answerCode = MHD_HTTP_OK; if (testURIWithPattern(parsedURI, p_image) && conInfo.connectionType == PUT) { u_int32_t i_imageId = atoi(parsedURI[2].c_str()); u_int32_t i_ret = featureExtractor->processNewImage( i_imageId, conInfo.uploadedData.size(), conInfo.uploadedData.data()); ret["type"] = Converter::codeToString(i_ret); ret["image_id"] = Json::Value(i_imageId); } else if (testURIWithPattern(parsedURI, p_image) && conInfo.connectionType == DELETE) { u_int32_t i_imageId = atoi(parsedURI[2].c_str()); u_int32_t i_ret = index->removeImage(i_imageId); ret["type"] = Converter::codeToString(i_ret); ret["image_id"] = Json::Value(i_imageId); } else if (testURIWithPattern(parsedURI, p_searchImage) && conInfo.connectionType == POST) { SearchRequest req; req.imageData = conInfo.uploadedData; req.client = NULL; u_int32_t i_ret = imageSearcher->searchImage(req); ret["type"] = Converter::codeToString(i_ret); if (i_ret == OK) { Json::Value imageIds(Json::arrayValue); for (unsigned i = 0; i < req.results.size(); ++i) imageIds.append(req.results[i]); ret["image_ids"] = imageIds; } } else if (testURIWithPattern(parsedURI, p_ioIndex) && conInfo.connectionType == POST) { string dataStr(conInfo.uploadedData.begin(), conInfo.uploadedData.end()); Json::Value data = StringToJson(dataStr); u_int32_t i_ret; if (data["type"] == "LOAD") i_ret = index->load(data["index_path"].asString()); else if (data["type"] == "WRITE") i_ret = index->write(data["index_path"].asString()); else if (data["type"] == "CLEAR") i_ret = index->clear(); else i_ret = ERROR_GENERIC; ret["type"] = Converter::codeToString(i_ret); } else { conInfo.answerCode = MHD_HTTP_INTERNAL_SERVER_ERROR; ret["type"] = Converter::codeToString(ERROR_GENERIC); } conInfo.answerString = JsonToString(ret); }
// Received new data: void received(int id, asio::streambuf &readBuffer, std::size_t bytesTransferred) { string dataStr(boost::asio::buffer_cast<const char*>(readBuffer.data()), readBuffer.size()); string error; //we're expecting a new request: if (mState==REQUEST || mState==WAIT_LONGPOLL) { //if there is still an outstanding longpoll, cancel it: if (mState==WAIT_LONGPOLL) { respond(true); } //resize data to first delimiter: dataStr.resize(dataStr.find(delimiter)+delimiter.length()); readBuffer.consume(dataStr.length()); DEB(id << " got http REQUEST: \n" << dataStr); //determine the kind of request: smatch what; if (!regex_search( dataStr, what, boost::regex("^(GET|POST) ([^? ]*)([^ ]*) HTTP/(1..)$") )) { error="Cant parse request."; } else { mRequestType=what[1]; mRequestUrl=what[2]; mRequestQuery=what[3]; mRequestVersion=what[4]; DEB("REQUEST query: " << mRequestQuery); //create a regex iterator for http headers mHeaders.clear(); boost::sregex_iterator headerI( dataStr.begin(), dataStr.end(), boost::regex("^([[:alnum:]-]*): (.*?)$") ); //parse http headers while (headerI!=sregex_iterator()) { string header=(*headerI)[1].str(); string value=(*headerI)[2].str(); //headers handling is lowercase in synapse! transform(header.begin(), header.end(), header.begin(), ::tolower); mHeaders[header]=value; headerI++; } //this header MUST be set on longpoll requests: //if the client doesnt has one yet, httpSessionMan will assign a new one. try { mAuthCookie=mHeaders["x-synapse-authcookie"]; } catch(...) { mAuthCookie=0; } //proceed based on requestType: //a GET or empty POST: if (mRequestType=="GET" || (int)mHeaders["content-length"]==0) { if (respond()) { mState=REQUEST; } else { DEB(id << " is now waiting for longpoll results"); mState=WAIT_LONGPOLL; } return; } //a POST with content: else { if ( (int)mHeaders["content-length"]<0 || (int)mHeaders["content-length"] > config["maxContent"] ) { error="Invalid Content-Length"; } else { //change state to read the contents of the POST: mState=CONTENT; return; } } } } else //we're expecting the contents of a POST request. if (mState==CONTENT) { if (readBuffer.size() < mHeaders["content-length"]) { error="Didn't receive enough content-bytes!"; DEB(id << " ERROR: Expected " << mHeaders["content-length"].str() << " bytes, but only got: " << bytesTransferred); } else { dataStr.resize(mHeaders["content-length"]); readBuffer.consume(mHeaders["content-length"]); DEB(id << " got http CONTENT with length=" << dataStr.size() << ": \n" << dataStr); //POST to the special send url? if (mRequestUrl=="/synapse/send") { error=httpSessionMan.sendMessage(mAuthCookie, dataStr); if (error=="") { //DONT:respond with jsondata if we have something in the queue anyways //DONT:respondJsonQueue(false,false); //we cant do this, because then the order of messages isnt garanteed. so just respond with a boring empty string: respondString(200, ""); } else respondError(400, error); mState=REQUEST; return; } else { //ignore whatever is posted, and just respond normally: DEB(id << " ignored POST content"); if (respond()) mState=REQUEST; else mState=WAIT_LONGPOLL; return; } } } //ERROR(id << " had error while processing http data: " << error); error="Bad request: "+error; respondError(400, error); doDisconnect(); return; }
void LoaderCutsceneDAT::load(CutsceneTracks &tracks, FileHandle file) { std::string dataStr(file->data, file->length); std::stringstream ss(dataStr); int numZooms = 0; ss >> numZooms; ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); for(int i = 0; i < numZooms; ++i) { float t = 0.f; float z = 0.f; ss >> t; ss.ignore(1, ','); ss >> z; ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); tracks.zoom[t] = z; tracks.duration = std::max(t, tracks.duration); } ss.ignore(std::numeric_limits<std::streamsize>::max(), ';'); int numRotations = 0; ss >> numRotations; ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); for(int i = 0; i < numRotations; ++i) { float t = 0.f; float r = 0.f; ss >> t; ss.ignore(1, ','); ss >> r; ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); tracks.rotation[t] = r; tracks.duration = std::max(t, tracks.duration); } ss.ignore(std::numeric_limits<std::streamsize>::max(), ';'); int numPositions = 0; ss >> numPositions; ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); for(int i = 0; i < numPositions; ++i) { float t = 0.f; glm::vec3 p; ss >> t; ss.ignore(1, ','); ss >> p.x; ss.ignore(1, ','); ss >> p.y; ss.ignore(1, ','); ss >> p.z; ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); tracks.position[t] = p; tracks.duration = std::max(t, tracks.duration); } ss.ignore(std::numeric_limits<std::streamsize>::max(), ';'); int numTargets = 0; ss >> numTargets; ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); for(int i = 0; i < numTargets; ++i) { float t = 0.f; glm::vec3 p; ss >> t; ss.ignore(1, ','); ss >> p.x; ss.ignore(1, ','); ss >> p.y; ss.ignore(1, ','); ss >> p.z; ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); tracks.target[t] = p; tracks.duration = std::max(t, tracks.duration); } }