int run_server(int port) { struct soap soap; int ret; /* Enable MTOM */ #ifdef WITH_GZIP soap_init1(&soap, SOAP_ENC_MTOM | SOAP_ENC_ZLIB); /* Enable MTOM */ #else soap_init1(&soap, SOAP_ENC_MTOM); #endif /* Set the MIME callbacks */ soap.fmimereadopen = mime_read_open; soap.fmimereadclose = mime_read_close; soap.fmimeread = mime_read; soap.fmimewriteopen = mime_server_write_open; soap.fmimewriteclose = mime_server_write_close; soap.fmimewrite = mime_server_write; /* Bind socket */ if (!soap_valid_socket(soap_bind(&soap, NULL, port, 100))) soap_print_fault(&soap, stderr); else { fprintf(stderr, "Bind to port %d successful\n", port); /* Optional: let server time out after one hour */ soap.accept_timeout = 3600; /* Unix/Linux SIGPIPE, this is OS dependent: soap.accept_flags = SO_NOSIGPIPE; // some systems like this soap.socket_flags = MSG_NOSIGNAL; // others need this signal(SIGPIPE, sigpipe_handle); // or a sigpipe handler (more portable) */ /* Server loop */ for (;;) { int sock = soap_accept(&soap); if (!soap_valid_socket(sock)) { if (soap.errnum) soap_print_fault(&soap, stderr); else { fprintf(stderr, "Server timed out (see code how to change this)\n"); break; } } fprintf(stderr, "Accepting socket %d connection from IP %d.%d.%d.%d... ", sock, (int)(soap.ip>>24)&0xFF, (int)(soap.ip>>16)&0xFF, (int)(soap.ip>>8)&0xFF, (int)soap.ip&0xFF); if (soap_serve(&soap)) soap_print_fault(&soap, stderr); fprintf(stderr, "done\n"); soap_destroy(&soap); soap_end(&soap); } } ret = soap.error; soap_destroy(&soap); soap_end(&soap); soap_done(&soap); return ret; }
int run_server(int port) { struct soap soap; int i, ret; /* Enable MTOM */ #ifdef WITH_GZIP soap_init1(&soap, SOAP_ENC_MTOM | SOAP_ENC_ZLIB); /* Enable MTOM */ #else soap_init1(&soap, SOAP_ENC_MTOM); #endif /* Set the MIME callbacks */ soap.fmimereadopen = mime_read_open; soap.fmimereadclose = mime_read_close; soap.fmimeread = mime_read; soap.fmimewriteopen = mime_server_write_open; soap.fmimewriteclose = mime_server_write_close; soap.fmimewrite = mime_server_write; /* Bind socket */ if (!soap_valid_socket(soap_bind(&soap, NULL, port, 100))) soap_print_fault(&soap, stderr); else { fprintf(stderr, "Bind to port %d successful\n", port); /* Optional: let server time out after one hour */ soap.accept_timeout = 3600; /* Unix/Linux SIGPIPE, this is OS dependent: soap.accept_flags = SO_NOSIGPIPE; // some systems like this soap.socket_flags = MSG_NOSIGNAL; // others need this signal(SIGPIPE, sigpipe_handle); // or a sigpipe handler (more portable) */ /* Main thread spawns server threads */ for (i = 1; ; i++) { struct soap *tsoap; pthread_t tid; int sock = soap_accept(&soap); if (!soap_valid_socket(sock)) { if (soap.errnum) soap_print_fault(&soap, stderr); else { fprintf(stderr, "Server timed out (see code how to change this)\n"); break; } } fprintf(stderr, "Thread %d accepts socket %d connection from IP %d.%d.%d.%d\n", i, sock, (int)(soap.ip>>24)&0xFF, (int)(soap.ip>>16)&0xFF, (int)(soap.ip>>8)&0xFF, (int)soap.ip&0xFF); /* Copy soap environment and spawn thread */ tsoap = soap_copy(&soap); pthread_create(&tid, NULL, (void*(*)(void*))process_request, (void*)tsoap); } } ret = soap.error; soap_done(&soap); return ret; }
void grisu_auth_header(void) { /* CURRENT - fixing crappy windows soap failure */ /* WINDOWS seems to require a reinit EVERY time - or it forgets stuff and soap calls fail */ /* TODO - test if this bollocks up linux or not ... */ soap_init1(&soap, SOAP_ENC_MTOM); if (soap_ssl_client_context(&soap, SOAP_SSL_SKIP_HOST_CHECK, NULL, NULL, NULL, grisu_cert_path, NULL)) printf("grisu_auth_header(): SSL init failed.\n"); /* allocate if necessary */ if (!grisu_soap_header) grisu_soap_header = g_malloc(sizeof(struct SOAP_ENV__Header)); /* fill out the header with current values */ grisu_soap_header->username = grisu_username; grisu_soap_header->password = grisu_password; grisu_soap_header->myproxyserver = grisu_server; grisu_soap_header->myproxyport = grisu_port; #if DEBUG_GRISU_AUTH_HEADER printf("SOAP Header: ptr = %p\n", grisu_soap_header); printf("SOAP Header: username = %s\n", grisu_soap_header->username); printf("SOAP Header: password = %s\n", grisu_soap_header->password); printf("SOAP Header: server = %s\n", grisu_soap_header->myproxyserver); printf("SOAP Header: port = %s\n", grisu_soap_header->myproxyport); #endif /* use the header if auth is turned on */ if (grisu_auth) soap.header = grisu_soap_header; else soap.header = NULL; }
int main(int argc, char **argv) { struct soap soap; double a, b, result; if (argc < 4) { fprintf(stderr, "Usage: [setAuto] num[Sentido] num[Direccion]\n"); exit(0); } soap_init1(&soap, SOAP_XML_INDENT); a = strtod(argv[2], NULL); b = strtod(argv[3], NULL); switch (*argv[1]) { case 's': soap_call_ns__setAuto(&soap, server, "", a, b, &result); break; default: fprintf(stderr, "Unknown command\n"); exit(0); } if (soap.error) { soap_print_fault(&soap, stderr); exit(1); } else printf("result = %g\n", result); soap_destroy(&soap); soap_end(&soap); soap_done(&soap); return 0; }
int save_options(const char *file, const char *name, struct option *options) { struct soap soap; soap_init1(&soap, SOAP_XML_TREE); soap.namespaces = NULL; soap.encodingStyle = NULL; if (file) { soap.sendfd = open(file, O_CREAT | O_WRONLY); if (soap.sendfd < 0) { soap_done(&soap); return EOF; } } if (!soap_begin_send(&soap) && !soap_element_begin_out(&soap, name, 0, NULL)) { struct option *p; struct t__Option t; for (p = options; p->name; p++) { t.val = NULL; if (!p->name[0]) { if (!p->value) continue; t.key = NULL; t.val = p->value; } else if (p->name[1] == '.') t.key = (char*)p->name + 2; else t.key = (char*)p->name; if (p->selections && strchr(p->selections, ' ')) { const char *s = p->selections - 1; char *r; int i; for (i = p->selected; i > 0; i--) { s = strchr(s + 1, ' '); if (!s) break; } if (s) { t.val = soap_strdup(&soap, s + 1); r = strchr(t.val, ' '); if (r) *r = '\0'; } } else if (p->value) t.val = p->value; else if (!p->selected) continue; if (soap_out_t__Option(&soap, "option", 0, &t, NULL)) break; } if (!soap_element_end_out(&soap, name)) soap_end_send(&soap); } if (file) close(soap.sendfd); soap_end(&soap); soap_done(&soap); return soap.error; }
int main(int args, char* argv[]) { char *s; jcl_ws w; soap_init1(w.soap, SOAP_ENC_MTOM); // MTOM // w.endpoint = "http://mvs.open-bpm.org/mvsserver.cgi"; if (args==3) { w.soap->userid = argv[1]; w.soap->passwd = argv[2]; } if (w.jcl_ws__Ping(s) == SOAP_OK) std::cout << s << std::endl; else { soap_print_fault(w.soap, stderr); return -1; } struct jcl_data__Payload jcl; openReadFile(w.soap, "input.txt", &jcl); writeFileName = "output.txt"; // Alloc return Structure struct jcl_ws__jclResponse response; response._return = soap_new_jcl_ws__output(w.soap, -1); std::string param = "Test"; // Call EchoTest w.soap->userid = argv[1]; w.soap->passwd = argv[2]; w.soap->fmimereadopen = readOpenCallback; w.soap->fmimereadclose = readCloseCallback; w.soap->fmimeread = readCallback; w.soap->fmimewriteopen = writeOpenCallback; w.soap->fmimewriteclose = writeCloseCallback; w.soap->fmimewrite = writeCallback; if ( w.jcl_ws__EchoTest(param, &jcl, response) == SOAP_OK ) std::cout << "EchoTest OK" << std::endl; else { soap_print_fault(w.soap, stderr); return -1; } soap_destroy(w.soap); soap_end(w.soap); soap_done(w.soap); return 0; }
int run_client(int argc, char **argv) { struct soap soap; int ret = 0; #ifdef WITH_GZIP soap_init1(&soap, SOAP_ENC_MTOM | SOAP_ENC_ZLIB); /* Enable MTOM */ #else soap_init1(&soap, SOAP_ENC_MTOM); /* Enable MTOM */ #endif /* Set the MIME callbacks */ soap.fmimereadopen = mime_read_open; soap.fmimereadclose = mime_read_close; soap.fmimeread = mime_read; soap.fmimewriteopen = mime_client_write_open; soap.fmimewriteclose = mime_client_write_close; soap.fmimewrite = mime_client_write; /* Connect timeout value (sec) (not supported by Linux) */ soap.connect_timeout = 10; /* IO timeouts (sec) */ soap.send_timeout = 30; soap.recv_timeout = 30; /* Unix/Linux SIGPIPE, this is OS dependent: soap.accept_flags = SO_NOSIGPIPE; // some systems like this soap.socket_flags = MSG_NOSIGNAL; // others need this signal(SIGPIPE, sigpipe_handle); // or a sigpipe handler (more portable) */ switch (argv[1][1]) { case 'p': ret = client_putData(&soap, argc, argv); break; case 'g': ret = client_getData(&soap, argc, argv); break; default: fprintf(stderr, "Usage: mtom-stream-test -p file1 file2 file3 ...\n"); fprintf(stderr, " mtom-stream-test -g key1 key2 key3 ...\n"); } soap_destroy(&soap); soap_end(&soap); soap_done(&soap); return ret; }
int main(int argc, char **argv) { struct soap soap; // use HTTP 1.1 chunking // HTTP chunking allows streaming of DIME content without requiring DIME attachment size to be set // DIME attachments can be streamed without chunking ONLY if the attachment size is set soap_init1(&soap, SOAP_IO_CHUNK); // set DIME callbacks soap.fdimereadopen = dime_read_open; soap.fdimereadclose = dime_read_close; soap.fdimeread = dime_read; soap.fdimewriteopen = dime_write_open; soap.fdimewriteclose = dime_write_close; soap.fdimewrite = dime_write; // connect timeout value (not supported by Linux) soap.connect_timeout = 10; // IO timeouts soap.send_timeout = 30; soap.recv_timeout = 30; // Unix/Linux SIGPIPE, this is OS dependent: // soap.accept_flags = SO_NOSIGPIPE; // some systems like this // soap.socket_flags = MSG_NOSIGNAL; // others need this // signal(SIGPIPE, sigpipe_handle); // or a sigpipe handler (portable) if (argc < 3) { char *name; if (argc < 2) name = "image.jpg"; else name = argv[1]; getImage(&soap, name); } else { switch (argv[1][1]) { case 'p': endpoint = localhost; putData(&soap, argc, argv); break; case 'g': endpoint = localhost; getData(&soap, argc, argv); break; default: fprintf(stderr, "Usage: [-p] [-g] name ...\n"); exit(0); } } soap_destroy(&soap); soap_end(&soap); soap_done(&soap); return SOAP_OK; }
int main() { struct soap soap; init_received(); soap_init1(&soap, SOAP_IO_UDP); if (!soap_valid_socket(soap_bind(&soap, NULL, 10000, 100))) { soap_print_fault(&soap, stderr); exit(1); } for (;;) { printf("Accepting requests...\n"); if (soap_serve(&soap)) soap_print_fault(&soap, stderr); soap_destroy(&soap); soap_end(&soap); } soap_done(&soap); return 0; }
int main(int argc, char * argv[]) { SOAP_SOCKET m, s; struct soap soap; soap_init1(&soap, SOAP_IO_UDP); m = soap_bind(&soap, NULL, PORT, 100); /* reuse address */ soap.bind_flags = SO_REUSEADDR; if (!soap_valid_socket(m)) { soap_print_fault(&soap, stderr); exit(-1); } /* optionally join a multicast group */ if (MULTICAST_GROUP) { struct ip_mreq mreq; mreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_GROUP); mreq.imr_interface.s_addr = htonl(INADDR_ANY); if (setsockopt(soap.socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) { printf("setsockopt failed\n"); exit(-1); } } printf("socket bind success %d\n", m); for (;;) { printf("socket connect %d\n", s); s = soap_accept(&soap); if (!soap_valid_socket(s)) { soap_print_fault(&soap, stderr); exit(-1); } if (soap_serve(&soap) != SOAP_OK) { soap_print_fault(&soap, stderr); } soap_destroy(&soap); soap_end(&soap); } soap_done(&soap); return 0; }
int main(int argc, char **argv) { struct soap soap; double a, b, result; if (argc < 4) { fprintf(stderr, "Usage: [add|sub|mul|div|pow] num num\n"); exit(0); } soap_init1(&soap, SOAP_XML_INDENT); a = strtod(argv[2], NULL); b = strtod(argv[3], NULL); switch (*argv[1]) { case 'a': soap_call_ns__add(&soap, server, "", a, b, &result); break; case 's': soap_call_ns__sub(&soap, server, "", a, b, &result); break; case 'm': soap_call_ns__mul(&soap, server, "", a, b, &result); break; case 'd': soap_call_ns__div(&soap, server, "", a, b, &result); break; case 'p': soap_call_ns__pow(&soap, server, "", a, b, &result); break; default: fprintf(stderr, "Unknown command\n"); exit(0); } if (soap.error) { soap_print_fault(&soap, stderr); exit(1); } else printf("result = %g\n", result); soap_destroy(&soap); soap_end(&soap); soap_done(&soap); return 0; }
int main(int argc, char * argv[]) { SOAP_SOCKET m, s; struct soap soap; soap_init1(&soap, SOAP_ENC_MTOM); m = soap_bind(&soap, NULL, PORT, 100); if (!soap_valid_socket(m)) { soap_print_fault(&soap, stderr); exit(-1); } printf("socket bind success %d\n", m); soap.fmimewriteopen = mime_server_write_open; soap.fmimewriteclose = mime_server_write_close; soap.fmimewrite = mime_server_write; for (;;) { printf("socket connect %d\n", s); s = soap_accept(&soap); if (!soap_valid_socket(s)) { soap_print_fault(&soap, stderr); exit(-1); } if (soap_serve(&soap) != SOAP_OK) { soap_print_fault(&soap, stderr); } soap_destroy(&soap); soap_end(&soap); } soap_done(&soap); return 0; }
int soap_parser_decode(void *handle, const char *xml) { SoapParser *parser = (SoapParser *)handle; struct soap *soap; int fd[2]; if (parser == NULL) { return -1; } if (xml == NULL) { LOGE(LOG_TAG, "input xml is empty"); return -1; } soap = parser->soap; pipe(fd); /*soap_init(soap);*/ soap_init1(soap, SOAP_XML_IGNORENS); soap_set_namespaces(soap, namespaces); soap->socket = -1; soap->recvfd = fd[0]; write(fd[1], xml, strlen(xml)); close(fd[1]); if (soap_begin_recv(soap) != 0 || soap_envelope_begin_in(soap) != 0) { LOGE(LOG_TAG, "begin decode failed, error=%d", soap->error); return -1; } if (soap_recv_header(soap) != 0) { LOGE(LOG_TAG, "decode soap header failed, %d", soap->error); return -1; } _soap_header_parse(soap->header, &(parser->id), &(parser->hold_requests), &(parser->session_timeout), &(parser->supported_cwmp_versions), &(parser->use_cwmp_version)); if (soap_body_begin_in(soap) != 0) { LOGE(LOG_TAG, "decode soap body failed, %d", soap->error); return -1; } parser->_namespaces = _soap_namespaces_parse(soap); parser->namespaces = parser->_namespaces; parser->version = _soap_version_parse(xml, parser->namespaces); if (parser->version == CWMP_VERSION_1_2) { if (parser->supported_cwmp_versions != 0 && parser->use_cwmp_version != 0) { parser->version = CWMP_VERSION_1_4; } else if (parser->session_timeout > 0) { parser->version = CWMP_VERSION_1_3; } } if (soap_recv_fault(soap, 1) != 0) { parser->type = CWMP_MSG_FAULT; _soap_fault_dump(soap->fault); if (soap->fault != NULL && soap->fault->detail != NULL && soap->fault->detail->__type == SOAP_TYPE__cwmp__Fault) { struct _cwmp__Fault *cwmp_fault; cwmp_fault = (struct _cwmp__Fault *)soap->fault->detail->fault; if (cwmp_fault != NULL) { if (cwmp_fault->FaultCode != NULL) { parser->fault_code = atoi(cwmp_fault->FaultCode); } parser->fault_string = cwmp_fault->FaultString; parser->fault_body = cwmp_fault; parser->body = cwmp_fault; } } return 0; } int gsoap_type; parser->body = soap_getelement(soap, &gsoap_type); parser->type = _get_cwmp_type(gsoap_type); if (soap->error) { LOGE(LOG_TAG, "get cwmp body failed, error=%d", soap->error); return -1; } if (soap_body_end_in(soap) || soap_envelope_end_in(soap) || soap_end_recv(soap)) { LOGE(LOG_TAG, "end decode failed, %d", soap->error); return -1; } close(fd[0]); return 0; }
/** * Constructor for DataLocationInterface * * @param endpoint SOAP endpoint (URL) of the remote catalogue * example: http://localhost:8085/ */ dli::DataLocationInterfaceSOAP::DataLocationInterfaceSOAP() : m_ctx(0) { soap_init1(&m_soap, SOAP_IO_KEEPALIVE); // SOAP_IO_KEEPALIVE/SOAP_IO_CHUNK m_soap.namespaces = datalocationinterface_namespaces; }
gpointer onvif_discovery_server_thread_func(gpointer data) { IpcamIOnvifDiscovery *ionvif_discovery = IPCAM_IONVIF_DISCOVERY(data); SOAP_SOCKET m, s; struct soap soap; soap_init1(&soap, SOAP_IO_UDP); soap.user = ionvif_discovery; /* reuse address */ soap.bind_flags = SO_REUSEADDR; m = soap_bind(&soap, NULL, ONVIF_DISCOVERY_PORT, 100); if (!soap_valid_socket(m)) { soap_print_fault(&soap, stderr); exit(-1); } /* optionally join a multicast group */ if (ONVIF_MULTICAST_GROUP) { struct ifaddrs *ifaddr, *ifa; if (getifaddrs(&ifaddr) == -1) { perror("getifaddrs"); exit(-1); } for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { if (ifa->ifa_addr == NULL) continue; int family = ifa->ifa_addr->sa_family; if ((family == AF_PACKET) && (ifa->ifa_flags & IFF_MULTICAST)) { struct ifreq ifr; struct ip_mreqn mreqn; strncpy(ifr.ifr_name, ifa->ifa_name, IFNAMSIZ); if (ioctl(soap.socket, SIOCGIFINDEX, &ifr)) { perror("ioctl"); continue; } mreqn.imr_multiaddr.s_addr = inet_addr(ONVIF_MULTICAST_GROUP); mreqn.imr_address.s_addr = htonl(INADDR_ANY); mreqn.imr_ifindex = ifr.ifr_ifindex; if (setsockopt(soap.socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreqn, sizeof(mreqn)) < 0) { perror("setsockopt failed:"); continue; } printf("Add %s to multicast group\n", ifa->ifa_name); } } freeifaddrs(ifaddr); } for (;;) { s = soap_accept(&soap); if (!soap_valid_socket(s)) { soap_print_fault(&soap, stderr); exit(-1); } if (soap_serve(&soap) != SOAP_OK) { soap_print_fault(&soap, stderr); } soap_destroy(&soap); soap_end(&soap); } soap_done(&soap); return 0; }
int main(int argc, char *argv[]) { long_t master; int32_t Signal; GMI_RESULT Result = GMI_SUCCESS; struct soap soap; sigset_t NewMask; sigset_t OldMask; struct sigaction Sa; //signal Sa.sa_handler = SignalHandler; sigfillset(&Sa.sa_mask); Sa.sa_flags = SA_NOMASK; sigemptyset(&NewMask); for (Signal = 1; Signal <= _NSIG; ++Signal) { if ( ( Signal == SIGIO ) || ( Signal == SIGPOLL ) || ( Signal == SIGINT ) || ( Signal == SIGQUIT ) || ( Signal == SIGHUP ) || ( Signal == SIGPIPE ) || ( Signal == SIGSEGV ) ) { sigaction(Signal, &Sa, NULL); } else { sigaddset(&NewMask, Signal); } } sigprocmask(SIG_BLOCK, &NewMask, &OldMask); //get debug opt const char_t *OptString = "ei"; struct option Opts[] = { {"error", no_argument, NULL, 'e'}, {"info", no_argument, NULL, 'i'}, {0, 0, 0, 0}, }; int C; boolean_t ErrLog = false; boolean_t InfoLog = false; while ((C = getopt_long(argc, argv, OptString, Opts, NULL)) != -1) { switch (C) { case 'e': ErrLog = true; break; case 'i': InfoLog = true; break; default: break; } printf("opts:%d:%d\n", ErrLog, InfoLog); } //log init Result = LogInitial(ErrLog, InfoLog); if (FAILED(Result)) { ONVIF_ERROR("LogInitial fail, Result = 0x%lx\n", Result); return Result; } //daemon register to daemon server Result = DaemonRegister(); if (FAILED(Result)) { ONVIF_ERROR("DaemonRegister fail, Result = 0x%lx\n", Result); DEBUG_LOG(g_DefaultLogClient, e_DebugLogLevel_Exception, " DaemonRegister fail, Result = 0x%lx\n", Result); return Result; } //system initial Result = SysInitialize(GMI_ONVIF_AUTH_PORT); if (FAILED(Result)) { DaemonUnregister(); ONVIF_ERROR("SysInitialize fail, Result = 0x%lx\n", Result); DEBUG_LOG(g_DefaultLogClient, e_DebugLogLevel_Exception, " SysInitialize fail, Result = 0x%lx\n", Result); return Result; } //get onvif port, rtsp port uint16_t SessionId = 0; uint32_t AuthValue = 0; SysPkgNetworkPort SysNetworkPort; Result = SysGetNetworkPort(SessionId, AuthValue, &SysNetworkPort); if (FAILED(Result)) { g_ONVIF_Port = DEFAULT_SERVER_PORT; g_RTSP_Port = DEFAULT_RTSP_PORT; ONVIF_ERROR("SysGetNetworkPort fail, Result = 0x%lx\n", Result); } else { g_ONVIF_Port = SysNetworkPort.s_ONVIF_Port; g_RTSP_Port = SysNetworkPort.s_RTSP_Port; } ONVIF_INFO("ONVIF_Port %d, RTSP_Port %d\n", g_ONVIF_Port, g_RTSP_Port); //ptz service __tptz__Initialize(); //soap server init soap_init1(&soap, SOAP_ENC_MTOM); soap.socket_flags = MSG_NOSIGNAL; soap.accept_flags |= SO_LINGER; soap.connect_flags |= SO_LINGER; soap.linger_time = 2; soap.bind_flags = SO_REUSEADDR; soap.send_timeout = 2; soap.recv_timeout = 2; soap.accept_timeout = 10; soap.connect_timeout = 10; soap.keep_alive = 5; soap_set_mode(&soap, SOAP_C_UTFSTRING); master = soap_bind(&soap, NULL, g_ONVIF_Port, 30); if (!soap_valid_socket(master)) { ONVIF_ERROR("soap_bind fail, Result = 0x%lx\n", Result); DEBUG_LOG(g_DefaultLogClient, e_DebugLogLevel_Exception, " soap_bind fail, Result = 0x%lx\n", Result); soap_print_fault(&soap, stderr); SysDeinitialize(); DaemonUnregister(); exit(1); } //main server start ServerLoop(&soap); ONVIF_INFO("soap_end start\n"); //soap release soap_end(&soap); soap_done(&soap); ONVIF_INFO("soap_end stop\n"); //ptz deinitialize __tptz__Deinitialize(); ONVIF_INFO("SysDeinitialize start\n"); SysDeinitialize(); ONVIF_INFO("SysDeinitialize end\n"); ONVIF_INFO("DaemonUnregister start\n"); //daemon unregister DaemonUnregister(); ONVIF_INFO("DaemonUnregister end\n"); return 0; }
//////////////////////////////////////////////////////////////////////////////// // // Main // //////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { (void) signal(SIGINT, signalhandler_func); #if 1 struct soap soap; char *s = getenv("TMPDIR"); if (s) TMPDIR = s; // use HTTP chunking when possible // chunking allows streaming of DIME content without requiring DIME attachment size to be set // DIME attachments can be streamed without chunking only if the attachment size is set soap_init1(&soap, SOAP_IO_KEEPALIVE | SOAP_IO_CHUNK); // set DIME callbacks soap.fdimereadopen = dime_read_open; soap.fdimereadclose = dime_read_close; soap.fdimeread = dime_read; soap.fdimewriteopen = dime_write_open; soap.fdimewriteclose = dime_write_close; soap.fdimewrite = dime_write; #ifdef _POSIX_THREADS pthread_t tid; #endif struct soap *tsoap; int port = 8085; int m, sk, i; if (soap_ssl_server_context(&soap, SOAP_SSL_DEFAULT | SOAP_SSL_SKIP_HOST_CHECK, /* use SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION to verify clients: client must provide a key file e.g. "client.pem" and "password" */ "server.pem", /* keyfile (cert+key): see README.txt to create this file */ "password", /* password to read the private key in the key file */ "cacert.pem", /* cacert file to store trusted certificates (to authenticate clients), see README.txt */ NULL, /* capath */ "dh2048.pem", /* DH file name or DH param key len bits in string (e.g. "2048"), if NULL then RSA with 2048 bits is used instead (bits defined by SOAP_SSL_RSA_BITS) */ NULL, /* if randfile!=NULL: use a file with random data to seed randomness */ "sslserver" /* server identification for SSL session cache (unique server name, e.g. use argv[0]) */ )) { soap_print_fault(&soap, stderr); exit(1); } // Unix SIGPIPE, this is OS dependent: // soap.accept_flags = SO_NOSIGPIPE; // some systems like this // soap.socket_flags = MSG_NOSIGNAL; // others need this // signal(SIGPIPE, sigpipe_handle); // or a sigpipe handler (portable) // port is first command line argument //port = atoi(argv[1]); // bind to current host and specified port m = soap_bind(&soap, NULL, port, BACKLOG); // if we could not bind, exit if (m < 0) { soap_print_fault(&soap, stderr); exit(1); } fprintf(stderr, "Socket connection successful %d, port %d \n", m, port); // die after 24 hrs waiting for activity on port soap.accept_timeout = 24*60*60; // IO timeouts soap.send_timeout = 30; soap.recv_timeout = 30; // loop through requests //for (i = 1; ; i++) while(is_main_running) { // accept request sk = soap_accept(&soap); // if timeout or error, report if (sk < 0) { if (soap.errnum) soap_print_fault(&soap, stderr); else fprintf(stderr, "Server timed out\n"); break; } fprintf(stderr, "Thread %d accepts socket %d connection from IP %d.%d.%d.%d\n", i, s, (int)(soap.ip>>24)&0xFF, (int)(soap.ip>>16)&0xFF, (int)(soap.ip>>8)&0xFF, (int)soap.ip&0xFF); // copy soap environment and spawn thread (if Pthreads is installed) tsoap = soap_copy(&soap); #ifdef _POSIX_THREADS pthread_create(&tid, NULL, (void*(*)(void*))process_request, (void*)tsoap); #else process_request((void*)tsoap); #endif } // detach soap_done(&soap); #endif return 0; }
int grisu_init(void) { gint value=0; const gchar *home; /* soap setup */ //soap_init(&soap); /* enable MTOM for file xfer -> attachment/streaming */ soap_init1(&soap, SOAP_ENC_MTOM); /* grisu init */ if (!grisu_username) grisu_username = grid_random_alpha(10); if (!grisu_password) grisu_password = grid_random_alphanum(12); if (!grisu_server) grisu_server=g_strdup("myproxy.arcs.org.au"); // FIXME - sometimes needed when myproxy plays up also might need to setenv // MYPROXY_SERVER_DN = /C=AU/O=APACGrid/OU=VPAC/CN=myproxy2.arcs.org.au // grisu_server=g_strdup("myproxy2.arcs.org.au"); if (!grisu_port) grisu_port=g_strdup("7512"); /* certificate path init */ home = g_get_home_dir(); if (home) grisu_cert_path = g_build_filename(home, ".globus", "certificates", NULL); if (!g_file_test(grisu_cert_path, G_FILE_TEST_IS_DIR)) { printf("ERROR in grisu_init(), bad certificate location: %s\n", grisu_cert_path); g_free(grisu_cert_path); /* don't return if no certs - we can soldier on */ /* as it's only myproxy-init that won't work */ grisu_cert_path=NULL; } #if DEBUG_GRISU_CLIENT printf("Using certificate location: %s\n", grisu_cert_path); #endif /* use SOAP_SSL_DEFAULT in production code */ /* keyfile: required only when client must authenticate to server */ /* password to read the keyfile */ /* optional cacert file to store trusted certificates */ /* optional capath to directory with trusted certificates */ /* if randfile!=NULL: use a file with random data to seed randomness */ /* if (soap_ssl_client_context(&soap, SOAP_SSL_NO_AUTHENTICATION, NULL, NULL, NULL, NULL, NULL)) */ /* CURRENT - to verify server we use the standard (CA signed) certificates */ /* CURRENT - if no certs is this secure? */ /* if (soap_ssl_client_context(&soap, SOAP_SSL_DEFAULT, NULL, NULL, NULL, path, NULL)) */ /* CURRENT - this has to be done before all calls anyway ... */ /* create header for soap struct with grisu authentication info */ /* grisu_auth_header(); */ /* if (soap_ssl_client_context(&soap, SOAP_SSL_SKIP_HOST_CHECK, NULL, NULL, NULL, path, NULL)) { soap_print_fault(&soap, stderr); value = 1; } else { #if DEBUG_GRISU_CLIENT printf("Requiring secure context.\n"); #endif } */ return(value); }