Command RESTfulParser::Parse (const char* data, size_t length) { Command cmd; size_t parsedLength = http_parser_execute(&this->parser, &this->settings, data, length); if(this->parser.upgrade) { } else if(parsedLength != length) { } http_parser_url pu; memset(&pu, 0, sizeof(http_parser_url)); int result = http_parser_parse_url(this->request.url.c_str(), this->request.url.length(), 0, &pu); if (result != 0) { cmd.type_ = Command::None; return cmd; } std::string rest; std::string query; if(pu.field_data[UF_PATH].len != 0) rest = this->request.url.substr(pu.field_data[UF_PATH].off, pu.field_data[UF_PATH].len); if(pu.field_data[UF_QUERY].len != 0) query = this->request.url.substr(pu.field_data[UF_QUERY].off, pu.field_data[UF_QUERY].len); /* if(this->parser.method == HTTP_GET) { std::string doc; std::string key; typedef boost::tokenizer<boost::char_separator<char> > tokenizer; boost::char_separator<char> sep("/"); tokenizer tokens(rest, sep); int idx = 0; for (tokenizer::iterator tok_iter = tokens.begin(); tok_iter != tokens.end(); ++tok_iter, idx++) { switch(idx) { case 0 : doc = *tok_iter; break; case 1: key = *tok_iter; break; default: break; } } cmd.type_ = Command::Read; cmd.docName_ = doc; cmd.key_ = atoi(key.c_str()); } else if (this->parser.method == HTTP_POST) */{ std::string cmdType; std::string doc; std::string key; typedef boost::tokenizer<boost::char_separator<char> > tokenizer; boost::char_separator<char> sep("/"); tokenizer tokens(rest, sep); int idx = 0; for (tokenizer::iterator tok_iter = tokens.begin(); tok_iter != tokens.end(); ++tok_iter, idx++) { switch(idx) { case 0: cmdType = *tok_iter; case 1: doc = *tok_iter; break; case 2: key = *tok_iter; break; default: break; } } ACE_DEBUG((LM_DEBUG,ACE_TEXT ("Cmd Type : %s\n"), cmdType.c_str())); if (boost::iequals(cmdType, "create")) { cmd.type_ = Command::CreateDocument; } else if (boost::iequals(cmdType, "drop")) { cmd.type_ = Command::DeleteDocument; } else if (boost::iequals(cmdType, "insert")) { cmd.type_ = Command::Create; } else if (boost::iequals(cmdType, "read")) { cmd.type_ = Command::Read; } else if (boost::iequals(cmdType, "delete")) { cmd.type_ = Command::Delete; } else if (boost::iequals(cmdType, "update")) { cmd.type_ = Command::Update; } cmd.docName_ = doc; if(!key.empty()) cmd.key_.key_ = boost::lexical_cast<QWORD>(key.c_str()); cmd.value_.rev_ = 0; if(this->request.bodySize > 0) { ACE_DEBUG((LM_DEBUG,ACE_TEXT ("Body Parsing...\n"))); Json::Reader reader; std::string body(&data[this->request.bodyOffset], this->request.bodySize); bool parsingSuccessful = reader.parse(body, cmd.value_.data_); if ( !parsingSuccessful ) { cmd.type_ = Command::None; return cmd; } } } /* else { cmd.type_ = Command::None; }*/ return cmd; }
int main(int argc, char* argv[]) { std::string fileName; int returnAmount = -1; fileName = argv[1]; returnAmount = atoi(argv[2]); std::ifstream t(fileName); std::string JSONData((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>()); std::string searchKey = ""; for(int x = 3; x < argc; x++) if(x > 3) searchKey += " " + std::string(argv[x]); else searchKey += std::string(argv[x]); Json::Value root; Json::Reader reader; bool parsedSuccess = reader.parse(JSONData, root, false); std::vector<int> compareOverlayValues; std::vector<int> TotalValues; std::vector<int> placeVector; double score = 0; bool adding; bool hasTag; for(int place = 0; place < root.size(); place++) { adding = false; hasTag = false; score = 0; score = compareShift(searchKey, root[place]["Name"].asString()); if(score == 1 || score == 0) adding = true; for(int tag = 0; tag < root[place]["Tags"].size(); tag++) { if(searchKey == root[place]["Tags"][tag].asString()) { hasTag = true; adding = true; } } if(adding) { compareOverlayValues.push_back(compareOverlay(searchKey, root[place]["Name"].asString())); score = (double)compareOverlayValues.at(compareOverlayValues.size()-1)/(score+1); if(hasTag) score += 30; score += sqrt(root[place]["Score"].asInt()*10); TotalValues.push_back(score); placeVector.push_back(place); } } if(returnAmount >= placeVector.size()) returnAmount = placeVector.size()-1; if(TotalValues.size() > 0 && returnAmount < placeVector.size()) { auto zipped = view::zip(placeVector, TotalValues); sort(zipped, less{}, get_n<1>{}); for(int place = 0; place <= returnAmount; place++) std::cout << root[placeVector.at(placeVector.size()-1-place)]["ID"] << std::endl;// << TotalValues.at(placeVector.size()-1-place) << std::endl; } return 0; }
void MadeupWindow::loadPreferences() { canvas->makeCurrent(); try { std::ifstream in(config_path); Json::Reader reader; Json::Value prefs; reader.parse(in, prefs); int width = prefs.get("window.width", 1200).asUInt(); int height = prefs.get("window.height", 600).asUInt(); resize(width, height); int x = prefs.get("window.x", -1).asInt(); int y = prefs.get("window.y", -1).asInt(); if (x >= 0 && y >= 0) { move(x, y); } float stroke_width = (float) prefs.get("path.stroke.width", renderer->getPathStrokeWidth()).asDouble(); renderer->setPathStrokeWidth(stroke_width); path_stroke_width_spinner->setValue(stroke_width); float vertex_size = (float) prefs.get("vertex.size", renderer->getVertexSize()).asDouble(); renderer->setVertexSize(vertex_size); vertex_size_spinner->setValue(vertex_size); string font_face = prefs.get("font.face", "Courier New").asString(); int font_size = prefs.get("font.size", 18).asUInt(); QFont font; font.setFamily(font_face.c_str()); font.setPointSize(font_size); editor->setFont(font); console->setFont(font); renderer->showHeading(prefs.get("show.heading", renderer->showHeading()).asBool()); show_heading_checkbox->setChecked(renderer->showHeading()); renderer->showHeading(prefs.get("show.path", renderer->showPath()).asBool()); show_path_checkbox->setChecked(renderer->showPath()); renderer->showStops(prefs.get("show.stops", renderer->showStops()).asBool()); show_stops_checkbox->setChecked(renderer->showStops()); Json::Value show_axis_node = prefs.get("show.axis", Json::nullValue); Json::Value show_grid_node = prefs.get("show.grid", Json::nullValue); Json::Value grid_extent_node = prefs.get("grid.extent", Json::nullValue); Json::Value grid_spacing_node = prefs.get("grid.spacing", Json::nullValue); for (int d = 0; d < 3; ++d) { bool show_axis = show_axis_node.get(Json::ArrayIndex(d), renderer->showAxis(d)).asBool(); renderer->showAxis(d, show_axis); show_axis_checkboxes[d]->setChecked(renderer->showAxis(d)); bool show_grid = show_grid_node.get(Json::ArrayIndex(d), renderer->showGrid(d)).asBool(); renderer->showGrid(d, show_grid); show_grid_checkboxes[d]->setChecked(renderer->showGrid(d)); float grid_extent = (float) grid_extent_node.get(Json::ArrayIndex(d), renderer->getGridExtent(d)).asDouble(); renderer->setGridExtent(d, grid_extent); grid_extent_spinners[d]->setValue(renderer->getGridExtent(d)); float grid_spacing = (float) grid_spacing_node.get(Json::ArrayIndex(d), renderer->getGridSpacing(d)).asDouble(); renderer->setGridSpacing(d, grid_spacing); grid_spacing_spinners[d]->setValue(renderer->getGridSpacing(d)); } // Background color Json::Value background_color_node = prefs.get("background.color", Json::nullValue); if (!background_color_node.isNull()) { td::QVector4<float> color = renderer->getBackgroundColor(); for (int i = 0; i < 4; ++i) { color[i] = (float) background_color_node.get(i, 0.0).asDouble(); } renderer->setBackgroundColor(color); } QPalette background_color_palette; background_color_palette.setColor(QPalette::Button, toQColor(renderer->getBackgroundColor())); background_color_button->setPalette(background_color_palette); // Path color Json::Value path_color_node = prefs.get("path.color", Json::nullValue); if (!path_color_node.isNull()) { td::QVector4<float> color = renderer->getPathColor(); for (int i = 0; i < 4; ++i) { color[i] = (float) path_color_node.get(i, 0.0).asDouble(); } renderer->setPathColor(color); } QPalette path_color_palette; path_color_palette.setColor(QPalette::Button, toQColor(renderer->getPathColor())); path_color_button->setPalette(path_color_palette); // Vertex color Json::Value vertex_color_node = prefs.get("vertex.color", Json::nullValue); if (!vertex_color_node.isNull()) { td::QVector4<float> color = renderer->getPathColor(); for (int i = 0; i < 4; ++i) { color[i] = (float) vertex_color_node.get(i, 0.0).asDouble(); } renderer->setVertexColor(color); } QPalette vertex_color_palette; vertex_color_palette.setColor(QPalette::Button, toQColor(renderer->getVertexColor())); vertex_color_button->setPalette(vertex_color_palette); // Face style int face_style = prefs.get("render.style", renderer->getRenderStyle()).asUInt(); renderer->setRenderStyle(face_style); face_style_picker->setCurrentIndex(renderer->getRenderStyle()); // Show preferences bool show_settings = prefs.get("show.settings", false).asBool(); action_settings->setChecked(show_settings); // Show console bool show_console = prefs.get("show.console", true).asBool(); show_console_checkbox->setChecked(show_console); int settings_page = prefs.get("settings.page", 0).asUInt(); settings_picker->setCurrentIndex(settings_page); double autopathify_delay = prefs.get("autopathify.delay", 0.25).asDouble(); autopathify_delay_spinner->setValue(autopathify_delay); float axis_stroke_width = (float) prefs.get("axis.stroke.width", renderer->getAxisStrokeWidth()).asDouble(); axis_stroke_width_spinner->setValue(axis_stroke_width); float grid_stroke_width = (float) prefs.get("grid.stroke.width", renderer->getGridStrokeWidth()).asDouble(); grid_stroke_width_spinner->setValue(grid_stroke_width); bool autopathify = prefs.get("autopathify", true).asBool(); autopathify_checkbox->setChecked(autopathify); console->setVisible(show_console); bool faceted = prefs.get("show.faceted", true).asBool(); faceted_checkbox->setChecked(faceted); bool autorotate = prefs.get("autorotate", renderer->hasAutorotate()).asBool(); has_autorotate_checkbox->setChecked(autorotate); bool has_specular = prefs.get("light.has.specular", renderer->hasSpecular()).asBool(); // TODO renderer->hasSpecular(has_specular); has_specular_checkbox->setChecked(renderer->hasSpecular()); bool is_two_sided = prefs.get("light.two.sided", renderer->isTwoSided()).asBool(); is_two_sided_checkbox->setChecked(is_two_sided); double azimuth_angle = prefs.get("light.azimuth.angle", renderer->getAzimuthAngle()).asDouble(); azimuth_angle_spinner->setValue(azimuth_angle); double elevation_angle = prefs.get("light.elevation.angle", renderer->getElevationAngle()).asDouble(); elevation_angle_spinner->setValue(elevation_angle); double shininess = prefs.get("light.shininess", renderer->getShininess()).asDouble(); shininess_spinner->setValue(shininess); double light_distance_factor = prefs.get("light.distance.factor", renderer->getLightDistanceFactor()).asDouble(); light_distance_factor_spinner->setValue(light_distance_factor); // Horizontal splitter Json::Value horizontal_sizes_node = prefs.get("horizontal.splitter.sizes", Json::nullValue); if (!horizontal_sizes_node.isNull()) { QList<int> sizes; sizes.push_back(horizontal_sizes_node.get(Json::ArrayIndex(0), -1).asUInt()); sizes.push_back(horizontal_sizes_node.get(Json::ArrayIndex(1), -1).asUInt()); sizes.push_back(horizontal_sizes_node.get(Json::ArrayIndex(2), -1).asUInt()); horizontal_splitter->setSizes(sizes); } // Vertical splitter Json::Value vertical_sizes_node = prefs.get("vertical.splitter.sizes", Json::nullValue); if (!vertical_sizes_node.isNull()) { QList<int> sizes; sizes.push_back(vertical_sizes_node.get(Json::ArrayIndex(0), -1).asUInt()); sizes.push_back(vertical_sizes_node.get(Json::ArrayIndex(1), -1).asUInt()); vertical_splitter->setSizes(sizes); } last_directory = QString(prefs.get("last.directory", last_directory.toStdString()).asString().c_str()); } catch (int i) { } canvas->update(); }
render::render(std::string manifest) { std::string in = get_file_contents(manifest.c_str()); Json::Value root; Json::Reader reader; bool stat = reader.parse( in, root ); if (stat){ FONT_NAME_ARIAL = root["FontArial"].asString(); FONT_NAME_COMIC = root["FontComic"].asString(); WINDOW_SIZE_X = root["WindowSize"]["x"].asInt(); WINDOW_SIZE_Y = root["WindowSize"]["y"].asInt(); TILE_SIZE = root["TileSize"].asInt(); BATTLEBACKGROUND = root["BattleBackground"].asString(); FRAME = root["Frame"].asString(); FRAME_SIDE = root["FrameSide"].asString(); FRAME_TITLE = root["FrameTitle"].asString(); CHAR_MENU = root["CharMenuOption"].asString(); CHAR_MENU_SELECTED = root["CharMenuSelect"].asString(); PROMPT = root["Prompt"].asString(); BATTLEMENU = root["BattleMenu"].asString(); }else{ std::cout << "Failed to parse manifest\n" << reader.getFormatedErrorMessages(); exit(128); } if (SDL_Init(SDL_INIT_EVERYTHING) != 0){ std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl; throw(122); } win = SDL_CreateWindow("RPG", 100, 100, WINDOW_SIZE_X, WINDOW_SIZE_Y, SDL_WINDOW_SHOWN); if (win == nullptr){ std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl; throw(122); } ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); if (ren == nullptr){ std::cout << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl; throw(122); } TTF_Init(); font_arial16 = TTF_OpenFont(FONT_NAME_ARIAL.c_str(), 16); font_comic16 = TTF_OpenFont(FONT_NAME_COMIC.c_str(), 16); font_comic32 = TTF_OpenFont(FONT_NAME_COMIC.c_str(), 32); font_comic50 = TTF_OpenFont(FONT_NAME_COMIC.c_str(), 50); if (font_arial16 == nullptr){ std::cout << "SDL_CreateFont Error: " << SDL_GetError() << std::endl; throw(122); } if (font_comic16 == nullptr){ std::cout << "SDL_CreateFont Error: " << SDL_GetError() << std::endl; throw(122); } if (font_comic32 == nullptr){ std::cout << "SDL_CreateFont Error: " << SDL_GetError() << std::endl; throw(122); } if (font_comic50 == nullptr){ std::cout << "SDL_CreateFont Error: " << SDL_GetError() << std::endl; throw(122); } }
OSVR_ReturnCode operator()(OSVR_PluginRegContext ctx) { bool gotDevice; #ifdef OSVR_MULTISERVER_VERBOSE bool first = true; #endif do { gotDevice = false; struct hid_device_info *enumData = hid_enumerate(0, 0); for (struct hid_device_info *dev = enumData; dev != nullptr; dev = dev->next) { if (m_isPathHandled(dev->path)) { continue; } #ifdef OSVR_MULTISERVER_VERBOSE if (first) { std::cout << "[OSVR Multiserver] HID Enumeration: " << boost::format("0x%04x") % dev->vendor_id << ":" << boost::format("0x%04x") % dev->product_id << std::endl; } #endif if (gotDevice) { continue; } // Razer Hydra if (dev->vendor_id == 0x1532 && dev->product_id == 0x0300) { gotDevice = true; m_handlePath(dev->path); auto hydraJsonString = osvr::util::makeString( com_osvr_Multiserver_RazerHydra_json); Json::Value hydraJson; Json::Reader reader; if (!reader.parse(hydraJsonString, hydraJson)) { throw std::logic_error("Faulty JSON file for Hydra - " "should not be possible!"); } /// Decorated name for Hydra std::string name; { // Razer Hydra osvr::vrpnserver::VRPNDeviceRegistration reg(ctx); name = reg.useDecoratedName(m_data.getName("RazerHydra")); reg.registerDevice(new vrpn_Tracker_RazerHydra( name.c_str(), reg.getVRPNConnection())); reg.setDeviceDescriptor(hydraJsonString); } std::string localName = "*" + name; { // Copy semantic paths for corresponding filter: just // want left/$target and right/$target Json::Value filterJson; if (!reader.parse( osvr::util::makeString( com_osvr_Multiserver_OneEuroFilter_json), filterJson)) { throw std::logic_error("Faulty JSON file for One " "Euro Filter - should not " "be possible!"); } auto &filterSem = (filterJson["semantic"] = Json::objectValue); auto &hydraSem = hydraJson["semantic"]; for (auto const &element : {"left", "right"}) { filterSem[element] = Json::objectValue; filterSem[element]["$target"] = hydraSem[element]["$target"]; } auto &filterAuto = (filterJson["automaticAliases"] = Json::objectValue); filterAuto["$priority"] = 130; // enough to override a normal automatic route. auto &hydraAuto = hydraJson["automaticAliases"]; for (auto const &element : {"/me/hands/left", "/me/hands/right"}) { filterAuto[element] = hydraAuto[element]; } // Corresponding filter osvr::vrpnserver::VRPNDeviceRegistration reg(ctx); reg.registerDevice(new vrpn_Tracker_FilterOneEuro( reg.useDecoratedName( m_data.getName("OneEuroFilter")).c_str(), reg.getVRPNConnection(), localName.c_str(), 2, 1.15, 1.0, 1.2, 1.5, 5.0, 1.2)); reg.setDeviceDescriptor(filterJson.toStyledString()); } continue; } // OSVR Hacker Dev Kit if ((dev->vendor_id == 0x1532 && dev->product_id == 0x0300) || (dev->vendor_id == 0x03EB && dev->product_id == 0x2421)) { gotDevice = true; m_handlePath(dev->path); osvr::vrpnserver::VRPNDeviceRegistration reg(ctx); reg.constructAndRegisterDevice< vrpn_Tracker_OSVRHackerDevKit>( m_data.getName("OSVRHackerDevKit")); reg.setDeviceDescriptor(osvr::util::makeString( com_osvr_Multiserver_OSVRHackerDevKit_json)); continue; } } hid_free_enumeration(enumData); #ifdef OSVR_MULTISERVER_VERBOSE first = false; #endif } while (gotDevice); return OSVR_RETURN_SUCCESS; }
Apsis::Registry::Scene::Scene(const char* path, const Apsis::Engine::Object& loader) { Json::Reader reader; Json::Value value; std::ifstream file(path); reader.parse(file, value); file.close(); if (value.isMember("type") && value["type"].compare(Json::Value("scene")) == 0) { } else { throw "Scene file given is not of type 'scene'."; } if (value.isMember("inherit")) { // TODO: inherit scenes } if (value.isMember("actors")) { // Load actors for (Json::Value::iterator it = value["actors"].begin(); it != value["actors"].end(); ++it) { if ((*it).isObject()) { if ((*it).isMember("thing") && (*it).isMember("x") && (*it).isMember("y")) { ActorInfo actor_info; actor_info.thing = &loader.loadThing((*it)["thing"].asCString()); actor_info.x = (float)((*it)["x"].asDouble()); actor_info.y = (float)((*it)["y"].asDouble()); _actors.push_back(actor_info); } } else { throw "Scene file's 'actors' section is malformed."; } } } if (value.isMember("map")) { // Just one map if (value.isMember("maps")) { // Error throw "Scene file has both 'map' and 'maps' which is not allowed."; } MapInfo map_info; if (value["map"].isString()) { // x and y are 0 map_info.x = 0; map_info.y = 0; map_info.map = &loader.loadMap(value["map"].asCString()); } else if (value["map"].isMember("map") && value["map"].isMember("x") && value["map"].isMember("y")) { // x and y are given map_info.x = (float)(value["map"]["x"].asDouble()); map_info.y = (float)(value["map"]["y"].asDouble()); map_info.map = &loader.loadMap(value["map"]["map"].asCString()); } _maps.push_back(map_info); } else if (value.isMember("maps")) { // More than one map for (Json::Value::iterator it = value["maps"].begin(); it != value["maps"].end(); ++it) { if ((*it).isMember("map") && (*it).isMember("x") && (*it).isMember("y")) { // x and y are given MapInfo map_info; map_info.x = (float)((*it)["x"].asDouble()); map_info.y = (float)((*it)["y"].asDouble()); map_info.map = &Apsis::World::Map::load((*it)["map"].asCString(), loader); _maps.push_back(map_info); } else { throw "Scene file's 'maps' section is malformed."; } } } }
//{ paramList:[{"id":"参数id1","value":"新值1"},{"id":"参数id2","value":"新值2"}], "status":"成功、失败、取消等标识代码" } BOOL CCxStructTreeRunResult::Parse( LPCTSTR lpszData, CCxStructTree * pTree ) { Clear(); CString strSrc = lpszData == NULL ? "" : lpszData; if (strSrc.IsEmpty()) return FALSE; Json::Reader reader; Json::Value obj, arrValue; CCxStructTreeRunResultParam * pValue = NULL; CCxStructTreeNode * pNode = NULL; STRUCTTREEMAP_PARAM_VALUE::iterator itrExistNode; CCxStructTreeRunResultParam * pExistValue = NULL; CCxStructTreeRunResultComponent * pComponent = NULL; CCxStructTreeRunResultFlow * pFlow = NULL; CString str; CDlgSvg* pSvg = GetSvgDilogPtr(); try { if (!reader.parse((char*)(LPCTSTR)strSrc, obj, false)) return FALSE; if (!obj.isObject()) return FALSE; m_strStatus = ( obj["status"].isString()) ? obj["status"].asCString() : _T(""); arrValue = obj["paramList"]; if ( !arrValue.isNull() && arrValue.isArray() ) { for ( Json::Value::iterator itr = arrValue.begin(); itr != arrValue.end(); ++itr) { pValue = new CCxStructTreeRunResultParam(); pValue->m_strId = ( (*itr)["id"].isString()) ? (*itr)["id"].asCString() : _T(""); pValue->m_strValue = ( (*itr)["value"].isString()) ? (*itr)["value"].asCString() : _T(""); if ( pTree != NULL ) { pNode = pTree->Find( pValue->m_strId ); if ( pNode == NULL ) { ::MessageBox( GetMainWnd(),"异常,返回的参数Id,在结构树中不存在", g_lpszAppTitle, MB_OK|MB_ICONERROR ); Clear(); return FALSE; } if ( !pNode->IsParamNode() ) { ::MessageBox( GetMainWnd(), "异常,返回的结果不是参数", g_lpszAppTitle, MB_OK|MB_ICONERROR ); Clear(); return FALSE; } pValue->m_pNode = (CCxStructTreeNodeParam *)pNode; } itrExistNode = m_mapRunReturn.find( pValue->m_strId ); if ( itrExistNode != m_mapRunReturn.end() ) { pExistValue = itrExistNode->second; m_mapRunReturn.erase( itrExistNode ); delete pExistValue; pExistValue = NULL; } m_mapRunReturn.insert( make_pair( pValue->m_strId, pValue ) ); } } if ( !obj["flowIdList"].isNull() && obj["flowIdList"].isArray() ) { arrValue = obj["flowIdList"]; for ( Json::Value::iterator itr = arrValue.begin(); itr != arrValue.end(); ++itr) { pFlow = new CCxStructTreeRunResultFlow(); str = ( (*itr)["id"].isString()) ? (*itr)["id"].asCString() : _T(""); if ( pSvg != NULL ) { pFlow->m_strId = pSvg->JsMethod_ConvertFlowId( str ); } pFlow->m_strStatus = ( (*itr)["status"].isString()) ? (*itr)["status"].asCString() : _T(""); if ( pTree != NULL ) { pNode = pTree->Find( pFlow->m_strId ); if ( pNode == NULL ) { ::MessageBox(GetMainWnd(), "异常,返回的流程Id,在结构树中不存在", g_lpszAppTitle, MB_OK|MB_ICONERROR ); Clear(); return FALSE; } if ( !pNode->IsFlowNode() ) { ::MessageBox(GetMainWnd(), "异常,返回的流程Id与节点类型不匹配", g_lpszAppTitle, MB_OK|MB_ICONERROR ); Clear(); return FALSE; } pFlow->m_pNode = (CCxStructTreeNodeFlow *)pNode; } if ( find( m_vFlows.begin(), m_vFlows.end(), pFlow ) == m_vFlows.end() ) { m_vFlows.push_back( pFlow ); } } } if ( !obj["componentIdList"].isNull() && obj["componentIdList"].isArray() ) { arrValue = obj["componentIdList"]; for ( Json::Value::iterator itr = arrValue.begin(); itr != arrValue.end(); ++itr) { pComponent = new CCxStructTreeRunResultComponent(); pComponent->m_strId = ( (*itr)["id"].isString()) ? (*itr)["id"].asCString() : _T(""); pComponent->m_strStatus = ( (*itr)["status"].isString()) ? (*itr)["status"].asCString() : _T(""); if ( pTree != NULL ) { pNode = pTree->Find( pComponent->m_strId ); if ( pNode == NULL ) { ::MessageBox(GetMainWnd(), "异常,返回的组件Id,在结构树中不存在", g_lpszAppTitle, MB_OK|MB_ICONERROR ); Clear(); return FALSE; } if ( !pNode->IsComponentNode() ) { ::MessageBox(GetMainWnd(), "异常,返回的组件Id与节点类型不匹配", g_lpszAppTitle, MB_OK|MB_ICONERROR ); Clear(); return FALSE; } pComponent->m_pNode = (CCxStructTreeNodeComponent *)pNode; } if ( find( m_vComponents.begin(), m_vComponents.end(), pComponent ) == m_vComponents.end() ) { m_vComponents.push_back( pComponent ); } } } } catch (...) { Clear(); return FALSE; } return TRUE; }
void SnifferMain::OnRecvCommand(SnifferClient* client, const SCMD &scmd) { switch(scmd.header.scmdt) { case ExcuteCommand:{ // 执行Shell命令 string cmd = scmd.param; string result = SystemComandExecuteWithResult(cmd); FileLog(SnifferLogFileName, "SnifferMain::OnRecvCommand( 执行 : %s )", cmd.c_str()); FileLog(SnifferLogFileName, "SnifferMain::OnRecvCommand( 执行结果 : %s )", result.c_str()); // 返回命令结果 SCMD scmdSend; scmdSend.header.scmdt = ExcuteCommandResult; scmdSend.header.bNew = false; scmdSend.header.seq = scmd.header.seq; scmdSend.header.len = MIN(result.length(), MAX_PARAM_LEN - 1); memcpy(scmdSend.param, result.c_str(), scmdSend.header.len); scmdSend.param[scmdSend.header.len] = '\0'; client->SendCommand(scmdSend); }break; case SnifferListDir:{ // 列目录 Json::FastWriter writer; Json::Value rootSend; string result; rootSend[COMMON_RET] = 0; Json::Reader reader; Json::Value rootRecv; reader.parse(scmd.param, rootRecv); int index = 0; if( rootRecv[COMMON_PAGE_INDEX].isInt() ) { index = rootRecv[COMMON_PAGE_INDEX].asInt(); } int size = 0; if( rootRecv[COMMON_PAGE_SIZE].isInt() ) { size = rootRecv[COMMON_PAGE_SIZE].asInt(); } string dir = ""; if( rootRecv[DIRECTORY].isString() ) { dir = rootRecv[DIRECTORY].asString(); } DIR *dirp; dirent *dp; int i = 0; if( (dirp = opendir(dir.c_str())) != NULL ) { rootSend[COMMON_RET] = 1; int i = 0; while( (dp = readdir(dirp)) != NULL ) { Json::Value dirItem; dirItem[D_TYPE] = dp->d_type; if( dp->d_type == DT_DIR ) { if( strcmp(dp->d_name, ".") != 0 ) { if( i >= index * size && i < (index + 1) * size ) { dirItem[D_NAME] = dp->d_name; rootSend[FILE_LIST].append(dirItem); } i++; } } else { if( i >= index * size && i < (index + 1) * size ) { dirItem[D_NAME] = dp->d_name; rootSend[FILE_LIST].append(dirItem); } i++; } } closedir(dirp); rootSend[COMMON_TOTAL] = i; } result = writer.write(rootSend); SCMD scmdSend; scmdSend.header.scmdt = SnifferTypeClientInfoResult; scmdSend.header.bNew = false; scmdSend.header.seq = scmd.header.seq; scmdSend.header.len = MIN(result.length(), MAX_PARAM_LEN - 1); memcpy(scmdSend.param, result.c_str(), scmdSend.header.len); scmdSend.param[scmdSend.header.len] = '\0'; client->SendCommand(scmdSend); }break; case SinfferTypeStart:{ // 开始监听 FileLog(SnifferLogFileName, "SnifferMain::OnRecvCommand( 开始监听 )"); mSniffer.StartSniffer(); }break; case SinfferTypeStop:{ // 停止监听 FileLog(SnifferLogFileName, "SnifferMain::OnRecvCommand( 停止监听 )"); mSniffer.StopSniffer(); }break; case SinfferTypeVersion:{ // 返回版本 FileLog(SnifferLogFileName, "SnifferMain::OnRecvCommand( 返回版本号 : %s )", SnifferVersion); SCMD scmdSend; scmdSend.header.scmdt = SinfferTypeVersionResult; scmdSend.header.bNew = false; scmdSend.header.seq = scmd.header.seq; scmdSend.header.len = MIN(strlen(SnifferVersion), MAX_PARAM_LEN - 1); memcpy(scmdSend.param, SnifferVersion, scmdSend.header.len); scmdSend.param[scmdSend.header.len] = '\0'; client->SendCommand(scmdSend); }break; case SinfferTypeNone:{ // 与服务端连接已经断开 }break; default:break; } }
void UpdateUserData::handle(Manager* manager, SharedManager* sManager) { bool validation = this->validateInput(); if(validation) { struct mg_str *cl_header = mg_get_http_header(hm, "Token"); if(!cl_header) { this->response(1, "Token Missing ", returnEmptyJsonObject()); return; } Json::Reader r = Json::Reader(); Json::Value value = Json::Value(); r.parse(hm->body.p, value); // Local user update User* user = manager->getUser(value.get("username","").asString()); if(!user) { this->response(1, "User could not be modified", returnEmptyJsonObject()); return; } std::string token(getHeaderParam(cl_header->p)); if(token.compare(user->getToken()) != 0) { this->response(2, "Invalid Token", returnEmptyJsonObject()); return; } user->updateWithJson(value); bool updateUser = manager->updateUser(user); if(updateUser) { value["id"] = user->getId(); if(value.isMember("photoProfile") || value.isMember("photo_profile")) { // Photo Profile Upload std::string key = ""; value.isMember("photoProfile") ? key = "photoProfile" : key = "photo_profile"; Json::Value uploadP = Json::Value(); uploadP["photo"] = value.get(key, "").asString(); uploadP["id"] = user->getId(); value.removeMember(key); int photoUp = sManager->putUserPhoto(uploadP); if(!photoUp) { this->response(1, "User photo profile could not be uploaded", returnEmptyJsonObject()); return; } } // Rest of user data to update on Shared Server // TODO: Falta subir los intereses nuevos que haya! if(value.isMember("interests")) { Json::Value interests = value.get("interests", Json::Value(Json::arrayValue)); Json::ValueConstIterator interestsIt = interests.begin(); while(interestsIt != interests.end()) { Json::Value response = sManager->postInterest(*interestsIt); // TODO: Alguna cola para reupload de intereses que debieron subir // pero no pudieron por algun problema (que no sea duplicado) interestsIt++; } } if(value.isMember("edad")) value["age"] = value.get("edad", 18).asInt(); int sharedUpdate = sManager->putUser(value); if(sharedUpdate) { this->response(0, "Modified", user->getJson()); } else { this->response(1, "User could not be modified", returnEmptyJsonObject()); } } else { this->response(1, "User could not be modified", returnEmptyJsonObject()); } delete user; } }
static int handle_default(struct mg_connection *conn, Settings& settings) { send_headers(conn); if ( !settings.run_scripts.size() ) { return send_error(conn, "Internal error: no scripts"); } // hook up converter to engine Engine engine(settings); Converter converter(&engine, settings); bool conversion_success = engine.run(); // collect info QString result = engine.scriptResult(); double run_elapsedms = engine.runTime(); double convert_elapsedms = engine.convertTime(); QVector<QString> warnings = converter.warnings(); QVector<QString> errors = converter.errors(); debug_settings( settings, result, warnings, errors, conversion_success, run_elapsedms, convert_elapsedms ); // create json return Json::Value root; root["path"] = settings.out.toLocal8Bit().constData(); Json::Reader reader; Json::Value result_root; bool parsingSuccessful = false; parsingSuccessful = reader.parse( result.toLocal8Bit().constData(), result_root ); if ( !parsingSuccessful ) { result_root = Json::Value(); } root["result"] = result_root; root["conversion"] = conversion_success; root["run_elapsed"] = run_elapsedms; root["convert_elapsed"] = convert_elapsedms; Json::Value js_warnings; for( QVector<QString>::iterator it = warnings.begin(); it != warnings.end(); ++it ) { js_warnings.append( it->toLocal8Bit().constData() ); } root["warnings"] = js_warnings; Json::Value js_errors; for( QVector<QString>::iterator it = errors.begin(); it != errors.end(); ++it ) { js_errors.append( it->toLocal8Bit().constData() ); } root["errors"] = js_errors; QFile* file = new QFile(settings.out); file->open(QIODevice::ReadOnly); QByteArray image = file->readAll(); int originalSize = image.length(); QString encoded = QString(image.toBase64()); int encodedSize = encoded.size(); root["image"] = encoded.toLocal8Bit().constData(); root["image_original_size"] = originalSize; root["image_encoded_size"] = encodedSize; root["image_format"] = settings.fmt.toLocal8Bit().constData(); Json::StyledWriter writer; std::string json = writer.write(root); mg_send_data(conn, json.c_str(), json.length()); if ( settings.statsd ) { settings.statsd->inc(settings.statsd_ns + "request"); } QString xtra = QString(LOG_STRING).arg(settings.in).arg(settings.screen_width).arg(settings.screen_height).arg(settings.out).arg(settings.fmt) .arg(settings.selector.length()?settings.selector:"''") .arg(settings.crop_rect.width()).arg(settings.crop_rect.height()).arg(settings.crop_rect.x()).arg(settings.crop_rect.y()) .arg(run_elapsedms).arg(convert_elapsedms); log( conn, xtra.toLocal8Bit().constData() ); return MG_TRUE; }
bool CICYThermostat::GetSerialAndToken() { std::stringstream sstr; sstr << "username="******"&password="******""; if ((m_companymode == CMODE_UNKNOWN) || (m_companymode == CMODE_PORTAL)) sURL = ICY_LOGIN_URL; else if (m_companymode == CMODE_ENI) sURL = ENI_LOGIN_URL; else sURL = SEC_LOGIN_URL; if (!HTTPClient::POST(sURL, szPostdata, ExtraHeaders, sResult)) { _log.Log(LOG_ERROR,"ICYThermostat: Error login!"); return false; } if (sResult.find("BadLogin") != std::string::npos) { if (m_companymode == CMODE_UNKNOWN) { //Try ENI mode sURL = ENI_LOGIN_URL; sResult = ""; if (!HTTPClient::POST(sURL, szPostdata, ExtraHeaders, sResult)) { _log.Log(LOG_ERROR, "ICYThermostat: Error login!"); return false; } if (sResult.find("BadLogin") != std::string::npos) { if (m_companymode == CMODE_UNKNOWN) { //Try SEC mode sURL = SEC_LOGIN_URL; sResult = ""; if (!HTTPClient::POST(sURL, szPostdata, ExtraHeaders, sResult)) { _log.Log(LOG_ERROR, "ICYThermostat: Error login!"); return false; } if (sResult.find("BadLogin") != std::string::npos) { _log.Log(LOG_ERROR, "ICYThermostat: Error login! (Check username/password)"); return false; } } else { _log.Log(LOG_ERROR, "ICYThermostat: Error login! (Check username/password)"); return false; } } } else { _log.Log(LOG_ERROR, "ICYThermostat: Error login! (Check username/password)"); return false; } } Json::Value root; Json::Reader jReader; bool ret = jReader.parse(sResult, root); if (!ret) { _log.Log(LOG_ERROR, "ICYThermostat: Invalid data received, or invalid username/password!"); return false; } if (root["serialthermostat1"].empty() == true) { _log.Log(LOG_ERROR, "ICYThermostat: Invalid data received, or invalid username/password!"); return false; } m_SerialNumber = root["serialthermostat1"].asString(); if (root["token"].empty() == true) { _log.Log(LOG_ERROR, "ICYThermostat: Invalid data received, or invalid username/password!"); return false; } m_Token = root["token"].asString(); if (m_companymode == CMODE_UNKNOWN) { if (sURL == ICY_LOGIN_URL) m_companymode = CMODE_PORTAL; else if (sURL == ENI_LOGIN_URL) m_companymode = CMODE_ENI; else m_companymode = CMODE_SEC; } return true; }
int main () { int connectionFd, rc, index = 0, limit = MAX_BUFFER; struct sockaddr_in servAddr, localAddr; char buffer[MAX_BUFFER+1]; #ifdef WIN32 // Start up WinSock2 WSADATA wsaData; if( WSAStartup( WINSOCKVERSION, &wsaData) != 0 ) return ERROR; #endif memset(&servAddr, 0, sizeof(servAddr)); servAddr.sin_family = AF_INET; servAddr.sin_port = htons(PORT); servAddr.sin_addr.s_addr = inet_addr(HOST); // Create socket connectionFd = socket(AF_INET, SOCK_STREAM, 0); /* bind any port number */ localAddr.sin_family = AF_INET; localAddr.sin_addr.s_addr = htonl(INADDR_ANY); localAddr.sin_port = htons(0); rc = bind(connectionFd, (struct sockaddr *) &localAddr, sizeof(localAddr)); // Connect to Server connect(connectionFd, (struct sockaddr *)&servAddr, sizeof(servAddr)); // Send request to Server sprintf( buffer, "%s", "{\"robo1\":{\"x\":1,\"y\":2}, \"robo2\":{\"x\":3,\"y\":4}}" ); send( connectionFd, buffer, strlen(buffer), 0 ); printf("Client sent to sever %s\n", buffer); // Receive data from Server sprintf( buffer, "%s", "" ); recv(connectionFd, buffer, MAX_BUFFER, 0); std::string strJson = buffer; Json::Value root; Json::Reader reader; bool parsingSuccessful = reader.parse(strJson.c_str(), root); if(!parsingSuccessful){ std::cout<<"Failed to parse"<<std::endl; } std::cout<<"Object json - "<<root.get("robo1","A Default Value if not exists")<<std::endl; printf("Client read from Server %s\n", buffer); #ifdef WIN32 closesocket(connectionFd); #else close(connectionFd); #endif printf("Client closed.\n"); return(0); }
CScalePredictor::CScalePredictor(string filename) { if (filename.compare("none") ==0) { return; } string contents = get_file_contents(filename); Json::Value root; Json::Reader reader; bool parsingSuccessful = reader.parse(contents, root); if (!parsingSuccessful) { std::cout << "Failed to parse \n" << reader.getFormatedErrorMessages()<< endl; } // Get the input scaler this->InputScaler = parse_cscaler(root["InputScaler"]); this->OutputScaler = parse_cscaler(root["OutputScaler"]); this->Pred = parse_predictor(root["Predictor"]); // Check the predictions int nTestInputs = root["TestInputs"].size(); int nTestOutputs = root["TestOutputs"].size(); if (nTestInputs != nTestOutputs) { cout << "Number of test inputs and number of test outputs doesn't match" << endl; } Json::Value testInputs = root["TestInputs"]; Json::Value testOutputs = root["TestOutputs"]; for (int i = 0; i < nTestInputs; i++) { int nInputs = testInputs[i].size(); int nOutputs = testOutputs[i].size(); double *input = new double[nInputs]; double *output = new double[nOutputs]; for (int j = 0; j < nInputs; j++) { input[j] = testInputs[i][j].asDouble(); } for (int j=0; j < nOutputs; j++) { output[j] = testOutputs[i][j].asDouble(); } double *predOutput = new double[nOutputs]; this->Predict(input, predOutput); bool mismatch = 0; for (int j = 0; j < nOutputs; j++) { double max = abs(output[j]); if (predOutput[j] > max) { max = abs(predOutput[j]); } if (max < 1.0) { max = 1.0; } if (abs(output[j] - predOutput[j])/(max) > 1e-12) { mismatch = 1; } cout.precision(16); if (mismatch) { cout << "Prediction mismatch" << endl; for (int j = 0; j < nOutputs; j++) { cout << "j = " << " true: " << output[j] << " pred: " << predOutput[j] << " rel error: " << abs(output[j] - predOutput[j])/(max) << endl; } throw string("mismatch"); } } // if (mismatch) { // throw(-1); // } delete [] predOutput; delete [] input; delete [] output; } return; }
bool sinsp_container_manager::parse_docker(sinsp_container_info* container) { string file = string(scap_get_host_root()) + "/var/run/docker.sock"; int sock = socket(PF_UNIX, SOCK_STREAM, 0); if(sock < 0) { ASSERT(false); return false; } struct sockaddr_un address; memset(&address, 0, sizeof(struct sockaddr_un)); address.sun_family = AF_UNIX; strncpy(address.sun_path, file.c_str(), sizeof(address.sun_path) - 1); address.sun_path[sizeof(address.sun_path) - 1]= '\0'; if(connect(sock, (struct sockaddr *) &address, sizeof(struct sockaddr_un)) != 0) { return false; } string message = "GET /containers/" + container->m_id + "/json HTTP/1.0\r\n\n"; if(write(sock, message.c_str(), message.length()) != (ssize_t) message.length()) { ASSERT(false); close(sock); return false; } char buf[256]; string json; ssize_t res; while((res = read(sock, buf, sizeof(buf))) != 0) { if(res == -1) { ASSERT(false); close(sock); return false; } buf[res] = 0; json += buf; } close(sock); size_t pos = json.find("{"); if(pos == string::npos) { ASSERT(false); return false; } Json::Value root; Json::Reader reader; bool parsingSuccessful = reader.parse(json.substr(pos), root); if(!parsingSuccessful) { ASSERT(false); return false; } container->m_image = root["Config"]["Image"].asString(); container->m_name = root["Name"].asString(); if(!container->m_name.empty()) { container->m_name = container->m_name.substr(1); } string ip = root["NetworkSettings"]["IPAddress"].asString(); if(inet_pton(AF_INET, ip.c_str(), &container->m_container_ip) == -1) { ASSERT(false); } container->m_container_ip = ntohl(container->m_container_ip); vector<string> ports = root["NetworkSettings"]["Ports"].getMemberNames(); for(vector<string>::const_iterator it = ports.begin(); it != ports.end(); ++it) { size_t tcp_pos = it->find("/tcp"); if(tcp_pos == string::npos) { continue; } uint16_t container_port = atoi(it->c_str()); Json::Value& v = root["NetworkSettings"]["Ports"][*it]; if(v.isArray()) { for(uint32_t j = 0; j < v.size(); ++j) { sinsp_container_info::container_port_mapping port_mapping; ip = v[j]["HostIp"].asString(); string port = v[j]["HostPort"].asString(); if(inet_pton(AF_INET, ip.c_str(), &port_mapping.m_host_ip) == -1) { ASSERT(false); continue; } port_mapping.m_host_ip = ntohl(port_mapping.m_host_ip); port_mapping.m_container_port = container_port; port_mapping.m_host_port = atoi(port.c_str()); container->m_port_mappings.push_back(port_mapping); } } } return true; }
bool CPhilipsHue::SwitchLight(const int nodeID, const std::string &LCmd, const int svalue) { std::vector<std::string> ExtraHeaders; std::string sResult; std::stringstream sPostData; if (LCmd=="On") { sPostData << "{\"on\": true }"; } else if (LCmd == "Off") { sPostData << "{\"on\": false }"; } else if (LCmd == "Set Level") { sPostData << "{\"on\": true, \"bri\": " << svalue << " }"; } else if (LCmd == "Set White") { sPostData << "{\"on\": true, \"sat\": 0 , \"bri\": 255, \"hue\": 0 }"; } else if (LCmd == "Set Hue") { sPostData << "{\"on\": true, \"sat\": 255 , \"hue\": " << svalue << " }"; } else { _log.Log(LOG_ERROR, "Philips Hue: Invalid light command received!"); return false; } std::stringstream sstr2; sstr2 << "http://" << m_IPAddress << ":" << m_Port << "/api/" << m_UserName << "/lights/" << nodeID << "/state"; std::string sURL = sstr2.str(); if (!HTTPClient::PUT(sURL, sPostData.str(), ExtraHeaders, sResult)) { _log.Log(LOG_ERROR, "Philips Hue: Error connecting to Hue bridge, (Check IPAddress/Username)"); return false; } Json::Value root; Json::Reader jReader; bool ret = jReader.parse(sResult, root); if (!ret) { _log.Log(LOG_ERROR, "Philips Hue: Invalid data received, or invalid IPAddress/Username!"); return false; } if (sResult.find("error") != std::string::npos) { //We had an error _log.Log(LOG_ERROR, "Philips Hue: Error received: %s", root[0]["error"]["description"].asString().c_str()); return false; } return true; }
void cMojangAPI::CacheNamesToUUIDs(const AStringVector & a_PlayerNames) { // Create a list of names to query, by removing those that are already cached: AStringVector NamesToQuery; NamesToQuery.reserve(a_PlayerNames.size()); { cCSLock Lock(m_CSNameToUUID); for (AStringVector::const_iterator itr = a_PlayerNames.begin(), end = a_PlayerNames.end(); itr != end; ++itr) { if (m_NameToUUID.find(*itr) == m_NameToUUID.end()) { NamesToQuery.push_back(*itr); } } // for itr - a_PlayerNames[] } // Lock(m_CSNameToUUID) while (!NamesToQuery.empty()) { // Create the request body - a JSON containing up to MAX_PER_QUERY playernames: Json::Value root; int Count = 0; AStringVector::iterator itr = NamesToQuery.begin(), end = NamesToQuery.end(); for (; (itr != end) && (Count < MAX_PER_QUERY); ++itr, ++Count) { Json::Value req(*itr); root.append(req); } // for itr - a_PlayerNames[] NamesToQuery.erase(NamesToQuery.begin(), itr); Json::FastWriter Writer; AString RequestBody = Writer.write(root); // Create the HTTP request: AString Request; Request += "POST " + m_NameToUUIDAddress + " HTTP/1.0\r\n"; // We need to use HTTP 1.0 because we don't handle Chunked transfer encoding Request += "Host: " + m_NameToUUIDServer + "\r\n"; Request += "User-Agent: MCServer\r\n"; Request += "Connection: close\r\n"; Request += "Content-Type: application/json\r\n"; Request += Printf("Content-Length: %u\r\n", (unsigned)RequestBody.length()); Request += "\r\n"; Request += RequestBody; // Get the response from the server: AString Response; if (!SecureRequest(m_NameToUUIDServer, Request, Response)) { continue; } // Check the HTTP status line: const AString Prefix("HTTP/1.1 200 OK"); AString HexDump; if (Response.compare(0, Prefix.size(), Prefix)) { LOGINFO("%s failed: bad HTTP status line received", __FUNCTION__); LOGD("Response: \n%s", CreateHexDump(HexDump, Response.data(), Response.size(), 16).c_str()); continue; } // Erase the HTTP headers from the response: size_t idxHeadersEnd = Response.find("\r\n\r\n"); if (idxHeadersEnd == AString::npos) { LOGINFO("%s failed: bad HTTP response header received", __FUNCTION__); LOGD("Response: \n%s", CreateHexDump(HexDump, Response.data(), Response.size(), 16).c_str()); continue; } Response.erase(0, idxHeadersEnd + 4); // Parse the returned string into Json: Json::Reader reader; if (!reader.parse(Response, root, false) || !root.isArray()) { LOGWARNING("%s failed: Cannot parse received data (NameToUUID) to JSON!", __FUNCTION__); LOGD("Response body:\n%s", CreateHexDump(HexDump, Response.data(), Response.size(), 16).c_str()); continue; } // Store the returned results into cache: Json::Value::UInt JsonCount = root.size(); Int64 Now = time(NULL); { cCSLock Lock(m_CSNameToUUID); for (Json::Value::UInt idx = 0; idx < JsonCount; ++idx) { Json::Value & Val = root[idx]; AString JsonName = Val.get("name", "").asString(); AString JsonUUID = MakeUUIDShort(Val.get("id", "").asString()); if (JsonUUID.empty()) { continue; } m_NameToUUID[StrToLower(JsonName)] = sProfile(JsonName, JsonUUID, "", "", Now); NotifyNameUUID(JsonName, JsonUUID); } // for idx - root[] } // cCSLock (m_CSNameToUUID) // Also cache the UUIDToName: { cCSLock Lock(m_CSUUIDToName); for (Json::Value::UInt idx = 0; idx < JsonCount; ++idx) { Json::Value & Val = root[idx]; AString JsonName = Val.get("name", "").asString(); AString JsonUUID = MakeUUIDShort(Val.get("id", "").asString()); if (JsonUUID.empty()) { continue; } m_UUIDToName[JsonUUID] = sProfile(JsonName, JsonUUID, "", "", Now); } // for idx - root[] } } // while (!NamesToQuery.empty()) }
bool CPhilipsHue::GetLightStates() { std::vector<std::string> ExtraHeaders; std::string sResult; #ifdef DEBUG_PhilipsHue sResult= ReadFile("E:\\philipshue.jon"); #else std::stringstream sstr2; sstr2 << "http://" << m_IPAddress << ":" << m_Port << "/api/" << m_UserName; //Get Data std::string sURL = sstr2.str(); if (!HTTPClient::GET(sURL, ExtraHeaders, sResult)) { _log.Log(LOG_ERROR, "Philips Hue: Error getting Light States, (Check IPAddress/Username)"); return false; } #endif #ifdef DEBUG_PhilipsHue2 SaveString2Disk(sResult, "E:\\philipshue.jon"); #endif Json::Value root; Json::Reader jReader; bool ret = jReader.parse(sResult, root); if (!ret) { _log.Log(LOG_ERROR, "Philips Hue: Invalid data received, or invalid IPAddress/Username!"); return false; } if (sResult.find("error") != std::string::npos) { //We had an error _log.Log(LOG_ERROR, "Philips Hue: Error received: %s", root[0]["error"]["description"].asString().c_str()); return false; } if (sResult.find("lights") == std::string::npos) { return false; } int totLights = root["lights"].size(); char szNode[10]; for (int ii = 0; ii < 255; ii++) { sprintf(szNode, "%d", ii + 1); if (root["lights"][szNode].empty()) continue; std::string ltype = root["lights"][szNode]["type"].asString(); if ( (ltype == "Dimmable plug-in unit") || (ltype == "Dimmable light") ) { //Normal light (with dim option) bool bIsOn = root["lights"][szNode]["state"]["on"].asBool(); int tbri = root["lights"][szNode]["state"]["bri"].asInt(); int BrightnessLevel = int((100.0f / 255.0f)*float(tbri)); _tHueLight tlight; if (bIsOn) { tlight.cmd = (BrightnessLevel != 0) ? light2_sSetLevel: light2_sOn; } else tlight.cmd = light2_sOff; tlight.level = BrightnessLevel; tlight.sat = 0; tlight.hue = 0; bool bDoSend = true; if (m_lights.find(ii + 1) != m_lights.end()) { _tHueLight alight = m_lights[ii + 1]; if ( (alight.cmd == tlight.cmd) && (alight.level == tlight.level) ) { bDoSend = false; } } m_lights[ii + 1] = tlight; if (bDoSend) InsertUpdateSwitch(ii + 1, HLTYPE_DIM, bIsOn, BrightnessLevel, 0, 0, root["lights"][szNode]["name"].asString()); } else if ( (ltype == "Extended color light") || (ltype == "Color light") ) { //RGBW type bool bIsOn = root["lights"][szNode]["state"]["on"].asBool(); int tbri = root["lights"][szNode]["state"]["bri"].asInt(); int tsat = root["lights"][szNode]["state"]["sat"].asInt(); int thue = root["lights"][szNode]["state"]["hue"].asInt(); int BrightnessLevel = int((100.0f / 255.0f)*float(tbri)); _tHueLight tlight; if (bIsOn) { tlight.cmd = (BrightnessLevel != 0) ? Limitless_SetBrightnessLevel : Limitless_LedOn; } else tlight.cmd = Limitless_LedOff; tlight.level = BrightnessLevel; tlight.sat = tsat; tlight.hue = thue; bool bDoSend = true; if (m_lights.find(ii + 1) != m_lights.end()) { _tHueLight alight = m_lights[ii + 1]; if ( (alight.cmd == tlight.cmd) && (alight.level == tlight.level)&& (alight.sat == tlight.sat)&& (alight.hue == tlight.hue) ) { bDoSend = false; } } m_lights[ii + 1] = tlight; if (bDoSend) InsertUpdateSwitch(ii + 1, HLTYPE_RGBW, bIsOn, BrightnessLevel, tsat, thue, root["lights"][szNode]["name"].asString()); } } return true; }
void cMojangAPI::CacheUUIDToProfile(const AString & a_UUID) { ASSERT(a_UUID.size() == 32); // Check if already present: { if (m_UUIDToProfile.find(a_UUID) != m_UUIDToProfile.end()) { return; } } // Create the request address: AString Address = m_UUIDToProfileAddress; ReplaceString(Address, "%UUID%", a_UUID); // Create the HTTP request: AString Request; Request += "GET " + Address + " HTTP/1.0\r\n"; // We need to use HTTP 1.0 because we don't handle Chunked transfer encoding Request += "Host: " + m_UUIDToProfileServer + "\r\n"; Request += "User-Agent: MCServer\r\n"; Request += "Connection: close\r\n"; Request += "Content-Length: 0\r\n"; Request += "\r\n"; // Get the response from the server: AString Response; if (!SecureRequest(m_UUIDToProfileServer, Request, Response)) { return; } // Check the HTTP status line: const AString Prefix("HTTP/1.1 200 OK"); AString HexDump; if (Response.compare(0, Prefix.size(), Prefix)) { LOGINFO("%s failed: bad HTTP status line received", __FUNCTION__); LOGD("Response: \n%s", CreateHexDump(HexDump, Response.data(), Response.size(), 16).c_str()); return; } // Erase the HTTP headers from the response: size_t idxHeadersEnd = Response.find("\r\n\r\n"); if (idxHeadersEnd == AString::npos) { LOGINFO("%s failed: bad HTTP response header received", __FUNCTION__); LOGD("Response: \n%s", CreateHexDump(HexDump, Response.data(), Response.size(), 16).c_str()); return; } Response.erase(0, idxHeadersEnd + 4); // Parse the returned string into Json: Json::Reader reader; Json::Value root; if (!reader.parse(Response, root, false) || !root.isObject()) { LOGWARNING("%s failed: Cannot parse received data (NameToUUID) to JSON!", __FUNCTION__); LOGD("Response body:\n%s", CreateHexDump(HexDump, Response.data(), Response.size(), 16).c_str()); return; } /* Example response: { "id": "b1caf24202a841a78055a079c460eee7", "name": "xoft", "properties": [ { "name": "textures", "value": "eyJ0aW1lc3RhbXAiOjE0MDcwNzAzMjEyNzEsInByb2ZpbGVJZCI6ImIxY2FmMjQyMDJhODQxYTc4MDU1YTA3OWM0NjBlZWU3IiwicHJvZmlsZU5hbWUiOiJ4b2Z0IiwiaXNQdWJsaWMiOnRydWUsInRleHR1cmVzIjp7IlNLSU4iOnsidXJsIjoiaHR0cDovL3RleHR1cmVzLm1pbmVjcmFmdC5uZXQvdGV4dHVyZS9iNzc5YmFiZjVhNTg3Zjk0OGFkNjc0N2VhOTEyNzU0MjliNjg4Mjk1YWUzYzA3YmQwZTJmNWJmNGQwNTIifX19", "signature": "XCty+jGEF39hEPrPhYNnCX087kPaoCjYruzYI/DS4nkL5hbjnkSM5Rh15hnUyv/FHhC8OF5rif3D1tQjtMI19KSVaXoUFXpbJM8/+PB8GDgEbX8Fc3u9nYkzOcM/xfxdYsFAdFhLQMkvase/BZLSuPhdy9DdI+TCrO7xuSTZfYmmwVuWo3w5gCY+mSIAnqltnOzaOOTcly75xvO0WYpVk7nJdnR2tvSi0wfrQPDrIg/uzhX7p0SnDqijmBU4QaNez/TNKiFxy69dAzt0RSotlQzqkDbyVKhhv9a4eY8h3pXi4UMftKEj4FAKczxLImkukJXuOn5NN15/Q+le0rJVBC60/xjKIVzltEsMN6qjWD0lQjey7WEL+4pGhCVuWY5KzuZjFvgqszuJTFz7lo+bcHiceldJtea8/fa02eTRObZvdLxbWC9ZfFY0IhpOVKfcLdno/ddDMNMQMi5kMrJ8MZZ/PcW1w5n7MMGWPGCla1kOaC55AL0QYSMGRVEZqgU9wXI5M7sHGZKGM4mWxkbEJYBkpI/p3GyxWgV6v33ZWlsz65TqlNrR1gCLaoFCm7Sif8NqPBZUAONHYon0roXhin/DyEanS93WV6i6FC1Wisscjq2AcvnOlgTo/5nN/1QsMbjNumuMGo37sqjRqlXoPb8zEUbAhhztYuJjEfQ2Rd8=" } ] } */ // Store the returned result into caches: AString PlayerName = root.get("name", "").asString(); if (PlayerName.empty()) { // No valid playername, bail out return; } Json::Value Properties = root.get("properties", ""); Int64 Now = time(NULL); { cCSLock Lock(m_CSUUIDToProfile); m_UUIDToProfile[a_UUID] = sProfile(PlayerName, a_UUID, Properties, Now); } { cCSLock Lock(m_CSUUIDToName); m_UUIDToName[a_UUID] = sProfile(PlayerName, a_UUID, Properties, Now); } { cCSLock Lock(m_CSNameToUUID); m_NameToUUID[StrToLower(PlayerName)] = sProfile(PlayerName, a_UUID, Properties, Now); } NotifyNameUUID(PlayerName, a_UUID); }
void json_api::deserialize(std::string &str,Json::Value &val) { Json::Reader r; r.parse(str,val,false); }
void mtsOptoforce3D::Configure(const std::string &filename) { matrix_a_valid = false; #if CISST_HAS_JSON configured = false; try { std::ifstream jsonStream; Json::Value jsonConfig; Json::Reader jsonReader; jsonStream.open(filename.c_str()); if (!jsonReader.parse(jsonStream, jsonConfig)) { CMN_LOG_CLASS_INIT_ERROR << "Configure: failed to parse configuration" << std::endl << jsonReader.getFormattedErrorMessages(); return; } const Json::Value jsonScale = jsonConfig["scale"]; if (jsonScale.isNull()) { CMN_LOG_CLASS_INIT_ERROR << "Configure: cannot find \"scale\" data in " << filename << std::endl; return; } else { cmnDataJSON<vctDouble3>::DeSerializeText(scale, jsonScale); CMN_LOG_CLASS_INIT_VERBOSE << "Configure: parsed scale = " << scale << std::endl; } const Json::Value jsonSpeed = jsonConfig["speed"]; if (jsonSpeed.isNull()) { CMN_LOG_CLASS_INIT_VERBOSE << "Configure: \"speed\" (update rate from sensor) not specified," << " using default value of " << (unsigned int)sensorSpeed << std::endl; } else { sensorSpeed = static_cast<unsigned char>(jsonSpeed.asUInt()); CMN_LOG_CLASS_INIT_VERBOSE << "Configure: parsed speed (update rate from sensor) = " << (unsigned int)sensorSpeed << std::endl; } const Json::Value jsonFilter = jsonConfig["filter"]; if (jsonFilter.isNull()) { CMN_LOG_CLASS_INIT_VERBOSE << "Configure: \"filter\" (cutoff frequency) not specified," << " using default value of " << (unsigned int)sensorFilter << std::endl; } else { sensorFilter = static_cast<unsigned char>(jsonFilter.asUInt()); CMN_LOG_CLASS_INIT_VERBOSE << "Configure: parsed filter (cutoff frequency) = " << (unsigned int)sensorFilter << std::endl; } const Json::Value jsonCalMatrix = jsonConfig["cal-matrix"]; if (jsonCalMatrix.isNull()) { CMN_LOG_CLASS_INIT_VERBOSE << "Configure: \"cal-matrix\" not specified" << std::endl; } else { cmnDataJSON<vctDouble3x6>::DeSerializeText(matrix_a, jsonCalMatrix); matrix_a_valid = true; CMN_LOG_CLASS_INIT_VERBOSE << "Configure: parsed cal-matrix (A) = " << std::endl << matrix_a << std::endl; } configured = true; } catch (const std::runtime_error &e) { CMN_LOG_CLASS_INIT_ERROR << "Configure: runtime_error parsing JSON file: " << e.what() << std::endl; } catch (...) { CMN_LOG_CLASS_INIT_ERROR << "Configure: make sure file \"" << filename << "\" is in JSON format" << std::endl; } #else // If cisst is not compiled with JSON support, the software returns the raw force values by default. CMN_LOG_CLASS_INIT_WARNING << "Configure: JSON support not enabled in cisst, setting scale to 1" << std::endl; scale.SetAll(1.0); configured = true; #endif }
BOOL CCxStructTreeUpdateParamsData::Parse( LPCTSTR lpszData, CCxStructTree * pTree ) { Clear(); CString strSrc = lpszData == NULL ? "" : lpszData; if (strSrc.IsEmpty()) return FALSE; CString str; Json::Reader reader; Json::Value obj( Json::objectValue ), arrValue( Json::arrayValue ); //CCxStructTreeRunResultParam * pValue = NULL; CCxStructTreeNode * pNode = NULL; CCxStructTreeNodeGroup * pGroupNode = NULL; CCxStructTreeNodeParam * pParamNode = NULL; CCxStructTreeUpdateParamsOperatorData * pOperatorData = NULL; try { if (!reader.parse((char*)(LPCTSTR)strSrc, obj, false)) return FALSE; if (!obj.isObject()) return FALSE; //m_strFlowNodeId = ( obj["flowId"].isString()) ? obj["flowId"].asCString() : _T(""); //str = ( obj["startIndex"].isString()) ? obj["startIndex"].asCString() : _T(""); //if ( !str.IsEmpty() ) //{ // m_nStartIndex = strtol( (char*)(LPCTSTR)str, NULL, 10 ); //} if ( !obj["groupList"].isNull() && obj["groupList"].isArray() ) { arrValue = obj["groupList"]; if ( pTree != NULL ) { pTree->m_bNodeParseing = TRUE; pTree->m_mapParseNodeCache.clear(); } for ( Json::Value::iterator itr = arrValue.begin(); itr != arrValue.end(); ++itr) { str = ( (*itr)["nodeType"].isString() ) ? (*itr)["nodeType"].asCString() : _T(""); int nNodeType = CCxStructTreeNode::ConvertNodeType( (LPCTSTR)str ); pNode = CCxStructTreeNode::GetNewNodeByType( nNodeType, pTree ); if ( pNode == NULL ) { Clear(); if ( pTree != NULL ) { pTree->m_bNodeParseing = FALSE; pTree->m_mapParseNodeCache.clear(); } return FALSE; } if ( !pNode->Parse( *itr/*reinterpret_cast< LPVOID > ( (Json::Value *)& (*itr) )*/ , pNode, nNodeType, NULL ) ) { delete pNode; pNode = NULL; Clear(); if ( pTree != NULL ) { pTree->m_bNodeParseing = FALSE; pTree->m_mapParseNodeCache.clear(); } return FALSE; } if ( !pNode->IsGroupNode() ) { delete pNode; pNode = NULL; Clear(); if ( pTree != NULL ) { pTree->m_bNodeParseing = FALSE; pTree->m_mapParseNodeCache.clear(); } return FALSE; } pGroupNode = (CCxStructTreeNodeGroup *)pNode; m_vGroups.push_back( pGroupNode ); } } for ( int i=0; i<(int)m_vGroups.size(); i++ ) { m_mapGroupNode.insert( make_pair( m_vGroups[i]->m_strID, m_vGroups[i] ) ); } if ( !obj["paramList"].isNull() && obj["paramList"].isArray() ) { arrValue = obj["paramList"]; if ( pTree != NULL ) { pTree->m_bNodeParseing = TRUE; pTree->m_mapParseNodeCache.clear(); } for ( Json::Value::iterator itr = arrValue.begin(); itr != arrValue.end(); ++itr) { str = ( (*itr)["nodeType"].isString() ) ? (*itr)["nodeType"].asCString() : _T(""); int nNodeType = CCxStructTreeNode::ConvertNodeType( (LPCTSTR)str ); pNode = CCxStructTreeNode::GetNewNodeByType( nNodeType, pTree ); if ( pNode == NULL ) { Clear(); if ( pTree != NULL ) { pTree->m_bNodeParseing = FALSE; pTree->m_mapParseNodeCache.clear(); } return FALSE; } if ( !pNode->Parse( *itr/*reinterpret_cast< LPVOID > ( (Json::Value *)& (*itr) )*/ , pNode, nNodeType, NULL ) ) { delete pNode; pNode = NULL; Clear(); if ( pTree != NULL ) { pTree->m_bNodeParseing = FALSE; pTree->m_mapParseNodeCache.clear(); } return FALSE; } if ( !pNode->IsParamNode() ) { delete pNode; pNode = NULL; Clear(); if ( pTree != NULL ) { pTree->m_bNodeParseing = FALSE; pTree->m_mapParseNodeCache.clear(); } return FALSE; } pParamNode = (CCxStructTreeNodeParam *)pNode; m_vParams.push_back( pParamNode ); } } for ( int i=0; i<(int)m_vParams.size(); i++ ) { m_mapParamNode.insert( make_pair( m_vParams[i]->m_strID, m_vParams[i] ) ); } if ( !obj["operateList"].isNull() && obj["operateList"].isArray() ) { arrValue = obj["operateList"]; for ( Json::Value::iterator itr = arrValue.begin(); itr != arrValue.end(); ++itr) { pOperatorData = new CCxStructTreeUpdateParamsOperatorData(); pOperatorData->m_strId = ( (*itr)["id"].isString() ) ? (*itr)["id"].asCString() : _T(""); pOperatorData->m_strFlag = ( (*itr)["flag"].isString() ) ? (*itr)["flag"].asCString() : _T(""); m_vOperators.push_back( pOperatorData ); } } if ( pTree != NULL ) { pTree->m_bNodeParseing = FALSE; pTree->m_mapParseNodeCache.clear(); } } catch (...) { Clear(); if ( pTree != NULL ) { pTree->m_bNodeParseing = FALSE; pTree->m_mapParseNodeCache.clear(); } return FALSE; } return TRUE; }
bool cPlayer::LoadFromDisk() { LoadPermissionsFromDisk(); // Log player permissions, cause it's what the cool kids do LOGINFO("Player %s has permissions:", m_PlayerName.c_str() ); for( PermissionMap::iterator itr = m_ResolvedPermissions.begin(); itr != m_ResolvedPermissions.end(); ++itr ) { if( itr->second ) LOGINFO("%s", itr->first.c_str() ); } AString SourceFile; Printf(SourceFile, "players/%s.json", m_PlayerName.c_str() ); cFile f; if (!f.Open(SourceFile, cFile::fmRead)) { // This is a new player whom we haven't seen yet, bail out, let them have the defaults return false; } AString buffer; if (f.ReadRestOfFile(buffer) != f.GetSize()) { LOGWARNING("Cannot read player data from file \"%s\"", SourceFile.c_str()); return false; } f.Close(); Json::Value root; Json::Reader reader; if (!reader.parse(buffer, root, false)) { LOGWARNING("Cannot parse player data in file \"%s\", player will be reset", SourceFile.c_str()); } Json::Value & JSON_PlayerPosition = root["position"]; if (JSON_PlayerPosition.size() == 3) { SetPosX(JSON_PlayerPosition[(unsigned int)0].asDouble()); SetPosY(JSON_PlayerPosition[(unsigned int)1].asDouble()); SetPosZ(JSON_PlayerPosition[(unsigned int)2].asDouble()); m_LastPosX = GetPosX(); m_LastPosY = GetPosY(); m_LastPosZ = GetPosZ(); m_LastFoodPos = GetPosition(); } Json::Value & JSON_PlayerRotation = root["rotation"]; if (JSON_PlayerRotation.size() == 3) { SetRotation ((float)JSON_PlayerRotation[(unsigned int)0].asDouble()); SetPitch ((float)JSON_PlayerRotation[(unsigned int)1].asDouble()); SetRoll ((float)JSON_PlayerRotation[(unsigned int)2].asDouble()); } m_Health = root.get("health", 0).asInt(); m_AirLevel = root.get("air", MAX_AIR_LEVEL).asInt(); m_FoodLevel = root.get("food", MAX_FOOD_LEVEL).asInt(); m_FoodSaturationLevel = root.get("foodSaturation", MAX_FOOD_LEVEL).asDouble(); m_FoodTickTimer = root.get("foodTickTimer", 0).asInt(); m_FoodExhaustionLevel = root.get("foodExhaustion", 0).asDouble(); m_GameMode = (eGameMode) root.get("gamemode", eGameMode_NotSet).asInt(); m_Inventory.LoadFromJson(root["inventory"]); m_LoadedWorldName = root.get("world", "world").asString(); LOGD("Player \"%s\" was read from file, spawning at {%.2f, %.2f, %.2f} in world \"%s\"", m_PlayerName.c_str(), GetPosX(), GetPosY(), GetPosZ(), m_LoadedWorldName.c_str() ); return true; }
detect::detect(std::string url, std::string cfgfile) { try { std::map<std::string, std::string> options = get_options(cfgfile); std::string json = http_get(options["SERVER"] + options["VERSION"] + std::string("/detection/detect?url=") + url + "&api_secret=" + options["API_SECRET"] + "&api_key=" + options["API_KEY"]); Json::Reader reader; Json::Value root; Json::Value faces; unsigned int i; reader.parse(json, root, false); faces = root["face"]; for (i = 0; i < faces.size(); i++) { age_t age; age.range = faces[i]["attribute"]["age"]["range"].asUInt(); age.value = faces[i]["attribute"]["age"]["value"].asUInt(); gender_t gender; gender.confidence = faces[i]["attribute"]["gender"]["confidence"].asFloat(); gender.value = faces[i]["attribute"]["gender"]["value"].asString(); race_t race; race.confidence = faces[i]["attribute"]["race"]["confidence"].asFloat(); race.value = faces[i]["attribute"]["race"]["value"].asString(); attribute_t attribute; attribute.age = age; attribute.gender = gender; attribute.race = race; attribute.smiling = faces[i]["attribute"]["smiling"]["value"].asFloat(); face_t face; face.attribute = attribute; face.face_id = faces[i]["face_id"].asString(); position_t position; point_t center; center.x = faces[i]["position"]["center"]["x"].asFloat(); center.y = faces[i]["position"]["center"]["y"].asFloat(); position.center = center; point_t eye_left; eye_left.x = faces[i]["position"]["eye_left"]["x"].asFloat(); eye_left.y = faces[i]["position"]["eye_left"]["y"].asFloat(); position.eye_left = eye_left; point_t eye_right; eye_right.x = faces[i]["position"]["eye_right"]["x"].asFloat(); eye_right.y = faces[i]["position"]["eye_right"]["y"].asFloat(); position.eye_right = eye_right; position.height = faces[i]["position"]["height"].asFloat(); point_t mouth_left; mouth_left.x = faces[i]["position"]["mouth_left"]["x"].asFloat(); mouth_left.y = faces[i]["position"]["mouth_left"]["y"].asFloat(); position.mouth_left = mouth_left; point_t mouth_right; mouth_right.x = faces[i]["position"]["mouth_right"]["x"].asFloat(); mouth_right.y = faces[i]["position"]["mouth_right"]["y"].asFloat(); position.mouth_right = mouth_right; point_t nose; nose.x = faces[i]["position"]["nose"]["x"].asFloat(); nose.y = faces[i]["position"]["nose"]["y"].asFloat(); position.nose = nose; position.width = faces[i]["position"]["width"].asFloat(); face.position = position; m_faces.push_back(face); } } catch (std::string ex) { std::cout << ex << std::endl; } }
/* create_poll: create a strawpoll, return id */ static int create_poll(char *out, char *pollbuf, struct command *c) { /* json values to hold created poll, poll options and http response */ Json::Value poll, options(Json::arrayValue), response; Json::FastWriter fw; Json::Reader reader; cpr::Response resp; char buf[MAX_MSG]; char *quest, *s, *t; argvcat(buf, c->argc, c->argv, l_optind, 1); quest = buf; if (!(s = strchr(quest, '|'))) { if (!binary) { snprintf(out, MAX_MSG, "%s: poll must have a question " "and at least two answers", c->argv[0]); return EXIT_FAILURE; } } else { *s = '\0'; if (binary) { snprintf(out, MAX_MSG, "%s: cannot provide answers " "for binary poll", c->argv[0]); return EXIT_FAILURE; } } if (binary) { options.append("yes"); options.append("no"); } else { for (++s; *s && (t = strchr(s, '|')); s = t + 1) { *t = '\0'; options.append(s); } if (*s) options.append(s); } if (options.size() < 2) { snprintf(out, MAX_MSG, "%s: poll must have a question " "and at least two answers", c->argv[0]); return EXIT_FAILURE; } /* populate the poll json */ poll["title"] = quest; poll["options"] = options; poll["captcha"] = captcha; poll["multi"] = multi; /* format and post the poll */ snprintf(buf, MAX_MSG, "%s%s", STRAWPOLL_HOST, STRAWPOLL_API); resp = cpr::Post(cpr::Url(buf), cpr::Body(fw.write(poll)), cpr::Header{ { "Connection", "close" }, { "Content-Type", "application/json" } }); /* read id from response */ if (reader.parse(resp.text, response)) { if (!response.isMember("id")) { snprintf(out, MAX_MSG, "%s: poll could not be created", c->argv[0]); return EXIT_FAILURE; } snprintf(pollbuf, MAX_LEN, "%d", response["id"].asInt()); snprintf(out, MAX_MSG, "[STRAWPOLL] %s/%s", STRAWPOLL_HOST, pollbuf); return EXIT_SUCCESS; } snprintf(out, MAX_MSG, "%s: could not parse response", c->argv[0]); return EXIT_FAILURE; }
int main(int argc,char** argv){ int daemonize=0; int version=0; const char* group="www-data"; try { openlog("ftd",LOG_PERROR,LOG_DAEMON); // Set logmask, default is LOG_NOTICE (5) setlogmask(LOG_UPTO( FtdConfig::Instance().GetIntegerOrDefault("general","loglevel",5))); signal(SIGPIPE, SIG_IGN); signal(SIGINT, sighandler); signal(SIGTERM,sighandler); poptContext optCon; struct poptOption opts[]={ {"fg",'f',POPT_ARG_NONE,&daemonize,0,"Run in foreground, dont daemonize",NULL}, {"version",'v',POPT_ARG_NONE,&version,0,"Show version",NULL}, {"group",'g',POPT_ARG_STRING,&group,0,"Group allowed to talk to ftd","group"}, POPT_AUTOHELP { NULL, 0, 0, NULL, 0} }; optCon=poptGetContext(NULL,argc,(const char**)argv,opts,0); int rc = poptGetNextOpt(optCon); if (rc<-1) { fprintf(stderr, "%s: %s\n", poptBadOption(optCon, POPT_BADOPTION_NOALIAS), poptStrerror(rc)); return 1; } poptFreeContext(optCon); if (version) { cerr << "Version: "<< appversion<<endl; cerr << "Built : "<< builddate<<endl; return 0; } if (getuid()!=0) { syslog(LOG_ERR, "Started as non root terminating"); cerr << "You must be root to run application"<<endl; return 1; } syslog(LOG_INFO,"Started"); if (!daemonize) { daemon(1,0); syslog(LOG_INFO,"Daemonizing"); ofstream pidfile("/var/run/ftd.pid"); pidfile<<getpid()<<endl; pidfile.close(); } unlink("/tmp/ftdaemon"); UnixServerSocket sock(SOCK_STREAM,"/tmp/ftdaemon"); chmod("/tmp/ftdaemon",0660); FileUtils::Chown("/tmp/ftdaemon","root",group); FtdApp& fapp=FtdApp::Instance(); // Order is important here both curl and torrent downloader acccept the same scheme fapp.AddFilter(&SocketFdDownloadManager::Instance()); fapp.AddFilter(&CurlDownloadManager::Instance()); fapp.AddFilter(&TorrentDownloadManager::Instance()); Json::Reader reader; do { try{ UnixClientSocket* con=sock.Accept(); if(!con){ continue; } char buf[16384]; ssize_t r=con->Receive(buf, 16384); if(r>0){ buf[r]=0; Json::Value res; bool success=reader.parse(buf,res); if(!success){ syslog(LOG_ERR,"No valid request"); fapp.SendFail(con); delete con; continue; } if(!res.isMember("cmd")){ syslog(LOG_ERR,"Request missing command"); fapp.SendFail(con); delete con; continue; } if(!res["cmd"].isInt()){ syslog(LOG_ERR,"Command illegal format"); fapp.SendFail(con); delete con; continue; } #ifdef DEBUG printValueTree(res); #endif switch(res["cmd"].asInt()){ case ADD_DOWNLOAD: fapp.AddDownload(res,con); break; case CANCEL_DOWNLOAD: fapp.CancelDownload(res); break; case LIST_DOWNLOADS: fapp.ListDownloads(res,con); break; case GET_DOWNLOAD_THROTTLE: fapp.GetDownloadThrottle(res,con); break; case SET_DOWNLOAD_THROTTLE: fapp.SetDownloadThrottle(res,con); break; case GET_UPLOAD_THROTTLE: fapp.GetUploadThrottle(res,con); break; case SET_UPLOAD_THROTTLE: fapp.SetUploadThrottle(res,con); break; case CMD_SHUTDOWN: do_shutdown=true; fapp.SendOk(con); break; default: fapp.SendFail(con); break; } } delete con; }catch(std::runtime_error* err){ syslog(LOG_NOTICE,"Caught exception waiting for message: [%s]",err->what()); } } while ( !do_shutdown); } catch (std::runtime_error* err) { cout << "Caught exception:"<<err->what()<<endl; return 1; } if(do_shutdown){ syslog(LOG_NOTICE,"shutting down"); FtdApp::Instance().ShutDown(); TorrentDownloadManager::Instance().Shutdown(); syslog(LOG_NOTICE,"terminating"); } return 0; }
// General search SearchResponse& sbol::PartShop::search(std::string search_text, rdf_type object_type, int offset, int limit) { string url = parseURLDomain(resource); /* Perform HTTP request */ string response; CURL *curl; CURLcode res; /* In windows, this will init the winsock stuff */ curl_global_init(CURL_GLOBAL_ALL); struct curl_slist *headers = NULL; // headers = curl_slist_append(headers, "Accept: application/json"); headers = curl_slist_append(headers, "Content-Type: application/x-www-form-urlencoded"); // headers = curl_slist_append(headers, "charsets: utf-8"); /* get a curl handle */ curl = curl_easy_init(); if(curl) { /* Specify the GET data */ // Specify the type of SBOL object to search for string parameters = "objectType=" + parseClassName(object_type) + "&"; // Specify partial search text. Specify how many records to retrieve parameters = parameters + search_text; encode_http(search_text); // Specify how many records to retrieve parameters += "/?offset=" + to_string(offset) + "&limit=" + to_string(limit); parameters = url + "/remoteSearch/" + parameters; /* First set the URL that is about to receive our GET. */ //curl_easy_setopt(curl, CURLOPT_URL, Config::getOption("validator_url").c_str()); curl_easy_setopt(curl, CURLOPT_URL, parameters.c_str()); curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); /* Now specify the callback to read the response into string */ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWrite_CallbackFunc_StdString); curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response); /* Perform the request, res will get the return code */ res = curl_easy_perform(curl); /* Check for errors */ if(res != CURLE_OK) throw SBOLError(SBOL_ERROR_BAD_HTTP_REQUEST, "Attempt to validate online failed with " + string(curl_easy_strerror(res))); /* always cleanup */ curl_easy_cleanup(curl); } curl_slist_free_all(headers); curl_global_cleanup(); SearchResponse& search_response = * new SearchResponse(); Json::Value json_response; Json::Reader reader; bool parsed = reader.parse( response, json_response ); //parse process if ( parsed ) { for( Json::ValueIterator i_entry = json_response.begin() ; i_entry != json_response.end(); i_entry++ ) { Json::Value json_entry = *i_entry; Identified* record = new Identified(SBOL_IDENTIFIED, "dummy", "0"); record->identity.set( json_entry.get("uri", response ).asString() ); record->displayId.set( json_entry.get("displayId", response ).asString() ); record->name.set( json_entry.get("name", response ).asString() ); record->description.set( json_entry.get("description", response ).asString() ); record->version.set( json_entry.get("version", response ).asString() ); search_response.records.push_back(record); } } else throw SBOLError(SBOL_ERROR_BAD_HTTP_REQUEST, "Search failed with error message" + response); return search_response; };
//TODO: Abstract create entity methods, take a list of images from a file + default values. // These files will have list of components and their default values. // E.g. [name:Tree],[SpriteComponent:filePath,redraw,isLoaded],etc. JSON would be handy for this. void GameWorld::CreatePlayerEntity() { //TODO: Entity must correspond with components place in component vector. //TODO: Let entitys be a pair, a bool determining existance and its id or index of the array for any component identified by the entity // E.G. SpriteComponents[newEntity] = new Sprite; // Need to work out how to do this. Probably have to revert to arrays and have a fixed pool of entitys. Json::Value root; Json::Value allEntities; Json::Value entity; Json::Value component; Json::Value spriteComponent; Json::Reader reader; Json::Value positionComponent; std::filebuf fb; if (fb.open ("C:/Devroot/Game_Engine/bin/Debug/world_entitys.txt",std::ios::in)) { std::istream is(&fb); bool parsingSuccessful = reader.parse( is, root ); if ( !parsingSuccessful ) { // report to the user the failure and their locations in the document. std::cout << "Failed to parse configuration\n" << std::endl; std::cout << reader.getFormatedErrorMessages() << std::endl; } }; fb.close(); allEntities = root["entities"]; for ( int i = 0; i < allEntities.size(); ++i ) // Iterates over the sequence elements. { int newEntity = m_EnityManager.CreateNewEntity(); entity = allEntities[i]; for(int j = 0; j < entity.size();++j) { component = entity[j]; spriteComponent = component["Sprite"]; positionComponent = component["Position"]; if(spriteComponent != Json::nullValue) { shared_ptr<Sprite> newSprite = shared_ptr<Sprite>(new Sprite); newSprite->entity = newEntity; newSprite->texture = NULL; for(int x=0; x < spriteComponent.size();++x) { Json::Value spriteComponentItr = spriteComponent[x]; Json::Value filePath = spriteComponentItr["FilePath"]; Json::Value reDraw = spriteComponentItr["reDraw"]; Json::Value isLoaded = spriteComponentItr["isLoaded"]; if(filePath != Json::nullValue) { newSprite->filePath = filePath.asString(); } if(reDraw != Json::nullValue) { newSprite->redraw = reDraw.asBool(); } if(isLoaded != Json::nullValue) { newSprite->isLoaded = isLoaded.asBool(); } } m_ComponentStore.AddSpriteComponent(newSprite); } if(positionComponent != Json::nullValue) { shared_ptr<Position> newPosition = shared_ptr<Position>(new Position); newPosition->entity = newEntity; for(int x=0; x < positionComponent.size(); ++x) { Json::Value positionComponentItr = positionComponent[x]; Json::Value xPos = positionComponentItr["x"]; Json::Value yPos = positionComponentItr["y"]; if(xPos != Json::nullValue) { newPosition->x = xPos.asInt(); } if(yPos != Json::nullValue) { newPosition->y = yPos.asInt(); } } m_ComponentStore.AddPositionComponent(newPosition); } } } }
// Advanced search SearchResponse& sbol::PartShop::search(SearchQuery& q) { string url = parseURLDomain(resource); /* Perform HTTP request */ string response; CURL *curl; CURLcode res; /* In windows, this will init the winsock stuff */ curl_global_init(CURL_GLOBAL_ALL); struct curl_slist *headers = NULL; // headers = curl_slist_append(headers, "Accept: application/json"); headers = curl_slist_append(headers, "Content-Type: application/x-www-form-urlencoded"); // headers = curl_slist_append(headers, "charsets: utf-8"); /* get a curl handle */ curl = curl_easy_init(); /* Specify the GET parameters */ if(curl) { string parameters; // Specify the type of SBOL object to search for if (q["objectType"].size() == 1) parameters = "objectType=" + parseClassName(q["objectType"].get()) + "&"; else throw SBOLError(SBOL_ERROR_INVALID_ARGUMENT, "SearchQuery is invalid because it does not have an objectType specified"); // Get the search criteria, while ignoring special search parameters like objectType, offset, and limit vector<string> search_criteria = q.getProperties(); auto i_ignore = std::find(std::begin(search_criteria), std::end(search_criteria), SBOL_IDENTITY); search_criteria.erase(i_ignore); i_ignore = std::find(std::begin(search_criteria), std::end(search_criteria), SBOL_URI "#objectType"); search_criteria.erase(i_ignore); i_ignore = std::find(std::begin(search_criteria), std::end(search_criteria), SBOL_URI "#offset"); search_criteria.erase(i_ignore); i_ignore = std::find(std::begin(search_criteria), std::end(search_criteria), SBOL_URI "#limit"); search_criteria.erase(i_ignore); // Form GET request from the search criteria for (auto & property_uri : search_criteria) for (auto & property_val : q.getPropertyValues(property_uri)) { if (property_val.length() > 0) { parameters += "<" + property_uri + ">="; if (property_val.find("http") == 0) parameters += "<" + property_val + ">&"; // encode property value as a URI else parameters += "'" + property_val + "'&"; // encode property value as a literal } } // Specify index of the first record to retrieve if (q["offset"].size() == 1) parameters += "/?offset=" + q["offset"].get(); else throw SBOLError(SBOL_ERROR_INVALID_ARGUMENT, "Invalid offset parameter specified"); // Specify how many records to retrieve if (q["limit"].size() == 1) parameters += "&limit=" + q["limit"].get(); else throw SBOLError(SBOL_ERROR_INVALID_ARGUMENT, "Invalid limit parameter specified"); encode_http(parameters); parameters = url + "/remoteSearch/" + parameters; /* First set the URL that is about to receive our GET. */ //curl_easy_setopt(curl, CURLOPT_URL, Config::getOption("validator_url").c_str()); curl_easy_setopt(curl, CURLOPT_URL, parameters.c_str()); curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); /* Now specify the callback to read the response into string */ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWrite_CallbackFunc_StdString); curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response); /* Perform the request, res will get the return code */ res = curl_easy_perform(curl); /* Check for errors */ if(res != CURLE_OK) throw SBOLError(SBOL_ERROR_BAD_HTTP_REQUEST, "Attempt to validate online failed with " + string(curl_easy_strerror(res))); /* always cleanup */ curl_easy_cleanup(curl); } curl_slist_free_all(headers); curl_global_cleanup(); SearchResponse& search_response = * new SearchResponse(); Json::Value json_response; Json::Reader reader; bool parsed = reader.parse( response, json_response ); //parse process if ( parsed ) { for( Json::ValueIterator i_entry = json_response.begin() ; i_entry != json_response.end(); i_entry++ ) { Json::Value json_entry = *i_entry; Identified* record = new Identified(SBOL_IDENTIFIED, "dummy", "0"); record->identity.set( json_entry.get("uri", response ).asString() ); record->displayId.set( json_entry.get("displayId", response ).asString() ); record->name.set( json_entry.get("name", response ).asString() ); record->description.set( json_entry.get("description", response ).asString() ); record->version.set( json_entry.get("version", response ).asString() ); search_response.records.push_back(record); } } else throw SBOLError(SBOL_ERROR_BAD_HTTP_REQUEST, "Search failed with error message" + response); return search_response; };
std::string Reader::getFormatedErrorMessages() const { std::string formattedMessage; for ( Errors::const_iterator itError = errors_.begin(); itError != errors_.end(); ++itError ) { const ErrorInfo &error = *itError; formattedMessage += "* " + getLocationLineAndColumn( error.token_.start_ ) + "\n"; formattedMessage += " " + error.message_ + "\n"; if ( error.extra_ ) formattedMessage += "See " + getLocationLineAndColumn( error.extra_ ) + " for detail.\n"; } return formattedMessage; } std::istream& operator>>( std::istream &sin, Value &root ) { Json::Reader reader; bool ok = reader.parse(sin, root, true); //JSON_ASSERT( ok ); if (!ok) throw std::runtime_error(reader.getFormatedErrorMessages()); return sin; } } // namespace Json
void json_writer_t::update(const game_t &game) { auto &packets = root["packets"]; bounding_box_t bounding_box = game.get_arena().bounding_box; // copy boundary values Json::Value coordinate(Json::arrayValue); coordinate.append(std::get<0>(bounding_box.bottom_left)); coordinate.append(std::get<1>(bounding_box.bottom_left)); root["map_boundaries"].append(coordinate); coordinate.clear(); coordinate.append(std::get<0>(bounding_box.upper_right)); coordinate.append(std::get<1>(bounding_box.upper_right)); root["map_boundaries"].append(coordinate); root["recorder_id"] = game.get_recorder_id(); Json::Value summary; Json::Reader reader; const buffer_t &buffer = game.get_game_begin(); std::string summary_str(buffer.begin(), buffer.end()); reader.parse(summary_str, summary); root["summary"] = summary; for (auto &packet : game.get_packets()) { Json::Value value(Json::objectValue); if (packet.has_property(property_t::type)) { value["type"] = packet.type(); } if (packet.has_property(property_t::clock)) { value["clock"] = packet.clock(); } if (packet.has_property(property_t::player_id)) { value["player_id"] = packet.player_id(); int team_id = game.get_team_id(packet.player_id()); if (team_id != -1) { value["team"] = team_id; } } if (packet.has_property(property_t::position)) { Json::Value positionValue(Json::arrayValue); const auto &position = packet.position(); positionValue.append(std::get<0>(position)); positionValue.append(std::get<1>(position)); positionValue.append(std::get<2>(position)); value["position"] = positionValue; } if (packet.has_property(property_t::hull_orientation)) { Json::Value orientationValue(Json::arrayValue); const auto &orientation = packet.hull_orientation(); orientationValue.append(std::get<0>(orientation)); orientationValue.append(std::get<1>(orientation)); orientationValue.append(std::get<2>(orientation)); value["hull_orientation"] = orientationValue; } if (packet.has_property(property_t::tank_destroyed)) { uint32_t target, destroyed_by; std::tie(target, destroyed_by) = packet.tank_destroyed(); value["target"] = target; value["destroyed_by"] = destroyed_by; } if (packet.has_property(property_t::health)) { value["health"] = packet.health(); } if (packet.has_property(property_t::source)) { value["source"] = packet.source(); } if (packet.has_property(property_t::message)) { value["message"] = packet.message(); } if (packet.has_property(property_t::sub_type)) { value["sub_type"] = packet.sub_type(); } if (packet.has_property(property_t::target)) { value["target"] = packet.target(); } if (packet.has_property(property_t::destroyed_track_id)) { value["destroyed_track_id"] = packet.destroyed_track_id(); } if (packet.has_property(property_t::alt_track_state)) { value["alt_track_state"] = packet.alt_track_state(); } packets.append(value); } }