2219 lines
54 KiB
C++
2219 lines
54 KiB
C++
/***************************************************************************************
|
|
*
|
|
* IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
*
|
|
* By downloading, copying, installing or using the software you agree to this license.
|
|
* If you do not agree to this license, do not download, install,
|
|
* copy or use the software.
|
|
*
|
|
* Copyright (C) 2014-2022, Happytimesoft Corporation, all rights reserved.
|
|
*
|
|
* Redistribution and use in binary forms, with or without modification, are permitted.
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software distributed
|
|
* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
|
|
* language governing permissions and limitations under the License.
|
|
*
|
|
****************************************************************************************/
|
|
|
|
#include "sys_inc.h"
|
|
#include "hsip.h"
|
|
#include "sua.h"
|
|
#include "sip_parse.h"
|
|
#include "sip_tx.h"
|
|
#include "sip_cm.h"
|
|
#include "sip_reg.h"
|
|
#include "sip_msg.h"
|
|
#include "gb28181.h"
|
|
#include "gb28181_msg.h"
|
|
#include "xml_node.h"
|
|
#include "gb28181_cfg.h"
|
|
|
|
/***********************************************************************/
|
|
extern HSIP_CLASS hsip;
|
|
extern HSIP_USER g_user;
|
|
|
|
/***********************************************************************/
|
|
BOOL gb28181_record_info_res_get(GB28181_RECORD_INFO_REQ * p_req, GB28181_RECORD_INFO_RES * p_res, int start, int max)
|
|
{
|
|
// todo : get the record list
|
|
|
|
int total = 10; // ¼Ïñ×ÜÊý
|
|
|
|
if (start > total)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
int remain = total - start;
|
|
|
|
p_res->SumNum = total;
|
|
p_res->Num = remain > max ? max : remain;
|
|
|
|
if (0 == p_res->Num)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
p_res->RecordList = (GB28181_RECORD_INFO *)malloc(sizeof(GB28181_RECORD_INFO) * p_res->Num);
|
|
if (NULL == p_res->RecordList)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, memory malloc failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
memset(p_res->RecordList, 0, sizeof(GB28181_RECORD_INFO) * p_res->Num);
|
|
|
|
for (int i = 0; i < p_res->Num; i++)
|
|
{
|
|
strcpy(p_res->RecordList[i].DeviceID, p_req->hdr.DeviceID);
|
|
strcpy(p_res->RecordList[i].Name, "HTIPC");
|
|
|
|
p_res->RecordList[i].FilePathFlag = p_req->FilePathFlag;
|
|
strcpy(p_res->RecordList[i].FilePath, p_req->FilePath);
|
|
|
|
p_res->RecordList[i].AddressFlag = 1;
|
|
strcpy(p_res->RecordList[i].Address, p_req->Address);
|
|
|
|
p_res->RecordList[i].StartTimeFlag = 1;
|
|
p_res->RecordList[i].EndTimeFlag = 1;
|
|
|
|
p_res->RecordList[i].StartTime = p_req->StartTime + (i + start) * 10 * 60;
|
|
p_res->RecordList[i].EndTime = p_res->RecordList[i].StartTime + 10 * 60;
|
|
|
|
p_res->RecordList[i].Secrecy = 0;
|
|
|
|
p_res->RecordList[i].TypeFlag = 1;
|
|
if (p_req->TypeFlag && p_req->Type[0] != '\0')
|
|
{
|
|
strcpy(p_res->RecordList[i].Type, p_req->Type);
|
|
}
|
|
else
|
|
{
|
|
strcpy(p_res->RecordList[i].Type, "time");
|
|
}
|
|
|
|
p_res->RecordList[i].RecorderIDFlag = p_req->RecorderIDFlag;
|
|
strcpy(p_res->RecordList[i].RecorderID, p_req->RecorderID);
|
|
|
|
p_res->RecordList[i].FileSizeFlag = 1;
|
|
p_res->RecordList[i].FileSize = 10 * 1024 * 1024;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_status_res_get(GB28181_DEVICE_STATUS_REQ * p_req, GB28181_DEVICE_STATUS_RES * p_res)
|
|
{
|
|
// todo : get the device status
|
|
|
|
p_res->Result = RESULT_OK;
|
|
p_res->Online = 1;
|
|
|
|
p_res->Status = RESULT_OK;
|
|
p_res->EncodeFlag = 1;
|
|
p_res->Encode = STATUS_ON;
|
|
p_res->RecordFlag = 1;
|
|
p_res->Record = STATUS_ON;
|
|
p_res->DeviceTimeFlag = 1;
|
|
p_res->DeviceTime = time(NULL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_info_res_get(GB28181_DEVICE_INFO_REQ * p_req, GB28181_DEVICE_INFO_RES * p_res)
|
|
{
|
|
// todo : get the device info
|
|
|
|
strcpy(p_res->DeviceName, g_gb28181_cfg.device_name);
|
|
p_res->Result = RESULT_OK;
|
|
|
|
p_res->ManufacturerFlag = 1;
|
|
strcpy(p_res->Manufacturer, "Happytimesoft");
|
|
|
|
p_res->ModelFlag = 1;
|
|
strcpy(p_res->Model, "HTIPC");
|
|
|
|
p_res->FirmwareFlag = 1;
|
|
strcpy(p_res->Firmware, "V1.0");
|
|
|
|
p_res->ChannelFlag = 1;
|
|
p_res->Channel = g_gb28181_cfg.channel_nums;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_catalog_res_get(GB28181_CATALOG_REQ * p_req, GB28181_CATALOG_RES * p_res, int start, int max)
|
|
{
|
|
// todo : get the catalog list ...
|
|
|
|
if (start > g_gb28181_cfg.channel_nums)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
int remain = g_gb28181_cfg.channel_nums - start;
|
|
|
|
p_res->SumNum = g_gb28181_cfg.channel_nums;
|
|
p_res->Num = remain > max ? max : remain;
|
|
|
|
if (0 == p_res->Num)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
p_res->DeviceList = (GB28181_DEVICE *)malloc(sizeof(GB28181_DEVICE) * p_res->Num);
|
|
if (NULL == p_res->DeviceList)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, memory malloc failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
memset(p_res->DeviceList, 0, sizeof(GB28181_DEVICE) * p_res->Num);
|
|
|
|
for (int i = 0; i < p_res->Num; i++)
|
|
{
|
|
int idx = i + start;
|
|
|
|
strcpy(p_res->DeviceList[i].DeviceID, g_gb28181_cfg.channels[idx].cid);
|
|
strcpy(p_res->DeviceList[i].Name, g_gb28181_cfg.channels[idx].cname);
|
|
strcpy(p_res->DeviceList[i].Manufacturer, "Happytimesoft");
|
|
strcpy(p_res->DeviceList[i].Model, "IPC");
|
|
p_res->DeviceList[i].RegisterWay = 1;
|
|
strcpy(p_res->DeviceList[i].ParentID, g_gb28181_cfg.device_id);
|
|
strcpy(p_res->DeviceList[i].Owner, "Owner");
|
|
strcpy(p_res->DeviceList[i].CivilCode, "CivilCode");
|
|
strcpy(p_res->DeviceList[i].Address, "Address");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_config_res_get(GB28181_CONFIG_REQ * p_req, GB28181_CONFIG_RES * p_res)
|
|
{
|
|
// todo : get the config params ...
|
|
|
|
if (strstr(p_req->ConfigType, "BasicParam"))
|
|
{
|
|
p_res->BasicParamFlag = 1;
|
|
strcpy(p_res->BasicParam.Name, "HTIPC");
|
|
p_res->BasicParam.Expiration = g_user.expires_time;
|
|
p_res->BasicParam.HeartBeatInterval = g_gb28181_cfg.heartbeat_interval;
|
|
p_res->BasicParam.HeartBeatCount = g_gb28181_cfg.heartbeat_count;
|
|
}
|
|
|
|
if (strstr(p_req->ConfigType, "VideoParamOpt"))
|
|
{
|
|
p_res->VideoParamOptFlag = 1;
|
|
p_res->VideoParamOpt.DownloadSpeedFlag = 1;
|
|
strcpy(p_res->VideoParamOpt.DownloadSpeed, "1");
|
|
p_res->VideoParamOpt.ResolutionFlag = 1;
|
|
strcpy(p_res->VideoParamOpt.Resolution, "5/6");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_preset_res_get(GB28181_PRESET_REQ * p_req, GB28181_PRESET_RES * p_res)
|
|
{
|
|
// todo : get the preset list ...
|
|
|
|
p_res->Num = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_control(GB28181_DEVICE_CONTROL_REQ * p_req, GB28181_DEVICE_CONTROL_RES * p_res)
|
|
{
|
|
// todo : exec the device control command ...
|
|
|
|
p_res->Result = RESULT_OK;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_config(GB28181_DEVICE_CONFIG_REQ * p_req, GB28181_DEVICE_CONFIG_RES * p_res)
|
|
{
|
|
// todo : the device config ...
|
|
|
|
p_res->Result = RESULT_OK;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_broadcast_notify(GB28181_BROADCAST_NOTIFY_REQ * p_req, GB28181_BROADCAST_NOTIFY_RES * p_res)
|
|
{
|
|
// todo : the broadcast notify ...
|
|
|
|
strcpy(p_res->DeviceID, p_req->TargetID);
|
|
p_res->Result = RESULT_OK;
|
|
|
|
// ÒôƵºô½Ð
|
|
sip_audio_call_out(p_req->TargetID, p_req->SourceID);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************/
|
|
HSIP_MSG * gb28181_msg_build(HSIP_USER * p_user, char * dst_uri, char * p_xml, int len)
|
|
{
|
|
HSIP_MSG * tx_msg = sip_get_msg_large_buf(1024 + len);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, get message buffer failed\r\n", __FUNCTION__);
|
|
return NULL;
|
|
}
|
|
|
|
tx_msg->msg_type = 0;
|
|
tx_msg->msg_sub_type = SIP_MT_MSG;
|
|
tx_msg->msg_crpty_mode = p_user->user_crpty_mode;
|
|
tx_msg->local_port = p_user->sip_port;
|
|
|
|
sip_add_tx_msg_fline(tx_msg, "MESSAGE", "%s SIP/2.0", p_user->server_sip_addr);
|
|
|
|
if (p_user->usrf_tcp_sip == 1)
|
|
{
|
|
sip_add_tx_msg_via(tx_msg, "SIP/2.0/TCP %s:%u;branch=z9hG4bK%x",
|
|
p_user->user_ip, p_user->user_port, (uint32)time(NULL));
|
|
}
|
|
else
|
|
{
|
|
sip_add_tx_msg_via(tx_msg, "SIP/2.0/UDP %s:%u;branch=z9hG4bK%x",
|
|
p_user->user_ip, p_user->user_port, (uint32)time(NULL));
|
|
}
|
|
|
|
sip_add_tx_msg_line(tx_msg, "From", "<%s>;tag=%08x", p_user->user_sip_addr, rand());
|
|
sip_add_tx_msg_line(tx_msg, "To", "<%s>", dst_uri);
|
|
sip_add_tx_msg_line(tx_msg, "Call-ID", "%08X%08X@%s", rand(), rand(), p_user->user_ip);
|
|
sip_add_tx_msg_line(tx_msg, "CSeq", "%d MESSAGE", ++p_user->message_cseq);
|
|
sip_add_tx_msg_line(tx_msg, "Max-Forwards", "70");
|
|
sip_add_tx_msg_line(tx_msg, "User-Agent", p_user->user_agent_desc);
|
|
sip_add_tx_msg_line(tx_msg, "Content-Type", "Application/MANSCDP+xml");
|
|
sip_add_tx_msg_line(tx_msg, "Content-Length", "%d", len+2);
|
|
|
|
sip_add_tx_msg_sdp_line(tx_msg, "", "%s", p_xml);
|
|
|
|
tx_msg->remote_ip = inet_addr(p_user->server_ipstr);
|
|
tx_msg->remote_port = htons(p_user->server_port);
|
|
|
|
return tx_msg;
|
|
}
|
|
|
|
BOOL gb28181_record_info_res_build(GB28181_RECORD_INFO_REQ * p_req, GB28181_RECORD_INFO_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>RecordInfo</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Name>HTIPC</Name>\r\n"
|
|
"<SumNum>%d</SumNum>\r\n",
|
|
p_req->hdr.SN, p_req->hdr.DeviceID, p_res->SumNum);
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "<RecordList Num=\"%d\">\r\n", p_res->Num);
|
|
|
|
for (int i = 0; i < p_res->Num; i++)
|
|
{
|
|
char ststr[32], etstr[32];
|
|
GB28181_RECORD_INFO * p_info = &p_res->RecordList[i];
|
|
|
|
get_tstring_by_time(p_info->StartTime, ststr, sizeof(ststr));
|
|
get_tstring_by_time(p_info->EndTime, etstr, sizeof(etstr));
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Item>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Name>%s</Name>\r\n",
|
|
p_info->DeviceID,
|
|
p_info->Name);
|
|
|
|
if (p_info->FilePathFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<FilePath>%s</FilePath>\r\n",
|
|
p_info->FilePath);
|
|
}
|
|
|
|
if (p_info->AddressFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Address>%s</Address>\r\n",
|
|
p_info->Address);
|
|
}
|
|
|
|
if (p_info->StartTimeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<StartTime>%s</StartTime>\r\n",
|
|
ststr);
|
|
}
|
|
|
|
if (p_info->EndTimeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<EndTime>%s</EndTime>\r\n",
|
|
etstr);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "<Secrecy>%d</Secrecy>\r\n", p_info->Secrecy);
|
|
|
|
if (p_info->TypeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Type>%s</Type>\r\n",
|
|
p_info->Type);
|
|
}
|
|
|
|
if (p_info->RecorderIDFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<RecorderID>%s</RecorderID>\r\n",
|
|
p_info->RecorderID);
|
|
}
|
|
|
|
if (p_info->FileSizeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<FileSize>%d</FileSize>\r\n",
|
|
p_info->FileSize);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "</Item>\r\n");
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "</RecordList>\r\n");
|
|
offset += snprintf(xml+offset, tlen-offset, "</Response>\r\n");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_status_res_build(GB28181_DEVICE_STATUS_REQ * p_req, GB28181_DEVICE_STATUS_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
char timestr[32];
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
get_tstring_by_time(p_res->DeviceTime, timestr, sizeof(timestr));
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>DeviceStatus</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Result>%s</Result>\r\n"
|
|
"<Online>%s</Online>\r\n"
|
|
"<Status>%s</Status>\r\n",
|
|
p_req->hdr.SN, p_user->user_name,
|
|
p_res->Result == RESULT_OK ? "OK" : "ERROR",
|
|
p_res->Online ? "ONLINE" : "OFFLINE",
|
|
p_res->Status == RESULT_OK ? "OK" : "ERROR");
|
|
|
|
if (p_res->EncodeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Encode>%s</Encode>\r\n",
|
|
p_res->Encode == STATUS_ON ? "ON" : "OFF");
|
|
}
|
|
|
|
if (p_res->RecordFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Record>%s</Record>\r\n",
|
|
p_res->Record == STATUS_ON ? "ON" : "OFF");
|
|
}
|
|
|
|
if (p_res->DeviceTimeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<DeviceTime>%s</DeviceTime>\r\n",
|
|
timestr);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "</Response>\r\n");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_info_res_build(GB28181_DEVICE_INFO_REQ * p_req, GB28181_DEVICE_INFO_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>DeviceInfo</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<DeviceName>%s</DeviceName>\r\n"
|
|
"<Result>%s</Result>\r\n",
|
|
p_req->hdr.SN, p_user->user_name,
|
|
p_res->DeviceName,
|
|
p_res->Result == RESULT_OK ? "OK" : "ERROR");
|
|
|
|
if (p_res->ManufacturerFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Manufacturer>%s</Manufacturer>\r\n",
|
|
p_res->Manufacturer);
|
|
}
|
|
|
|
if (p_res->ModelFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Model>%s</Model>\r\n",
|
|
p_res->Model);
|
|
}
|
|
|
|
if (p_res->FirmwareFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Firmware>%s</Firmware>\r\n",
|
|
p_res->Firmware);
|
|
}
|
|
|
|
if (p_res->ChannelFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Channel>%d</Channel>\r\n",
|
|
p_res->Channel);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "</Response>\r\n");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int gb28181_device_ex_xml_build(char * xml, int tlen, GB28181_DEVICE_EX * p_res)
|
|
{
|
|
int offset = 0;
|
|
|
|
if (p_res->PTZTypeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<PTZType>%d</PTZType>\r\n", p_res->PTZType);
|
|
}
|
|
|
|
if (p_res->PositionTypeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<PositionType>%d</PositionType>\r\n", p_res->PositionType);
|
|
}
|
|
|
|
if (p_res->RoomTypeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<RoomType>%d</RoomType>\r\n", p_res->RoomType);
|
|
}
|
|
|
|
if (p_res->UseTypeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<UseType>%d</UseType>\r\n", p_res->UseType);
|
|
}
|
|
|
|
if (p_res->SupplyLightTypeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<SupplyLightType>%d</SupplyLightType>\r\n", p_res->SupplyLightType);
|
|
}
|
|
|
|
if (p_res->DirectionTypeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<DirectionType>%d</DirectionType>\r\n", p_res->DirectionType);
|
|
}
|
|
|
|
if (p_res->ResolutionFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Resolution>%s</Resolution>\r\n", p_res->Resolution);
|
|
}
|
|
|
|
if (p_res->BusinessGroupIDFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<BusinessGroupID>%s</BusinessGroupID>\r\n", p_res->BusinessGroupID);
|
|
}
|
|
|
|
if (p_res->DownloadSpeedFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<DownloadSpeed>%s</DownloadSpeed>\r\n", p_res->DownloadSpeed);
|
|
}
|
|
|
|
if (p_res->SVCSpaceSupportModeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<SVCSpaceSupportMode>%d</SVCSpaceSupportMode>\r\n", p_res->SVCSpaceSupportMode);
|
|
}
|
|
|
|
if (p_res->SVCTimeSupportModeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<SVCTimeSupportMode>%d</SVCTimeSupportMode>\r\n", p_res->SVCTimeSupportMode);
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
int gb28181_device_xml_build(char * xml, int tlen, GB28181_DEVICE * p_res)
|
|
{
|
|
int offset = 0;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Name>%s</Name>\r\n"
|
|
"<Manufacturer>%s</Manufacturer>\r\n"
|
|
"<Model>%s</Model>\r\n"
|
|
"<Owner>%s</Owner>\r\n"
|
|
"<CivilCode>%s</CivilCode>\r\n",
|
|
p_res->DeviceID,
|
|
p_res->Name,
|
|
p_res->Manufacturer,
|
|
p_res->Model,
|
|
p_res->Owner,
|
|
p_res->CivilCode);
|
|
|
|
if (p_res->BlockFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Block>%s</Block>\r\n", p_res->Block);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Address>%s</Address>\r\n"
|
|
"<Parental>%d</Parental>\r\n"
|
|
"<ParentID>%s</ParentID>\r\n",
|
|
p_res->Address,
|
|
p_res->Parental,
|
|
p_res->ParentID);
|
|
|
|
if (p_res->SafetyWayFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<SafetyWay>%d</SafetyWay>\r\n", p_res->SafetyWay);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "<RegisterWay>%d</RegisterWay>\r\n", p_res->RegisterWay);
|
|
|
|
if (p_res->CertNumFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<CertNum>%s</CertNum>\r\n", p_res->CertNum);
|
|
}
|
|
|
|
if (p_res->CertifiableFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Certifiable>%d</Certifiable>\r\n", p_res->Certifiable);
|
|
}
|
|
|
|
if (p_res->ErrCodeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<ErrCode>%d</ErrCode>\r\n", p_res->ErrCode);
|
|
}
|
|
|
|
if (p_res->EndTimeFlag)
|
|
{
|
|
char str[32];
|
|
get_tstring_by_time(p_res->EndTime, str, sizeof(str));
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "<EndTime>%s</EndTime>\r\n", str);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "<Secrecy>%d</Secrecy>\r\n", p_res->Secrecy);
|
|
|
|
if (p_res->IPAddressFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<IPAddress>%s</IPAddress>\r\n", p_res->IPAddress);
|
|
}
|
|
|
|
if (p_res->PortFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Port>%d</Port>\r\n", p_res->Port);
|
|
}
|
|
|
|
if (p_res->PasswordFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Password>%s</Password>\r\n", p_res->Password);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Status>%s</Status>\r\n",
|
|
p_res->Status == STATUS_ON ? "ON" : "OFF");
|
|
|
|
if (p_res->LongitudeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Longitude>%f</Longitude>\r\n", p_res->Longitude);
|
|
}
|
|
|
|
if (p_res->LatitudeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Latitude>%f</Latitude>\r\n", p_res->Latitude);
|
|
}
|
|
|
|
if (p_res->InfoFlag)
|
|
{
|
|
offset += gb28181_device_ex_xml_build(xml+offset, tlen-offset, &p_res->Info);
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
BOOL gb28181_catalog_res_build(GB28181_CATALOG_REQ * p_req, GB28181_CATALOG_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>Catalog</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<SumNum>%d</SumNum>\r\n"
|
|
"<DeviceList Num=\"%d\">\r\n",
|
|
p_req->hdr.SN, p_user->user_name,
|
|
p_res->SumNum, p_res->Num);
|
|
|
|
for (int i = 0; i < p_res->Num; i++)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Item>\r\n");
|
|
offset += gb28181_device_xml_build(xml+offset, tlen-offset, &p_res->DeviceList[i]);
|
|
offset += snprintf(xml+offset, tlen-offset, "</Item>\r\n");
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "</DeviceList>\r\n");
|
|
offset += snprintf(xml+offset, tlen-offset, "</Response>\r\n");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_config_res_build(GB28181_CONFIG_REQ * p_req, GB28181_CONFIG_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
if (p_res->BasicParamFlag)
|
|
{
|
|
offset = snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>ConfigDownload</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Result>%s</Result>\r\n",
|
|
p_req->hdr.SN, p_req->hdr.DeviceID,
|
|
p_res->Result == RESULT_OK ? "OK" : "ERROR");
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "<BasicParam>\r\n");
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Name>%s</Name>\r\n"
|
|
"<Expiration>%d</Expiration>\r\n"
|
|
"<HeartBeatInterval>%d</HeartBeatInterval>\r\n"
|
|
"<HeartBeatCount>%d</HeartBeatCount>\r\n",
|
|
p_res->BasicParam.Name,
|
|
p_res->BasicParam.Expiration,
|
|
p_res->BasicParam.HeartBeatInterval,
|
|
p_res->BasicParam.HeartBeatCount);
|
|
|
|
if (p_res->BasicParam.PositionCapabilityFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<PositionCapability>%d</PositionCapability>\r\n",
|
|
p_res->BasicParam.PositionCapability);
|
|
}
|
|
|
|
if (p_res->BasicParam.LongitudeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Longitude>%f</Longitude>\r\n",
|
|
p_res->BasicParam.Longitude);
|
|
}
|
|
|
|
if (p_res->BasicParam.LatitudeFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Latitude>%f</Latitude>\r\n",
|
|
p_res->BasicParam.Latitude);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "</BasicParam>\r\n");
|
|
offset += snprintf(xml+offset, tlen-offset, "</Response>\r\n");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
}
|
|
|
|
if (p_res->VideoParamOptFlag)
|
|
{
|
|
offset = snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>ConfigDownload</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Result>%s</Result>\r\n",
|
|
p_req->hdr.SN, p_req->hdr.DeviceID,
|
|
p_res->Result == RESULT_OK ? "OK" : "ERROR");
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "<VideoParamOpt>\r\n");
|
|
|
|
if (p_res->VideoParamOpt.DownloadSpeedFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<DownloadSpeed>%s</DownloadSpeed>\r\n",
|
|
p_res->VideoParamOpt.DownloadSpeed);
|
|
}
|
|
|
|
if (p_res->VideoParamOpt.ResolutionFlag)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<Resolution>%s</Resolution>\r\n",
|
|
p_res->VideoParamOpt.Resolution);
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "</VideoParamOpt>\r\n");
|
|
offset += snprintf(xml+offset, tlen-offset, "</Response>\r\n");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int gb28181_preset_xml_build(char * xml, int tlen, GB28181_PRESET * p_res)
|
|
{
|
|
int offset = 0;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<PresetID>%s</PresetID>\r\n"
|
|
"<PresetName>%s</PresetName>\r\n",
|
|
p_res->PresetID, p_res->PresetName);
|
|
|
|
return offset;
|
|
}
|
|
|
|
BOOL gb28181_preset_res_build(GB28181_PRESET_REQ * p_req, GB28181_PRESET_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>PresetQuery</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<PresetList Num=\"%d\">\r\n",
|
|
p_req->hdr.SN,
|
|
p_user->user_name,
|
|
p_res->Num);
|
|
|
|
for (int i = 0; i < p_res->Num; i++)
|
|
{
|
|
offset += snprintf(xml+offset, tlen-offset, "<Item>\r\n");
|
|
offset += gb28181_preset_xml_build(xml+offset, tlen-offset, &p_res->PresetList[i]);
|
|
offset += snprintf(xml+offset, tlen-offset, "</Item>\r\n");
|
|
}
|
|
|
|
offset += snprintf(xml+offset, tlen-offset, "</PresetList>\r\n");
|
|
offset += snprintf(xml+offset, tlen-offset, "</Response>\r\n");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_control_res_build(GB28181_DEVICE_CONTROL_REQ * p_req, GB28181_DEVICE_CONTROL_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>DeviceControl</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Result>%s</Result>\r\n"
|
|
"</Response>\r\n",
|
|
p_req->hdr.SN,
|
|
p_user->user_name,
|
|
p_res->Result == RESULT_OK ? "OK" : "ERROR");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_config_res_build(GB28181_DEVICE_CONFIG_REQ * p_req, GB28181_DEVICE_CONFIG_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>DeviceConfig</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Result>%s</Result>\r\n"
|
|
"</Response>\r\n",
|
|
p_req->hdr.SN,
|
|
p_user->user_name,
|
|
p_res->Result == RESULT_OK ? "OK" : "ERROR");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_broadcast_notify_res_build(GB28181_BROADCAST_NOTIFY_REQ * p_req, GB28181_BROADCAST_NOTIFY_RES * p_res)
|
|
{
|
|
char xml[SIP_MAX_BUFF];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
offset += snprintf(xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Response>\r\n"
|
|
"<CmdType>Broadcast</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Result>%s</Result>\r\n"
|
|
"</Response>\r\n",
|
|
p_req->hdr.SN,
|
|
p_res->DeviceID,
|
|
p_res->Result == RESULT_OK ? "OK" : "ERROR");
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int gb28181_alarm_notify_xml_build(char * p_xml, int tlen, GB28181_ALARM * p_req)
|
|
{
|
|
int offset = 0;
|
|
char timestr[32];
|
|
|
|
get_tstring_by_time(p_req->AlarmTime, timestr, sizeof(timestr));
|
|
|
|
if (g_user.gb28181_sn++ == 0)
|
|
{
|
|
g_user.gb28181_sn = 1;
|
|
}
|
|
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Notify>\r\n"
|
|
"<CmdType>Alarm</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<AlarmPriority>%d</AlarmPriority>\r\n"
|
|
"<AlarmMethod>%s</AlarmMethod>\r\n"
|
|
"<AlarmTime>%s</AlarmTime>\r\n",
|
|
g_user.gb28181_sn,
|
|
p_req->DeviceID,
|
|
p_req->AlarmPriority,
|
|
p_req->AlarmMethod,
|
|
timestr);
|
|
|
|
if (p_req->AlarmDescriptionFlag)
|
|
{
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<AlarmDescription>%s</AlarmDescription>\r\n",
|
|
p_req->AlarmDescription);
|
|
}
|
|
|
|
if (p_req->LongitudeFlag)
|
|
{
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<Longitude>%f</Longitude>\r\n",
|
|
p_req->Longitude);
|
|
}
|
|
|
|
if (p_req->LatitudeFlag)
|
|
{
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<Latitude>%f</Latitude>\r\n",
|
|
p_req->Latitude);
|
|
}
|
|
|
|
if (p_req->InfoFlag)
|
|
{
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<Info>\r\n"
|
|
"<AlarmType>%d</AlarmType>\r\n"
|
|
"</Info>\r\n",
|
|
p_req->Info.AlarmType);
|
|
}
|
|
|
|
offset += snprintf(p_xml+offset, tlen-offset, "</Notify>\r\n");
|
|
|
|
return offset;
|
|
}
|
|
|
|
int gb28181_media_notify_xml_build(char * p_xml, int tlen, GB28181_MEDIA_NOTIFY * p_req)
|
|
{
|
|
int offset = 0;
|
|
|
|
if (g_user.gb28181_sn++ == 0)
|
|
{
|
|
g_user.gb28181_sn = 1;
|
|
}
|
|
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Notify>\r\n"
|
|
"<CmdType>MediaStatus</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<NotifyType>%s</NotifyType>\r\n"
|
|
"</Notify>\r\n",
|
|
g_user.gb28181_sn,
|
|
p_req->DeviceID,
|
|
p_req->NotifyType);
|
|
|
|
return offset;
|
|
}
|
|
|
|
int gb28181_catalog_notify_xml_build(char * p_xml, int tlen, GB28181_CATALOG * p_req)
|
|
{
|
|
int offset = 0;
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
if (g_user.gb28181_sn++ == 0)
|
|
{
|
|
g_user.gb28181_sn = 1;
|
|
}
|
|
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Notify>\r\n"
|
|
"<CmdType>Catalog</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<SumNum>%d</SumNum>\r\n"
|
|
"<DeviceList Num=\"%d\">\r\n",
|
|
g_user.gb28181_sn, p_user->user_name,
|
|
p_req->SumNum, p_req->Num);
|
|
|
|
for (int i = 0; i < p_req->Num; i++)
|
|
{
|
|
offset += snprintf(p_xml+offset, tlen-offset, "<Item>\r\n");
|
|
offset += gb28181_device_xml_build(p_xml+offset, tlen-offset, &p_req->DeviceList[i]);
|
|
offset += snprintf(p_xml+offset, tlen-offset, "</Item>\r\n");
|
|
}
|
|
|
|
offset += snprintf(p_xml+offset, tlen-offset, "</DeviceList>\r\n");
|
|
offset += snprintf(p_xml+offset, tlen-offset, "</Notify>\r\n");
|
|
|
|
return offset;
|
|
}
|
|
|
|
int gb28181_mobile_position_notify_xml_build(char * p_xml, int tlen, GB28181_MOBILE_POSITION * p_req)
|
|
{
|
|
int offset = 0;
|
|
char timestr[32] = {'\0'};
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
get_tstring_by_time(p_req->Time, timestr, sizeof(timestr));
|
|
|
|
if (g_user.gb28181_sn++ == 0)
|
|
{
|
|
g_user.gb28181_sn = 1;
|
|
}
|
|
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Notify>\r\n"
|
|
"<CmdType>MobilePosition</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<TargetID>%s</TargetID>\r\n"
|
|
"<Time>%s</Time>\r\n"
|
|
"<Longitude>%lf</Longitude>\r\n"
|
|
"<Latitude>%lf</Latitude>\r\n",
|
|
g_user.gb28181_sn, p_user->user_name, p_req->TargetID,
|
|
timestr, p_req->Longitude, p_req->Latitude);
|
|
|
|
if (p_req->SpeedFlag)
|
|
{
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<Speed>%lf</Speed>\r\n",
|
|
p_req->Speed);
|
|
}
|
|
|
|
if (p_req->DirectionFlag)
|
|
{
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<Direction>%lf</Direction>\r\n",
|
|
p_req->Direction);
|
|
}
|
|
|
|
if (p_req->AltitudeFlag)
|
|
{
|
|
offset += snprintf(p_xml+offset, tlen-offset,
|
|
"<Altitude>%d</Altitude>\r\n",
|
|
p_req->Altitude);
|
|
}
|
|
|
|
offset += snprintf(p_xml+offset, tlen-offset, "</Notify>\r\n");
|
|
|
|
return offset;
|
|
}
|
|
|
|
|
|
/***********************************************************************/
|
|
|
|
void * gb28181_hb_tx_thread(void * argv)
|
|
{
|
|
char * p_xml = (char *)argv;
|
|
|
|
int ret = sip_message_tx("Application/MANSCDP+xml", p_xml, 10*1000);
|
|
if (ret != 200)
|
|
{
|
|
g_user.hb_tm_count++;
|
|
|
|
// g_gb28181_cfg.heartbeat_countµÈÓÚ0£¬²»¼ì²é·þÎñÆ÷ÐÄÌøÏìÓ¦
|
|
|
|
if (g_gb28181_cfg.heartbeat_count != 0 && g_user.hb_tm_count >= g_gb28181_cfg.heartbeat_count)
|
|
{
|
|
log_print(HT_LOG_WARN, "%s, hb_tm_count=%d, heartbeat_count=%d\r\n",
|
|
__FUNCTION__, g_user.hb_tm_count, g_gb28181_cfg.heartbeat_count);
|
|
|
|
// ·þÎñÆ÷¶Ï¿ª»òÎÞЧ£¬³¢ÊÔÖØÐÂ×¢²á
|
|
|
|
g_user.hb_tm_count = 0;
|
|
g_user.usrf_auth = 0;
|
|
g_user.user_state = HSIP_AUTH_IDLE;
|
|
|
|
// ¶Ï¿ªËùÓеĻỰ
|
|
SUA * p_sua = sua_lookup_start();
|
|
while (p_sua)
|
|
{
|
|
cm_sip_cmd((void *) p_sua, PUCMD_DISCONNECT);
|
|
|
|
p_sua = sua_lookup_next(p_sua);
|
|
}
|
|
sua_lookup_stop();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_user.hb_tm_count = 0;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void gb28181_heartbeat_tx(HSIP_USER * p_user)
|
|
{
|
|
static char xml[1024] = {'\0'};
|
|
|
|
if (g_user.gb28181_sn++ == 0)
|
|
{
|
|
g_user.gb28181_sn = 1;
|
|
}
|
|
|
|
sprintf(xml,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Notify>\r\n"
|
|
"<CmdType>Keepalive</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<Status>OK</Status>\r\n"
|
|
"</Notify>\r\n",
|
|
p_user->gb28181_sn,
|
|
p_user->user_name);
|
|
|
|
sys_os_create_thread((void *)gb28181_hb_tx_thread, xml);
|
|
}
|
|
|
|
void gb28181_media_status_tx(HSIP_USER * p_user, GB28181_MEDIA_NOTIFY * p_req)
|
|
{
|
|
char xml[1024];
|
|
int offset = 0;
|
|
|
|
if (g_user.gb28181_sn++ == 0)
|
|
{
|
|
g_user.gb28181_sn = 1;
|
|
}
|
|
|
|
offset = sprintf(xml,
|
|
"<?xml version=\"1.0\"?>\r\n"
|
|
"<Notify>\r\n"
|
|
"<CmdType>MediaStatus</CmdType>\r\n"
|
|
"<SN>%u</SN>\r\n"
|
|
"<DeviceID>%s</DeviceID>\r\n"
|
|
"<NotifyType>%s</NotifyType>\r\n"
|
|
"</Notify>\r\n",
|
|
g_user.gb28181_sn,
|
|
p_req->DeviceID,
|
|
p_req->NotifyType);
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
}
|
|
|
|
void gb28181_alarm_tx(GB28181_ALARM * p_req)
|
|
{
|
|
char xml[1024];
|
|
int offset = 0;
|
|
int tlen = sizeof(xml);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
offset = gb28181_alarm_notify_xml_build(xml, tlen, p_req);
|
|
|
|
HSIP_MSG * tx_msg = gb28181_msg_build(p_user, p_user->server_sip_addr, xml, offset);
|
|
if (NULL == tx_msg)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, message build failed\r\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
user_tx_free_msg(p_user, tx_msg);
|
|
}
|
|
|
|
/***********************************************************************/
|
|
|
|
XMLN * gb28181_msg_parse(HSIP_MSG * rx_msg)
|
|
{
|
|
if (rx_msg->ctx_type != SIP_CTX_XML)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
HDRV * pHdr = sip_find_sdp_headline(rx_msg, "");
|
|
if (NULL == pHdr)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, find headline failed\r\n", __FUNCTION__);
|
|
return NULL;
|
|
}
|
|
|
|
XMLN * p_root = xxx_hxml_parse(pHdr->value_string, rx_msg->sdp_len);
|
|
if (NULL == p_root)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, xml parse failed\r\n", __FUNCTION__);
|
|
return NULL;
|
|
}
|
|
|
|
if (strcasecmp(p_root->name, "Notify") == 0)
|
|
{
|
|
rx_msg->manscdp = MANSCDP_Notify;
|
|
}
|
|
else if(strcasecmp(p_root->name, "Query") == 0)
|
|
{
|
|
rx_msg->manscdp = MANSCDP_Query;
|
|
}
|
|
else if(strcasecmp(p_root->name, "Control") == 0)
|
|
{
|
|
rx_msg->manscdp = MANSCDP_Control;
|
|
}
|
|
else if(strcasecmp(p_root->name, "Response") == 0)
|
|
{
|
|
rx_msg->manscdp = MANSCDP_Response;
|
|
}
|
|
else
|
|
{
|
|
xml_node_del(p_root);
|
|
log_print(HT_LOG_ERR, "%s, invalid command %s\r\n", __FUNCTION__, p_root->name);
|
|
return NULL;
|
|
}
|
|
|
|
XMLN * p_cmdt = xml_node_get(p_root, "CmdType");
|
|
if (NULL == p_cmdt || NULL == p_cmdt->data)
|
|
{
|
|
xml_node_del(p_root);
|
|
log_print(HT_LOG_ERR, "%s, without CmdType\r\n", __FUNCTION__);
|
|
return NULL;
|
|
}
|
|
strncpy(rx_msg->cmdt, p_cmdt->data, sizeof(rx_msg->cmdt)-1);
|
|
|
|
return p_root;
|
|
}
|
|
|
|
BOOL gb28181_req_hdr_parse(XMLN * p_root, GB28181_REQ_HDR * p_req)
|
|
{
|
|
XMLN * p_SN;
|
|
XMLN * p_DeviceID;
|
|
|
|
p_SN = xml_node_get(p_root, "SN");
|
|
if (!p_SN || !p_SN->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without SN\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->SN = strtoul(p_SN->data, NULL, 0);
|
|
|
|
p_DeviceID = xml_node_get(p_root, "DeviceID");
|
|
if (p_DeviceID && p_DeviceID->data)
|
|
{
|
|
strncpy(p_req->DeviceID, p_DeviceID->data, sizeof(p_req->DeviceID)-1);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_record_info_req_parse(XMLN * p_root, GB28181_RECORD_INFO_REQ * p_req)
|
|
{
|
|
XMLN * p_StartTime;
|
|
XMLN * p_EndTime;
|
|
XMLN * p_FilePath;
|
|
XMLN * p_Address;
|
|
XMLN * p_Secrecy;
|
|
XMLN * p_Type;
|
|
XMLN * p_RecorderID;
|
|
XMLN * p_IndistinctQuery;
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &p_req->hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p_StartTime = xml_node_get(p_root, "StartTime");
|
|
if (!p_StartTime || !p_StartTime->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without StartTime\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->StartTime = get_time_by_tstring(p_StartTime->data);
|
|
|
|
p_EndTime = xml_node_get(p_root, "EndTime");
|
|
if (!p_EndTime || !p_EndTime->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without EndTime\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->EndTime = get_time_by_tstring(p_EndTime->data);
|
|
|
|
p_FilePath = xml_node_get(p_root, "FilePath");
|
|
if (p_FilePath && p_FilePath->data)
|
|
{
|
|
p_req->FilePathFlag = 1;
|
|
strncpy(p_req->FilePath, p_FilePath->data, sizeof(p_req->FilePath)-1);
|
|
}
|
|
|
|
p_Address = xml_node_get(p_root, "Address");
|
|
if (p_Address && p_Address->data)
|
|
{
|
|
p_req->AddressFlag = 1;
|
|
strncpy(p_req->Address, p_Address->data, sizeof(p_req->Address)-1);
|
|
}
|
|
|
|
p_Secrecy = xml_node_get(p_root, "Secrecy");
|
|
if (p_Secrecy && p_Secrecy->data)
|
|
{
|
|
p_req->SecrecyFlag = 1;
|
|
p_req->Secrecy = atoi(p_Secrecy->data);
|
|
}
|
|
|
|
p_Type = xml_node_get(p_root, "Type");
|
|
if (p_Type && p_Type->data)
|
|
{
|
|
p_req->TypeFlag = 1;
|
|
strncpy(p_req->Type, p_Type->data, sizeof(p_req->Type)-1);
|
|
}
|
|
|
|
p_RecorderID = xml_node_get(p_root, "RecorderID");
|
|
if (p_RecorderID && p_RecorderID->data)
|
|
{
|
|
p_req->RecorderIDFlag = 1;
|
|
strncpy(p_req->RecorderID, p_RecorderID->data, sizeof(p_req->RecorderID)-1);
|
|
}
|
|
|
|
p_IndistinctQuery = xml_node_get(p_root, "IndistinctQuery");
|
|
if (p_IndistinctQuery && p_IndistinctQuery->data)
|
|
{
|
|
p_req->IndistinctQueryFlag = 1;
|
|
p_req->IndistinctQuery = atoi(p_IndistinctQuery->data);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_catalog_req_parse(XMLN * p_root, GB28181_CATALOG_REQ * p_req)
|
|
{
|
|
XMLN * p_StartTime;
|
|
XMLN * p_EndTime;
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &p_req->hdr))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, parse header failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
p_StartTime = xml_node_get(p_root, "StartTime");
|
|
if (p_StartTime && p_StartTime->data)
|
|
{
|
|
p_req->StartTimeFlag = 1;
|
|
p_req->StartTime = get_time_by_tstring(p_StartTime->data);
|
|
}
|
|
|
|
p_EndTime = xml_node_get(p_root, "EndTime");
|
|
if (p_EndTime && p_EndTime->data)
|
|
{
|
|
p_req->EndTimeFlag = 1;
|
|
p_req->EndTime = get_time_by_tstring(p_EndTime->data);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_config_req_parse(XMLN * p_root, GB28181_CONFIG_REQ * p_req)
|
|
{
|
|
XMLN * p_ConfigType;
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &p_req->hdr))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, parse header failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
p_ConfigType = xml_node_get(p_root, "ConfigType");
|
|
if (!p_ConfigType || !p_ConfigType->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without ConfigType\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
strncpy(p_req->ConfigType, p_ConfigType->data, sizeof(p_req->ConfigType)-1);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_drag_zoom_parse(XMLN * p_root, GB28181_DRAG_ZOOM * p_req)
|
|
{
|
|
XMLN * p_Length;
|
|
XMLN * p_Width;
|
|
XMLN * p_MidPointX;
|
|
XMLN * p_MidPointY;
|
|
XMLN * p_LengthX;
|
|
XMLN * p_LengthY;
|
|
|
|
p_Length = xml_node_get(p_root, "Length");
|
|
if (!p_Length || !p_Length->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without Length\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->Length = atoi(p_Length->data);
|
|
|
|
p_Width = xml_node_get(p_root, "Width");
|
|
if (!p_Width || !p_Width->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without Width\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->Width = atoi(p_Width->data);
|
|
|
|
p_MidPointX = xml_node_get(p_root, "MidPointX");
|
|
if (!p_MidPointX || !p_MidPointX->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without MidPointX\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->MidPointX = atoi(p_MidPointX->data);
|
|
|
|
p_MidPointY = xml_node_get(p_root, "MidPointY");
|
|
if (!p_MidPointY || !p_MidPointY->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without MidPointY\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->MidPointY = atoi(p_MidPointY->data);
|
|
|
|
p_LengthX = xml_node_get(p_root, "LengthX");
|
|
if (!p_LengthX || !p_LengthX->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without LengthX\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->LengthX = atoi(p_LengthX->data);
|
|
|
|
p_LengthY = xml_node_get(p_root, "LengthY");
|
|
if (!p_LengthY || !p_LengthY->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without LengthY\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->LengthY = atoi(p_LengthY->data);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_home_pos_parse(XMLN * p_root, GB28181_HOME_POS * p_req)
|
|
{
|
|
XMLN * p_Enabled;
|
|
XMLN * p_ResetTime;
|
|
XMLN * p_PresetIndex;
|
|
|
|
p_Enabled = xml_node_get(p_root, "Enabled");
|
|
if (!p_Enabled || !p_Enabled->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without Enabled\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
p_req->Enabled = atoi(p_Enabled->data);
|
|
|
|
p_ResetTime = xml_node_get(p_root, "ResetTime");
|
|
if (p_ResetTime && p_ResetTime->data)
|
|
{
|
|
p_req->ResetTimeFlag = 1;
|
|
p_req->ResetTime = atoi(p_ResetTime->data);
|
|
}
|
|
|
|
p_PresetIndex = xml_node_get(p_root, "PresetIndex");
|
|
if (p_PresetIndex && p_PresetIndex->data)
|
|
{
|
|
p_req->PresetIndexFlag = 1;
|
|
p_req->PresetIndex = atoi(p_PresetIndex->data);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_control_req_parse(XMLN * p_root, GB28181_DEVICE_CONTROL_REQ * p_req)
|
|
{
|
|
XMLN * p_PTZCmd;
|
|
XMLN * p_TeleBoot;
|
|
XMLN * p_RecordCmd;
|
|
XMLN * p_GuardCmd;
|
|
XMLN * p_AlarmCmd;
|
|
XMLN * p_IFrameCmd;
|
|
XMLN * p_DragZoomIn;
|
|
XMLN * p_DragZoomOut;
|
|
XMLN * p_HomePosition;
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &p_req->hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p_PTZCmd = xml_node_get(p_root, "PTZCmd");
|
|
if (p_PTZCmd && p_PTZCmd->data)
|
|
{
|
|
p_req->PTZCmdFlag = 1;
|
|
strncpy(p_req->PTZCmd, p_PTZCmd->data, sizeof(p_req->PTZCmd)-1);
|
|
}
|
|
|
|
p_TeleBoot = xml_node_get(p_root, "TeleBoot");
|
|
if (p_TeleBoot && p_TeleBoot->data)
|
|
{
|
|
p_req->TeleBootFlag = 1;
|
|
strncpy(p_req->TeleBoot, p_TeleBoot->data, sizeof(p_req->TeleBoot)-1);
|
|
}
|
|
|
|
p_RecordCmd = xml_node_get(p_root, "RecordCmd");
|
|
if (p_RecordCmd && p_RecordCmd->data)
|
|
{
|
|
p_req->RecordCmdFlag = 1;
|
|
strncpy(p_req->RecordCmd, p_RecordCmd->data, sizeof(p_req->RecordCmd)-1);
|
|
}
|
|
|
|
p_GuardCmd = xml_node_get(p_root, "GuardCmd");
|
|
if (p_GuardCmd && p_GuardCmd->data)
|
|
{
|
|
p_req->GuardCmdFlag = 1;
|
|
strncpy(p_req->GuardCmd, p_GuardCmd->data, sizeof(p_req->GuardCmd)-1);
|
|
}
|
|
|
|
p_AlarmCmd = xml_node_get(p_root, "AlarmCmd");
|
|
if (p_AlarmCmd && p_AlarmCmd->data)
|
|
{
|
|
p_req->AlarmCmdFlag = 1;
|
|
strncpy(p_req->AlarmCmd, p_AlarmCmd->data, sizeof(p_req->AlarmCmd)-1);
|
|
}
|
|
|
|
p_IFrameCmd = xml_node_get(p_root, "IFrameCmd");
|
|
if (p_IFrameCmd && p_IFrameCmd->data)
|
|
{
|
|
p_req->IFameCmdFlag = 1;
|
|
strncpy(p_req->IFameCmd, p_IFrameCmd->data, sizeof(p_req->IFameCmd)-1);
|
|
}
|
|
|
|
p_DragZoomIn = xml_node_get(p_root, "DragZoomIn");
|
|
if (p_DragZoomIn && p_DragZoomIn->data)
|
|
{
|
|
p_req->DragZoomInFlag = gb28181_drag_zoom_parse(p_DragZoomIn, &p_req->DragZoomIn);
|
|
}
|
|
|
|
p_DragZoomOut = xml_node_get(p_root, "DragZoomOut");
|
|
if (p_DragZoomOut && p_DragZoomOut->data)
|
|
{
|
|
p_req->DragZoomOutFlag = gb28181_drag_zoom_parse(p_DragZoomOut, &p_req->DragZoomOut);
|
|
}
|
|
|
|
p_HomePosition = xml_node_get(p_root, "HomePosition");
|
|
if (p_HomePosition && p_HomePosition->data)
|
|
{
|
|
p_req->HomePositionFlag = gb28181_home_pos_parse(p_HomePosition, &p_req->HomePosition);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL gb28181_device_config_req_parse(XMLN * p_root, GB28181_DEVICE_CONFIG_REQ * p_req)
|
|
{
|
|
XMLN * p_BasicParam;
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &p_req->hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p_BasicParam = xml_node_get(p_root, "BasicParam");
|
|
if (p_BasicParam)
|
|
{
|
|
XMLN * p_Name;
|
|
XMLN * p_Expiration;
|
|
XMLN * p_HeartBeatInterval;
|
|
XMLN * p_HeartBeatCount;
|
|
|
|
p_req->BasicParamFlag = 1;
|
|
|
|
p_Name = xml_node_get(p_BasicParam, "Name");
|
|
if (p_Name && p_Name->data)
|
|
{
|
|
p_req->BasicParam.NameFlag = 1;
|
|
strncpy(p_req->BasicParam.Name, p_Name->data, sizeof(p_req->BasicParam.Name)-1);
|
|
}
|
|
|
|
p_Expiration = xml_node_get(p_BasicParam, "Expiration");
|
|
if (p_Expiration && p_Expiration->data)
|
|
{
|
|
p_req->BasicParam.ExpirationFlag = 1;
|
|
p_req->BasicParam.Expiration = atoi(p_Expiration->data);
|
|
}
|
|
|
|
p_HeartBeatInterval = xml_node_get(p_BasicParam, "HeartBeatInterval");
|
|
if (p_HeartBeatInterval && p_HeartBeatInterval->data)
|
|
{
|
|
p_req->BasicParam.HeartBeatIntervalFlag = 1;
|
|
p_req->BasicParam.HeartBeatInterval = atoi(p_HeartBeatInterval->data);
|
|
}
|
|
|
|
p_HeartBeatCount = xml_node_get(p_BasicParam, "HeartBeatCount");
|
|
if (p_HeartBeatCount && p_HeartBeatCount->data)
|
|
{
|
|
p_req->BasicParam.HeartBeatCountFlag = 1;
|
|
p_req->BasicParam.HeartBeatCount = atoi(p_HeartBeatCount->data);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_broadcast_notify_req_parse(XMLN * p_root, GB28181_BROADCAST_NOTIFY_REQ * p_req)
|
|
{
|
|
XMLN * p_SourceID;
|
|
XMLN * p_TargetID;
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &p_req->hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p_SourceID = xml_node_get(p_root, "SourceID");
|
|
if (!p_SourceID || !p_SourceID->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without SourceID\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
strncpy(p_req->SourceID, p_SourceID->data, sizeof(p_req->SourceID)-1);
|
|
|
|
p_TargetID = xml_node_get(p_root, "TargetID");
|
|
if (!p_TargetID || !p_TargetID->data)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, without TargetID\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
strncpy(p_req->TargetID, p_TargetID->data, sizeof(p_req->TargetID)-1);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_alarm_req_parse(XMLN * p_root, GB28181_ALARM_REQ * p_req)
|
|
{
|
|
XMLN * p_StartAlarmPriority;
|
|
XMLN * p_EndAlarmPriority;
|
|
XMLN * p_AlarmMethod;
|
|
XMLN * p_AlarmType;
|
|
XMLN * p_StartAlarmTime;
|
|
XMLN * p_EndAlarmTime;
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &p_req->hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p_StartAlarmPriority = xml_node_get(p_root, "StartAlarmPriority");
|
|
if (p_StartAlarmPriority && p_StartAlarmPriority->data)
|
|
{
|
|
p_req->StartAlarmPriorityFlag = 1;
|
|
p_req->StartAlarmPriority = atoi(p_StartAlarmPriority->data);
|
|
}
|
|
|
|
p_EndAlarmPriority = xml_node_get(p_root, "EndAlarmPriority");
|
|
if (p_EndAlarmPriority && p_EndAlarmPriority->data)
|
|
{
|
|
p_req->EndAlarmPriorityFlag = 1;
|
|
p_req->EndAlarmPriority = atoi(p_EndAlarmPriority->data);
|
|
}
|
|
|
|
p_AlarmMethod = xml_node_get(p_root, "AlarmMethod");
|
|
if (p_AlarmMethod && p_AlarmMethod->data)
|
|
{
|
|
p_req->AlarmMethodFlag = 1;
|
|
strncpy(p_req->AlarmMethod, p_AlarmMethod->data, sizeof(p_req->AlarmMethod)-1);
|
|
}
|
|
|
|
p_AlarmType = xml_node_get(p_root, "AlarmType");
|
|
if (p_AlarmType && p_AlarmType->data)
|
|
{
|
|
p_req->AlarmTypeFlag = 1;
|
|
strncpy(p_req->AlarmType, p_AlarmType->data, sizeof(p_req->AlarmType)-1);
|
|
}
|
|
|
|
p_StartAlarmTime = xml_node_get(p_root, "StartAlarmTime");
|
|
if (p_StartAlarmTime && p_StartAlarmTime->data)
|
|
{
|
|
p_req->StartAlarmTimeFlag = 1;
|
|
p_req->StartAlarmTime = get_time_by_tstring(p_StartAlarmTime->data);
|
|
}
|
|
|
|
p_EndAlarmTime = xml_node_get(p_root, "EndAlarmTime");
|
|
if (p_EndAlarmTime && p_EndAlarmTime->data)
|
|
{
|
|
p_req->EndAlarmTimeFlag = 1;
|
|
p_req->EndAlarmTime = get_time_by_tstring(p_EndAlarmTime->data);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_mobile_position_req_parse(XMLN * p_root, GB28181_MOBILE_POSITION_REQ * p_req)
|
|
{
|
|
XMLN * p_Interval;
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &p_req->hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p_Interval = xml_node_get(p_root, "Interval");
|
|
if (p_Interval && p_Interval->data)
|
|
{
|
|
p_req->IntervalFlag = 1;
|
|
p_req->Interval = atoi(p_Interval->data);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************/
|
|
|
|
BOOL gb28181_record_info_query(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_RECORD_INFO_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_record_info_req_parse(p_root, &req))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_record_info_req_parse failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
int max = 2; // µ¥¸öÏûÏ¢·µ»ØµÄ×î´ó¼Ïñ¸öÊý
|
|
int count = 0;
|
|
|
|
while (1)
|
|
{
|
|
GB28181_RECORD_INFO_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_record_info_res_get(&req, &res, count, max))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_record_info_res_get failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL ret = gb28181_record_info_res_build(&req, &res);
|
|
|
|
if (res.RecordList)
|
|
{
|
|
free(res.RecordList);
|
|
}
|
|
|
|
if (!ret)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
count += res.Num;
|
|
|
|
if (count >= res.SumNum)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
usleep(1000);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_device_status_query(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_DEVICE_STATUS_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &req.hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GB28181_DEVICE_STATUS_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_device_status_res_get(&req, &res))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_device_status_res_get failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
return gb28181_device_status_res_build(&req, &res);
|
|
}
|
|
|
|
BOOL gb28181_device_info_query(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_DEVICE_INFO_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &req.hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GB28181_DEVICE_INFO_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_device_info_res_get(&req, &res))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_device_info_res_get failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
return gb28181_device_info_res_build(&req, &res);
|
|
}
|
|
|
|
BOOL gb28181_catalog_query(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_CATALOG_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_catalog_req_parse(p_root, &req))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
int max = 20; // µ¥¸öÏûÏ¢·µ»ØµÄ×î´óĿ¼¸öÊý
|
|
int count = 0;
|
|
|
|
while (1)
|
|
{
|
|
GB28181_CATALOG_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_catalog_res_get(&req, &res, count, max))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_catalog_res_get failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL ret = gb28181_catalog_res_build(&req, &res);
|
|
|
|
if (res.DeviceList)
|
|
{
|
|
free(res.DeviceList);
|
|
}
|
|
|
|
if (!ret)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
count += res.Num;
|
|
|
|
if (count >= res.SumNum)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
usleep(1000);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL gb28181_config_query(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_CONFIG_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_config_req_parse(p_root, &req))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_config_req_parse failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
GB28181_CONFIG_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_config_res_get(&req, &res))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_config_res_get failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
return gb28181_config_res_build(&req, &res);
|
|
}
|
|
|
|
BOOL gb28181_preset_query(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_PRESET_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_req_hdr_parse(p_root, &req.hdr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GB28181_PRESET_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_preset_res_get(&req, &res))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_preset_res_get failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL ret = gb28181_preset_res_build(&req, &res);
|
|
|
|
if (res.PresetList)
|
|
{
|
|
free(res.PresetList);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL gb28181_query_rx(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
if (strcasecmp(rx_msg->cmdt, "RecordInfo") == 0) // ¼Ïñ²éѯ
|
|
{
|
|
ret = gb28181_record_info_query(rx_msg, p_root);
|
|
}
|
|
else if (strcasecmp(rx_msg->cmdt, "DeviceStatus") == 0) // É豸״̬²éѯ
|
|
{
|
|
ret = gb28181_device_status_query(rx_msg, p_root);
|
|
}
|
|
else if (strcasecmp(rx_msg->cmdt, "DeviceInfo") == 0) // É豸ÐÅÏ¢²éѯ
|
|
{
|
|
ret = gb28181_device_info_query(rx_msg, p_root);
|
|
}
|
|
else if (strcasecmp(rx_msg->cmdt, "Catalog") == 0) // É豸Ŀ¼²éѯ
|
|
{
|
|
ret = gb28181_catalog_query(rx_msg, p_root);
|
|
}
|
|
else if (strcasecmp(rx_msg->cmdt, "ConfigDownload") == 0)// ÅäÖòéѯ
|
|
{
|
|
ret = gb28181_config_query(rx_msg, p_root);
|
|
}
|
|
else if (strcasecmp(rx_msg->cmdt, "PresetQuery") == 0) // Ô¤ÖÃλ²éѯ
|
|
{
|
|
ret = gb28181_preset_query(rx_msg, p_root);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL gb28181_device_control_req(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_DEVICE_CONTROL_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_device_control_req_parse(p_root, &req))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_device_control_req_parse failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
GB28181_DEVICE_CONTROL_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_device_control(&req, &res))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_device_control failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL ret = gb28181_device_control_res_build(&req, &res);
|
|
|
|
// todo : the following code for test
|
|
|
|
if ((req.GuardCmdFlag && strcasecmp(req.GuardCmd, "SetGuard") == 0) ||
|
|
(req.AlarmCmdFlag && strcasecmp(req.AlarmCmd, "ResetAlarm") == 0))
|
|
{
|
|
sleep(3);
|
|
|
|
GB28181_ALARM alarm;
|
|
memset(&alarm, 0, sizeof(alarm));
|
|
|
|
strcpy(alarm.DeviceID, req.hdr.DeviceID);
|
|
alarm.AlarmPriority = 4;
|
|
strcpy(alarm.AlarmMethod, "2");
|
|
alarm.AlarmTime = time(NULL);
|
|
|
|
gb28181_alarm_tx(&alarm);
|
|
}
|
|
else if (req.TeleBootFlag && strcasecmp(req.TeleBoot, "Boot") == 0)
|
|
{
|
|
sleep(3);
|
|
|
|
HSIP_USER * p_user = &g_user;
|
|
|
|
p_user->expires_time = 0;
|
|
|
|
HSIP_MSG * tx_msg = sip_build_register_normal_msg(p_user, inet_addr(p_user->server_ipstr), htons(p_user->server_port));
|
|
user_tx_free_msg(p_user,tx_msg);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL gb28181_device_config_req(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_DEVICE_CONFIG_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_device_config_req_parse(p_root, &req))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_device_config_req_parse failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
GB28181_DEVICE_CONFIG_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_device_config(&req, &res))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_device_config failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
return gb28181_device_config_res_build(&req, &res);
|
|
}
|
|
|
|
BOOL gb28181_control_rx(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
if (strcasecmp(rx_msg->cmdt, "DeviceControl") == 0)
|
|
{
|
|
ret = gb28181_device_control_req(rx_msg, p_root);
|
|
}
|
|
else if (strcasecmp(rx_msg->cmdt, "DeviceConfig") == 0)
|
|
{
|
|
ret = gb28181_device_config_req(rx_msg, p_root);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL gb28181_broadcast_notify_req(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
GB28181_BROADCAST_NOTIFY_REQ req;
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
if (!gb28181_broadcast_notify_req_parse(p_root, &req))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_broadcast_notify_req_parse failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
GB28181_BROADCAST_NOTIFY_RES res;
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
if (!gb28181_broadcast_notify(&req, &res))
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_broadcast_notify failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
return gb28181_broadcast_notify_res_build(&req, &res);
|
|
}
|
|
|
|
BOOL gb28181_notify_rx(HSIP_MSG * rx_msg, XMLN * p_root)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
if (strcasecmp(rx_msg->cmdt, "Broadcast") == 0)
|
|
{
|
|
ret = gb28181_broadcast_notify_req(rx_msg, p_root);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL gb28181_msg_rx(HSIP_MSG * rx_msg)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
XMLN * p_root = gb28181_msg_parse(rx_msg);
|
|
if (p_root == NULL)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, gb28181_msg_parse failed\r\n", __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
|
|
switch(rx_msg->manscdp)
|
|
{
|
|
case MANSCDP_Notify:
|
|
ret = gb28181_notify_rx(rx_msg, p_root);
|
|
break;
|
|
|
|
case MANSCDP_Query:
|
|
ret = gb28181_query_rx(rx_msg, p_root);
|
|
break;
|
|
|
|
case MANSCDP_Control:
|
|
ret = gb28181_control_rx(rx_msg, p_root);
|
|
break;
|
|
|
|
case MANSCDP_Response:
|
|
break;
|
|
}
|
|
|
|
xml_node_del(p_root);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
|