/** * Initializes this task database * * @return true if successful */ bool FTestTrackProvider::Init() { TDLOG( TEXT( "TestTrack: Initializing TestTrack provider" ) ); // Allocate SOAP interface to TestTrack Pro TestTrackSoap = new ttsoapcgi(); check( TestTrackSoap != NULL ); // @todo: Are there any other SOAP options we want to be configuring here? // Disable multi-referenced strings (href="#_12"). This makes the XML structures larger but // TestTrack doesn't support resolving graph references. This effectively changes the graph // to a tree with duplicated strings where needed. soap_clr_omode( TestTrackSoap->soap, SOAP_XML_GRAPH ); soap_set_omode( TestTrackSoap->soap, SOAP_XML_TREE ); // Set timeouts for SOAP network I/O TestTrackSoap->soap->recv_timeout = 10000; /* when > 0, gives socket recv timeout in seconds, < 0 in usec */ TestTrackSoap->soap->send_timeout = 4000; /* when > 0, gives socket send timeout in seconds, < 0 in usec */ TestTrackSoap->soap->connect_timeout = 4000; /* when > 0, gives socket connect() timeout in seconds, < 0 in usec */ TestTrackSoap->soap->accept_timeout = 4000; /* when > 0, gives socket accept() timeout in seconds, < 0 in usec */ TDLOG( TEXT( "TestTrack: TestTrack provider finished initializing" ) ); return true; }
int main() { struct soap soap; soap_init2(&soap, SOAP_IO_KEEPALIVE, SOAP_IO_KEEPALIVE | SOAP_XML_INDENT); /* Events A to C do not generate a response from the server */ fprintf(stderr, "Client Sends Event: A\n"); if (soap_send_ns__handle(&soap, event_handler_endpoint, event_handler_action, EVENT_A)) soap_print_fault(&soap, stderr); if (synchronous && soap_recv_empty_response(&soap)) soap_print_fault(&soap, stderr); fprintf(stderr, "Client Sends Event: B\n"); if (soap_send_ns__handle(&soap, event_handler_endpoint, event_handler_action, EVENT_B)) soap_print_fault(&soap, stderr); if (synchronous && soap_recv_empty_response(&soap)) soap_print_fault(&soap, stderr); /* reset keep-alive when client needs to inform the server that it will close the connection. It may reconnect later */ soap_clr_omode(&soap, SOAP_IO_KEEPALIVE); fprintf(stderr, "Client Sends Event: C\n"); if (soap_send_ns__handle(&soap, event_handler_endpoint, event_handler_action, EVENT_C)) soap_print_fault(&soap, stderr); if (synchronous && soap_recv_empty_response(&soap)) soap_print_fault(&soap, stderr); /* close the socket */ soap_closesock(&soap); /* re-enable keep-alive which is required to accept and execute multiple receives */ soap_set_omode(&soap, SOAP_IO_KEEPALIVE); /* Events Z generates a series of response from the server */ fprintf(stderr, "Client Sends Event: Z\n"); if (soap_send_ns__handle(&soap, event_handler_endpoint, event_handler_action, EVENT_Z)) soap_print_fault(&soap, stderr); else { struct ns__handle response; for (;;) { if (!soap_valid_socket(soap.socket)) { fprintf(stderr, "Connection was terminated (keep alive disabled?)\n"); break; } if (soap_recv_ns__handle(&soap, &response)) { if (soap.error == SOAP_EOF) fprintf(stderr, "Connection was gracefully closed by server\n"); else soap_print_fault(&soap, stderr); break; } else { switch (response.event) { case EVENT_A: fprintf(stderr, "Client Received Event: A\n"); break; case EVENT_B: fprintf(stderr, "Client Received Event: B\n"); break; case EVENT_C: fprintf(stderr, "Client Received Event: C\n"); break; case EVENT_Z: fprintf(stderr, "Client Received Event: Z\n"); break; } } } } soap_closesock(&soap); /* soap_send operations keep the socket open to possibly accept responses, so we need to explicitly close the socket now */ soap_end(&soap); /* this will close the socket too (if keep alive is off), just in case */ soap_done(&soap); /* detach environment (also closes sockets even with keep-alive) */ return 0; }
std::ostream &operator<<(std::ostream &o, const MultiXTpm__ConfigData &p) { if (!p.soap) return o; // need a gSOAP environment to serialize std::ostream *os = p.soap->os; p.soap->os = &o; soap_omode(p.soap, SOAP_XML_GRAPH); // XML tree or graph p.soap_serialize(p.soap); soap_begin_send(p.soap); p.soap_put(p.soap, "ConfigData", NULL); soap_end_send(p.soap); p.soap->os = os; soap_clr_omode(p.soap, SOAP_XML_GRAPH); return o; }
int main() { struct soap *ctx = soap_new1(SOAP_XML_INDENT); soap_set_namespaces(ctx, nosoap_nsmap); // a tree: Graph tree; // with 5 branches: for (int i = 0; i < 4; ++i) { Graph *branch = soap_new_Graph(ctx); tree.edges.push_back(branch); // each branch has a couple of leaves: for (int j = 0; j < i; ++j) branch->edges.push_back(soap_new_Graph(ctx)); } std::cout << "**** XML TREE FROM C++ TREE ****" << std::endl; soap_write_Graph(ctx, &tree); std::cout << std::endl << std::endl; std::cout << "**** XML TREE FROM C++ DIGRAPH ****" << std::endl; tree.edges[0] = tree.edges[1]; // first pair of edges point to shared node tree.edges[2] = tree.edges[3]; // second pair of edges point to shared node soap_write_Graph(ctx, &tree); std::cout << std::endl << std::endl; std::cout << "**** XML ID-REF DIGRAPH FROM C++ DIGRAPH ****" << std::endl; soap_set_omode(ctx, SOAP_XML_GRAPH); soap_write_Graph(ctx, &tree); std::cout << std::endl << std::endl; soap_clr_omode(ctx, SOAP_XML_GRAPH); std::cout << "**** XML ID-REF DIGRAPH FROM C++ CYCLIC GRAPH ****" << std::endl; tree.edges[0]->edges = tree.edges; // create cycle soap_set_omode(ctx, SOAP_XML_GRAPH); soap_write_Graph(ctx, &tree); std::cout << std::endl << std::endl; soap_clr_omode(ctx, SOAP_XML_GRAPH); std::cout << "**** XML TREE (PRUNED CYCLIC BRANCHES) FROM C++ CYCLIC GRAPH ****" << std::endl; soap_set_omode(ctx, SOAP_XML_TREE); soap_write_Graph(ctx, &tree); std::cout << std::endl << std::endl; soap_clr_omode(ctx, SOAP_XML_TREE); std::cout << "**** SOAP 1.1 ENCODED GRAPH FROM C++ CYCLIC GRAPH ****" << std::endl; soap_set_namespaces(ctx, soap11_nsmap); soap_set_version(ctx, 1); // enable SOAP 1.1 soap_write_Graph(ctx, &tree); std::cout << std::endl << std::endl; std::cout << "**** SOAP 1.2 ENCODED GRAPH FROM C++ CYCLIC GRAPH ****" << std::endl; soap_set_namespaces(ctx, soap12_nsmap); soap_set_version(ctx, 2); // enable SOAP 1.2 soap_write_Graph(ctx, &tree); std::cout << std::endl << std::endl; soap_destroy(ctx); // delete objects soap_end(ctx); // free temp data soap_free(ctx); // release context return 0; }
messages_t* getMessages(struct soap* soap, char* date) { struct _ns1__messageResponseTypeDef* msgs = getMessage(soap, new_reqList(soap, "getMessageAll", "sent", "greaterthan", date)); if (msgs) { int old_fd = soap->sendfd; messages_t* msg_t = NULL; msg_t = (messages_t*) malloc(sizeof(messages_t)); if (!msg_t) { perror("Error converting alerts to text. Out of memory [0]"); return NULL; } msg_t->size = msgs->__sizealert; msg_t->alerts = (char**) malloc(sizeof(char*)*(msg_t->size)); if (!msg_t->alerts) { perror("Error converting alerts to text. Out of memory [1]"); free(msg_t); return NULL; } msg_t->ids = (char**) malloc(sizeof(char*)*(msg_t->size)); if (!msg_t->ids) { perror("Error converting alerts to text. Out of memory [2]"); free(msg_t->alerts); free(msg_t); return NULL; } msg_t->expires = (time_t**) malloc(sizeof(time_t*)*(msg_t->size)); if (!msg_t->ids) { perror("Error converting alerts to text. Out of memory [3]"); free(msg_t->ids); free(msg_t->alerts); free(msg_t); return NULL; } for (unsigned int i = 0; i < msg_t->size; i++) { msg_t->alerts[i] = NULL; msg_t->ids[i] = NULL; msg_t->expires[i] = NULL; } for (int i = 0; i < msgs->__sizealert; i++) { FILE* tmpf = tmpfile(); struct stat stbuf; soap->sendfd = fileno(tmpf); soap_set_omode(soap, SOAP_ENC_XML); soap_begin_send(soap); soap_serialize__ns4__alert(soap, &(msgs->ns4__alert[i])); soap_put__ns4__alert(soap, &(msgs->ns4__alert[i]), NULL, NULL); soap_end_send(soap); soap_clr_omode(soap, SOAP_ENC_XML); soap->sendfd = old_fd; if ( fstat(fileno(tmpf), &stbuf) == -1 ) { perror("Encountered error converting alert to text"); goto error_inconsistent_msg_t; } msg_t->alerts[i] = (char*) malloc(stbuf.st_size+1); if (msg_t->alerts[i]) { rewind(tmpf); if (fread(msg_t->alerts[i], stbuf.st_size, 1, tmpf) < 1) { perror("Incomplete conversion of alert to text. Discarding"); free(msg_t->alerts[i]); goto error_inconsistent_msg_t; } msg_t->alerts[i][stbuf.st_size] = '\0'; fclose(tmpf); msg_t->ids[i] = strdup(msgs->ns4__alert[i].identifier); if (!msg_t->ids[i]) { perror("Incomplete conversion of alert to text, discarding"); free(msg_t->alerts[i]); goto error_inconsistent_msg_t; } // Get the latest expiration date for(int j = 0; j < msgs->ns4__alert[i].__sizeinfo; j++) { if (msg_t->expires[i] == NULL) { // Don't alloc more than once msg_t->expires[i] = malloc(sizeof(time_t)); if (msg_t->expires[i]) { if (msgs->ns4__alert[i].info) { if (msgs->ns4__alert[i].info[j].expires) { *(msg_t->expires[i]) = *(msgs->ns4__alert[i].info[j].expires); } else { error(0, 0, "Allocated info doesn't have expires field"); free(msg_t->expires[i]); msg_t->expires[i] = NULL; } } else { error(0, 0, "Despite the sizeinfo %d, no allocation at info %d", msgs->ns4__alert[i].__sizeinfo, j); } } else { perror("Incomplete conversion of alert to text, discarding"); free(msg_t->alerts[i]); free(msg_t->ids[i]); goto error_inconsistent_msg_t; } } else { if (difftime(*msg_t->expires[i],*(msgs->ns4__alert[i].info[j].expires)) < 0.) { *(msg_t->expires[i]) = *(msgs->ns4__alert[i].info[j].expires); } } } // If there was no info block, make it expire in a week. if (msg_t->expires[i] == NULL) { msg_t->expires[i] = malloc(sizeof(time_t)); if (msg_t->expires[i]) *(msg_t->expires[i]) = msgs->ns4__alert[i].sent + 60*60*24*7; else { perror("Incomplete conversion of alert to text, discarding"); free(msg_t->alerts[i]); free(msg_t->ids[i]); goto error_inconsistent_msg_t; } } } else { perror("Ran out of memory converting alert to text"); goto error_inconsistent_msg_t; } continue; error_inconsistent_msg_t: fclose(tmpf); if ( i > 0 ) { msg_t->size = i; return msg_t; } else { perror("Unable to convert alerts to text [2]"); free(msg_t->expires); free(msg_t->ids); free(msg_t->alerts); free(msg_t); return NULL; } } return msg_t; } else { perror("Error retreiving alerts"); return NULL; } }