static void s_SetDefaultReferer(SERV_ITER iter, SConnNetInfo* net_info)
{
char* str, *referer = 0;
if (strcasecmp(iter->op->name, "DISPD") == 0)
referer = ConnNetInfo_URL(net_info);
else if ((str = strdup(iter->op->name)) != 0) {
const char* host = net_info->client_host;
const char* args = net_info->args;
const char* name = iter->name;
if (!*net_info->client_host
&& !SOCK_gethostbyaddr(0, net_info->client_host,
sizeof(net_info->client_host))) {
SOCK_gethostname(net_info->client_host,
sizeof(net_info->client_host));
}
if (!(referer = (char*) malloc(3 + 1 + 1 + 1 + 2*strlen(strlwr(str)) +
strlen(host) + (args[0]
? strlen(args)
: 8 + strlen(name))))) {
return;
}
strcat(strcat(strcat(strcat(strcpy
(referer, str), "://"), host), "/"), str);
if (args[0])
strcat(strcat(referer, "?"), args);
else
strcat(strcat(referer, "?service="), name);
free(str);
}
assert(!net_info->http_referer);
net_info->http_referer = referer;
}
int gb28181_init_env(pSipEnv *env)
{
TRACE("Init GB28181 env\n");
//constly
SYSCONF_t *sysconf = SYSCONF_dup();
pSipEnv p = (pSipEnv)calloc(1,sizeof(sSipEnv));
*env = p;
char devip[20];
SOCK_gethostname(devip);
GB_ASSERT(*env,"Calloc env Node failed\n");
printf("calloc env hdr node %p\n",*env);
SIP_ENV_insert(p,"Model",sysconf->ipcam.info.device_model);
SIP_ENV_insert(p,"UserAgent",sysconf->ipcam.info.device_name);
SIP_ENV_insert(p,"Firmware",sysconf->ipcam.info.software_version);
SIP_ENV_insert(p,"MaxAlarm","1");
SIP_ENV_insert(p,"MaxCamera","1");
SIP_ENV_insert(p,"Manufacturer","JUAN");
// variable
Gb28181Conf_t gb_conf;
memset(&gb_conf, 0, sizeof(Gb28181Conf_t));
gb28181_read_env(&gb_conf,sizeof(Gb28181Conf_t));
if(strlen(gb_conf.SipServerId) > 0)
//if(0)
{
TRACE("use the env in the flash,SipServerId:%s:%d\n",gb_conf.SipServerId,
strlen(gb_conf.SipServerId));
SIP_ENV_insert(p,"Realm",gb_conf.LoginDomain);
SIP_ENV_insert(p,"SipServerId",gb_conf.SipServerId);
SIP_ENV_insert(p,"SipServerIp",gb_conf.SipServerIp);
SIP_ENV_insert(p,"SipServerPort",ITOA(gb_conf.SipServerPort));
SIP_ENV_insert(p,"UserId",gb_conf.UserId);
SIP_ENV_insert(p,"UserPwd",gb_conf.UserPwd);
SIP_ENV_insert(p,"DevPort",ITOA(GB28181_DEFAULT_DEV_PORT));
SIP_ENV_insert(p,"DevIp",devip);
SIP_ENV_insert(p,"AliveTime",ITOA(gb_conf.AliveTime));
SIP_ENV_insert(p,"HeartBeatTime",ITOA(gb_conf.HeartBeatTime));
SIP_ENV_insert(p,"Alarm1",gb_conf.AlarmId[0]);
SIP_ENV_insert(p,"Video1",gb_conf.VideoId[0]);
}
else{ // use the default gb28181 env
TRACE("NULL gb28181 env ,use default env\n");
gb28181_write_env(&def_gb_conf,sizeof(Gb28181Conf_t));
SIP_ENV_insert(p,"Realm",def_gb_conf.LoginDomain);
SIP_ENV_insert(p,"SipServerId",def_gb_conf.SipServerId);
SIP_ENV_insert(p,"SipServerIp",def_gb_conf.SipServerIp);
SIP_ENV_insert(p,"SipServerPort",ITOA(def_gb_conf.SipServerPort));
SIP_ENV_insert(p,"UserId",def_gb_conf.UserId);
SIP_ENV_insert(p,"UserPwd",def_gb_conf.UserPwd);
SIP_ENV_insert(p,"DevIp",devip);
SIP_ENV_insert(p,"DevPort",ITOA(GB28181_DEFAULT_DEV_PORT));
SIP_ENV_insert(p,"AliveTime",ITOA(def_gb_conf.AliveTime));
SIP_ENV_insert(p,"HeartBeatTime",ITOA(def_gb_conf.HeartBeatTime));
SIP_ENV_insert(p,"Alarm1",def_gb_conf.AlarmId[0]);
SIP_ENV_insert(p,"Video1",def_gb_conf.VideoId[0]);
}
return 0;
}
static void s_MakeFrom(char* buf, size_t buf_size)
{
size_t buf_len, hostname_len;
if (!CORE_GetUsername(buf, buf_size) || !*buf)
strncpy0(buf, "anonymous", buf_size - 1);
buf_len = strlen(buf);
hostname_len = buf_size - buf_len;
if (hostname_len-- > 1) {
buf[buf_len++] = '@';
if ((!SOCK_gethostbyaddr(0, &buf[buf_len], hostname_len) ||
!strchr(&buf[buf_len], '.'))
&& SOCK_gethostname(&buf[buf_len], hostname_len) != 0) {
buf[--buf_len] = '\0';
}
}
}
void* JASTS_SEARCH_proc(void *para)
{
int ret;
fd_set read_set;
struct timeval timeout;
char dst_ip[20],mine_ip[20];
int dst_port,mine_port;
char buff[1024];
char msg[1024];
Jast_t *jast=NULL;
JastSession_t *session=NULL;
const char *format="JAST/1.0 200 OK\r\n"\
"Location: %s:%d\r\n"\
"\r\n";
pthread_detach(pthread_self());
printf("JAST server enter!!!!!!!!\n");
server_fd=SOCK_udp_init(JAST_DISCOVERY_SPORT,JAST_SOCK_TIMEOUT);
if(server_fd < JAST_RET_FAIL) return NULL;
#ifndef JAST_USE_BROADCAST
if(SOCK_add_membership(server_fd,JAST_MULTICAST_ADDR) < JAST_RET_FAIL) return NULL;
system("route add -net 224.0.0.0 netmask 224.0.0.0 dev eth0");
#endif
do {
FD_ZERO(&read_set);
FD_SET(server_fd,&read_set);
timeout.tv_sec = 0;
timeout.tv_usec = 1000*50;
ret = select(server_fd + 1,&read_set,NULL,NULL,&timeout);
if(ret < 0){
printf("JAST server select failed!\n");
return NULL;
}else if(ret == 0){
// timeout
//printf("select timeout!!\n");
}else{
if(FD_ISSET(server_fd,&read_set) == true){
ret = SOCK_recvfrom(server_fd,dst_ip,&dst_port,buff,sizeof(buff));
if(ret < 0) return NULL;
buff[ret]=0;
VLOG(VLOG_DEBUG,"recv %d ok,recv data:\n%s\n",ret,buff);
if(memcmp(buff,"DISCOVERY * JAST/1.0",strlen("DISCOVERY * JAST/1.0"))==0){
printf("Discovery from %s:%d!\n",dst_ip,dst_port);
// send response
//SOCK_getsockname(server_fd,mine_ip);
SOCK_gethostname(mine_ip);
// init a jast session
if((session=JAST_session_find(dst_ip)) == NULL){
mine_port = g_JastServerPort;
sprintf(msg,format,mine_ip,mine_port);
g_JastServerPort++;
//
printf("add new session\n",dst_ip,dst_port);
jast=JAST_server_init(dst_ip,mine_port);
if(jast == NULL) return NULL;
session=JAST_session_add(dst_ip,jast->sock,jast);
if(session == NULL) return NULL;
}else{
jast = (Jast_t *)session->data.context;
jast->bLogin = false;
//
sprintf(msg,format,jast->ip_me,jast->port_me);
printf("session:%s exist!!!\n",dst_ip);
}
VLOG(VLOG_DEBUG2,"ack:\n%s\n",msg);
ret = SOCK_sendto(server_fd,dst_ip,dst_port,msg,strlen(msg));
if( ret == JAST_RET_FAIL) break;
}
}else{
printf("JAST select:something wrong!\n");
return NULL;
}
}
} while (m_toggle);
printf("JAST server exit!!!!!!!!\n");
return (void *)1;
}
/* Main function
* Parse command-line options, initialize and cleanup API internals;
* run client or server test
*/
extern int main(int argc, const char* argv[])
{
/* Setup log stream */
CORE_SetLOGFormatFlags(fLOG_None | fLOG_Level |
fLOG_OmitNoteLevel | fLOG_DateTime);
CORE_SetLOGFILE(stderr, 0/*false*/);
/* Parse cmd.-line args and decide whether it's a client or a server
*/
switch ( argc ) {
case 1:
/*** Try to set various fake MT safety locks ***/
CORE_SetLOCK( MT_LOCK_Create(0,
TEST_LockHandler, TEST_LockCleanup) );
CORE_SetLOCK(0);
CORE_SetLOCK(0);
CORE_SetLOCK( MT_LOCK_Create(&TEST_LockUserData,
TEST_LockHandler, TEST_LockCleanup) );
SOCK_SetDataLoggingAPI(eOn);
assert(SOCK_InitializeAPI() == eIO_Success);
SOCK_SetDataLoggingAPI(eOff);
{{
char local_host[64];
assert(SOCK_gethostname(local_host, sizeof(local_host)) == 0);
CORE_LOGF(eLOG_Note,
("Running NCBISOCK test on host \"%s\"", local_host));
}}
TEST_gethostby();
TEST_SOCK_isip();
assert(SOCK_ShutdownAPI() == eIO_Success);
CORE_SetLOCK(0);
break;
case 2: {
/*** SERVER ***/
TEST__server(argv[1]);
assert(SOCK_ShutdownAPI() == eIO_Success);
CORE_SetLOG(0);
return 0;
}
case 3: case 4: {
/*** CLIENT ***/
const char* host;
unsigned short port;
STimeout* tmo;
STimeout x_tmo;
/* host */
host = argv[1];
/* port */
if (sscanf(argv[2], "%hu", &port) != 1)
break;
/* timeout */
if (argc == 4) {
double v;
char* e = (char*) argv[3];
if (!*e || (v = NCBI_simple_atof(e, &e)) < 0.0 || errno || *e)
break;
x_tmo.sec = (unsigned int) v;
x_tmo.usec = (unsigned int)((v - x_tmo.sec) * 1000000.0);
tmo = &x_tmo;
} else
tmo = 0/*infinite*/;
TEST__client(host, port, tmo);
assert(SOCK_ShutdownAPI() == eIO_Success);
CORE_SetLOG(0);
return 0;
}
} /* switch */
/* USAGE */
fprintf(stderr,
"\nClient/Server USAGE:\n"
"Client: %s <host> <port> [timeout]\n"
"Server: %s <port>\n\n",
argv[0], argv[0]);
CORE_SetLOG(0);
return argc == 1 ? 0 : 1;
}
/* Main function
* Parse command-line options, initialize and cleanup API internals;
* run client or server test
*/
extern int main(int argc, char** argv)
{
/* Setup log stream */
CORE_SetLOGFormatFlags(fLOG_None | fLOG_Level |
fLOG_OmitNoteLevel | fLOG_DateTime);
CORE_SetLOGFILE(stderr, 0/*false*/);
/* Test client or server using hard-coded parameters */
#if defined(DO_SERVER)
argc = 2;
#elif defined(DO_CLIENT)
argc = 3;
#endif
/* Parse cmd.-line args and decide whether it's a client or a server
*/
switch ( argc ) {
case 1:
/*** Try to set various fake MT safety locks ***/
CORE_SetLOCK( MT_LOCK_Create(0,
TEST_LockHandler, TEST_LockCleanup) );
CORE_SetLOCK(0);
CORE_SetLOCK(0);
CORE_SetLOCK( MT_LOCK_Create(&TEST_LockUserData,
TEST_LockHandler, TEST_LockCleanup) );
SOCK_SetDataLoggingAPI(eOn);
assert(SOCK_InitializeAPI() == eIO_Success);
SOCK_SetDataLoggingAPI(eOff);
{{
char local_host[64];
assert(SOCK_gethostname(local_host, sizeof(local_host)) == 0);
CORE_LOGF(eLOG_Note,
("Running NCBISOCK test on host \"%s\"", local_host));
}}
TEST_gethostby();
TEST_SOCK_isip();
assert(SOCK_ShutdownAPI() == eIO_Success);
CORE_SetLOCK(0);
break;
case 2: {
/*** SERVER ***/
int port;
#if defined(DO_SERVER)
port = DEF_PORT;
#else
if (sscanf(argv[1], "%d", &port) != 1 || port < MIN_PORT)
break;
#endif /* DO_SERVER */
TEST__server((unsigned short) port);
assert(SOCK_ShutdownAPI() == eIO_Success);
CORE_SetLOG(0);
return 0;
}
case 3: case 4: {
/*** CLIENT ***/
const char* host;
int port;
STimeout* tmo;
#if defined(DO_CLIENT)
host = DEF_HOST;
port = DEF_PORT;
tmo = 0/*infinite*/;
#else
STimeout x_tmo;
/* host */
host = argv[1];
/* port */
if (sscanf(argv[2], "%d", &port) != 1 || port < MIN_PORT)
break;
/* timeout */
if (argc == 4) {
double val = atof(argv[3]);
if (val < 0)
break;
x_tmo.sec = (unsigned int) val;
x_tmo.usec = (unsigned int)((val - x_tmo.sec) * 1000000);
tmo = &x_tmo;
} else
tmo = 0/*infinite*/;
#endif /* DO_CLIENT */
TEST__client(host, (unsigned short) port, tmo);
assert(SOCK_ShutdownAPI() == eIO_Success);
CORE_SetLOG(0);
return 0;
}
} /* switch */
/* USAGE */
fprintf(stderr,
"\nClient/Server USAGE:\n"
"Client: %s <host> <port> [timeout]\n"
"Server: %s <port>\n"
"where <port> is greater than %d, and [timeout] is a double\n\n",
argv[0], argv[0], MIN_PORT);
CORE_SetLOG(0);
return argc == 1 ? 0 : 1;
}
const char* CORE_SendMailEx(const char* to,
const char* subject,
const char* body,
const SSendMailInfo* uinfo)
{
static const STimeout zero = {0, 0};
const SSendMailInfo* info;
SSendMailInfo ainfo;
char buffer[1024];
SOCK sock = 0;
info = uinfo ? uinfo : SendMailInfo_Init(&ainfo);
if (info->magic_number != MX_MAGIC_NUMBER)
SENDMAIL_RETURN(6, "Invalid magic number");
if ((!to || !*to) &&
(!info->cc || !*info->cc) &&
(!info->bcc || !*info->bcc)) {
SENDMAIL_RETURN(7, "At least one message recipient must be specified");
}
/* Open connection to sendmail */
if (SOCK_Create(info->mx_host, info->mx_port, &info->mx_timeout, &sock)
!= eIO_Success) {
SENDMAIL_RETURN(8, "Cannot connect to sendmail");
}
SOCK_SetTimeout(sock, eIO_ReadWrite, &info->mx_timeout);
/* Follow the protocol conversation, RFC821 */
if (!SENDMAIL_READ_RESPONSE(220, 0, buffer))
SENDMAIL_RETURN2(9, "Protocol error in connection init", buffer);
if ((!(info->mx_options & fSendMail_StripNonFQDNHost) ||
!SOCK_gethostbyaddr(0, buffer, sizeof(buffer))) &&
SOCK_gethostname(buffer, sizeof(buffer)) != 0) {
SENDMAIL_RETURN(10, "Unable to get local host name");
}
if (!s_SockWrite(sock, "HELO ", 0) ||
!s_SockWrite(sock, buffer, 0) ||
!s_SockWrite(sock, MX_CRLF, 2)) {
SENDMAIL_RETURN(11, "Write error in HELO command");
}
if (!SENDMAIL_READ_RESPONSE(250, 0, buffer))
SENDMAIL_RETURN2(12, "Protocol error in HELO command", buffer);
if (!s_SockWrite(sock, "MAIL FROM: <", 0) ||
!s_SockWrite(sock, info->from, s_FromSize(info)) ||
!s_SockWrite(sock, ">" MX_CRLF, 1 + 2)) {
SENDMAIL_RETURN(13, "Write error in MAIL command");
}
if (!SENDMAIL_READ_RESPONSE(250, 0, buffer))
SENDMAIL_RETURN2(14, "Protocol error in MAIL command", buffer);
if (to && *to) {
const char* error = SENDMAIL_SENDRCPT("To", to, buffer);
if (error)
return error;
}
if (info->cc && *info->cc) {
const char* error = SENDMAIL_SENDRCPT("Cc", info->cc, buffer);
if (error)
return error;
}
if (info->bcc && *info->bcc) {
const char* error = SENDMAIL_SENDRCPT("Bcc", info->bcc, buffer);
if (error)
return error;
}
if (!s_SockWrite(sock, "DATA" MX_CRLF, 0))
SENDMAIL_RETURN(15, "Write error in DATA command");
if (!SENDMAIL_READ_RESPONSE(354, 0, buffer))
SENDMAIL_RETURN2(16, "Protocol error in DATA command", buffer);
if (!(info->mx_options & fSendMail_NoMxHeader)) {
/* Follow RFC822 to compose message headers. Note that
* 'Date:'and 'From:' are both added by sendmail automagically.
*/
if (!s_SockWrite(sock, "Subject: ", 0) ||
(subject && !s_SockWrite(sock, subject, 0)) ||
!s_SockWrite(sock, MX_CRLF, 2))
SENDMAIL_RETURN(17, "Write error in sending subject");
if (to && *to) {
if (!s_SockWrite(sock, "To: ", 0) ||
!s_SockWrite(sock, to, 0) ||
!s_SockWrite(sock, MX_CRLF, 2))
SENDMAIL_RETURN(18, "Write error in sending To");
}
if (info->cc && *info->cc) {
if (!s_SockWrite(sock, "Cc: ", 0) ||
!s_SockWrite(sock, info->cc, 0) ||
!s_SockWrite(sock, MX_CRLF, 2))
SENDMAIL_RETURN(19, "Write error in sending Cc");
}
} else if (subject && *subject)
CORE_LOG_X(2, eLOG_Warning,
"[SendMail] Subject ignored in as-is messages");
if (!s_SockWrite(sock, "X-Mailer: CORE_SendMail (NCBI "
NCBI_SENDMAIL_TOOLKIT " Toolkit)" MX_CRLF, 0)) {
SENDMAIL_RETURN(20, "Write error in sending mailer information");
}
assert(sizeof(buffer) > sizeof(MX_CRLF) && sizeof(MX_CRLF) >= 3);
if (info->header && *info->header) {
size_t n = 0, m = strlen(info->header);
int/*bool*/ newline = 0/*false*/;
while (n < m) {
size_t k = 0;
if (SOCK_Wait(sock, eIO_Read, &zero) != eIO_Timeout)
break;
while (k < sizeof(buffer) - sizeof(MX_CRLF)) {
if (info->header[n] == '\n') {
memcpy(&buffer[k], MX_CRLF, sizeof(MX_CRLF) - 1);
k += sizeof(MX_CRLF) - 1;
newline = 1/*true*/;
} else {
if (info->header[n] != '\r' || info->header[n+1] != '\n')
buffer[k++] = info->header[n];
newline = 0/*false*/;
}
if (++n >= m)
break;
}
buffer[k] = '\0'/*just in case*/;
if (!s_SockWrite(sock, buffer, k))
SENDMAIL_RETURN(21, "Write error while sending custom header");
}
if (n < m)
SENDMAIL_RETURN(22, "Header write error");
if (!newline && !s_SockWrite(sock, MX_CRLF, 2))
SENDMAIL_RETURN(23, "Write error while finalizing custom header");
}
if (body) {
size_t n = 0, m = info->body_size ? info->body_size : strlen(body);
int/*bool*/ newline = 0/*false*/;
if (!(info->mx_options & fSendMail_NoMxHeader) && m) {
if (!s_SockWrite(sock, MX_CRLF, 2))
SENDMAIL_RETURN(24, "Write error in message body delimiter");
}
while (n < m) {
size_t k = 0;
if (SOCK_Wait(sock, eIO_Read, &zero) != eIO_Timeout)
break;
while (k < sizeof(buffer) - sizeof(MX_CRLF)) {
if (body[n] == '\n') {
memcpy(&buffer[k], MX_CRLF, sizeof(MX_CRLF) - 1);
k += sizeof(MX_CRLF) - 1;
newline = 1/*true*/;
} else {
if (body[n] != '\r' || (n+1 < m && body[n+1] != '\n')){
if (body[n] == '.' && (newline || !n)) {
buffer[k++] = '.';
buffer[k++] = '.';
} else
buffer[k++] = body[n];
}
newline = 0/*false*/;
}
if (++n >= m)
break;
}
buffer[k] = '\0'/*just in case*/;
if (!s_SockWrite(sock, buffer, k))
SENDMAIL_RETURN(25, "Write error while sending message body");
}
if (n < m)
SENDMAIL_RETURN(26, "Body write error");
if ((!newline && m && !s_SockWrite(sock, MX_CRLF, 2))
|| !s_SockWrite(sock, "." MX_CRLF, 1 + 2)) {
SENDMAIL_RETURN(27, "Write error while finalizing message body");
}
} else if (!s_SockWrite(sock, "." MX_CRLF, 1 + 2))
SENDMAIL_RETURN(28, "Write error while finalizing message");
if (!SENDMAIL_READ_RESPONSE(250, 0, buffer))
SENDMAIL_RETURN2(29, "Protocol error in sending message", buffer);
if (!s_SockWrite(sock, "QUIT" MX_CRLF, 0))
SENDMAIL_RETURN(30, "Write error in QUIT command");
if (!SENDMAIL_READ_RESPONSE(221, 0, buffer))
SENDMAIL_RETURN2(31, "Protocol error in QUIT command", buffer);
SOCK_Close(sock);
return 0;
}
