//监听指定端口，事件参考event.c
//用于监听IPC上线或下线、或响应客户探测
//timeout设置超时时间,>0单位为秒 =0 用不超时 <0单位为微秒
static int listenPort(int port,int timeout)
{
struct soap *serv = soap_new1(SOAP_IO_UDP); // to invoke messages
int ret;
//绑定端口号
if (!soap_valid_socket(soap_bind(serv,NULL,port, 100)))
{
soap_print_fault(serv, stderr);
printf("soap_bind error\n");
ret = -1;
goto ERR0;
}
//加入多播地址
struct ip_mreq mreq;
mreq.imr_multiaddr.s_addr = inet_addr("239.255.255.250");
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(serv->socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0)
{
printf("add multiaddr is error\n");
goto ERR0;
}
//监听
ret = soap_wsdd_listen(serv,timeout);
if(ret!=SOAP_OK)
{
soap_print_fault(serv, stderr);
printf("soap_wsdd_listen error,ret=%d\n",ret);
goto ERR0;
}
printf("soap_wsdd_listen return\n");
ERR0:
soap_end(serv);
soap_free(serv);
return ret;
}
int run_serve(int port)
{ struct soap *soap = soap_new1(SOAP_ENC_MTOM); /* enable MTOM */
int ret;
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);
soap->accept_timeout = 3600; /* let server time out after one hour */
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\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_free(soap); /* done and free */
return ret;
}
int main(int argc, char** argv)
{
struct soap* serv = soap_new1(SOAP_IO_UDP | SOAP_IO_KEEPALIVE);
serv->bind_flags=SO_REUSEADDR;
serv->connect_flags = SO_BROADCAST;
if (!soap_valid_socket(soap_bind(serv, NULL, port, 1000)))
{
soap_print_fault(serv, stderr);
exit(1);
}
ip_mreq mcast;
mcast.imr_multiaddr.s_addr = inet_addr(host);
mcast.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(serv->master, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mcast, sizeof(mcast))<0)
{
std::cout << "group membership failed:" << strerror(errno) << std::endl;
}
sendHello();
mainloop(serv);
signal(SIGINT, &sighandler);
while (!stop)
{
mainloop(serv);
}
sendBye();
mainloop(serv);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2)
{
fprintf(stderr, "Usage: json-GitHub hostname [username password]\nFor example: json-GitHub https://api.github.com/orgs/Genivia/repos\n\n");
exit(1);
}
else
{
soap *ctx = soap_new1(SOAP_C_UTFSTRING | SOAP_XML_INDENT);
value response(ctx);
if (argc > 3)
{
/* Basic authentication with username password */
if (strncmp(argv[1], "https", 5))
{
fprintf(stderr, "Basic authentication over http is not secure: use https\n");
exit(1);
}
ctx->userid = argv[2];
ctx->passwd = argv[3];
}
if (json_call(ctx, argv[1], NULL, &response))
soap_print_fault(ctx, stderr);
else
json_write(ctx, response);
printf("\n\nOK\n");
soap_end(ctx);
soap_free(ctx);
}
return 0;
}
//采用单播形式发送probe，发送会马上阻塞等待一个事件响应，事件参考event.c
//只能接收一个event，用于指定地址probe，比如手动添加IPC
static int probeUnicast(const char *endpoint, const char * types, const char *scopes,int timeout)
{
struct soap *soap = soap_new1(SOAP_IO_UDP); // to invoke messages
int ret;
const char *id = soap_wsa_rand_uuid(soap);
//设置超时时间,>0单位为秒 =0 用不超时 <0单位为微秒
soap->accept_timeout = soap->recv_timeout = soap->send_timeout = timeout;
ret = soap_wsdd_Probe(soap,
SOAP_WSDD_MANAGED,//SOAP_WSDD_ADHOC, // ad-hoc mode
SOAP_WSDD_TO_TS, // to a TS
endpoint, // address of TS; "soap.udp://239.255.255.250:3702"
id, // message ID
NULL, // ReplyTo,表示回应的message ID,因为是主动回发起，所以没有，填NULL
types, //types,搜寻的设备类型"dn:NetworkVideoTransmitter tds:Device"
scopes, //scopes,指定搜索范围，无填 NULL
NULL); //match by，匹配规则，无填 NULL
if(ret!=SOAP_OK)
{
soap_print_fault(soap, stderr);
printf("soap_wsdd_Probe error,ret=%d\n",ret);
}
soap_end(soap);
soap_free(soap);
return ret;
}
int main(int argc, char **argv)
{
if (argc < 2)
return soap_serve(soap_new1(SOAP_XML_INDENT));
else if (argc < 3)
return run_serve(atoi(argv[1]));
else
return run_tests(argc, argv);
}
int main()
{
struct soap *soap;
soap = soap_new1(SOAP_C_UTFSTRING|SOAP_IO_STORE);
soap_serve(soap); // call the incoming remote method request dispatcher
return 0;
}
int run_tests(int argc, char **argv)
{
struct soap *soap = soap_new1(SOAP_XML_INDENT);
struct ns__echoString r;
char *endpoint, *arg;
int ret;
soap_register_plugin(soap, http_da);
endpoint = argv[1];
arg = argv[2];
if (strchr(arg, 'c'))
soap_set_omode(soap, SOAP_IO_CHUNK);
if (strchr(arg, 'z'))
soap_set_omode(soap, SOAP_ENC_ZLIB);
if (soap_call_ns__echoString(soap, endpoint, NULL, arg, &r))
{
if (soap->error == 401)
{
if (!strcmp(soap->authrealm, authrealm))
{
/* save userid and passwd for basic or digest authentication */
struct http_da_info info;
http_da_save(soap, &info, authrealm, "Mufasa", "Circle Of Life");
if (!soap_call_ns__echoString(soap, endpoint, NULL, arg, &r))
{
soap_end(soap);
/* need to restore for authentication */
http_da_restore(soap, &info);
if (!soap_call_ns__echoString(soap, endpoint, NULL, arg, &r))
{
if (!strcmp(arg, r.arg))
printf("EchoString test OK\n");
else
printf("Transmission error\n");
}
}
http_da_release(soap, &info);
/* regular calls may follow */
}
}
}
if (soap->error)
soap_print_fault(soap, stderr);
ret = soap->error;
soap_destroy(soap);
soap_end(soap);
soap_free(soap);
return ret;
}
struct soap* init_soap(void) {
FILE *fd = NULL;
struct soap* soap = NULL;
char passwd[10] = {'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'};
soap = soap_new1(SOAP_XML_CANONICAL | SOAP_XML_INDENT);
soap_ssl_init();
// soap_register_plugin(soap, plugin); // register plugin
soap_register_plugin(soap, soap_wsse);
fd = fopen("secrets", "r");
if (fd) {
fgets(passwd, 10, fd);
fclose(fd);
if (passwd == NULL) {
perror("Unable to read password for X509 certificate.");
return NULL;
}
} else {
perror("Unable to open secrets file");
return NULL;
}
fd = fopen("DMOPEN_100014_PRIVATE.pem", "r");
if (fd) {
rsa_private_key = PEM_read_PrivateKey(fd, NULL, NULL, passwd);
fclose(fd);
if (rsa_private_key == NULL) {
perror("Error reading private key");
return NULL;
}
} else {
perror("Unable to open Private X509 .pem file");
return NULL;
}
fd = fopen("DMOPEN_100014.pem", "r");
if (fd) {
cert = PEM_read_X509(fd, NULL, NULL, NULL);
fclose(fd);
if (cert == NULL) {
perror("Error reading certificate file");
return NULL;
}
} else {
perror("Unable to open publix X509 .pem file");
return NULL;
}
return soap;
}
//采用多播形式发送probe，立即返回不阻塞等待事件响应，获取事件响应要主动接下对应的sock或调用soap_wsdd_listen函数，事件参考event.c
//可以接收多个event，用于探测网络中存在的IPC
static int probeMulticast(const char *endpoint, const char * types, const char *scopes,int timeout)
{
struct soap *serv = soap_new1(SOAP_IO_UDP); // to invoke messages
int ret;
const char *id = soap_wsa_rand_uuid(serv);
ret = soap_wsdd_Probe(serv,
SOAP_WSDD_ADHOC,//SOAP_WSDD_ADHOC, // ad-hoc mode
SOAP_WSDD_TO_TS, // to a TS
endpoint, // address of TS; "soap.udp://239.255.255.250:3702"
id, // message ID
NULL, // ReplyTo,表示回应的message ID,因为是主动回发起，所以没有，填NULL
types, //types,搜寻的设备类型"dn:NetworkVideoTransmitter tds:Device"
scopes, //scopes,指定搜索范围，无填 NULL
NULL); //match by，匹配规则，无填 NULL
if(ret!=SOAP_OK)
{
soap_print_fault(serv, stderr);
printf("soap_wsdd_Probe error,ret=%d\n",ret);
goto ERR0;
}
if (!soap_valid_socket(serv->socket))
{
soap_print_fault(serv, stderr);
printf("sock is error\n");
ret = -1;
goto ERR0;
}
serv->master = serv->socket;//必须指定，否则无法监听
ret = soap_wsdd_listen(serv,timeout);
if(ret!=SOAP_OK)
{
soap_print_fault(serv, stderr);
printf("soap_wsdd_listen error,ret=%d\n",ret);
goto ERR0;
}
ERR0:
soap_end(serv);
soap_free(serv);
return ret;
}
void sendBye()
{
struct soap* soap = soap_new1(SOAP_IO_UDP);
printf("call soap_wsdd_Bye\n");
int res = soap_wsdd_Bye(soap,
SOAP_WSDD_ADHOC, // mode
"soap.udp://239.255.255.250:3702", // address of TS
soap_wsa_rand_uuid(soap), // message ID
_endpoint,
NULL,
_type,
NULL,
_xaddr,
_metadataVersion);
if (res != SOAP_OK)
{
soap_print_fault(soap, stderr);
}
soap_end(soap);
}
int run_serve(int port)
{
struct soap *soap = soap_new1(SOAP_XML_INDENT);
int ret;
if (soap_register_plugin(soap, http_da))
exit(1);
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);
soap->accept_timeout = 3600; /* let server time out after one hour */
for (;;)
{
SOAP_SOCKET sock = soap_accept(soap);
if (!soap_valid_socket(sock))
{
if (soap->errnum)
soap_print_fault(soap, stderr);
else
{
fprintf(stderr, "Server timed out\n");
break;
}
}
fprintf(stderr, "Accepting socket %d connection from IP %d.%d.%d.%d\n", 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, "Served\n\n");
soap_destroy(soap);
soap_end(soap);
}
}
ret = soap->error;
soap_destroy(soap);
soap_end(soap);
soap_free(soap);
return ret;
}
int
bes_init(struct bes_context **context)
{
struct bes_context *ctx;
struct soap *soap;
if (context == NULL) {
return BESE_BAD_ARG;
}
ctx = (struct bes_context *)malloc(sizeof(struct bes_context));
if (ctx == NULL) {
// fprintf (stderr, "err 1\n");
return BESE_SYS_ERR;
}
memset(ctx, 0, sizeof(struct bes_context));
soap_ssl_init();
soap = soap_new1(SOAP_C_UTFSTRING);
if (soap == NULL) {
free(ctx);
// fprintf (stderr, "err 2\n");
return BESE_SYS_ERR;
}
soap_set_recv_logfile(soap, NULL);
soap_set_sent_logfile(soap, NULL);
soap_set_test_logfile(soap, NULL);
soap_register_plugin(soap, soap_wsse);
soap_set_namespaces(soap, default_namespaces);
soap_header(soap);
ctx->soap = soap;
*context = ctx;
return BESE_OK;
}
int cgi_server()
{ /* CGI-style: serve request from stdin to stdout */
return soap_serve(soap_new1(SOAP_ENC_MTOM)); /* Enable MTOM XOP attachments */
}
int run_tests(int argc, char **argv)
{ struct soap *soap = soap_new1(SOAP_ENC_MTOM); /* enable MTOM */
int i, ret;
struct x__DataType data;
struct x__WrapperType wrap;
struct m__EchoTestSingleResponse single;
struct m__EchoTestMultipleResponse multiple;
soap_default_x__DataType(soap, &data);
soap_default_x__WrapperType(soap, &wrap);
/* First test call */
data.__union = SOAP_UNION_x__data_base64;
data.choice.base64.__ptr = (unsigned char*)argv[2];
data.choice.base64.__size = (int)strlen(argv[2]) + 1;
if (soap_call_m__EchoTestSingle(soap, argv[1], NULL, &data, &single))
{ soap_print_fault(soap, stderr);
}
else
{ if (!single.x__Data || single.x__Data->__union != SOAP_UNION_x__data_xop__Include || !single.x__Data->choice.xop__Include.__ptr || single.x__Data->choice.xop__Include.__size != data.choice.base64.__size || strcmp((char*)single.x__Data->choice.xop__Include.__ptr, (char*)data.choice.base64.__ptr))
fprintf(stderr, "EchoTestSingle 1: data transcription error\n");
else
fprintf(stderr, "EchoTestSingle 1: OK\n");
/* Second test call */
data.__union = SOAP_UNION_x__data_xop__Include;
data.choice.xop__Include.__ptr = (unsigned char*)argv[2];
data.choice.xop__Include.__size = (int)strlen(argv[2]) + 1;
data.choice.xop__Include.id = NULL;
data.choice.xop__Include.type = "text/xml";
data.choice.xop__Include.options = NULL;
data.xmime5__contentType = "text/xml";
#ifdef WITH_NOIDREF
/* compiling with WITH_NOIDREF removes auto-detection of attachments */
soap_set_mime(soap, NULL, NULL); /* so we explicitly set MIME attachments */
#endif
if (soap_call_m__EchoTestSingle(soap, argv[1], NULL, &data, &single))
{ soap_print_fault(soap, stderr);
}
else
{ if (!single.x__Data
|| single.x__Data->__union != SOAP_UNION_x__data_base64
|| !single.x__Data->choice.base64.__ptr
|| single.x__Data->choice.base64.__size != data.choice.xop__Include.__size
|| strcmp((char*)single.x__Data->choice.base64.__ptr, (char*)data.choice.xop__Include.__ptr))
fprintf(stderr, "EchoTestSingle 2: data transcription error\n");
else
{ fprintf(stderr, "EchoTestSingle 2: OK\n");
/* Third test call */
wrap.__size = argc - 2;
wrap.Data = (struct x__DataType*)soap_malloc(soap, wrap.__size * sizeof(struct x__DataType));
for (i = 0; i < wrap.__size; ++i)
{ soap_default_x__DataType(soap, &wrap.Data[i]);
wrap.Data[i].__union = SOAP_UNION_x__data_base64;
wrap.Data[i].choice.base64.__ptr = (unsigned char*)argv[i + 2];
wrap.Data[i].choice.base64.__size = (int)strlen(argv[i + 2]) + 1;
wrap.Data[i].xmime5__contentType = "text/xml";
}
if (soap_call_m__EchoTestMultiple(soap, argv[1], NULL, &wrap, &multiple))
soap_print_fault(soap, stderr);
else
{ int okay = 1;
if (!multiple.x__EchoTest
|| multiple.x__EchoTest->__size != wrap.__size)
okay = 0;
else
{ for (i = 0; i < multiple.x__EchoTest->__size; ++i)
if (multiple.x__EchoTest->Data[i].__union != SOAP_UNION_x__data_xop__Include
|| !multiple.x__EchoTest->Data[i].choice.xop__Include.__ptr
|| multiple.x__EchoTest->Data[i].choice.xop__Include.__size != wrap.Data[i].choice.base64.__size
|| strcmp((char*)multiple.x__EchoTest->Data[i].choice.xop__Include.__ptr, (char*)wrap.Data[i].choice.base64.__ptr))
okay = 0;
}
if (!okay)
fprintf(stderr, "EchoTestMultiple 1: data transcription error\n");
else
{ fprintf(stderr, "EchoTestMultiple 1: OK\n");
/* Fourth test call */
for (i = 0; i < wrap.__size; ++i)
{ soap_default_x__DataType(soap, &wrap.Data[i]);
wrap.Data[i].__union = SOAP_UNION_x__data_xop__Include;
wrap.Data[i].choice.xop__Include.__ptr = (unsigned char*)argv[i + 2];
wrap.Data[i].choice.xop__Include.__size = (int)strlen(argv[i + 2]) + 1;
wrap.Data[i].choice.xop__Include.id = NULL;
wrap.Data[i].choice.xop__Include.type = "text/xml";
wrap.Data[i].choice.xop__Include.options = NULL;
wrap.Data[i].xmime5__contentType = "text/xml";
}
if (soap_call_m__EchoTestMultiple(soap, argv[1], NULL, &wrap, &multiple))
soap_print_fault(soap, stderr);
else
{ int okay = 1;
if (!multiple.x__EchoTest
|| multiple.x__EchoTest->__size != wrap.__size)
okay = 0;
else
{ for (i = 0; i < multiple.x__EchoTest->__size; ++i)
if (multiple.x__EchoTest->Data[i].__union != SOAP_UNION_x__data_base64
|| !multiple.x__EchoTest->Data[i].choice.base64.__ptr
|| multiple.x__EchoTest->Data[i].choice.base64.__size != wrap.Data[i].choice.xop__Include.__size || strcmp((char*)multiple.x__EchoTest->Data[i].choice.base64.__ptr, (char*)wrap.Data[i].choice.xop__Include.__ptr))
okay = 0;
}
if (!okay)
fprintf(stderr, "EchoTestMultiple 2: data transcription error\n");
else
fprintf(stderr, "EchoTestMultiple 2: OK\n");
}
}
}
}
}
}
ret = soap->error;
soap_destroy(soap);
soap_end(soap);
soap_done(soap);
free(soap);
return ret;
}
int
bes_createActivityFromString(struct bes_context *context,
epr_t endpointepr,
char *jsdl,
epr_t *activityepr)
{
struct soap *s;
struct bes__CreateActivityType req;
struct bes__CreateActivityResponseType rsp;
struct soap_dom_element dom, *tmpdom;
struct soap_dom_attribute *attr;
struct bes_epr *epr;
int jsdl_fd, size = 0, ret = BESE_OK;
char *endpoint, filename[] = "/tmp/XXXXXX";
if (context == NULL
|| endpointepr == NULL
|| jsdl == NULL
|| activityepr == NULL) {
return BESE_BAD_ARG;
}
if ((jsdl_fd = mkstemp(filename)) < 0) {
// fprintf (stderr, "err 4\n");
setErrorString(context, NULL, BESE_SYS_ERR);
return BESE_SYS_ERR;
}
unlink(filename);
if (write(jsdl_fd, jsdl, strlen(jsdl)) < 0) {
close(jsdl_fd);
// fprintf (stderr, "err 5\n");
setErrorString(context, NULL, BESE_SYS_ERR);
return BESE_SYS_ERR;
}
if (lseek(jsdl_fd, 0, SEEK_SET) == -1) {
close(jsdl_fd);
// fprintf (stderr, "err 6\n");
setErrorString(context, NULL, BESE_SYS_ERR);
return BESE_SYS_ERR;
}
s = context->soap;
if (ret = generateAddressingHeaders(context, endpointepr, CREATE_ACT, &endpoint)) {
return ret;
}
memset(&dom, 0, sizeof(struct soap_dom_element));
dom.soap = soap_new1(SOAP_DOM_TREE|SOAP_C_UTFSTRING);
dom.soap->recvfd = jsdl_fd;
if (soap_begin_recv(dom.soap)
|| soap_in_xsd__anyType(dom.soap, NULL, &dom, NULL) == NULL
|| soap_end_recv(dom.soap)) {
setErrorString(context, dom.soap, BESE_SOAP_ERR);
close(jsdl_fd);
ret = BESE_SOAP_ERR;
goto end;
}
close(jsdl_fd);
memset(&req, 0, sizeof(struct bes__CreateActivityType));
memset(&rsp, 0, sizeof(struct bes__CreateActivityResponseType));
req.bes__ActivityDocument.__any = &dom;
if (soap_call___bes__CreateActivity(s, endpoint, CREATE_ACT, &req, &rsp) != SOAP_OK) {
setErrorString(context, s, BESE_SOAP_ERR);
ret = BESE_SOAP_ERR;
goto end;
}
else {
tmpdom = rsp.__any;
cleanDom(tmpdom);
epr = (struct bes_epr *)malloc(sizeof(struct bes_epr));
if (!epr) {
setErrorString(context, NULL, BESE_MEM_ALLOC);
ret = BESE_MEM_ALLOC;
goto end;
}
memset(epr, 0, sizeof(struct bes_epr));
epr->str = generateEPRString(tmpdom, NULL);
if (!epr->str) {
free(epr);
setErrorString(context, NULL, BESE_MEM_ALLOC);
ret = BESE_MEM_ALLOC;
goto end;
}
epr->dom = tmpdom;
*activityepr = (epr_t)epr;
}
end:
soap_end(dom.soap);
soap_done(dom.soap);
free(dom.soap);
return ret;
}
int
bes_readEPRFromFile(struct bes_context *context, char *filename, epr_t *epr)
{
int fd, size = 0, ret = BESE_OK;
struct soap_dom_element *dom;
struct bes_epr *tmpEPR;
struct stat fileStat;
if (context == NULL || epr == NULL || filename == NULL) {
return BESE_BAD_ARG;
}
fd = open(filename, O_RDONLY, 0);
if (fd == -1) {
// fprintf (stderr, "err 9: %s\n", filename);
setErrorString(context, NULL, BESE_SYS_ERR);
return BESE_SYS_ERR;
}
dom = (struct soap_dom_element *)soap_malloc(context->soap, sizeof(struct soap_dom_element));
if (!dom) {
close(fd);
setErrorString(context, NULL, BESE_MEM_ALLOC);
return BESE_MEM_ALLOC;
}
dom->soap = soap_new1(SOAP_DOM_TREE|SOAP_C_UTFSTRING);
dom->soap->recvfd = fd;
if (soap_begin_recv(dom->soap)
|| soap_in_xsd__anyType(dom->soap, NULL, dom, NULL) == NULL
|| soap_end_recv(dom->soap)) {
setErrorString(context, dom->soap, BESE_SOAP_ERR);
ret = BESE_SOAP_ERR;
goto error_end;
}
tmpEPR = (struct bes_epr *)malloc(sizeof(struct bes_epr));
if (!tmpEPR) {
setErrorString(context, NULL, BESE_MEM_ALLOC);
ret = BESE_MEM_ALLOC;
goto error_end;
}
memset(tmpEPR, 0, sizeof(struct bes_epr));
if (lseek(fd, 0, SEEK_SET) == -1) {
free(tmpEPR);
// fprintf (stderr, "err 10\n");
setErrorString(context, NULL, BESE_SYS_ERR);
ret = BESE_SYS_ERR;
goto error_end;
}
if (fstat(fd, &fileStat)) {
free(tmpEPR);
// fprintf (stderr, "err 11\n");
setErrorString(context, NULL, BESE_SYS_ERR);
ret = BESE_SYS_ERR;
goto error_end;
}
size = fileStat.st_size;
tmpEPR->str = (char *)malloc(size + 1);
if (!tmpEPR->str) {
free(tmpEPR);
setErrorString(context, NULL, BESE_MEM_ALLOC);
ret = BESE_MEM_ALLOC;
goto error_end;
}
memset(tmpEPR->str, 0, size + 1);
if (read(fd, tmpEPR->str, size) == -1) {
free(tmpEPR);
// fprintf (stderr, "err 12\n");
setErrorString(context, NULL, BESE_SYS_ERR);
ret = BESE_SYS_ERR;
goto error_end;
}
close(fd);
tmpEPR->dom = dom;
tmpEPR->domCreateFlag = FromMalloc;
*epr = (epr_t)tmpEPR;
return BESE_OK;
error_end:
close(fd);
soap_end(dom->soap);
soap_done(dom->soap);
free(dom->soap);
return ret;
}
int main()
{
bmd_conf *konfiguracja=NULL;
char *serverURL = NULL;
char *host = NULL;
long int ssl_enabled=0;
long int authenticate=0;
char *keyfile=NULL;
char *keyfile_passwd=NULL;
char *keyfile_ssl=NULL;
char *keyfile_passwd_ssl=NULL;
char *cacert=NULL;
char *capath=NULL;
int status = 0;
struct bmd230__mtdsSearchValues *mtds = NULL;
struct bmd230__mtdsValues *formMtds = NULL;
struct bmd230__searchSortInfoList *sortInfo;
struct bmd230__searchResults *searchResults = NULL;
struct xsd__base64Binary *base64Cert = NULL;
int iter=0;
int jupiter=0;
#ifdef ENABLE_WS_SECURITY
bmdWSSecurityClient_t WSSEclientStruct;
#endif /*ifdef ENABLE_WS_SECURITY*/
struct soap *soap = soap_new1(SOAP_XML_CANONICAL); /// !!!!istotne aby wlaczona postac kanoninczna
/*zaladowanie bibliotek ssl-owych*/
SSL_load_error_strings();
SSL_library_init();
/*funkcje konfiguracyjne*/
load_soap_configuration(&konfiguracja);
configuration(konfiguracja,&host,&keyfile,&keyfile_passwd,&keyfile_ssl,&keyfile_passwd_ssl,&cacert,&capath,&ssl_enabled);
/*funkcja ustanowienia połaczenia z serwerem*/
status=connection(soap,ssl_enabled,authenticate,keyfile_ssl,keyfile_passwd_ssl,cacert,capath);
if (status!=SOAP_OK)
{
printf("SOAPCLIENTERR Connection error\n");
return 0;
}
#ifdef ENABLE_WS_SECURITY
/**WS SECURITY BEGIN ******/
status=WSSecurity_client_init(soap, "wszczygiel072010_priv.pem", "12345678", "wszczygiel072010_cert.pem", "HereYouCanSetUserName", "HerYouCanSetPassword", &WSSEclientStruct);
if(status != 0)
{
printf("WS Security client side error\n");
return -1;
}
/**WS SECURITY END ******/
#endif /*ifdef ENABLE_WS_SECURITY*/
/*formularz - wydobywane metadane*/
formMtds = (struct bmd230__mtdsValues *)malloc(sizeof(struct bmd230__mtdsValues));
formMtds->__size = 2;
formMtds->__ptr = (struct bmd230__mtdSingleValue *)malloc(sizeof(struct bmd230__mtdSingleValue)*(formMtds->__size));
/*wlasciciel*/
formMtds->__ptr[0].mtdOid = OID_SYS_METADATA_CRYPTO_OBJECTS_OWNER;
formMtds->__ptr[0].mtdValue = "";
formMtds->__ptr[0].mtdDesc = "";
/*numer faktury*/
formMtds->__ptr[1].mtdOid = "1.2.616.1.113527.4.3.3.1";
formMtds->__ptr[1].mtdValue = "";
formMtds->__ptr[1].mtdDesc = "";
/*przygotowanie danych niezbędnych do uruchomienia funkcji web-owej*/
mtds = (struct bmd230__mtdsSearchValues *)malloc(sizeof(struct bmd230__mtdsSearchValues));
mtds->__size = 3;
mtds->__ptr=(struct bmd230__mtdSearchSingleValue*)malloc(sizeof(struct bmd230__mtdSearchSingleValue)*mtds->__size);
mtds->__ptr[0].mtdOid = OID_ACTION_METADATA_USER_CLASS;
mtds->__ptr[0].mtdValue = "2";
mtds->__ptr[0].mtdStatement = NULL; //"POSITIVE";
mtds->__ptr[0].mtdAdjustment = NULL;//"NONE";
mtds->__ptr[0].noOfOpenBrackets = 0;
mtds->__ptr[0].noOfCloseBrackets = 0;
mtds->__ptr[0].mtdDesc = NULL; //"LIKE";
mtds->__ptr[0].mtdLogicalOperator = NULL;
mtds->__ptr[1].mtdOid = OID_ACTION_METADATA_ACTION;
mtds->__ptr[1].mtdValue = "16";
mtds->__ptr[1].mtdStatement = NULL; //"POSITIVE";
mtds->__ptr[1].mtdAdjustment = NULL; //"NONE";
mtds->__ptr[1].noOfOpenBrackets = 0;
mtds->__ptr[1].noOfCloseBrackets = 0;
mtds->__ptr[1].mtdDesc = NULL; //"LIKE";
mtds->__ptr[1].mtdLogicalOperator = NULL; //"AND";
mtds->__ptr[2].mtdOid = OID_ACTION_METADATA_ACTION;
mtds->__ptr[2].mtdValue = "12";
mtds->__ptr[2].mtdStatement = NULL; //"POSITIVE";
mtds->__ptr[2].mtdAdjustment = NULL; //"NONE";
mtds->__ptr[2].noOfOpenBrackets = 0;
mtds->__ptr[2].noOfCloseBrackets = 0;
mtds->__ptr[2].mtdDesc = NULL; //"LIKE";
mtds->__ptr[2].mtdLogicalOperator = NULL; //"AND";
/*mtds->__ptr[2].mtdOid = OID_SYS_METADATA_CRYPTO_OBJECTS_FILE_TYPE;
mtds->__ptr[2].mtdValue = "";
mtds->__ptr[2].mtdDesc = NULL; //"LIKE";
mtds->__ptr[2].mtdStatement = NULL; //"POSITIVE";
mtds->__ptr[2].mtdLogicalOperator = NULL; //"AND";
mtds->__ptr[2].noOfOpenBrackets = 0;
mtds->__ptr[2].noOfCloseBrackets = 0;
mtds->__ptr[2].mtdAdjustment = NULL; //"NONE";
mtds->__ptr[3].mtdOid = OID_SYS_METADATA_CRYPTO_OBJECTS_FILE_TYPE;
mtds->__ptr[3].mtdValue = "link";
mtds->__ptr[3].mtdDesc = NULL; //"LIKE";
mtds->__ptr[3].mtdStatement = NULL; //"POSITIVE";
mtds->__ptr[3].mtdLogicalOperator = "OR"; //"AND";
mtds->__ptr[3].noOfOpenBrackets = 0;
mtds->__ptr[3].noOfCloseBrackets = 0;
mtds->__ptr[3].mtdAdjustment = NULL; //"NONE";*/
GenBuf_t *cert_pem=NULL;
base64Cert = (struct xsd__base64Binary *)malloc(sizeof(struct xsd__base64Binary));
status = bmd_load_binary_content(keyfile,&cert_pem);
if (status != BMD_OK)
{
printf("SOAPCLIENTERR Error while reading certificate file\n");
return 0;
}
base64Cert->__ptr=(unsigned char*)cert_pem->buf;
base64Cert->__size=cert_pem->size;
/*sortowanie po nazwie pliku*/
sortInfo = (struct bmd230__searchSortInfoList *)malloc(sizeof(struct bmd230__searchSortInfoList));
sortInfo->__size = 1;
sortInfo->__ptr = (struct bmd230__searchSortInfo *)malloc( sizeof(struct bmd230__searchSortInfo) * (sortInfo->__size) );
sortInfo->__ptr[0].sortOid = OID_SYS_METADATA_CRYPTO_OBJECTS_FILENAME;
sortInfo->__ptr[0].sortOrder = "ASC";
soap_set_namespaces(soap, bmd230_namespaces);
/* wywolanie uslugi */
status=soap_call_bmd230__bmdSearchUnreceived(soap, host, NULL, base64Cert,
"1"/*userRoleId*/,
"1"/*userGroupId*/,
NULL/*userClassId*/,
0/*offset*/,
1000/*limit*/,
mtds,
formMtds,
sortInfo,
&searchResults);
#ifdef ENABLE_WS_SECURITY
WSSecurity_client_clear(&WSSEclientStruct);
#endif /*ifdef ENABLE_WS_SECURITY*/
if (status == SOAP_OK)
{
printf("\nIlość znalezionych dokumentów: %i\n",searchResults->__size);
for (iter=0; iter<searchResults->__size; iter++)
{
printf("\n---\n#%i: id = <%li> --> nazwa pliku: <%s> \n", iter, searchResults->__ptr[iter].id, searchResults->__ptr[iter].filename);
if(searchResults->__ptr[iter].mtds != NULL)
{
for (jupiter=0; jupiter<searchResults->__ptr[iter].mtds->__size; jupiter++)
{
printf("\n OID:<%s> | wartosc:<%s>",searchResults->__ptr[iter].mtds->__ptr[jupiter].mtdOid,searchResults->__ptr[iter].mtds->__ptr[jupiter].mtdValue);
}
}
else
{
printf("\nMETADATA = NULL\n");
}
}
printf("\n\nkoniec testu\n");
}
else
{
/*odpowiedź w razie błędu*/
soap_print_fault(soap, stderr);
soap_end(soap);
soap_done(soap);
free(serverURL);
return -1;
}
soap_end(soap);
soap_done(soap);
free(serverURL);
return 0;
}
int main(int argc, char **argv)
{
struct soap *soap = soap_new1(SOAP_XML_INDENT);
soap_register_plugin(soap, soap_wsa);
if (argc < 2)
{ /* no args: act as CGI service over stdin/out */
if (soap_serve(soap))
{ soap_print_fault(soap, stderr);
soap_print_fault_location(soap, stderr);
}
}
else
{
int port = atoi(argv[1]);
if (port)
{ /* stand-alone server serving messages over port */
soap->bind_flags = SO_REUSEADDR;
if (!soap_valid_socket(soap_bind(soap, NULL, port, 100)))
{ soap_print_fault(soap, stderr);
exit(1);
}
printf("Server is running\n");
while (soap_valid_socket(soap_accept(soap)))
{ if (soap_serve(soap))
{ soap_print_fault(soap, stderr);
soap_print_fault_location(soap, stderr);
}
printf("Request served\n");
soap_destroy(soap);
soap_end(soap);
}
}
else
{ /* client */
struct ns__wsademoResult res;
soap_wsa_request(soap, RequestMessageID, ToAddress, RequestAction);
if (argc >= 3)
{ if (strchr(argv[2], 'f'))
soap_wsa_add_From(soap, FromAddress);
if (strchr(argv[2], 'r'))
soap_wsa_add_ReplyTo(soap, ReplyToAddress);
if (strchr(argv[2], 'n'))
{
#ifdef SOAP_WSA_2005
soap_wsa_add_NoReply(soap);
#else
printf("'NoReply' feature not available with WS-Addressing 2003/2004\n");
#endif
}
if (strchr(argv[2], 'e'))
soap_wsa_add_FaultTo(soap, FaultToAddress);
}
if (soap_call_ns__wsademo(soap, ToAddress, NULL, argv[1], &res))
{
#ifdef SOAP_WSA_2005
wsa5__FaultCodesType fault;
const char *info;
if (soap->error == 202) /* HTTP ACCEPTED */
printf("Request was accepted\n");
else if (soap_wsa_check_fault(soap, &fault, &info))
{ switch (fault)
{ case wsa5__EndpointUnavailable:
fprintf(stderr, "Server %s is currently not available.\n", info?info:"");
break;
default:
fprintf(stderr, "A wsa fault %d occurred:\n", (int)fault);
soap_print_fault(soap, stderr);
break;
}
}
else
soap_print_fault(soap, stderr);
#else
if (soap->error == 202) /* HTTP ACCEPTED */
printf("Request was accepted\n");
else
soap_print_fault(soap, stderr);
#endif
}
else if (res.out)
printf("Result = %s\n", res.out);
}
}
soap_destroy(soap);
soap_end(soap);
soap_done(soap);
free(soap);
return 0;
}
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;
}
int cgi_serve()
{ /* CGI-style: serve request from stdin */
return soap_serve(soap_new1(SOAP_XML_INDENT | SOAP_ENC_MTOM)); /* enable MTOM XOP attachments (and XML indent) */
}
