bool CUpdateManager::checkUpdate(JSON::Object::Ptr& param, std::string& detail)
{
	if(!m_update_path.isDirectory())
	{
		warnf("%s, %d: Update manager check update error[update dir not exists], please init first.", __FILE__, __LINE__);
	}
	if(param.isNull() || !param->has(UPDATE_TYPE_STR))
	{
		detail = "450";
		return false;
	}
	std::string devType = param->getValue<std::string>(UPDATE_TYPE_STR);
	Path path(m_update_path);
	path.append(devType);
	path.append(Path::separator());
	if(!path.isDirectory())
	{
		detail = "451";
		return false;
	}
	path.append("Info");
	if(!path.isFile())
	{
		detail = "452";
		warnf("%s, %d: UpdateManager checkUpdate failed, %s update info file not exists.", __FILE__, __LINE__, devType.c_str());
		return false;
	}
	Util::JSONConfiguration updateConf;
	try
	{
		updateConf.load(path.toString());
	}
	catch(Exception& e)
	{
		detail = "453";
		warnf("%s, %d: Load JSON Configuration[%s] file failed.", __FILE__, __LINE__, path.toString().c_str());
		return false;
	}
	std::string version = updateConf.getString(UPDATE_VERSION_STR);
	std::string buildtime = updateConf.getString(UPDATE_BUILDTIME_STR);
	JSON::Object::Ptr pUpdate = new JSON::Object;
	pUpdate->set(UPDATE_VERSION_STR, version);
	pUpdate->set(UPDATE_BUILDTIME_STR, buildtime);
	std::string newfeature = updateConf.getRawString(UPDATE_NEWFEATURE_STR);
	JSON::Parser parser;
	Dynamic::Var var = parser.parse(newfeature);
	JSON::Array::Ptr pNew = var.extract<JSON::Array::Ptr>();
	pUpdate->set(UPDATE_NEWFEATURE_STR, pNew);
	param->set("update", pUpdate);
	return true;
}
Example #2
0
    PlayerSkinColors PlayerSkinColors::load(const std::string &profileRoot, const std::string &file) {
        Json::Parser parser;
        Json::Value root = parser.parse(profileRoot + file);

        PlayerSkinColors colors;
        colors.set(PlayerSkinColors::HairTop, Color::fromString(root.get("hairTop").asString()));
        colors.set(PlayerSkinColors::HairBottom, Color::fromString(root.get("hairBottom").asString()));
        colors.set(PlayerSkinColors::BodyInner, Color::fromString(root.get("bodyInner").asString()));
        colors.set(PlayerSkinColors::BodyOuter, Color::fromString(root.get("bodyOuter").asString()));
        colors.set(PlayerSkinColors::HandInner, Color::fromString(root.get("handInner").asString()));
        colors.set(PlayerSkinColors::HandOuter, Color::fromString(root.get("handOuter").asString()));
        colors.set(PlayerSkinColors::Trousers, Color::fromString(root.get("trousers").asString()));
        colors.set(PlayerSkinColors::Shoes, Color::fromString(root.get("shoes").asString()));
        colors.set(PlayerSkinColors::Face, Color::fromString(root.get("face").asString()));
        return colors;
    }
Example #3
0
	void ElevatorList::load(const std::string& path, bool mirror)
	{
		Json::Parser parser;
		Json::Value root = parser.parse(path);

		Int32 width = root.get("width").asInt();
		Int32 height = root.get("height").asInt();

		Size elevators = root.get("elevators").getLength();
		for (Size i = 0; i < elevators; i++) {
			Elevator elevator;
			Json::Value points = root.get("elevators").get(i).get("controlPoints");
			for (Size j = 0; j < points.getLength(); j++) {
				Int32 x = points.get(j).get("x").asInt();
				Int32 y = points.get(j).get("y").asInt();
				elevator.addControlPoint(Elevator::ControlPoint(mirror ? width - 1 - x : x, height - y));
			}
			add(elevator);
		}
	}
Example #4
0
	void Menu::loadPersonData(const std::string& filePath)
	{
		if (!File::exists(filePath))
		{
			return;
		}

		Json::Parser parser;
		Json::Value json = parser.parse(filePath);
		persons.fromJson(json.get("persons"));

		for (const Person& person : persons.list())
		{
			listbox[ALL_PLAYER_LIST]->addItem(person.getName());
		}

		Json::Value playing = json.get("playing");
		for (Size i = 0; i < playing.getLength(); i++)
		{
			std::string name = playing.get(i).asString();
			listbox[CUR_PLAYERS_LIST]->addItem(name);
			listbox[ALL_PLAYER_LIST]->removeItem(name);
		}
	}
Example #5
0
	void Level::load(const std::string& path, bool mirror)
	{
		levelData.clear();
		waterLevel = 0;
		Json::Parser parser;
		Json::Value root = parser.parse(path);

		width = root.get("width").asInt();
		height = root.get("height").asInt();

		Int32 blockCount = width * height;
		Json::Value blocks = root.get("blocks");
		levelData.resize(blockCount);
		for (Size i = 0; i < blocks.getLength(); i++)
		{
			levelData[i] = blocks.get(i).asInt();
		}

		if (mirror)
		{
			mirrorLevelData();
		}
		waterBlock = findWaterType();
	}
Example #6
0
void regTest5()
{
	tracef("reg test 5 begin:reg twice");
	Context::Ptr pContext = new Context(Context::TLSV1_CLIENT_USE, "", Context::VERIFY_NONE);
	SecureStreamSocket sss(pContext);
	SocketAddress sa("127.0.0.1", 12222);
	sss.connect(sa, Timespan(3, 0));
	DynamicStruct ds;
	ds["type"] = "request";
	ds["action"] = "server.token";
	Timestamp t;
	UInt64 tms = t.epochMicroseconds();
	char tms_str[32];
	snprintf(tms_str, 31, "%llu", tms);
	std::string key = "alpha2015";
	key += tms_str;
	MD5Engine md5;
	md5.update(key);
	const DigestEngine::Digest& digest = md5.digest();
	std::string md5key = DigestEngine::digestToHex(digest);
	DynamicStruct param;
	param["key"] = md5key;
	param["timestamp"] = tms_str;
	param["dev_name"] = "lock3";
	param["dev_type"] = "sc-01";
	param["uuid"] = "SC00000003";
	ds["param"] = param;

	tracef("data send: %s.", ds.toString().c_str());
	sss.sendBytes(ds.toString().c_str(), ds.toString().length());

	char buf[1024] = {0, };
	sss.receiveBytes(buf, 1024);

	JSON::Parser parser;
	Dynamic::Var var = parser.parse(buf);
	JSON::Object::Ptr pObj = var.extract<JSON::Object::Ptr>();
	DynamicStruct ds_recv = *pObj;
	std::string token = ds_recv["param"]["token"];

	DynamicStruct ds_reg;
	ds_reg["type"] = "request";
	ds_reg["action"] = "server.register";
	DynamicStruct param_reg;
	param_reg["token"] = token;
	param_reg["uuid"] = "SC00000003";
	ds_reg["param"] = param_reg;

	StreamSocket ss;
	SocketAddress sa2("127.0.0.1", 13333);
	ss.connect(sa2, Timespan(3, 0));

	ss.sendBytes(ds_reg.toString().c_str(), ds_reg.toString().length());
	tracef("reg data send: %s.", ds_reg.toString().c_str());
	memset(buf, 0, 1024);
	ss.receiveBytes(buf, 1024);
	tracef("receive bytes: %s.", buf);
	ss.close();
	Thread::sleep(2000);

	StreamSocket ss2;
	ss2.connect(sa2, Timespan(3, 0));
	tracef("reg data send again: %s.", ds_reg.toString().c_str());
	ss2.sendBytes(ds_reg.toString().c_str(), ds_reg.toString().length());
	memset(buf, 0, 1024);
	ss2.receiveBytes(buf, 1024);
	tracef("recv data: %s.", buf);
	ss2.close();
	tracef("reg test 5 finished.");
}
Example #7
0
int main(int argc, char** argv)
{
	if(argc < 4)
		return 0;
	std::string host = argv[1];
	UInt64 ssl_port = atoi(argv[2]);
	UInt64 reg_port = atoi(argv[3]);
	SocketAddress ssl_addr(host, ssl_port);
	SocketAddress reg_addr(host, reg_port);
	Context::Ptr pContext = new Context(Context::TLSV1_CLIENT_USE, "", Context::VERIFY_NONE);
	SecureStreamSocket* ssl_sock = new SecureStreamSocket(pContext);
	try
	{
		ssl_sock->connect(ssl_addr, Timespan(3, 0));
	}
	catch(Exception& e)
	{
		warnf("%s, %d: message: %s.", __FILE__, __LINE__, e.message().c_str());
	}
	tracef("%s, %d: now sleep.", __FILE__, __LINE__);
	Thread::sleep(3 * 1000);
	char buf[512] = {0, };
	DynamicStruct ssl_buf;
	ssl_buf["type"] = "request";
	ssl_buf["action"] = "server.token";
	DynamicStruct ssl_param;
	Timestamp t;
	UInt64 tms = t.epochMicroseconds();
	char tms_str[32] = {0, };
	snprintf(tms_str, 31, "%llu", tms);
	ssl_param["timestamp"] = tms_str;
	std::string key = "alpha2015";
	key += tms_str;
	MD5Engine md5;
	md5.update(key);
	const DigestEngine::Digest& digest = md5.digest();
	std::string md5key = DigestEngine::digestToHex(digest);
	ssl_param["key"] = md5key;
	ssl_param["uuid"] = "hjhjhjhj";
	ssl_param["dev_type"] = "abc";
	ssl_param["dev_name"] = "cba";
	ssl_buf["param"] = ssl_param;
	snprintf(buf, 511, "%s", ssl_buf.toString().c_str());
	tracef("%s, %d: send buf: %s\n", __FILE__, __LINE__, buf);
	ssl_sock->sendBytes(buf, 512);
	memset(buf, 0, 512);
	if(ssl_sock->poll(Timespan(30, 0), Socket::SELECT_READ) > 0)
	{
		ssl_sock->receiveBytes(buf, 512);
		tracef("%s, %d: receive buf: %s\n", __FILE__, __LINE__, buf);
	}
	ssl_sock->close();
	delete ssl_sock;
	pContext = NULL;
	Dynamic::Var var;
	JSON::Parser parser;
	try
	{
		var = parser.parse(buf);
	}
	catch(Exception& e)
	{
		warnf("%s, %d: %s\n", __FILE__, __LINE__, e.message().c_str());
		return 0;
	}
	JSON::Object::Ptr obj = var.extract<JSON::Object::Ptr>();
	DynamicStruct ssl_recv = *obj;
	std::string token = ssl_recv["token"];
	DynamicStruct reg_buf;
	reg_buf["action"] = "register";
	reg_buf["token"] = token;
	reg_buf["uuid"] = "hjhjhjhj";
	reg_buf["devType"] = "abc";
	memset(buf, 0, 512);
	snprintf(buf, 511, "%s", reg_buf.toString().c_str());
	StreamSocket* reg_sock = new StreamSocket(reg_addr);
	reg_sock->sendBytes(buf, 512);
	memset(buf, 0, 512);
	if(reg_sock->poll(Timespan(3, 0), Socket::SELECT_READ) > 0)
	{
		reg_sock->receiveBytes(buf, 512);
	}
	Thread::sleep(2000);
	while(1)
	{
		if(reg_sock->poll(Timespan(3, 0), Socket::SELECT_READ) > 0)
		{
			memset(buf, 0, 512);
			reg_sock->receiveBytes(buf, 512);
			parser.reset();
			Dynamic::Var recv_request = parser.parse(buf);
			JSON::Object::Ptr req_obj = recv_request.extract<JSON::Object::Ptr>();
			DynamicStruct req_ds = *req_obj;
			tracef("recv request:%s\n", req_ds.toString().c_str());
			req_ds["type"] = "response";
			req_ds["result"] = "good";
			snprintf(buf, 512, "%s", req_ds.toString().c_str());
			reg_sock->sendBytes(buf, 512);
			infof("send response[%s].\n", buf);
			char c;
			c = getchar();
			if(c == 'q')
				break;
		}
	}
	delete reg_sock;
	return 0;
}
void CHTTPRequestHandler::handleRequest(HTTPServerRequest& request, HTTPServerResponse& response)
{
	response.setContentType("application/json");
	response.setChunkedTransferEncoding(true);
	if(m_buf == NULL)
		m_buf = new char[512];
	memset(m_buf, 0, 512);
	request.stream().getline(m_buf, 512, '\n');
	infof("%s, %d: Receive HTTP request[%s]", __FILE__, __LINE__, m_buf);
	JSON::Parser parser;
	Dynamic::Var var;
	try
	{
		var = parser.parse(m_buf);
	}
	catch(Exception& e)
	{
		JSON::Object::Ptr re = new JSON::Object;
		re->set(KEY_TYPE_STR, TYPE_RESPONSE_STR);
		re->set(KEY_RESULT_STR, RESULT_FAIL_STR);
		re->set(KEY_DETAIL_STR, "100");
		DynamicStruct ds_res = *re;
		response.sendBuffer(ds_res.toString().c_str(), ds_res.toString().length());
		infof("%s, %d: Send Http response[%s].", __FILE__, __LINE__, ds_res.toString().c_str());
		re = NULL;
		return;
	}
	JSON::Object::Ptr obj = var.extract<JSON::Object::Ptr>();
	JSON::Object::Ptr res = new JSON::Object(*obj);
	if(!checkRequestFormat(obj, res))
	{
		DynamicStruct ds_res = *res;
		response.sendBuffer(ds_res.toString().c_str(), ds_res.toString().length());
		infof("%s, %d: Send Http response[%s].", __FILE__, __LINE__, ds_res.toString().c_str());
		res = NULL;
		return;
	}
	DynamicStruct ds = *obj;
	std::string uuid = ds[KEY_PARAM_STR][REG_UUID_STR].toString();
	std::string action = ds[KEY_ACTION_STR].toString();
	std::string component = "";
	std::string method = "";
	bool ret = parseAction(action, component, method);
	if(!ret)
	{
		res->set(KEY_RESULT_STR, RESULT_FAIL_STR);
		res->set(KEY_DETAIL_STR, "105");
		DynamicStruct ds_res = *res;
		response.sendBuffer(ds_res.toString().c_str(), ds_res.toString().length());
		infof("%s, %d: Send Http response[%s].", __FILE__, __LINE__, ds_res.toString().c_str());
		res = NULL;
		return;
	}
	if(component == COMPONENT_SERVER_STR)
	{
		if(method == SERVER_METHOD_CHECK)
		{
			res->set(KEY_RESULT_STR, RESULT_GOOD_STR);
			CDeviceManager* dev_mgr = CDeviceManager::instance();
			DeviceInfo* dev_info = dev_mgr->getDevice(uuid);
			DynamicStruct param;
			param[REG_UUID_STR] = uuid;
			if(dev_info != NULL)
			{
				param[REG_STATE_STR] = "online";
				param[REG_DEV_TYPE_STR] = dev_info->devType;
			}
			else
			{
				param[REG_STATE_STR] = "offline";
			}
			res->remove(KEY_PARAM_STR);
			res->set(KEY_PARAM_STR, param);
		}
		else
		{
			res->set(KEY_RESULT_STR, RESULT_FAIL_STR);
			res->set(KEY_DETAIL_STR, "106");
		}
		DynamicStruct ds_res = *res;
		infof("%s, %d: Send Http response[%s].", __FILE__, __LINE__, ds_res.toString().c_str());
		response.sendBuffer(ds_res.toString().c_str(), ds_res.toString().length());
		res = NULL;
		return;
	}
	else if(component == COMPONENT_UPDATE_STR)
	{
		std::string detail = "";
		if(method == UPDATE_METHOD_CHECK)
		{
			CUpdateManager* update_manager = CUpdateManager::instance();
			JSON::Object::Ptr pParam = obj->getObject(KEY_PARAM_STR);
			if(update_manager->checkUpdate(pParam, detail))
			{
				res->set(KEY_RESULT_STR, RESULT_GOOD_STR);
				res->remove(KEY_PARAM_STR);
				res->set(KEY_PARAM_STR, pParam);
			}
			else
			{
				res->set(KEY_RESULT_STR, RESULT_FAIL_STR);
				res->set(KEY_DETAIL_STR, detail);
			}
		}
		else
		{
			res->set(KEY_RESULT_STR, RESULT_FAIL_STR);
			res->set(KEY_DETAIL_STR, "106");
		}
		DynamicStruct ds_res = *res;
		infof("%s, %d: Send Http response[%s].", __FILE__, __LINE__, ds_res.toString().c_str());
		response.sendBuffer(ds_res.toString().c_str(), ds_res.toString().length());
		res = NULL;
		return;
	}
	RequestInfo* req = new RequestInfo((UInt64)this, uuid, 5*1000*1000, obj);
	CRegServer* reg_server = CRegServer::instance();
	//it will hang until response send back, or timeout
	reg_server->sendRequest(req);
	res = req->response;
	if(res.isNull())
	{
		warnf("%s, %d: Request timeout.", __FILE__, __LINE__);
		DynamicStruct result = *obj;
		result[KEY_RESULT_STR] = RESULT_FAIL_STR;
		result[KEY_DETAIL_STR] = "timeout";
		infof("%s, %d: Send Http response[%s].", __FILE__, __LINE__, result.toString().c_str());
		response.sendBuffer(result.toString().c_str(), result.toString().length());
	}
	else
	{
		DynamicStruct result = *res;
		infof("%s, %d: Send Http response[%s].", __FILE__, __LINE__, result.toString().c_str());
		response.sendBuffer(result.toString().c_str(), result.toString().length());
	}
	res = NULL;
	delete req;
}