int
match_command_line_opt( char *argvi, CommandLineOpts *options )
{
register char *ptr = argvi;
register int opt ;
if( ptr == NULL )
return -1;
show_debug (__FILE__,__FUNCTION__,__LINE__, "ptr = \"%s\"", ptr);
if( *ptr == '-' )
{
++ptr;
if( *ptr == '-' )
{
++ptr;
show_debug (__FILE__,__FUNCTION__,__LINE__, "ptr = \"%s\"", ptr);
for( opt = 0 ; options[opt].handler ; ++opt )
if( strcmp(options[opt].long_opt, ptr ) == 0 )
break;
}else
{
show_debug (__FILE__,__FUNCTION__,__LINE__, "ptr = \"%s\"", ptr);
for( opt = 0 ; options[opt].handler ; ++opt )
if( options[opt].short_opt )
if( strcmp(options[opt].short_opt, ptr ) == 0 )
break;
}
}else
opt = -1;
if( options[opt].handler == NULL )
opt = -1;
return opt;
}
static int hik_talk_open(struct service *srv, struct talk_info *talk,
talk_handle_t *hdl, media_info_t *info)
{
struct hik_service *hik_srv;
long talk_hanle;
NMP_ASSERT(srv && talk);
if(talk->frm)
{
free(talk->frm);
talk->frm = NULL;
}
talk->frm = (frame_t *)malloc(sizeof(frame_t) + MAX_ENCODE_BUFFER_LEN);
if(!talk->frm)
{
return -1;
}
hik_srv = (hik_service_t *)srv;
talk->handle = hik_get_user_id(&hik_srv->parm);
if (HIK_LOGOUT == hik_get_user_id(&hik_srv->parm))
{
show_debug("dah device is disconnected.\n");
}
else
{
talk->init_g722_encoder = NET_DVR_InitG722Encoder();
talk->init_g722_decoder = NET_DVR_InitG722Decoder();
if(hik_srv->init_g722_decoder == NULL && hik_srv->init_g722_encoder)
{
show_debug("NET_DVR_InitG722Encoder error[%d]\n", NET_DVR_GetLastError());
if(talk->frm)
{
free(talk->frm);
talk->frm = NULL;
}
return -1;
}
talk_hanle = NET_DVR_StartVoiceCom_MR_V30(talk->handle, info->channel + 1,
hik_audio_data_callback, (void *)talk);
if (talk_hanle < 0)
{
show_error("pyd---NET_DVR_StartVoiceCom_MR_V30 fail %d\n", NET_DVR_GetLastError());
if(talk->frm)
{
free(talk->frm);
talk->frm = NULL;
}
return -1;
}
show_info("**********hik talk->handle = %d, talk_handle = %ld\n", talk->handle, talk_hanle);
talk->talk_handle = talk_hanle;
}
return 0;
}
void asdbus_EndSessionOk ()
{
show_debug(__FILE__, __FUNCTION__, __LINE__, "dbus EndSessionOk");
#ifdef HAVE_DBUS_CONTEXT
if (ASDBus.session_conn) {
DBusMessage *message =
dbus_message_new_method_call (SESSIONMANAGER_NAME,
ASDBus.gnomeSessionPath, /*"/org/gnome/SessionManager", */
IFACE_SESSION_PRIVATE,
"EndSessionResponse");
show_debug(__FILE__, __FUNCTION__, __LINE__, "dbus EndSessionResponse to iface = \"%s\", path = \"%s\", manager = \"%s\"",
IFACE_SESSION_PRIVATE, ASDBus.gnomeSessionPath, SESSIONMANAGER_NAME);
if (message) {
DBusMessageIter iter;
char *reason = "";
dbus_bool_t ok = 1;
dbus_uint32_t msg_serial;
dbus_message_iter_init_append (message, &iter);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &ok);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &reason);
dbus_message_set_no_reply (message, TRUE);
if (!dbus_connection_send
(ASDBus.session_conn, message, &msg_serial))
show_error ("Failed to send EndSession indicator.");
else
show_progress ("Sent Ok to end session (time, %ld).", time (NULL));
dbus_message_unref (message);
}
}
#endif
}
static int
hie_record_data_callback(HSTREAM handle, const StreamMediaFrame *strm_data,
DWORD user_data)
{
stream_info_t *strm_info;
hie_rec_strm_t *rec_strm;
NMP_ASSERT(HIE_INVALID_HANDLE != handle);
NMP_ASSERT(strm_data);
NMP_ASSERT(user_data);
strm_info = (stream_info_t*)user_data;
rec_strm = (hie_rec_strm_t*)strm_info;
if (eFrameSysHeader == strm_data->dwFrameType)
{
if (!strm_info->opened && !strm_info->media_size)
{
memcpy(strm_info->media_info, strm_data->cFrameBuffer.pBuffer,
strm_data->cFrameBuffer.dwBufLen);
strm_info->media_size = strm_data->cFrameBuffer.dwBufLen;
}
}
else
{
if (!strm_data->cFrameBuffer.pBuffer)
return 0;
while (1)
{
if (strm_info->opened && rec_strm->enable)
{
if (!test_stream_blockable((gpointer)strm_info->opened,
(gsize)strm_data->cFrameBuffer.dwBufLen))
{//printf("----------->%d\n", (int)strm_data->dwDataSize);
show_debug("channel: %d, len: %d\n", strm_info->channel,
(int)strm_data->cFrameBuffer.dwBufLen);
write_stream_data((gpointer)strm_info->opened,
(gulong)strm_info->ts, (gulong)DEF_TIMESTAMP,
(guint8*)strm_data->cFrameBuffer.pBuffer,
(gsize)strm_data->cFrameBuffer.dwBufLen,
(guint8)strm_data->dwFrameType, (guint8*)NULL,
(gsize)0, (guint8)0);
break;
}
else
{
show_debug("Sleep some times.\n");
usleep(RECORD_PACKET_SLEEP_TIME);
}
}
else
break;
}
}
return 0;
}
static void config_upload_data(int fd, config_backup_t *cfg_bkp)
{
FILE *fpw;
backup_frame_t frame;
int n_read, n_left, seq = 0;
char buf[DEF_BACKUP_FRAME_SIZE];
fpw = fopen(DEF_REVERT_FILE, "w");
if (!fpw)
return ;
n_left = get_backup_left_size(cfg_bkp);
show_debug("left: %d<-----------------------\n", n_left);
while (n_left > 0)
{
n_read = my_recv(fd, &frame, sizeof(backup_frame_t), 0);
if (n_read != sizeof(backup_frame_t))
break;
n_left -= n_read;
if (DEF_REVERT_MAGIC != frame.magic)
break;
if (seq++ != frame.seq)
break;
if (0 >= frame.payload_len)
break;
if (DEF_BACKUP_KEY != frame.secret_key)
break;
n_read = my_recv(fd, buf, frame.payload_len, 0);
if (n_read != frame.payload_len)
break;
config_simple_decrypt(&frame, buf, n_read);
fwrite(buf, 1, n_read, fpw);
n_left -= n_read;
set_backup_left_size(cfg_bkp, n_left);
}
show_debug("left: %d<-----------------------\n", n_left);
fclose(fpw);
if (!n_left)
{
char sys_cmd[DEF_SYS_COMMAND_SIZE];
sprintf(sys_cmd, "tar -jxvf %s -C %s", DEF_REVERT_FILE,
(char*)proxy_get_data_file_path());
system(sys_cmd);
proxy_task_t *task;
task = proxy_new_task(REBOOT_SERVER, NULL, 0, NULL, NULL);
if (task)
proxy_thread_pool_push(task);
}
}
static void asdbus_set_dbus_timer (struct timeval *expires, DBusTimeout *timeout) {
int interval = dbus_timeout_get_interval(timeout);
gettimeofday (expires, NULL);
tv_add_ms(expires, interval);
show_debug(__FILE__,__FUNCTION__,__LINE__,"time = %d, adding dbus timeout data=%p, interval = %d\n", time(NULL), timeout, interval);
timer_new (interval, asdbus_handle_timer, timeout);
}
static int hbn_talk_recv(struct service *srv, talk_info_t *talk, char *data, int len, media_info_t *info)
{
int ret = -1;
hbn_service_t *hbn_srv;
unsigned int in_data_len = 0;
frame_t *frm = NULL;
NMP_ASSERT(srv && talk && data);
frm = (talk_frame_hdr_t*)data;
if(ntohl(frm->magic) != TALK_MAGIC)
{
show_warn("magic[0x%x] error", ntohl(frm->magic));
return -1;
}
in_data_len = ntohl(frm->frame_length);
printf("====================hbn_talk_recv len = %d\n", in_data_len);
hbn_srv = (hbn_service_t*)srv;
ret = HB_NET_VoiceComSendData(talk->talk_handle, (char *)frm->frame_data, in_data_len);
if(ret == FALSE)
{
show_debug("HB_NET_VoiceComSendData!, error = %d, user_id = %d\n",
(int)HB_NET_GetLastError(), (int )hbn_get_user_id(&hbn_srv->parm));
return -1;
}
return 0;
}
static dbus_bool_t add_watch(DBusWatch *w, void *data)
{
if (!dbus_watch_get_enabled(w))
return TRUE;
ASDBusFd *fd = safecalloc (1, sizeof(ASDBusFd));
fd->fd = dbus_watch_get_unix_fd(w);
unsigned int flags = dbus_watch_get_flags(w);
if (get_flags(flags, DBUS_WATCH_READABLE))
fd->readable = True;
/*short cond = EV_PERSIST;
if (flags & DBUS_WATCH_READABLE)
cond |= EV_READ;
if (flags & DBUS_WATCH_WRITABLE)
cond |= EV_WRITE; */
// TODO add to the list of FDs
dbus_watch_set_data(w, fd, NULL);
if (ASDBus.watchFds == NULL)
ASDBus.watchFds = create_asvector (sizeof(ASDBusFd*));
append_vector(ASDBus.watchFds, &fd, 1);
show_debug(__FILE__,__FUNCTION__,__LINE__,"added dbus watch fd=%d watch=%p readable =%d\n", fd->fd, w, fd->readable);
return TRUE;
}
int jny_proc_get_device_cfg(int user_id, void *parm, proxy_sdk_t *sdk_info)
{printf("---------------jny_proc_get_device_cfg-----enter\n");
int ret;
char addr[MAX_IP_LEN];
ST_InetAddr p_stAddr;
ST_DeviceSummaryParam p_pstDeviceSummaryInfo;
NMP_ASSERT(parm && sdk_info);
memset(addr, 0, sizeof(addr));
if (!proxy_resolve_host_immediate((const char*)sdk_info->dev_host, addr, sizeof(addr)))
{
show_debug("Proxy device ipaddr is not found!!!!!!!!!!!!!!\n");
return -1;
}
memset(&p_stAddr, 0, sizeof(ST_InetAddr));
memcpy(p_stAddr.szHostIP, addr, strlen(addr));
p_stAddr.nPORT = sdk_info->dev_port;
p_stAddr.nIPProtoVer = IPPROTO_V4;
memset(&p_pstDeviceSummaryInfo, 0, sizeof(ST_DeviceSummaryParam));
ret = Remote_System_GetSystemInfo(user_id, p_stAddr, &p_pstDeviceSummaryInfo, UDP);
if(ret != SN_SUCCESS)
{
jny_print_error(ret);
return -1;
}
memcpy(parm, (void *)&p_pstDeviceSummaryInfo, sizeof(ST_DeviceSummaryParam));
return 0;
}
int jny_set_user_id(jny_service *jny_srv, int user_id)
{
int ret, old;
jny_parm *pm;
NMP_ASSERT(jny_srv);
pm = &jny_srv->parm;
nmp_mutex_lock(pm->lock);
old = pm->user_id;
pm->user_id = user_id;
nmp_mutex_unlock(pm->lock);
if (JNY_LOGOUT != old)
{
ret = Remote_Camera2_Close(old);
show_debug("Remote_Camera2_Close: %s<-------------------------------\n",
(ret == SN_SUCCESS) ? "Success" : "Failure");
jny_logout(old);
}
if (JNY_LOGOUT == user_id)
jny_stop_all_stream(&jny_srv->rtsp);
return user_id;
}
void check_all_prompts(struct session *ses, char *original, char *line)
{
struct listroot *root = ses->list[LIST_PROMPT];
struct listnode *node;
if (!HAS_BIT(ses->flags, SES_FLAG_SPLIT))
{
return;
}
for (root->update = 0 ; root->update < root->used ; root->update++)
{
if (check_one_regexp(ses, root->list[root->update], line, original, 0))
{
node = root->list[root->update];
if (*node->right)
{
substitute(ses, node->right, original, SUB_ARG);
substitute(ses, original, original, SUB_VAR|SUB_FUN|SUB_COL|SUB_ESC);
}
show_debug(ses, LIST_PROMPT, "#DEBUG PROMPT {%s}", node->left);
do_one_prompt(ses, original, atoi(node->pr));
SET_BIT(ses->flags, SES_FLAG_GAG);
}
}
}
static int hbn_talk_close(struct service *srv, talk_info_t *talk)
{
int ret = -1;
hbn_service_t *hbn_srv;
NMP_ASSERT(srv && talk);
if(talk->frm)
{
nmp_dealloc(talk->frm, sizeof(frame_t) + MAX_ENCODE_BUFFER_LEN);
talk->frm = NULL;
}
if(talk->pri_data)
{
nmp_dealloc(talk->pri_data, sizeof(HB_NET_VOICECOMPARAM));
talk->pri_data = NULL;
}
hbn_srv = (hbn_service_t*)srv;
if (HB_NET_StopVoiceCom(talk->talk_handle))
{
ret = 0;
}
else
{
show_debug("------------HB_NET_StopVoiceCom (%d)\n", (int)HB_NET_GetLastError());
}
return ret;
}
char *
proxy_resolve_host_immediate(const char *host, char *addr, size_t size)
{
int err;
struct sockaddr_in socket;
NMP_ASSERT(host && addr && !strlen(addr));
find_host_node_by_host(hlist_manager, host, addr, size);
if (!strlen(addr))
{
memset(&socket, 0, sizeof(struct sockaddr_in));
err = nmp_resolve_host(&socket, (char*)host, 0);
if (err)
{
show_debug("nmp_resolve_host[%s] err: %d\n", host, err);
return NULL;
}
inet_ntop(socket.sin_family, &socket.sin_addr,
addr, size);
}
else
return NULL;
return addr;
}
static void config_download_data(int fd, config_backup_t *cfg_bkp)
{
FILE *fpr;
backup_frame_t frame;
int n_read, n_left, n_write;
char buf[DEF_BACKUP_FRAME_SIZE];
fpr = fopen(DEF_BACKUP_FILE, "r");
if (!fpr)
return ;
frame.magic = DEF_REVERT_MAGIC;
frame.seq = 0;
frame.payload_len = DEF_BACKUP_FRAME_SIZE;
frame.secret_key = DEF_BACKUP_KEY;
n_left = get_backup_left_size(cfg_bkp);
show_debug("left: %d<-----------------------\n", n_left);
while (n_left > 0)
{
n_left -= sizeof(backup_frame_t);
n_read = MIN(n_left, DEF_BACKUP_FRAME_SIZE);
frame.payload_len = fread(buf, 1, n_read, fpr);
config_simple_encrypt(&frame, buf, frame.payload_len);
if (0 > send(fd, &frame, sizeof(backup_frame_t), 0))
{
show_info("recv error.[err: %d]\n", errno);
break;
}
n_write = send(fd, buf, frame.payload_len, 0);
if (0 > n_write)
{
show_info("recv error.[err: %d]\n", errno);
break;
}
n_left -= n_write;
frame.seq++;
}
show_debug("left: %d<-----------------------\n", n_left);
fclose(fpr);
}
static void toggle_watch(DBusWatch *w, void *data)
{
show_debug(__FILE__,__FUNCTION__,__LINE__,"toggling dbus watch watch=%p\n", w);
if (dbus_watch_get_enabled(w))
add_watch(w, data);
else
remove_watch(w, data);
}
static void remove_watch(DBusWatch *w, void *data)
{
ASDBusFd* fd = dbus_watch_get_data(w);
vector_remove_elem (ASDBus.watchFds, &fd);
dbus_watch_set_data(w, NULL, NULL);
show_debug(__FILE__,__FUNCTION__,__LINE__,"removed dbus watch watch=%p\n", w);
}
static __inline__ int bsm_logout(int user_id)
{
if (HI_NET_DEV_Logout((HI_U32)user_id))
{
show_debug("bsm_logout() successful, user_id: %d\n", user_id);
return 0;
}
else
return -1;
}
void
standard_version (void)
{
show_debug (__FILE__,__FUNCTION__,__LINE__, "version = \"%s\", MyVersionFunc = %p", VERSION, MyVersionFunc);
if( MyVersionFunc )
MyVersionFunc();
else
printf ("%s version %s\n", MyClass, VERSION);
}
static __inline__ int
hie_logout(HUSER user_id)
{
if (!HieClient_UserLogout(user_id))
{
show_debug("HieClient_UserLogout() successful, user_id: %p\n", user_id);
return 0;
}
else
return -1;
}
int check_all_aliases(struct session *ses, char *input) {
struct listnode *node;
struct listroot *root;
char line[BUFFER_SIZE], tmp[BUFFER_SIZE], *arg;
int i;
root = ses->list[LIST_ALIAS];
if (HAS_BIT(root->flags, LIST_FLAG_IGNORE)) {
return FALSE;
}
for (i = 1; i < 100; i++) {
if (*gtd->vars[i]) {
RESTRING(gtd->vars[i], "");
}
}
substitute(ses, input, line, SUB_VAR | SUB_FUN);
for (root->update = 0; root->update < root->used; root->update++) {
if (check_one_regexp(ses, root->list[root->update], line, line, PCRE_ANCHORED)) {
node = root->list[root->update];
i = strlen(node->left);
if (!strncmp(node->left, line, i)) {
if (line[i] && line[i] != ' ') {
continue;
}
arg = get_arg_in_braces(ses, line, tmp, FALSE);
RESTRING(gtd->vars[0], arg) for (i = 1; i < 100 && *arg; i++) {
arg = get_arg_in_braces(ses, arg, tmp, FALSE);
RESTRING(gtd->vars[i], tmp);
}
}
substitute(ses, node->right, tmp, SUB_ARG);
if (!strncmp(node->left, line, strlen(node->left))
&& !strcmp(node->right, tmp) && *gtd->vars[0]) {
sprintf(input, "%s %s", tmp, gtd->vars[0]);
} else {
sprintf(input, "%s", tmp);
}
show_debug(ses, LIST_ALIAS, "#DEBUG ALIAS {%s} {%s}", node->left, gtd->vars[0]);
return TRUE;
}
}
static __inline__ int dah_logout(long user_id)
{
CLIENT_StopListen(user_id);
if (CLIENT_Logout(user_id))
{
show_debug("dah_logout() successful, user_id: %d\n", (int)user_id);
return 0;
}
else
return -1;
}
static _asdbus_add_match (DBusConnection *conn, const char* iface, const char* member) {
char match[256];
sprintf(match, member?"type='signal',interface='%s',member='%s'":"type='signal',interface='%s'", iface, member);
DBusError error;
dbus_error_init(&error);
dbus_bus_add_match(conn, match, &error);
show_debug(__FILE__,__FUNCTION__,__LINE__, "added match :[%s]", match);
if (dbus_error_is_set(&error)) {
show_error("dbus_bus_add_match() %s failed: %s\n", member, error.message);
dbus_error_free(&error);
}
}
static void
jny_stop_real_stream(struct stream_info *strm_info)
{show_debug("%s()<------------------------\n", __FUNCTION__);
NMP_ASSERT(strm_info);
if (-1 != strm_info->handle)
{
Remote_Camera2_Close(strm_info->handle);
strm_info->handle = -1;
}
return ;
}
static void
dah_stop_record_stream(stream_info_t *strm_info)
{show_debug("%s()<------------------------\n", __FUNCTION__);
NMP_ASSERT(strm_info);
if (DAH_INVALID_HANDLE != strm_info->handle)
{
CLIENT_StopPlayBack((LONG)strm_info->handle);
strm_info->handle = DAH_INVALID_HANDLE;
}
return ;
}
static void
bsm_stop_record_stream(stream_info_t *strm_info)
{show_debug("%s()<------------------------\n", __FUNCTION__);
NMP_ASSERT(strm_info);
if (BSM_INVALID_HANDLE != strm_info->handle)
{
//
strm_info->handle = BSM_INVALID_HANDLE;
}
return ;
}
static void
bsm_stop_real_stream(stream_info_t *strm_info)
{show_debug("%s()<------------------------\n", __FUNCTION__);
NMP_ASSERT(strm_info);
if (BSM_INVALID_HANDLE != strm_info->handle)
{
HI_NET_DEV_StopStream((HI_U32)strm_info->handle);
strm_info->handle = BSM_INVALID_HANDLE;
}
return ;
}
void asdbus_handleDispatches (){
#ifdef ASDBUS_DISPATCH
void *data;
while ((data = extract_first_bidirelem (ASDBus.dispatches)) != NULL){
ASDBusDispatch *d = (ASDBusDispatch*)data;
while (dbus_connection_get_dispatch_status(d->data) == DBUS_DISPATCH_DATA_REMAINS){
dbus_connection_dispatch(d->data);
show_debug(__FILE__,__FUNCTION__,__LINE__,"dispatching dbus data=%p\n", d->data);
}
free (d);
}
#endif
}
static __inline__ void dah_login(dah_service_t *dah_srv)
{
char addr[MAX_IP_LEN];
int state, error = 0;
int user_id = DAH_LOGOUT;
proxy_sdk_t sdk_info;
NMP_ASSERT(dah_srv);
if (proxy_get_device_private(dah_srv->owner, DEV_PRI_PRX_SDK, &sdk_info))
{
BUG();
}
memset(addr, 0, sizeof(addr));
if (proxy_resolve_host_immediate((const char*)sdk_info.dev_host, addr, sizeof(addr)))
{
user_id = CLIENT_Login(addr, sdk_info.dev_port,
sdk_info.username, sdk_info.password,
&dah_srv->dah_info, &error);
}
else
show_warn("Device host '%s' unsolved.\n", sdk_info.dev_host);
if (DAH_LOGOUT != user_id)
{
CLIENT_StartListen(user_id);
state = DAH_LOGIN;
error = 0;
show_debug("dah_login() successful, user_id: %d\n", user_id);
}
else
{
state = DAH_LOGOUT;
//error = ;
if (strlen(addr))
{
show_warn("dah_login(deviceID:%d) failure[%s:%s @ %s:%d]. Error: %d\n",
dah_srv->owner->fastenings.dev_id,
sdk_info.username, sdk_info.password,
addr, sdk_info.dev_port, error);
}
}
dah_set_user_id(dah_srv, user_id);
dah_set_state(dah_srv, (DAH_STATE_E)state, error);
return ;
}
static __inline__ void bsm_login(bsm_service_t *bsm_srv)
{
char addr[MAX_IP_LEN];
int state, error = 0;
int user_id = BSM_LOGOUT;
proxy_sdk_t sdk_info;
NMP_ASSERT(bsm_srv);
if (proxy_get_device_private(bsm_srv->owner, DEV_PRI_PRX_SDK, &sdk_info))
{
BUG();
}
memset(addr, 0, sizeof(addr));
if (proxy_resolve_host_immediate((const char*)sdk_info.dev_host, addr, sizeof(addr)))
{
error = HI_NET_DEV_Login((HI_U32*)&user_id,
sdk_info.username, sdk_info.password,
addr, sdk_info.dev_port);
}
else
show_warn("Device host '%s' unsolved.\n", sdk_info.dev_host);
if (BSM_LOGOUT != user_id)
{
state = BSM_LOGIN;
error = 0;
show_debug("bsm_login() successful, user_id: %d\n", user_id);
}
else
{
state = BSM_LOGOUT;
//error = ;
if (strlen(addr))
{
show_warn("bsm_login(deviceID:%d) failure[%s:%s @ %s:%d]. Error: %d\n",
bsm_srv->owner->fastenings.dev_id,
sdk_info.username, sdk_info.password,
addr, sdk_info.dev_port, error);
}
}
bsm_set_user_id(bsm_srv, user_id);
bsm_set_state(bsm_srv, (BSM_STATE_E)state, error);
return ;
}
static __inline__ int jny_logout(long user_id)
{
int ret;
ret = Remote_Nvd_UnInit(user_id);
if (ret != SN_SUCCESS)
{
show_debug("jny_logout() successful, user_id: %d\n", (int)user_id);
return 0;
}
else
{
return -1;
}
}
