//�����豸״̬
int upgradeapp::update_device(uint dev, uint cpy, int state, app_connection*n){
int upgrade_state = e_upgradesucc;
std::map<uint, dev_state> ::iterator it = m_devmap.find(dev);
if(it == m_devmap.end()){
dev_state ds;
ds.line_state = state;
ds.upgrade_state = e_upgradesucc;
ds.con = n;
m_devmap[dev] = ds;
}
else{
it->second.line_state = state;
it->second.con = n;
upgrade_state = it->second.upgrade_state;
}
if(state == em_online){
char data[128] = {0};
sprintf(data, "{\"device_id\":%d}", dev);
post_req(n, get_device_version_req, data);
log_out(log_debug, "update_device::get_device_version_req %s\n", data);
}
log_out(log_debug, "update_device::device(%u) company(%u) state(%u) upgrade(%u) count(%d)\n",
dev, cpy, state, upgrade_state, m_devmap.size());
return 0;
}
int upgradeapp::send_keepalive(){
std::map<uint, app_connection*>::iterator it = m_svrmap.begin();
for(; it != m_svrmap.end(); it++){
post_req(it->second, client_keepalive_mgr_req);
}
return 0;
}
int svrapp::client_req(param_list * pl){
ipaddr &peeraddr = pl->n->get_peeraddr();
log_out(log_debug, "client_req::%s..%s\n", peeraddr.ip, pl->content);
cnt_info * c = (cnt_info*)pl->n->get_context();
if (!c){
cJSON * jsfrom = cJSON_GetObjectItem(pl->jsdata, "from");
if(!jsfrom || jsfrom->type != cJSON_String
|| strcmp(jsfrom->valuestring, "web")){
log_out(log_debug, "client_req::no permission\n");
post_ack(pl->n, pl->ack_cmd, pl->serial, ERROR_NO_PERMISSION, "no permission");
return -1;
}
else{
c = new cnt_info(cnt_type);
c->parse_token(NULL) ;
pl->n->set_context(c);
m_cntmap[c->get_id()] = pl->n;
}
}
cJSON * jsdev = cJSON_GetObjectItem(pl->jsdata, "device_id");
if(!jsdev || jsdev->type != cJSON_Number){
log_out(log_error, "client_req::invalid device(%s)\n", pl->content);
post_ack(pl->n, pl->ack_cmd, pl->serial, ERROR_PARAM, "device id invalid");
return -1;
}
std::map<uint, app_connection*>::iterator it = m_devmap.find(jsdev->valueuint);
if(it == m_devmap.end()){
log_out(log_error, "client_req::device(%u) off line\n",jsdev->valueuint);
post_ack(pl->n, pl->ack_cmd, pl->serial, ERROR_DEV_OFFLINE, "device is offline");
return -1;
}
char new_serial[128] = {0};
create_serial(c->get_id(), pl->serial, new_serial, sizeof(new_serial));
char * out = cJSON_PrintUnformatted(pl->jsdata);
app_connection * dn = it->second;
post_req(dn, pl->cmd, out, new_serial);
free(out);
return 0;
}
int upgradeapp::login_mgr_req(const char * cpy_list, const char * svr_token, app_connection *n){
ipaddr & peer = n->get_peeraddr();
server_info * s = (server_info*)n->get_context();
m_svrmap[s->get_id()] = n;
s->reset_interval();
char events[256] = {0};
sprintf(events, "\"event\":[\"%s\",\"%s\"]", online_alarm, offline_alarm);
char identify[512] = {0};
sprintf(identify, "{\"token\":\"%s\",%s,\"company\":%s}", svr_token, events, cpy_list);
post_req(n, client_login_mgr_req, identify);
log_out(log_debug, "login_mgr_req::to(%s:%d) %s\n", peer.ip, peer.port, identify);
return 0;
}
//�����豸״̬
int upgradeapp::update_device(const char* dev, int state, app_connection*n){
int upgrade_state = e_upgradesucc;
std::map<strkey_t, dev_state> ::iterator it = m_devmap.find(dev);
if(it == m_devmap.end()){
dev_state ds;
ds.line_state = state;
ds.upgrade_state = e_upgradesucc;
ds.con = n;
m_devmap[dev] = ds;
}
if(state == em_offline && it != m_devmap.end()){
server_info * sif1 = (server_info*)it->second.con->get_context();
server_info * sif2 = (server_info*)n->get_context();
//fixed bug
upgrade_state = it->second.upgrade_state;
if(sif1->get_numkey() == sif2->get_numkey()){
it->second.line_state = state;
it->second.con = n;
//upgrade_state = it->second.upgrade_state;
}
else{
log_out(log_warn, "update_device::from different server\n");
}
}
if(state == em_online && it != m_devmap.end()){
it->second.line_state = state;
it->second.con = n;
upgrade_state = it->second.upgrade_state;
}
log_out(log_debug, "update_device::device(%s) state(%u) upgrade(%u) count(%d)\n",
dev, state, upgrade_state, m_devmap.size());
if(state == em_online){
char data[128] = {0};
sprintf(data, "{\"sn\":\"%s\"}", dev);
post_req(n, get_device_version_req, data);
log_out(log_debug, "update_device::get_device_version_req %s\n", data);
}
return 0;
}
int svrapp::cmd_poll(){
std::map<strkey_t, cmd_s> & temp = m_cmds_map[m_group_index];
std::map<strkey_t, cmd_s>::iterator it = temp.begin();
time_t now = time(NULL);
char devkey[strkey_len] = {0};
while(it != temp.end()){
cmd_s &cs = it->second;
if(now - cs.last_cmd_time < m_stop_threshold ||
strcmp(cs.last_cmd, stop_ctrl_req) == 0){
it++;
continue;
}
uint chn = 0;
parse_chnkey(devkey, chn, it->first.c_str());
std::map<strkey_t, app_connection*>::iterator it1 = m_devmap.find(devkey);
if (it1 == m_devmap.end()){
log_out(log_warn, "cmd_poll::device_id(%s) offline, delete cmd\n", devkey);
temp.erase(it++);
continue;
}
char buf[128] = {0};
sprintf(buf, "{\"devkey\":\"%s\",\"channel\":%u}", devkey, chn);
post_req(it1->second, stop_ctrl_req, buf, "ptzctrl");
log_out(log_debug, "cmd_poll::send stop cmd(%s), last_time(%u) last_cmd(%s)\n",
buf, cs.last_cmd_time, cs.last_cmd);
temp.erase(it++);
}
if(++m_group_index >= max_group_count){
m_group_index = 0;
}
return 0;
}
int svrapp::login_mgr_req(app_connection *n){
ipaddr & peer = n->get_peeraddr();
server_info * sif = (server_info*)n->get_context();
m_svrmap[sif->get_numkey()] = n;
sif->reset_interval();
const char *token = "\"token\":\"motiondetect\"";
char event_list[256] = {0};
sprintf(event_list, "\"event_list\":[\"%s\"]", motion_detect_alarm);
char identify[512] = {0};
sprintf(identify, "{%s,%s}", token, event_list);
post_req(n, client_login_mgr_req, identify);
log_out(log_debug, "login_mgr_req::to(%s:%d) %s\n", peer.ip, peer.port, identify);
return 0;
}
int baseapp::connect_mgr_ok(const char * cfg, const char * name, app_connection *n){
ipaddr & peer = n->get_peeraddr();
server_info * s = (server_info*)n->get_context();
m_svrmap[s->get_id()] = n;
s->reset_interval();
char events[256] = {0};
sprintf(events, "\"event\":[\"%s\",\"%s\"]", online_alarm, offline_alarm);
char companys[512] = {0};
read_companys(cfg, "company", companys);
char identify[512] = {0};
sprintf(identify, "{\"token\":\"%s\",%s,\"company\":%s}", name, events, companys);
post_req(n, client_login_mgr_req, identify);
log_out(log_debug, "connect ok %s:%d login mgr %s\n", peer.ip, peer.port, identify);
return 0;
}
/*
{
"serial":"",
"cmd":"",
"data":{
"channel":0,
"sub_channel":0
}
}
*/
int svrapp::send_dev_ctrl_req(realplay_info * rpif,
const char * cmd,
const char * serial){
//通知设备
stream_key * stmkey = rpif->get_stream_key();
uint device_id = stmkey->device_id;
std::map<uint, app_connection*> ::iterator it0 = m_devmap.find(device_id);
if(it0 == m_devmap.end()){
log_out(log_error, "send_dev_ctrl_req::%s->device(%u) offline\n", cmd, device_id);
return -1;
}
char sentbuf[256] = {0};
sprintf(sentbuf, "{\"device_id\":%u, \"channel\":%u,\"sub_channel\":%u}",
stmkey->device_id, stmkey->chn, stmkey->sub_chn);
post_req(it0->second, cmd, sentbuf, serial);
log_out(log_warn, "send_dev_ctrl_req::%s->%s\n", cmd, sentbuf);
return 0;
}
int svrapp::login_mgr_req(app_connection *n){
ipaddr & peer = n->get_peeraddr();
server_info * s = (server_info*)n->get_context();
m_svrmap[s->get_id()] = n;
s->reset_interval();
const char *token = "\"token\":\"offline alarm server\"";
char events[256] = {0};
sprintf(events, "\"event\":[\"%s\",\"%s\"]", online_alarm, offline_alarm);
char companys[512] = {0};
read_companys(ulu_c2hd_offline_conf, "company", companys);
char identify[512] = {0};
sprintf(identify, "{%s,%s,\"company\":%s}", token, events, companys);
post_req(n, client_login_mgr_req, identify);
log_out(log_debug, "login_mgr_req::to(%s:%d) %s\n", peer.ip, peer.port, identify);
return 0;
}
bool NetBalanceGetter::login_cabinet(){
QTimer timeout;
timeout.setSingleShot(true);
QEventLoop waitLoop;
QObject::connect(&timeout, SIGNAL(timeout()), &waitLoop, SLOT(quit()) );
QNetworkReply* reply;
timeout.start(timeout_ms);
reply = post_req();
QObject::connect(reply, SIGNAL(finished()), &waitLoop, SLOT(quit()));
waitLoop.exec();
if( timeout.isActive() && (reply->error() == QNetworkReply::NoError) ) {
timeout.stop();
return true;
}else
{
emit failed();
return false;
}
}
int upgradeapp::device_update_data(char * result, int length){
if(length <= 0){
log_out(log_warn, "device_update_data:receive data length is %d\n", length);
}
cJSON * json = cJSON_Parse(result);
if(!json){
log_out(log_error, "device_update_data:invalid json %s\n", result);
return -1;
}
cJSON * jscode = cJSON_GetObjectItem(json, "code");
cJSON * jsmessage = cJSON_GetObjectItem(json, "message");
cJSON * jsdata = cJSON_GetObjectItem(json, "data");
if(!jscode || jscode->type != cJSON_Number ||
!jsmessage || jsmessage->type != cJSON_String ||
!jsdata){
cJSON_Delete(json);
log_out(log_error, "device_update_data::invalid json %s\n", result);
return -1;
}
if(jscode->valueint != 0){
log_out(log_error, "device_update_data::code %d\n", jscode->valueint);
cJSON_Delete(json);
return -1;
}
cJSON * jslst = cJSON_GetObjectItem(jsdata, "upgrade");
if(!jslst){
log_out(log_warn, "device_update_data::no devices\n");
cJSON_Delete(json);
return -1;
}
int count = cJSON_GetArraySize(jslst);
log_out(log_debug, "device_update_data::device count %d\n", count);
for(int k = 0; k < count; k++){
cJSON * jsdev = cJSON_GetArrayItem(jslst, k);
cJSON * jsid = cJSON_GetObjectItem(jsdev, "device_id");
uint dev = jsid->valueuint;
cJSON * jsver = cJSON_GetObjectItem(jsdev, "version");
cJSON * jsforce = cJSON_GetObjectItem(jsdev, "force");
cJSON * jsurl = cJSON_GetObjectItem(jsdev, "url");
cJSON * jsver_id = cJSON_GetObjectItem(jsdev, "version_id");
cJSON * jscheck = cJSON_GetObjectItem(jsdev, "check");
cJSON * jstype = cJSON_GetObjectItem(jscheck, "type");
cJSON * jsvalue = cJSON_GetObjectItem(jscheck, "value");
cJSON * jssize = cJSON_GetObjectItem(jscheck, "size");
if(!jsforce || jsforce->type != cJSON_Number ||
!jsver || jsver->type != cJSON_String ||
!jsurl || jsurl->type != cJSON_String ||
!jsid || jsid->type != cJSON_Number ||
!jsver_id || jsver_id->type != cJSON_Number ||
!jscheck || !jstype || jstype->type != cJSON_String ||
!jsvalue || jsvalue->type != cJSON_String ||
!jssize || jssize->type != cJSON_Number){
log_out(log_error, "start_update_req::invalid json %s\n", jsdev->valuestring);
continue;
}
std::map<uint, dev_state>::iterator it = m_devmap.find(dev);
if(it != m_devmap.end()){
it->second.version_id = jsver_id->valueuint;
if(jsforce->valueuint == e_force && it->second.line_state == em_online){
char identify[512] = {0};
sprintf(identify, "{\"device_id\":%u,\"url\":\"%s\",\"check\":{\"type\":\"%s\",\"value\":\"%s\",\"size\":%d}}",
it->first, jsurl->valuestring, jstype->valuestring, jsvalue->valuestring, jssize->valueint);
post_req(it->second.con, start_update_req, identify);
it->second.upgrade_state = e_upgrading;
log_out(log_warn, "device_update_data:: mgrserver: %s\n", identify);
char buf[512] = {0};
sprintf(buf, "msg={\"platform\":\"device\",\"data\":[{\"device_id\":%u,\"version_id\":%u,\"status\":%d}]}",
it->first, it->second.version_id, e_upgrading);
log_out(log_debug, "device_update_data:post status %s\n", buf);
char result[128 * 128] = {0};
if(post(m_api_upgrade_status, buf, strlen(buf), result, sizeof(result)) < 0){
log_out(log_error, "device_update_data:post status fail\n");
}
}
}
else{
log_out(log_warn, "device_update_data:: invalid device(%u)\n", dev);
}
}
cJSON_Delete(json);
return 0;
}
int upgradeapp::login_mgr_ack(param_list * pl){
log_out(log_debug, "login_mgr_ack::%s\n", pl->content);
post_req(pl->n, get_online_device_req);
return 0;
}
int upgradeapp::device_update_data(char * result, int length){
if(length <= 0){
log_out(log_warn, "device_update_data:receive data length is %d\n", length);
return -1;
}
cJSON * json = cJSON_Parse(result);
if(!json){
log_out(log_error, "device_update_data:invalid json %s\n", result);
cJSON_Delete(json);
return -1;
}
cJSON * jscode = cJSON_GetObjectItem(json, "code");
cJSON * jsmessage = cJSON_GetObjectItem(json, "message");
cJSON * jsdata = cJSON_GetObjectItem(json, "data");
if(!jscode || jscode->type != cJSON_Number ||
!jsmessage || jsmessage->type != cJSON_String ||
!jsdata){
log_out(log_error, "device_update_data::invalid json %s\n", result);
cJSON_Delete(json);
return -1;
}
if(jscode->valueint != 0){
log_out(log_error, "device_update_data:: error code %d\n", jscode->valueint);
cJSON_Delete(json);
return -1;
}
int count = cJSON_GetArraySize(jsdata);
log_out(log_debug, "device_update_data::device count %d\n", count);
for(int k = 0; k < count; k++){
cJSON * jsdev = cJSON_GetArrayItem(jsdata, k);
cJSON * jsstatus = cJSON_GetObjectItem(jsdev, "status");
if(!jsstatus || jsstatus->type != cJSON_Number){
continue;
}
if(jsstatus->valueint){
continue;
}
cJSON * jssn = cJSON_GetObjectItem(jsdev, "ulusn");
cJSON * jsver = cJSON_GetObjectItem(jsdev, "target_ver");
cJSON * jsforce = cJSON_GetObjectItem(jsdev, "force");
cJSON * jsurl = cJSON_GetObjectItem(jsdev, "url");
cJSON * jsmiss_id = cJSON_GetObjectItem(jsdev, "mission_id");
cJSON * jstype = cJSON_GetObjectItem(jsdev, "check_type");
cJSON * jsvalue = cJSON_GetObjectItem(jsdev, "check_value");
cJSON * jssize = cJSON_GetObjectItem(jsdev, "size");
if(!jsforce || jsforce->type != cJSON_Number ||
!jsver || jsver->type != cJSON_String ||
!jssn || jssn->type != cJSON_String ||
!jsurl || jsurl->type != cJSON_String ||
!jsmiss_id || jsmiss_id->type != cJSON_Number ||
!jstype || jstype->type != cJSON_String ||
!jsvalue || jsvalue->type != cJSON_String ||
!jssize || jssize->type != cJSON_Number){
continue;
}
std::map<strkey_t, dev_state>::iterator it = m_devmap.find(jssn->valuestring);
if(it != m_devmap.end()){
it->second.mission_id = jsmiss_id->valueint;
if(jsforce->valueuint == e_force && it->second.line_state == em_online && (jsver->valuestring != it->second.version)
&& it->second.upgrade_state != e_upgrading){
char identify[512] = {0};
sprintf(identify, "{\"sn\":\"%s\",\"url\":\"%s\",\"check\":{\"type\":\"%s\",\"value\":\"%s\",\"size\":%d}}",
it->first.c_str(), jsurl->valuestring, jstype->valuestring, jsvalue->valuestring, jssize->valueint);
post_req(it->second.con, start_update_req, identify);
it->second.upgrade_state = e_upgrading;
log_out(log_debug, "device_update_data::post data to mgrserver: %s\n", identify);
char buf[512] = {0};
sprintf(buf, "{\"platform\":\"device\",\"sn\":\"%s\",\"version\":\"%s\",\"mission_id\":%d,\"status\":%d,\"time\":%d}",
it->first.c_str(), it->second.version.c_str(), it->second.mission_id, e_upgrading, (int)time(NULL));
char result[128 * 128] = {0};
if(post(gs_svr_data.m_api_upgrade_status, buf, strlen(buf), result, sizeof(result)) < 0){
// log_out(log_error, "device_update_data:post status fail\n");
// return -1;
}
log_out(log_debug, "device_update_data:post status %s\n", buf);
}
else{
log_out(log_warn, "device_update_data:: device(%s) offline or optional(%u) or upgrading or same version\n", jssn->valuestring, jsforce->valueuint);
}
}
else{
log_out(log_warn, "device_update_data:: invalid device(%s)\n", jssn->valuestring);
}
}
cJSON_Delete(json);
return 0;
}
/*
{
"serial":"",
"cmd":"start_realpaly_req",
"data":{
"token":"",
"channel":0,
"sub_channel":0,
}
}*/
int svrapp::start_realplay_reqx(param_list * pl){
realplay_info * rpif = (realplay_info*)pl->n->get_context();
if(!rpif){
post_ack(pl->n, pl->ack_cmd, pl->serial, ERROR_NO_SUPPORT, "try again");
log_out(log_error, "start_realplay_reqx::unknow error\n");
return -1;
}
if(rpif->is_playing()){
rpif->post_ack(pl->ack_cmd, pl->serial, ERROR_NO_SUPPORT, "is playing");
log_out(log_error, "start_realplay_reqx::is playing\n");
return -1;
}
stream_key * stmkey = rpif->get_stream_key();
uint64 key64 = rpif->get_key64();
//find dev
std::map<uint, app_connection*>::iterator it = m_devmap.find(stmkey->device_id);
if(it == m_devmap.end()){
log_out(log_error, "start_realpaly_req::device(%u) off line\n", stmkey->device_id);
rpif->post_ack(pl->ack_cmd, pl->serial, ERROR_DEV_OFFLINE, "device is offline");
return -1;
}
std::map<uint, app_connection*>::iterator it1 = m_cntmap.find(rpif->get_id());
if(it1 == m_cntmap.end() ){
m_cntmap[rpif->get_id()] = pl->n;
}
//判断是否已经在播放
std::map<uint64, stream_info*>::iterator it0 = m_realplaymap.find(key64);
if(it0 != m_realplaymap.end()){
stream_info * stmif = it0->second;
stmif->add(rpif->get_id(), pl->n);
rpif->reset_resource();
rpif->set_playing();
rpif->post_ack(pl->ack_cmd, pl->serial, ERROR_OK, "ok");
log_out(log_debug, "start_realpaly_req::appid(%d) stream(%llX) already playing, clients(%u)\n",
get_appid(), key64, stmif->client_number());
return 0;
}
else{
stream_info * stmif = new stream_info(stm_type, stmkey);
m_realplaymap[key64] = stmif;
stmif->add(rpif->get_id(), pl->n);
}
rpif->reset_resource();
rpif->set_playing();
///add realplay server
char serverAddr[64] = {0};
sprintf(serverAddr, "%s:%d",g_sdr->self_ipaddr.ip, g_sdr->self_ipaddr.port);
cJSON_AddStringToObject(pl->jsdata, "server", serverAddr);
cJSON_AddStringToObject(pl->jsdata, "transport_protocol", "tcp");
//generate token
char token[128] = {0};
sprintf(token, "%08X%04X%04X", stmkey->device_id, stmkey->chn, stmkey->sub_chn);
cJSON_DeleteItemFromObject(pl->jsdata, "token");
cJSON_AddStringToObject(pl->jsdata, "token", token);
//send request to mgr
char new_serial[128] = {0};
create_serial(rpif->get_id(), pl->serial, new_serial, sizeof(new_serial));
char * out = cJSON_PrintUnformatted(pl->jsdata);
log_out(log_debug, "start_realpaly_req::appid(%d) %s\n",get_appid(), out);
app_connection * dn = it->second;
post_req(dn, pl->cmd, out, new_serial);
free(out);
return 0;
}
int svrapp::client_req(param_list * pl){
ipaddr &peeraddr = pl->n->get_peeraddr();
log_out(log_debug, "client_req::%s..%s\n", peeraddr.ip, pl->content);
cnt_info * cif = (cnt_info*)pl->n->get_context();
if (!cif){
cif = new cnt_info(cnt_type);
cif->parse_token(NULL) ;
pl->n->set_context(cif);
m_cntmap[cif->get_numkey()] = pl->n;
}
cJSON * jsdev = cJSON_GetObjectItem(pl->jsdata, "device_id");
if(!jsdev || jsdev->type != cJSON_Number){
log_out(log_error, "client_req::invalid device(%s)\n", pl->content);
post_ack(pl->n, pl->ack_cmd, pl->serial, ERROR_PARAM, "device_id invalid");
return -1;
}
uint platform = get_platform_code_delete_item(pl->jsdata);
char devkey[strkey_len] = {0};
create_devkey(platform, jsdev->valueuint64, devkey);
std::map<strkey_t, app_connection*>::iterator it = m_devmap.find(devkey);
if(it == m_devmap.end()){
log_out(log_error, "client_req::device(%s) off line\n", devkey);
post_ack(pl->n, pl->ack_cmd, pl->serial, ERROR_DEV_OFFLINE, "device is offline");
return -1;
}
//***********save cmd****************
//here fixed
int channel = 0;
cJSON * jschn = cJSON_GetObjectItem(pl->jsdata, "channel");
if(jschn && jschn->type == cJSON_Number){
channel = jschn->valueint;
}
char chnkey[strkey_len] = {0};
create_chnkey(devkey, channel, chnkey);
int index = hash_key(jsdev->valueuint64, max_group_count);
std::map<strkey_t, cmd_s> & temp = m_cmds_map[index];
std::map<strkey_t, cmd_s>::iterator it1 = temp.find(chnkey);
if(it1 == temp.end()){
cmd_s cs;
memset(&cs, 0, sizeof(cs));
it1 = temp.insert(std::make_pair(chnkey, cs)).first;
}
cmd_s &cs = it1->second;
cs.last_cmd_time = (uint)time(NULL);
strncpy(cs.last_cmd, pl->cmd, sizeof(cs.last_cmd) -1 );
//***********save cmd****************
//create_serial
char new_serial[128] = {0};
create_serial(cif->get_numkey(), pl->serial, new_serial, sizeof(new_serial));
//create devkey
cJSON_DeleteItemFromParent(pl->jsdata, jsdev);
cJSON_AddStringToObject(pl->jsdata, "devkey", devkey);
char * out = cJSON_PrintUnformatted(pl->jsdata);
app_connection * dn = it->second;
post_req(dn, pl->cmd, out, new_serial);
free(out);
return 0;
}
