#include <stdio.h>
|
#include <stdlib.h>
|
#include <assert.h>
|
#include <time.h>
|
#include <signal.h>
|
|
#include "proto_comm.h"
|
#include "proto_dbg.h"
|
|
int timer_init(timer_t *timer_index, void (*timer_handler)(union sigval para)) {
|
struct sigevent event;
|
timer_t timer;
|
int ret;
|
|
memset(&event, 0x00, sizeof(event));
|
event.sigev_value.sival_int = ENABLE;
|
event.sigev_value.sival_ptr = NULL;
|
event.sigev_notify = SIGEV_THREAD;
|
event.sigev_notify_function = timer_handler;
|
|
ret = timer_create(CLOCK_REALTIME, &event, &timer);
|
if (ret) {
|
return -1;
|
}
|
|
if (timer_index != NULL) {
|
*timer_index = timer;
|
}
|
|
return 0;
|
}
|
|
int timer_start(timer_t timer_index, int sec) {
|
int ret;
|
struct itimerspec ts;
|
|
ts.it_interval.tv_sec = 0;
|
ts.it_interval.tv_nsec = 0;
|
ts.it_value.tv_sec = sec;
|
ts.it_value.tv_nsec = 0;
|
ret = timer_settime(timer_index, 0, &ts, NULL);
|
if (ret) {
|
return -1;
|
}
|
|
return ret;
|
}
|
|
int timer_stop(timer_t timer_index) {
|
|
int ret = timer_start(timer_index, 0);
|
|
return ret;
|
}
|
|
int timer_destroy(timer_t timer_index) {
|
int ret;
|
|
ret = timer_delete(timer_index);
|
|
return ret;
|
}
|
|
void soap_perror(struct soap *soap, const char *str)
|
{
|
if (NULL == str) {
|
SOAP_DBGERR("[soap] error: %d, %s, %s\n", soap->error, *soap_faultcode(soap), *soap_faultstring(soap));
|
} else {
|
SOAP_DBGERR("[soap] %s error: %d, %s, %s\n", str, soap->error, *soap_faultcode(soap), *soap_faultstring(soap));
|
}
|
|
return;
|
}
|
|
void* proto_soap_malloc(struct soap *soap, unsigned int n)
|
{
|
void *p = NULL;
|
|
if (n > 0) {
|
p = soap_malloc(soap, n);
|
SOAP_ASSERT(NULL != p);
|
memset(p, 0x00 ,n);
|
}
|
|
return p;
|
}
|
|
struct soap *proto_soap_new(int timeout)
|
{
|
struct soap *soap = NULL;
|
|
SOAP_ASSERT(NULL != (soap = soap_new()));
|
|
soap_set_namespaces(soap, namespaces);
|
soap->recv_timeout = timeout;
|
soap->send_timeout = timeout;
|
soap->connect_timeout = timeout;
|
|
#if defined(__linux__) || defined(__linux)
|
soap->socket_flags = MSG_NOSIGNAL;
|
#endif
|
|
soap_set_mode(soap, SOAP_C_UTFSTRING);
|
|
return soap;
|
}
|
|
void proto_soap_delete(struct soap *soap)
|
{
|
soap_destroy(soap); // remove deserialized class instances (C++ only)
|
soap_end(soap); // Clean up deserialized data (except class instances) and temporary data
|
soap_done(soap); // Reset, close communications, and remove callbacks
|
soap_free(soap); // Reset and deallocate the context created with soap_new or soap_copy
|
}
|
|
int proto_SetAuthInfo(struct soap *soap, const char *username, const char *password)
|
{
|
int result = 0;
|
|
SOAP_ASSERT(NULL != username);
|
SOAP_ASSERT(NULL != password);
|
|
result = soap_wsse_add_UsernameTokenDigest(soap, NULL, username, password);
|
SOAP_CHECK_ERROR(result, soap, "add_UsernameTokenDigest");
|
|
EXIT:
|
|
return result;
|
}
|
|
float para_check(float data)
|
{
|
float ret;
|
|
if (data > PARA_MAX) {
|
ret = PARA_MAX;
|
} else if (data < PARA_MIN) {
|
ret = PARA_MIN;
|
} else {
|
ret = data;
|
}
|
|
return ret;
|
}
|
|
void proto_init_header(struct soap *soap)
|
{
|
struct SOAP_ENV__Header *header = NULL;
|
|
SOAP_ASSERT(NULL != soap);
|
|
header = (struct SOAP_ENV__Header *)proto_soap_malloc(soap, sizeof(struct SOAP_ENV__Header));
|
soap_default_SOAP_ENV__Header(soap, header);
|
header->wsa__MessageID = (char*)soap_wsa_rand_uuid(soap);
|
header->wsa__MessageID = (char *)soap_strdup(soap, soap_rand_uuid(soap, "urn:uuid:"));
|
header->wsa__To = (char*)proto_soap_malloc(soap, strlen(SOAP_TO) + 1);
|
header->wsa__Action = (char*)proto_soap_malloc(soap, strlen(SOAP_ACTION) + 1);
|
strcpy(header->wsa__To, SOAP_TO);
|
strcpy(header->wsa__Action, SOAP_ACTION);
|
soap->header = header;
|
|
return;
|
}
|
|
void proto_init_ProbeType(struct soap *soap, struct wsdd__ProbeType *probe)
|
{
|
struct wsdd__ScopesType *scope = NULL;
|
|
SOAP_ASSERT(NULL != soap);
|
SOAP_ASSERT(NULL != probe);
|
|
scope = (struct wsdd__ScopesType *)proto_soap_malloc(soap, sizeof(struct wsdd__ScopesType));
|
soap_default_wsdd__ScopesType(soap, scope);
|
scope->__item = (char*)proto_soap_malloc(soap, strlen(SOAP_ITEM) + 1);
|
strcpy(scope->__item, SOAP_ITEM);
|
|
memset(probe, 0x00, sizeof(struct wsdd__ProbeType));
|
soap_default_wsdd__ProbeType(soap, probe);
|
probe->Scopes = scope;
|
probe->Types = (char*)proto_soap_malloc(soap, strlen(SOAP_TYPES) + 1);
|
strcpy(probe->Types, SOAP_TYPES);
|
|
return;
|
}
|
|
/************************************************************************
|
*rtsp://100.100.100.140:554/av0_0
|
*rtsp://username:password@100.100.100.140:554/av0_0
|
************************************************************************/
|
int bridge_uri(char *src_uri, const char *username, const char *password, char *dest_uri, unsigned int size_dest_uri)
|
{
|
int result = 0;
|
unsigned int needBufSize = 0;
|
|
SOAP_ASSERT(NULL != src_uri);
|
SOAP_ASSERT(NULL != username);
|
SOAP_ASSERT(NULL != password);
|
SOAP_ASSERT(NULL != dest_uri);
|
memset(dest_uri, 0x00, size_dest_uri);
|
|
needBufSize = strlen(src_uri) + strlen(username) + strlen(password) + 3; //check buf size with character ¡®:¡¯ and ¡®@'
|
if (size_dest_uri < needBufSize) {
|
SOAP_DBGERR("dest uri buf size is not enough.\n");
|
result = -1;
|
goto EXIT;
|
}
|
|
if (0 == strlen(username) && 0 == strlen(password)) {
|
strcpy(dest_uri, src_uri);
|
} else {
|
char *p = strstr(src_uri, "//");
|
if (NULL == p) {
|
SOAP_DBGERR("can't found '//', src uri is: %s.\n", src_uri);
|
result = -1;
|
goto EXIT;
|
}
|
p += 2;
|
|
memcpy(dest_uri, src_uri, p - src_uri);
|
sprintf(dest_uri + strlen(dest_uri), "%s:%s@", username, password);
|
strcat(dest_uri, p);
|
}
|
|
EXIT:
|
|
return result;
|
}
|
|
|
