rmc_register_alias (const char *guid, const char *lfn, char *errbuf, int errbufsz) { struct rmc__addAliasResponse out; int ret; int sav_errno = 0; struct soap soap; if (rmc_init (&soap, errbuf, errbufsz) < 0) return (-1); if ((ret = soap_call_rmc__addAlias (&soap, rmc_endpoint, "", (char *) guid, (char *) lfn, &out))) { if (ret == SOAP_FAULT) { if (strstr (soap.fault->faultcode, "ALIASEXISTS")) sav_errno = EEXIST; else if (strstr (soap.fault->faultcode, "VALUETOOLONG")) sav_errno = ENAMETOOLONG; else { gfal_errmsg (errbuf, errbufsz, GFAL_ERRLEVEL_ERROR, "%s", soap.fault->faultstring); sav_errno = ECOMM; } } else { gfal_errmsg (errbuf, errbufsz, GFAL_ERRLEVEL_ERROR, "%s", soap.fault->faultstring); sav_errno = ECOMM; } soap_end (&soap); soap_done (&soap); errno = sav_errno; return (-1); } soap_end (&soap); soap_done (&soap); return (0); }
char * rmc_guidfromlfn (const char *lfn, char *errbuf, int errbufsz) { struct rmc__guidForAliasResponse out; char *p; int ret; int sav_errno = 0; struct soap soap; if (rmc_init (&soap, errbuf, errbufsz) < 0) return (NULL); if ((ret = soap_call_rmc__guidForAlias (&soap, rmc_endpoint, "", (char *) lfn, &out))) { if (ret == SOAP_FAULT && strstr (soap.fault->faultcode, "NOSUCHALIAS")) sav_errno = ENOENT; else { gfal_errmsg (errbuf, errbufsz, GFAL_ERRLEVEL_ERROR, "%s", soap.fault->faultstring); sav_errno = ECOMM; } soap_end (&soap); soap_done (&soap); errno = sav_errno; return (NULL); } else { p = strdup (out._guidForAliasReturn); soap_end (&soap); soap_done (&soap); return (p); } }
char * lrc_guidforpfn (const char *pfn, char *errbuf, int errbufsz) { struct lrc__guidForPfnResponse out; char *p; int ret; int sav_errno = 0; struct soap soap; if (lrc_init (&soap, errbuf, errbufsz) < 0) return (NULL); if ((ret = soap_call_lrc__guidForPfn (&soap, lrc_endpoint, "", (char *) pfn, &out))) { if (ret == SOAP_FAULT && strstr (soap.fault->faultcode, "NOSUCHPFN")) { sav_errno = ENOENT; } else { gfal_errmsg (errbuf, errbufsz, GFAL_ERRLEVEL_ERROR, "%s", soap.fault->faultstring); sav_errno = ECOMM; } soap_end (&soap); soap_done (&soap); errno = sav_errno; return (NULL); } p = strdup (out._guidForPfnReturn); soap_end (&soap); soap_done (&soap); return (p); }
lrc_setfilesize (const char *pfn, GFAL_LONG64 filesize, char *errbuf, int errbufsz) { struct lrc__setStringPfnAttributeResponse out; int ret; int sav_errno = 0; struct soap soap; char tmpbuf[21]; if (lrc_init (&soap, errbuf, errbufsz) < 0) return (-1); sprintf (tmpbuf, GFAL_LONG64_FORMAT, filesize); if ((ret = soap_call_lrc__setStringPfnAttribute (&soap, lrc_endpoint, "", (char *) pfn, "size", tmpbuf, &out))) { if (ret == SOAP_FAULT && strstr (soap.fault->faultcode, "NOSUCHPFN")) { sav_errno = ENOENT; } else { gfal_errmsg (errbuf, errbufsz, GFAL_ERRLEVEL_ERROR, "%s", soap.fault->faultstring); sav_errno = ECOMM; } soap_end (&soap); soap_done (&soap); errno = sav_errno; return (-1); } soap_end (&soap); soap_done (&soap); return (0); }
int lrc_replica_exists (const char *guid, char *errbuf, int errbufsz) { struct lrc__getPfnsResponse out; int ret; int sav_errno = 0; struct soap soap; if (lrc_init (&soap, errbuf, errbufsz) < 0) return (-1); if ((ret = soap_call_lrc__getPfns (&soap, lrc_endpoint, "", (char *) guid, &out))) { if (ret == SOAP_FAULT && strstr (soap.fault->faultcode, "NOSUCHGUID")) { sav_errno = 0; } else { gfal_errmsg (errbuf, errbufsz, GFAL_ERRLEVEL_ERROR, "%s", soap.fault->faultstring); sav_errno = ECOMM; } soap_end (&soap); soap_done (&soap); // return 'false' if guid does not exist in LRC if(sav_errno == 0) return (0); errno = sav_errno; return (-1); } soap_end (&soap); soap_done (&soap); return (out._getPfnsReturn->__size==0?0:1); }
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; }
std::ostream &operator<<(std::ostream &o, const struct soap_dom_element &e) { if (!e.soap) { struct soap soap; soap_init2(&soap, SOAP_IO_DEFAULT, SOAP_XML_GRAPH); soap_mark_xsd__anyType(&soap, &e); soap_begin_send(&soap); soap_put_xsd__anyType(&soap, &e, NULL, NULL); soap_end_send(&soap); soap_end(&soap); soap_done(&soap); } else { std::ostream *os = e.soap->os; e.soap->os = &o; short omode = e.soap->omode; soap_set_omode(e.soap, SOAP_XML_GRAPH); soap_mark_xsd__anyType(e.soap, &e); soap_begin_send(e.soap); soap_put_xsd__anyType(e.soap, &e, NULL, NULL); soap_end_send(e.soap); e.soap->os = os; e.soap->omode = omode; } return o; }
int main(int argc, char **argv) { int result = -1; int id_count = 1; struct Namespace namespaces[] = { // {"ns-prefix", "ns-name"} {"SOAP-ENV", "http://www.w3.org/2003/05/soap-envelope"}, // MUST be first {"d", "http://schemas.xmlsoap.org/ws/2005/04/discovery"}, {"wsa", "http://schemas.xmlsoap.org/ws/2004/08/addressing"}, {"dn", "http://www.onvif.org/ver10/network/wsdl"}, // given by the service description {NULL, NULL} // end of table }; // Get UUID uuid_t uuid; char szUuid[36] = {0}; char szMsgID[50] = {0}; uuid_generate_time(uuid); uuid_unparse(uuid, szUuid); snprintf(szMsgID, sizeof(szMsgID), "uuid:%s", szUuid); struct soap soap; struct SOAP_ENV__Header header; // the SOAP Header soap_init(&soap); soap.send_timeout = 1; // 1s timeout soap.recv_timeout = 1; // 1s timeout soap_set_namespaces(&soap, namespaces); soap_default_SOAP_ENV__Header(&soap, &header); // init SOAP Header header.wsa__MessageID = szMsgID; header.wsa__To = "urn:schemas-xmlsoap-org:ws:2005:04:discovery"; header.wsa__Action = "http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe"; soap.header = &header; struct d__ProbeMatchType r; // Send and receive messages over UDP: if (soap_send_d__Probe(&soap, "soap.udp://239.255.255.250:3702", NULL, "", "")) { soap_print_fault(&soap, stderr); } // Send and receive messages over UDP: if (soap_send_d__ProbeMatches(&soap, "soap.udp://239.255.255.250:3702", NULL, NULL)) { soap_print_fault(&soap, stderr); } soap_destroy(&soap); // cleanup soap_end(&soap); // cleanup soap_done(&soap); // close connection (should not use soap struct after this) return 0; }
CWebServiceApi::~CWebServiceApi() { // 关闭SOAP soap_destroy(&clientSOAP); soap_end(&clientSOAP); soap_done(&clientSOAP); }
// Caller needs to free *output if non-NULL void condor_base64_decode(const char *input,unsigned char **output, int *output_length) { ASSERT( input ); ASSERT( output ); ASSERT( output_length ); int input_length = strlen(input); // safe to assume output length is <= input_length *output = (unsigned char *)malloc(input_length + 1); ASSERT( *output ); memset(*output, 0, input_length); struct soap soap; soap_init(&soap); soap_base642s(&soap,input,(char*)(*output),input_length,output_length); soap_destroy(&soap); soap_end(&soap); soap_done(&soap); if( *output_length < 0 ) { free( *output ); *output = NULL; } }
// Caller needs to free the returned pointer char* condor_base64_encode(const unsigned char *input, int length) { char *buff = NULL; if ( length < 1 ) { buff = (char *)malloc(1); buff[0] = '\0'; return buff; } int buff_len = (length+2)/3*4+1; buff = (char *)malloc(buff_len); ASSERT(buff); memset(buff,0,buff_len); struct soap soap; soap_init(&soap); soap_s2base64(&soap,input,buff,length); soap_destroy(&soap); soap_end(&soap); soap_done(&soap); return buff; }
int main() { struct soap soap; int m, s; // master and slave sockets int i; soap_init(&soap); m = soap_bind(&soap, "127.0.0.1", 9111, 100); if (m < 0) soap_print_fault(&soap, stderr); else { fprintf(stderr, "Socket connection successful: master socket = %d\n", m); for (i = 1; ; i++) { s = soap_accept(&soap); if (s < 0) { soap_print_fault(&soap, stderr); break; } fprintf(stderr, "%d: accepted connection from IP=%d.%d.%d.%d socket=%d\n", i, (soap.ip >> 24)&0xFF, (soap.ip>>16)&0xFF, (soap.ip>>8)&0xFF, soap.ip&0xFF, s); if(soap_serve(&soap) != SOAP_OK) // process RPC request soap_print_fault(&soap, stderr); // print error fprintf(stderr,"request served\n"); soap_destroy(&soap); // clean up class instances soap_end(&soap); // clean up everything and close socket } } soap_done(&soap); // close master socket and detach environment }
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; }
void cleanup(struct soap* soap) { /* release our connection and context */ xmpp_conn_release(conn); xmpp_ctx_free(ctx); /* final shutdown of the library */ xmpp_shutdown(); if (rsa_private_key) { EVP_PKEY_free(rsa_private_key); } if (cert) { X509_free(cert); } if (soap) { soap_end(soap); soap_done(soap); soap_free(soap); } ERR_remove_state(0); ENGINE_cleanup(); CONF_modules_unload(1); ERR_free_strings(); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); }
int main(int argc, char**argv) { struct soap soap; int m, s; size = 0; soap_init(&soap); m = soap_bind(&soap, hostname, port, 100); if (m < 0) soap_print_fault(&soap, stderr); else { fprintf(stderr, "Socket connection successful: master socket = %d; port = %d\n", m, port); int i; for (i = 1; ; i++) { s = soap_accept(&soap); if (s < 0) { soap_print_fault(&soap, stderr); break; } fprintf(stderr, "%d: accepted connection from IP=%d.%d.%d.%d socket=%d", i, (soap.ip >> 24)&0xFF, (soap.ip >> 16)&0xFF, (soap.ip >> 8)&0xFF, soap.ip&0xFF, s); if (soap_serve(&soap) != SOAP_OK) soap_print_fault(&soap, stderr); fprintf(stderr, "request served\n"); soap_destroy(&soap); soap_end(&soap); } } soap_done(&soap); }
void cleanup() { pmesg(LOG_INFO, __FILE__, __LINE__, "Server shutdown\n"); oph_server_is_running = 0; sleep(1); mysql_library_end(); soap_destroy(psoap); soap_end(psoap); soap_done(psoap); CRYPTO_thread_cleanup(); if (logfile) { fclose(logfile); fclose(stdout); fclose(stderr); } if (oph_server_params) hashtbl_destroy(oph_server_params); #ifdef OPH_SERVER_LOCATION if (oph_server_location) free(oph_server_location); #endif if (orm) free_oph_rmanager(orm); if (ophDB) oph_odb_free_ophidiadb(ophDB); #if defined(_POSIX_THREADS) || defined(_SC_THREADS) pthread_mutex_destroy(&global_flag); pthread_mutex_destroy(&libssh2_flag); pthread_cond_destroy(&termination_flag); #endif oph_tp_end_xml_parser(); }
int main() { struct _ns1__postMsgToQueue message; struct _ns1__postMsgToQueueResponse response; struct soap *soap; // gSOAP runtime environment message.in0 = "queue/testQueue"; message.in1 = "teste message"; soap = soap_new(); if (!soap) { return 1; } soap_call___ns1__postMsgToQueue(soap, NULL, NULL, &message, &response); /* if (*soap.error) { soap_print_fault(soap, stderr); exit(1); } */ soap_destroy(soap); soap_end(soap); soap_done(soap); }
static void* cms_soapThreadRun( void *thr) { cms_soapThread thread; struct soap* soap; c_char* result; thread = cms_soapThread(thr); os_mutexLock(&thread->soapMutex); while(cms_thread(thread)->terminate == FALSE){ if(thread->soap != NULL){ soap = thread->soap; thread->soap = NULL; cms_thread(thread)->results = NULL; soap->user = thr; soap_serve(soap); soap_destroy(soap); soap_end(soap); soap_done(soap); free(soap); u_entityAction( u_entity(thread->client->service->uservice), cms_soapThreadStatisticsRequestHandledAdd, thread->client->service); if(cms_thread(thread)->results != NULL){ result = (c_char*)(c_iterTakeFirst(cms_thread(thread)->results)); while(result){ os_free(result); result = (c_char*)(c_iterTakeFirst(cms_thread(thread)->results)); } c_iterFree(cms_thread(thread)->results); cms_thread(thread)->results = NULL; } } if(cms_thread(thread)->terminate == FALSE){ cms_thread(thread)->ready = TRUE; if(thread->client->service->configuration->verbosity >= 7){ OS_REPORT_1(OS_INFO, CMS_CONTEXT, 0, "soapThread '%s' ready.", cms_thread(thread)->name); } os_condWait(&thread->condition, &thread->soapMutex); if(thread->client->service->configuration->verbosity >= 7){ OS_REPORT_1(OS_INFO, CMS_CONTEXT, 0, "soapThread '%s' condition triggered.", cms_thread(thread)->name); } } } os_mutexUnlock(&thread->soapMutex); if(thread->client->service->configuration->verbosity >= 6){ OS_REPORT_1(OS_INFO, CMS_CONTEXT, 0, "soapThread '%s' ends.", cms_thread(thread)->name); } return NULL; }
std::ostream &operator<<(std::ostream &o, const struct soap_dom_element &e) { if (!e.soap) { struct soap soap; soap_init2(&soap, SOAP_IO_DEFAULT, SOAP_XML_GRAPH); soap_serialize_xsd__anyType(&soap, &e); soap_begin_send(&soap); soap.ns = 2; /* do not dump namespace table */ soap_out_xsd__anyType(&soap, NULL, 0, &e, NULL); soap_end_send(&soap); soap_end(&soap); soap_done(&soap); } else { std::ostream *os = e.soap->os; e.soap->os = &o; soap_mode omode = e.soap->omode; soap_set_omode(e.soap, SOAP_XML_GRAPH); soap_serialize_xsd__anyType(e.soap, &e); soap_begin_send(e.soap); e.soap->ns = 2; /* do not dump namespace table */ soap_out_xsd__anyType(e.soap, NULL, 0, &e, NULL); soap_end_send(e.soap); e.soap->os = os; e.soap->omode = omode; } return o; }
void TCSoapRunnable::run() { struct soap soap; soap_init(&soap); soap_set_imode(&soap, SOAP_C_UTFSTRING); soap_set_omode(&soap, SOAP_C_UTFSTRING); // check every 3 seconds if world ended soap.accept_timeout = 3; soap.recv_timeout = 5; soap.send_timeout = 5; if (!soap_valid_socket(soap_bind(&soap, _host.c_str(), _port, 100))) { TC_LOG_ERROR("network.soap", "Couldn't bind to %s:%d", _host.c_str(), _port); exit(-1); } TC_LOG_INFO("network.soap", "Bound to http://%s:%d", _host.c_str(), _port); while (!World::IsStopped()) { if (!soap_valid_socket(soap_accept(&soap))) continue; // ran into an accept timeout TC_LOG_DEBUG("network.soap", "Accepted connection from IP=%d.%d.%d.%d", (int)(soap.ip>>24)&0xFF, (int)(soap.ip>>16)&0xFF, (int)(soap.ip>>8)&0xFF, (int)soap.ip&0xFF); struct soap* thread_soap = soap_copy(&soap);// make a safe copy ACE_Message_Block* mb = new ACE_Message_Block(sizeof(struct soap*)); ACE_OS::memcpy(mb->wr_ptr(), &thread_soap, sizeof(struct soap*)); process_message(mb); } soap_done(&soap); }
void TCSoapThread(const std::string& host, uint16 port) { struct soap soap; soap_init(&soap); soap_set_imode(&soap, SOAP_C_UTFSTRING); soap_set_omode(&soap, SOAP_C_UTFSTRING); // check every 3 seconds if world ended soap.accept_timeout = 3; soap.recv_timeout = 5; soap.send_timeout = 5; if (!soap_valid_socket(soap_bind(&soap, host.c_str(), port, 100))) { TC_LOG_ERROR("network.soap", "Couldn't bind to %s:%d", host.c_str(), port); exit(-1); } TC_LOG_INFO("network.soap", "Bound to http://%s:%d", host.c_str(), port); while (!World::IsStopped()) { if (!soap_valid_socket(soap_accept(&soap))) continue; // ran into an accept timeout TC_LOG_DEBUG("network.soap", "Accepted connection from IP=%d.%d.%d.%d", (int)(soap.ip>>24)&0xFF, (int)(soap.ip>>16)&0xFF, (int)(soap.ip>>8)&0xFF, (int)soap.ip&0xFF); struct soap* thread_soap = soap_copy(&soap);// make a safe copy process_message(thread_soap); } soap_done(&soap); }
static void ProcessRequest(void *soap) { int32_t Ret; struct soap *tsoap = (struct soap*)soap; //pthread_detach(pthread_self()); //guoqiang.lu mask,11/20/2013 l_ThreadCnt++; Ret = soap_serve(tsoap); if (SOAP_OK != Ret && (tsoap->error != SOAP_EOF || (tsoap->errnum != 0 && !(tsoap->omode & SOAP_IO_KEEPALIVE)))) { fprintf(stderr, "Thread %d completed with failure %d, Ret %d\n", \ (int)(SOAP_SOCKET)tsoap->user, tsoap->error, Ret); DEBUG_LOG(g_DefaultLogClient, e_DebugLogLevel_Exception, "Thread %d completed with failure %d\n", (int)(SOAP_SOCKET)tsoap->user, tsoap->error); soap_print_fault(tsoap, stderr); } soap_destroy(tsoap); soap_end(tsoap); soap_done(tsoap); soap_free(tsoap); close((SOAP_SOCKET)tsoap->user); l_ThreadCnt--; ONVIF_INFO("======>%s %d exit, Total ThreadCnt %d\n", __func__, __LINE__, l_ThreadCnt); //mask by guoqiang.lu,2014/1/8 //pthread_exit(NULL); }
RequestStatus get( srm_array_of_strings surls, srm_array_of_strings protocols, srm_host_info host_info ) { char srmurl[SRM_MAX_URL_LEN]; RequestStatus rs = NULL; if( fillSrmUrl( srmurl, host_info) ) { int ret; class tns__getResponse out; class ArrayOfstring *arg0 = srm2g_string_array( surls ); class ArrayOfstring *arg1 = srm2g_string_array( protocols ); { struct soap soap; soap_init( &soap ); ret = soap_call_tns__get ( &soap, (const char*)srmurl, "get", arg0, arg1, &out); if ( ret == SOAP_OK ) rs = g2srm_RequestStatus( out._Result ); else soap_print_fault( &soap, stderr ); soap_end( &soap ); soap_done( &soap ); } freeArrayOfstring( arg0 ); freeArrayOfstring( arg1 ); } return rs; }
//srm_array_of_strings getProtocols( srm_host_info host_info ); // RequestStatus getRequestStatus( srm_int requestId, srm_host_info host_info ) { char srmurl[SRM_MAX_URL_LEN]; RequestStatus rs = NULL; if( fillSrmUrl( srmurl, host_info) ) { int ret; class tns__getRequestStatusResponse out; { struct soap soap; soap_init(&soap); ret = soap_call_tns__getRequestStatus( &soap, (const char*)srmurl, "getRequestStatus", (int)requestId, &out ); if ( ret ) soap_print_fault( &soap, stderr ); else rs = g2srm_RequestStatus( out._Result ); soap_end( &soap ); soap_done( &soap ); } } return rs; }
RequestStatus setFileStatus ( srm_int requestId, srm_int fileId, srm_string state, srm_host_info host_info ) { char *statestr = (char*) state; char srmurl[SRM_MAX_URL_LEN]; class tns__setFileStatusResponse out; RequestStatus rs = NULL; if( strcmp("Failed", statestr) && strcmp("Pending", statestr) && strcmp("Ready", statestr) && strcmp("Running", statestr) && strcmp("Done", statestr) ) return NULL; /* String NOT found, the state is invalid, just do nothing */ if( fillSrmUrl( srmurl, host_info) ) { struct soap soap; soap_init(&soap); if ( soap_call_tns__setFileStatus ( &soap, (const char*)srmurl, "setFileStatus", (int)requestId, (int)fileId, state, &out)) soap_print_fault( &soap, stderr ); else rs = g2srm_RequestStatus( out._Result ); soap_end( &soap ); soap_done( &soap ); } return rs; }
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 main(int argc, char **argv) { // initialize EMBASSY info embInitPV("kclique", argc, argv, "KBWS", "1.0.9"); struct soap soap; char* jobid; char* result; AjPFile infile; AjPFile outf; AjPStr substr; AjPStr indata = NULL; AjPStr line = NULL; infile = ajAcdGetInfile("infile"); outf = ajAcdGetOutfile("outfile"); while (ajReadline(infile, &line)) { ajStrAppendS(&indata, line); ajStrAppendC(&indata, "\n"); } soap_init(&soap); char* in0; in0 = ajCharNewS(indata); if ( soap_call_ns1__runClique( &soap, NULL, NULL, in0, &jobid ) == SOAP_OK ) { } else { soap_print_fault(&soap, stderr); } int check = 0; while ( check == 0 ) { if ( soap_call_ns1__checkStatus( &soap, NULL, NULL, jobid, &check ) == SOAP_OK ) { } else { soap_print_fault(&soap, stderr); } sleep(3); } if ( soap_call_ns1__getResult( &soap, NULL, NULL, jobid, &result ) == SOAP_OK ) { substr = ajStrNewC(result); ajFmtPrintF(outf,"%S\n",substr); } else { soap_print_fault(&soap, stderr); } soap_destroy(&soap); soap_end(&soap); soap_done(&soap); ajFileClose(&infile); ajFileClose(&outf); ajStrDel(&substr); embExit(); return 0; }
int ns__changeAdviceDispatchSetting(struct soap* soap, long dispatchSettingId, struct ns__awizoMessage* message, struct ns__dateTimeComplexList *dateTime, long *result) { /* ------------------------------ */ long longRet = 0; long attempt = 0; queueNode_t* iterator = NULL; char* host = NULL; struct soap soap2Eawizo; /* ------------------------------ */ attempt = MAX_ATTEMPT; soap_init2(&soap2Eawizo,SOAP_C_UTFSTRING,SOAP_C_UTFSTRING); iterator = (_GLOBAL_awizoConfig.bmdservers).head; for(;;){ asprintf(&host, "http://%s:%s",((bmdserver_t*)(iterator->node))->addr,((bmdserver_t*)(iterator->node))->port); longRet = soap_call_ns__changeAdviceDispatchSetting(&soap2Eawizo,host,NULL, dispatchSettingId, message, dateTime, result); free0(host); if (longRet == SOAP_OK) { PRINT_INFO("Zapisano rekord w bazie danych\n"); return SOAP_OK; } else { if (iterator->prev){ iterator=iterator->prev; continue; } else if (--attempt <= 0){ PRINT_ERROR("Nie udało się nawiązać połączenia z żadnym z serwerów e-Awiz. Error = %d\n", BMD_ERR_OP_FAILED); //soap_end(&soap2Eawizo); //soap_done(&soap2Eawizo); //return soap_receiver_fault(soap, "Nie udało się nawiązać połączenia z żadnym z serwerów e-Awiz.", NULL); attempt = MAX_ATTEMPT; } iterator = (_GLOBAL_awizoConfig.bmdservers).head; sleep(1); } } soap_end(&soap2Eawizo); soap_done(&soap2Eawizo); return SOAP_OK; }
int main(int argc, char **argv){ struct soap mySoap; char *rpDoc; char *passPtr; const int MAX_LEN = 1024; char input[MAX_LEN]; char username[MAX_LEN]; signal(SIGPIPE, sigpipe_handle); if(argc != 2){ printf("Usage:\n getResourcePropertyDoc <EPR of SWS>\n"); return 1; } snprintf(username, MAX_LEN, "%s", getenv("USER")); soap_init(&mySoap); /* If address of SWS begins with 'https' then initialize SSL context */ if( (strstr(argv[1], "https") == argv[1]) ){ /* - don't bother with mutually-authenticated SSL if( !(passPtr = getpass("Enter passphrase for key: ")) ){ printf("Failed to get passphrase from command line\n"); return 1; } strncpy(input, passPtr, MAX_LEN); */ init_ssl_context(&mySoap, REG_TRUE, NULL,/* user's cert. & key file */ NULL,/* Password to read key file */ "/etc/grid-security/certificates"); } if( !(passPtr = getpass("Enter SWS password: "******"Failed to get SWS password from command line\n"); return 1; } get_resource_property_doc(&mySoap, argv[1], username, passPtr, &rpDoc); fprintf(stdout, "\n\n%s\n\n", rpDoc); /* Explicitly wipe the passphrase from memory */ memset((void *)(input), '\0', MAX_LEN); soap_end(&mySoap); soap_done(&mySoap); return 0; }
Root::~Root() { if (soap_call_ns__release(soap, endpoint, "", status)) soap_print_fault(soap, stderr); // for demo, just print soap_destroy(soap); soap_end(soap); soap_done(soap); free(soap); }