int main()
{ struct soap soap;
double a, b, result;
/* Init SSL */
soap_ssl_init();
if (CRYPTO_thread_setup())
{ fprintf(stderr, "Cannot setup thread mutex for OpenSSL\n");
exit(1);
}
a = 10.0;
b = 20.0;
/* Init gSOAP context */
soap_init(&soap);
/* The supplied server certificate "server.pem" assumes that the server is
running on 'localhost', so clients can only connect from the same host when
verifying the server's certificate. Use SOAP_SSL_NO_AUTHENTICATION to omit
the authentication of the server and use encryption directly from any site.
To verify the certificates of third-party services, they must provide a
certificate issued by Verisign or another trusted CA. At the client-side,
the capath parameter should point to a directory that contains these
trusted (root) certificates or the cafile parameter should refer to one
file will all certificates. To help you out, the supplied "cacerts.pem"
file contains the certificates issued by various CAs. You should use this
file for the cafile parameter instead of "cacert.pem" to connect to trusted
servers. Note that the client may fail to connect if the server's
credentials have problems (e.g. expired). Use SOAP_SSL_NO_AUTHENTICATION
and set cacert to NULL to encrypt messages if you don't care about the
trustworthyness of the server. Note: setting capath may not work on
Windows.
*/
if (soap_ssl_client_context(&soap,
/* SOAP_SSL_NO_AUTHENTICATION, */ /* for encryption w/o authentication */
/* SOAP_SSL_DEFAULT | SOAP_SSL_SKIP_HOST_CHECK, */ /* if we don't want the host name checks since these will change from machine to machine */
SOAP_SSL_DEFAULT, /* use SOAP_SSL_DEFAULT in production code */
NULL, /* keyfile (cert+key): required only when client must authenticate to server (see SSL docs to create this file) */
NULL, /* password to read the keyfile */
"cacert.pem", /* optional cacert file to store trusted certificates, use cacerts.pem for all public certificates issued by common CAs */
NULL, /* optional capath to directory with trusted certificates */
NULL /* if randfile!=NULL: use a file with random data to seed randomness */
))
{ soap_print_fault(&soap, stderr);
exit(1);
}
soap.connect_timeout = 60; /* try to connect for 1 minute */
soap.send_timeout = soap.recv_timeout = 30; /* if I/O stalls, then timeout after 30 seconds */
if (soap_call_ns__add(&soap, server, "", a, b, &result) == SOAP_OK)
fprintf(stdout, "Result: %f + %f = %f\n", a, b, result);
else
soap_print_fault(&soap, stderr);
soap_destroy(&soap); /* C++ */
soap_end(&soap);
soap_done(&soap);
CRYPTO_thread_cleanup();
return 0;
}
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;
}
void *CbirGVT::GetGvtImagesCommon(string& access_token) const {
string msg = "CbirGVT::GetGvtImagesCommon() : ";
GetDataBase()->WriteLog(msg+"starting");
string endpoint, username;
// Get access_token
access_token = getAccessToken(username);
static bool first = true;
if (first) {
soap_ssl_init(); // init OpenSSL (just once)
first = false;
}
// Create the soap client
ImageCollectionServiceSoapBindingProxy *imageCollection = new ImageCollectionServiceSoapBindingProxy;
if (imageCollection == NULL) {
cerr << "Cannot connect to Web Service. Exiting." << endl;
return NULL;
}
if (!endpoint.empty()) {
// User gave an alternate endpoint, use it
imageCollection->soap_endpoint = endpoint.c_str();
}
// Set the alternate cacert if needed
if (!OpenXerox::GSoap::setCacert(imageCollection)) {
return NULL;
}
// Set the proxy from the https_proxy environment variable
OpenXerox::GSoap::setHttpsProxy(imageCollection);
// Set authentication before each call
setAuthorization(imageCollection, access_token);
gvt__getLoginName loginname_payload;
gvt__getLoginNameResponse loginname_response;
if (imageCollection->getLoginName(&loginname_payload, &loginname_response) == SOAP_OK) {
// cerr << "Your login name is: " << *loginname_response.return_ << endl;
}
else {
soap_print_fault(imageCollection, stderr);
}
setAuthorization(imageCollection, access_token);
return imageCollection;
}
void AmazonSimpleStorageService::initializeService()
{
if ( m_initialized ) {
return;
}
m_initialized = true;
// Hier müssen Sie Ihre eigenen Daten eintragen.
std::ifstream input("/home/eternus/PROG3Projekt/AmazonS3.data");
input >> m_key;
input >> m_value;
input.close();
soap_ssl_init();
}
int md5_handler(struct soap *soap, void **context, enum md5_action action, char *buf, size_t len)
{ EVP_MD_CTX *ctx;
unsigned char hash[EVP_MAX_MD_SIZE];
unsigned int size;
switch (action)
{ case MD5_INIT:
soap_ssl_init();
if (!*context)
{ *context = (void*)SOAP_MALLOC(soap, sizeof(EVP_MD_CTX));
EVP_MD_CTX_init((EVP_MD_CTX*)*context);
}
ctx = (EVP_MD_CTX*)*context;
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- MD5 Init %p\n", ctx));
EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
break;
case MD5_UPDATE:
ctx = (EVP_MD_CTX*)*context;
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- MD5 Update %p (%lu) --\n", ctx, (unsigned long)len));
DBGMSG(TEST, buf, len);
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n--"));
EVP_DigestUpdate(ctx, (const void*)buf, (unsigned int)len);
break;
case MD5_FINAL:
ctx = (EVP_MD_CTX*)*context;
EVP_DigestFinal_ex(ctx, (unsigned char*)hash, &size);
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- MD5 Final %p --\n", ctx));
DBGHEX(TEST, hash, size);
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n--"));
soap_memcpy((void*)buf, 16, (const void*)hash, 16);
break;
case MD5_DELETE:
ctx = (EVP_MD_CTX*)*context;
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- MD5 Delete %p --\n", ctx));
if (ctx)
{ EVP_MD_CTX_cleanup(ctx);
SOAP_FREE(soap, ctx);
}
*context = NULL;
}
return SOAP_OK;
}
int main(int argc, char **argv)
{
static const int count = 10;
pthread_t thread[count];
soap_ssl_init();
if (CRYPTO_thread_setup())
{
fprintf(stderr, "Cannot setup thread mutex for OpenSSL\n");
exit(1);
}
/*for (int i = 0; i < count; ++i)
{
pthread_create(&thread[i], NULL, thread_func, NULL);
}*/
pthread_create(&thread[0], NULL, thread_func, NULL);
pthread_create(&thread[1], NULL, thread_func_1, NULL);
pthread_create(&thread[2], NULL, thread_func_2, NULL);
pthread_create(&thread[3], NULL, thread_func_3, NULL);
pthread_create(&thread[4], NULL, thread_func_4, NULL);
pthread_create(&thread[5], NULL, thread_func_5, NULL);
pthread_create(&thread[6], NULL, thread_func_6, NULL);
pthread_create(&thread[7], NULL, thread_func_7, NULL);
pthread_create(&thread[8], NULL, thread_func_8, NULL);
pthread_create(&thread[9], NULL, thread_func_9, NULL);
while (1)
{
sleep(1);
}
CRYPTO_thread_cleanup();
return 0;
}
int main()
{
wsHttpWellthServiceProxy service;
//char request[64];
std::string request = "*****@*****.**";
char response[64];
_ns3__GetNameByEmailID soapRequest;
_ns3__GetNameByEmailIDResponse soapResponse;
struct soap *pSoap = NULL;
pSoap = soap_new();
soap_set_namespaces(pSoap,namespaces);
soap_ssl_init();
if (soap_ssl_client_context(pSoap, SOAP_SSL_NO_AUTHENTICATION, NULL,NULL,NULL,NULL,NULL) == SOAP_OK)
std::cout << "Client COntext set OK " << std::endl;
/**
strcpy(request,"*****@*****.**");
soapRequest.emailID = (std::string *)&request;
**/
pSoap->ssl_flags = SOAP_SSL_NO_AUTHENTICATION | SOAP_SSL_NO_DEFAULT_CA_PATH;
soapRequest.emailID = &request;
soapRequest.soap = pSoap;
// if (service.GetNameByEmailID((_ns3__GetNameByEmailID*)request,(_ns3__GetNameByEmailIDResponse*)response) == SOAP_OK)
//soap_call___ns1__GetNameByEmailID(pSoap,NULL,NULL,&soapRequest,&soapResponse);
if (service.GetNameByEmailID(&soapRequest,&soapResponse) == SOAP_OK)
std::cout << "The response is " << response << std::endl;
else
service.soap_stream_fault(std::cerr);
service.destroy(); // delete data and release memory
}
void initialize_soap_client(
const char *_merchant_id,
const char *_transaction_key,
const char *_cacerts_file,
const char *_server_url,
const bool _soap_debugging_mode)
{
if (MERCHANT_ID == NULL) {
printf("setting MERCHANT_ID..\n");
MERCHANT_ID = strdup(_merchant_id);
TRANSACTION_KEY = strdup(_transaction_key);
CACERTS_FILE = strdup(_cacerts_file);
SERVER_URL = strdup(_server_url);
if (!soap_client_initialized) {
// one-time initializations
printf("initialize_soap_client..\n");
signal(SIGPIPE, sigpipe_handle);
soap_ssl_init();
soap_client_initialized = true;
}
}
soap_debugging_mode = _soap_debugging_mode;
}
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;
}
/**
*
* @param argc
* @param argv[]
* @return
*/
int main(int argc, char* argv[])
{
bool fSSL = false;
const char *pcszArgEndpoint = "http://localhost:18083/";
int ap;
for (ap = 1; ap < argc; ap++)
{
if (argv[ap][0] == '-')
{
if (!strcmp(argv[ap], "-h"))
usage(0);
else if (!strcmp(argv[ap], "-c"))
{
ap++;
if (ap >= argc)
usage(1);
pcszArgEndpoint = argv[ap];
fSSL = !strncmp(pcszArgEndpoint, "https://", 8);
}
else
usage(1);
}
else
break;
}
if (argc < 1 + ap)
usage(1);
#ifdef WITH_OPENSSL
if (fSSL)
soap_ssl_init();
#endif /* WITH_OPENSSL */
struct soap soap; // gSOAP runtime environment
soap_init(&soap); // initialize runtime environment (only once)
#ifdef WITH_OPENSSL
// Use SOAP_SSL_NO_AUTHENTICATION here to accept broken server configs.
// In a real world setup please use at least SOAP_SSL_DEFAULT and provide
// the necessary CA certificate for validating the server's certificate.
if (fSSL && soap_ssl_client_context(&soap, SOAP_SSL_NO_AUTHENTICATION,
NULL /*clientkey*/, NULL /*password*/,
NULL /*cacert*/, NULL /*capath*/,
NULL /*randfile*/))
{
soap_print_fault(&soap, stderr);
exit(1);
}
#endif /* WITH_OPENSSL */
const char *pcszMode = argv[ap];
int soaprc = SOAP_SVR_FAULT;
if (!strcmp(pcszMode, "logon"))
{
if (argc < 3 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IWebsessionManager_USCORElogon req;
req.username = argv[ap + 1];
req.password = argv[ap + 2];
_vbox__IWebsessionManager_USCORElogonResponse resp;
if (!(soaprc = soap_call___vbox__IWebsessionManager_USCORElogon(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "VirtualBox objref: \"" << resp.returnval << "\"\n";
}
}
else if (!strcmp(pcszMode, "getsession"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IWebsessionManager_USCOREgetSessionObject req;
req.refIVirtualBox = argv[ap + 1];
_vbox__IWebsessionManager_USCOREgetSessionObjectResponse resp;
if (!(soaprc = soap_call___vbox__IWebsessionManager_USCOREgetSessionObject(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "session: \"" << resp.returnval << "\"\n";
}
}
else if (!strcmp(pcszMode, "logoff"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IWebsessionManager_USCORElogoff req;
req.refIVirtualBox = argv[ap + 1];
_vbox__IWebsessionManager_USCORElogoffResponse resp;
if (!(soaprc = soap_call___vbox__IWebsessionManager_USCORElogoff(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
{
;
}
}
}
else if (!strcmp(pcszMode, "version"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IVirtualBox_USCOREgetVersion req;
req._USCOREthis = argv[ap + 1];
_vbox__IVirtualBox_USCOREgetVersionResponse resp;
if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREgetVersion(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "version: \"" << resp.returnval << "\"\n";
}
}
else if (!strcmp(pcszMode, "gethost"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IVirtualBox_USCOREgetHost req;
req._USCOREthis = argv[ap + 1];
_vbox__IVirtualBox_USCOREgetHostResponse resp;
if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREgetHost(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
{
std::cout << "Host objref " << resp.returnval << "\n";
}
}
}
else if (!strcmp(pcszMode, "getpc"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IVirtualBox_USCOREgetPerformanceCollector req;
req._USCOREthis = argv[ap + 1];
_vbox__IVirtualBox_USCOREgetPerformanceCollectorResponse resp;
if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREgetPerformanceCollector(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
{
std::cout << "Performance collector objref " << resp.returnval << "\n";
}
}
}
else if (!strcmp(pcszMode, "getmachines"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IVirtualBox_USCOREgetMachines req;
req._USCOREthis = argv[ap + 1];
_vbox__IVirtualBox_USCOREgetMachinesResponse resp;
if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREgetMachines(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
{
size_t c = resp.returnval.size();
for (size_t i = 0;
i < c;
++i)
{
std::cout << "Machine " << i << ": objref " << resp.returnval[i] << "\n";
}
}
}
}
else if (!strcmp(pcszMode, "createmachine"))
{
if (argc < 4 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IVirtualBox_USCOREcreateMachine req;
req._USCOREthis = argv[ap + 1];
req.settingsFile = argv[ap + 2];
req.name = argv[ap + 3];
std::cout << "createmachine: settingsFile = \"" << req.settingsFile << "\", name = \"" << req.name << "\"\n";
_vbox__IVirtualBox_USCOREcreateMachineResponse resp;
if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREcreateMachine(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "Machine created: managed object reference ID is " << resp.returnval << "\n";
}
}
else if (!strcmp(pcszMode, "registermachine"))
{
if (argc < 3 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IVirtualBox_USCOREregisterMachine req;
req._USCOREthis = argv[ap + 1];
req.machine = argv[ap + 2];
_vbox__IVirtualBox_USCOREregisterMachineResponse resp;
if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREregisterMachine(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "Machine registered.\n";
}
}
else if (!strcmp(pcszMode, "getdvddrives"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IHost_USCOREgetDVDDrives req;
req._USCOREthis = argv[ap + 1];
_vbox__IHost_USCOREgetDVDDrivesResponse resp;
if (!(soaprc = soap_call___vbox__IHost_USCOREgetDVDDrives(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
{
size_t c = resp.returnval.size();
for (size_t i = 0;
i < c;
++i)
{
std::cout << "DVD drive " << i << ": objref " << resp.returnval[i] << "\n";
}
}
}
}
else if (!strcmp(pcszMode, "getname"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IMachine_USCOREgetName req;
req._USCOREthis = argv[ap + 1];
_vbox__IMachine_USCOREgetNameResponse resp;
if (!(soaprc = soap_call___vbox__IMachine_USCOREgetName(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
printf("Name is: %s\n", resp.returnval.c_str());
}
}
else if (!strcmp(pcszMode, "getid"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IMachine_USCOREgetId req;
req._USCOREthis = argv[ap + 1];
_vbox__IMachine_USCOREgetIdResponse resp;
if (!(soaprc = soap_call___vbox__IMachine_USCOREgetId(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "UUID is: " << resp.returnval << "\n";;
}
}
else if (!strcmp(pcszMode, "getostypeid"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IMachine_USCOREgetOSTypeId req;
req._USCOREthis = argv[ap + 1];
_vbox__IMachine_USCOREgetOSTypeIdResponse resp;
if (!(soaprc = soap_call___vbox__IMachine_USCOREgetOSTypeId(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "Guest OS type is: " << resp.returnval << "\n";
}
}
else if (!strcmp(pcszMode, "savesettings"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IMachine_USCOREsaveSettings req;
req._USCOREthis = argv[ap + 1];
_vbox__IMachine_USCOREsaveSettingsResponse resp;
if (!(soaprc = soap_call___vbox__IMachine_USCOREsaveSettings(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "Settings saved\n";
}
}
else if (!strcmp(pcszMode, "setupmetrics"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IPerformanceCollector_USCOREsetupMetrics req;
req._USCOREthis = argv[ap + 1];
// req.metricNames[0] = "*";
// req.objects
req.period = 1; // seconds
req.count = 100;
_vbox__IPerformanceCollector_USCOREsetupMetricsResponse resp;
if (!(soaprc = soap_call___vbox__IPerformanceCollector_USCOREsetupMetrics(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
{
size_t c = resp.returnval.size();
for (size_t i = 0;
i < c;
++i)
{
std::cout << "Metric " << i << ": objref " << resp.returnval[i] << "\n";
}
}
}
}
else if (!strcmp(pcszMode, "querymetricsdata"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IPerformanceCollector_USCOREqueryMetricsData req;
req._USCOREthis = argv[ap + 1];
// req.metricNames[0] = "*";
// req.objects
_vbox__IPerformanceCollector_USCOREqueryMetricsDataResponse resp;
if (!(soaprc = soap_call___vbox__IPerformanceCollector_USCOREqueryMetricsData(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
{
size_t c = resp.returnval.size();
for (size_t i = 0;
i < c;
++i)
{
std::cout << "long " << i << ": " << resp.returnval[i] << "\n";
}
}
}
}
else if (!strcmp(pcszMode, "errorinfo"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IVirtualBoxErrorInfo_USCOREgetResultCode req;
req._USCOREthis = argv[ap + 1];
_vbox__IVirtualBoxErrorInfo_USCOREgetResultCodeResponse resp;
if (!(soaprc = soap_call___vbox__IVirtualBoxErrorInfo_USCOREgetResultCode(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
{
std::cout << "ErrorInfo ResultCode: " << std::hex << resp.returnval << "\n";
_vbox__IVirtualBoxErrorInfo_USCOREgetText req2;
req2._USCOREthis = argv[ap + 1];
_vbox__IVirtualBoxErrorInfo_USCOREgetTextResponse resp2;
if (!(soaprc = soap_call___vbox__IVirtualBoxErrorInfo_USCOREgetText(&soap,
pcszArgEndpoint,
NULL,
&req2,
&resp2)))
{
std::cout << "ErrorInfo Text: " << resp2.returnval << "\n";
_vbox__IVirtualBoxErrorInfo_USCOREgetNext req3;
req3._USCOREthis = argv[ap + 1];
_vbox__IVirtualBoxErrorInfo_USCOREgetNextResponse resp3;
if (!(soaprc = soap_call___vbox__IVirtualBoxErrorInfo_USCOREgetNext(&soap,
pcszArgEndpoint,
NULL,
&req3,
&resp3)))
std::cout << "Next ErrorInfo: " << resp3.returnval << "\n";
}
}
}
}
else if (!strcmp(pcszMode, "release"))
{
if (argc < 2 + ap)
std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n";
else
{
_vbox__IManagedObjectRef_USCORErelease req;
req._USCOREthis = argv[ap + 1];
_vbox__IManagedObjectRef_USCOREreleaseResponse resp;
if (!(soaprc = soap_call___vbox__IManagedObjectRef_USCORErelease(&soap,
pcszArgEndpoint,
NULL,
&req,
&resp)))
std::cout << "Managed object reference " << req._USCOREthis << " released.\n";
}
}
else
std::cout << "Unknown mode parameter \"" << pcszMode << "\".\n";
if (soaprc)
{
if ( (soap.fault)
&& (soap.fault->detail)
)
{
// generic fault message whether the fault is known or not
std::cerr << "Generic fault message:\n";
soap_print_fault(&soap, stderr); // display the SOAP fault message on the stderr stream
if (soap.fault->detail->vbox__InvalidObjectFault)
{
std::cerr << "Bad object ID: " << soap.fault->detail->vbox__InvalidObjectFault->badObjectID << "\n";
}
else if (soap.fault->detail->vbox__RuntimeFault)
{
std::cerr << "Result code: 0x" << std::hex << soap.fault->detail->vbox__RuntimeFault->resultCode << "\n";
std::cerr << "ErrorInfo: " << soap.fault->detail->vbox__RuntimeFault->returnval << "\n";
}
}
else
{
std::cerr << "Invalid fault data, fault message:\n";
soap_print_fault(&soap, stderr); // display the SOAP fault message on the stderr stream
}
}
soap_destroy(&soap); // delete deserialized class instances (for C++ only)
soap_end(&soap); // remove deserialized data and clean up
soap_done(&soap); // detach the gSOAP environment
return soaprc;
}
/**
@fn int soap_mec_init(struct soap *soap, struct soap_mec_data *data, int alg, SOAP_MEC_KEY_TYPE *pkey, unsigned char *key, int *keylen)
@brief Initialize mecevp engine state and create context for
encryption/decryption algorithm using a private/public key or symmetric secret
key.
@param soap context
@param[in,out] data mecevp engine context
@param[in] alg encryption/decryption algorithm
@param[in] pkey public/private key or NULL
@param[in,out] key secret key or encrypted ephemeral secret key set with envelope encryption, or NULL
@param[in,out] keylen secret key length
@return SOAP_OK or SOAP_SSL_ERROR
*/
int
soap_mec_init(struct soap *soap, struct soap_mec_data *data, int alg, SOAP_MEC_KEY_TYPE *pkey, unsigned char *key, int *keylen)
{ int ok = 1;
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_mec_init()\n"));
soap_ssl_init();
data->ctx = (EVP_CIPHER_CTX*)SOAP_MALLOC(soap, sizeof(EVP_CIPHER_CTX));
if (!data->ctx)
return soap->error = SOAP_EOM;
EVP_CIPHER_CTX_init(data->ctx);
data->alg = alg;
data->state = SOAP_MEC_STATE_NONE;
if (alg & SOAP_MEC_DES_CBC)
data->type = EVP_des_ede3_cbc(); /* triple DES CBC */
else if (alg & SOAP_MEC_AES128_CBC)
data->type = EVP_get_cipherbyname("AES128");
else if (alg & SOAP_MEC_AES192_CBC)
data->type = EVP_get_cipherbyname("AES192");
else if (alg & SOAP_MEC_AES256_CBC)
data->type = EVP_get_cipherbyname("AES256");
else if (alg & SOAP_MEC_AES512_CBC)
data->type = EVP_get_cipherbyname("AES512");
else
data->type = EVP_enc_null();
data->buf = NULL;
data->rest = NULL;
data->restlen = 0;
if (alg & SOAP_MEC_ENC)
{ if (!data->type)
return soap_mec_check(soap, data, 0, "soap_mec_init() failed: cannot load cipher");
EVP_EncryptInit_ex(data->ctx, data->type, NULL, NULL, NULL);
}
if (alg & SOAP_MEC_OAEP)
EVP_CIPHER_CTX_set_padding(data->ctx, RSA_PKCS1_OAEP_PADDING);
else
EVP_CIPHER_CTX_set_padding(data->ctx, RSA_PKCS1_PADDING);
switch (alg & SOAP_MEC_MASK)
{ case SOAP_MEC_ENV_ENC_AES128_CBC:
case SOAP_MEC_ENV_ENC_AES192_CBC:
case SOAP_MEC_ENV_ENC_AES256_CBC:
case SOAP_MEC_ENV_ENC_AES512_CBC:
case SOAP_MEC_ENV_ENC_DES_CBC:
ok = EVP_CIPHER_CTX_rand_key(data->ctx, data->ekey);
/* generate ephemeral secret key */
#if (OPENSSL_VERSION_NUMBER >= 0x01000000L)
*keylen = EVP_PKEY_encrypt_old(key, data->ekey, EVP_CIPHER_CTX_key_length(data->ctx), pkey);
#else
*keylen = EVP_PKEY_encrypt(key, data->ekey, EVP_CIPHER_CTX_key_length(data->ctx), pkey);
#endif
key = data->ekey;
/* fall through to next arm */
case SOAP_MEC_ENC_DES_CBC:
case SOAP_MEC_ENC_AES128_CBC:
case SOAP_MEC_ENC_AES192_CBC:
case SOAP_MEC_ENC_AES256_CBC:
case SOAP_MEC_ENC_AES512_CBC:
data->bufidx = 0;
data->buflen = 1024; /* > iv in base64 must fit */
data->buf = (char*)SOAP_MALLOC(soap, data->buflen);
data->key = key;
break;
case SOAP_MEC_ENV_DEC_AES128_CBC:
case SOAP_MEC_ENV_DEC_AES192_CBC:
case SOAP_MEC_ENV_DEC_AES256_CBC:
case SOAP_MEC_ENV_DEC_AES512_CBC:
case SOAP_MEC_ENV_DEC_DES_CBC:
case SOAP_MEC_DEC_DES_CBC:
case SOAP_MEC_DEC_AES128_CBC:
case SOAP_MEC_DEC_AES192_CBC:
case SOAP_MEC_DEC_AES256_CBC:
case SOAP_MEC_DEC_AES512_CBC:
data->pkey = pkey;
data->key = key;
data->keylen = *keylen;
break;
default:
return soap_set_receiver_error(soap, "Unsupported encryption algorithm", NULL, SOAP_SSL_ERROR);
}
return soap_mec_check(soap, data, ok, "soap_mec_init() failed");
}
/**
@fn int soap_smd_init(struct soap *soap, struct soap_smd_data *data, int alg, const void *key, int keylen)
@brief Initiates a (signed) digest computation.
@param soap context
@param[in,out] data smdevp engine context
@param[in] alg is algorithm to use
@param[in] key is key to use or NULL for digests
@param[in] keylen is length of HMAC key (when provided)
@return SOAP_OK or SOAP_SSL_ERROR
*/
int
soap_smd_init(struct soap *soap, struct soap_smd_data *data, int alg, const void *key, int keylen)
{ int ok = 1;
const EVP_MD *type;
soap_ssl_init();
/* the algorithm to use */
data->alg = alg;
/* the key to use */
data->key = key;
/* allocate and init the OpenSSL HMAC or EVP_MD context */
if ((alg & SOAP_SMD_ALGO) == SOAP_SMD_HMAC)
{ data->ctx = (void*)SOAP_MALLOC(soap, sizeof(HMAC_CTX));
if (!data->ctx)
return soap_set_receiver_error(soap, "soap_smd_init() failed", "No context", SOAP_SSL_ERROR);
HMAC_CTX_init((HMAC_CTX*)data->ctx);
}
else
{ data->ctx = (void*)SOAP_MALLOC(soap, sizeof(EVP_MD_CTX));
if (!data->ctx)
return soap_set_receiver_error(soap, "soap_smd_init() failed", "No context", SOAP_SSL_ERROR);
EVP_MD_CTX_init((EVP_MD_CTX*)data->ctx);
}
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- SMD Init alg=%x (%p) --\n", alg, data->ctx));
/* init the digest or signature computations */
switch (alg & SOAP_SMD_HASH)
{ case SOAP_SMD_MD5:
type = EVP_md5();
break;
case SOAP_SMD_SHA1:
type = EVP_sha1();
break;
#if (OPENSSL_VERSION_NUMBER >= 0x0090800fL)
case SOAP_SMD_SHA224:
type = EVP_sha224();
break;
case SOAP_SMD_SHA256:
type = EVP_sha256();
break;
case SOAP_SMD_SHA384:
type = EVP_sha384();
break;
case SOAP_SMD_SHA512:
type = EVP_sha512();
break;
#endif
default:
return soap_smd_check(soap, data, 0, "soap_smd_init() failed: cannot load digest");
}
switch (alg & SOAP_SMD_ALGO)
{ case SOAP_SMD_HMAC:
HMAC_Init((HMAC_CTX*)data->ctx, key, keylen, type);
break;
case SOAP_SMD_DGST:
EVP_DigestInit((EVP_MD_CTX*)data->ctx, type);
break;
case SOAP_SMD_SIGN:
ok = EVP_SignInit((EVP_MD_CTX*)data->ctx, type);
break;
case SOAP_SMD_VRFY:
ok = EVP_VerifyInit((EVP_MD_CTX*)data->ctx, type);
break;
default:
return soap_set_receiver_error(soap, "Unsupported digest algorithm", NULL, SOAP_SSL_ERROR);
}
/* check and return */
return soap_smd_check(soap, data, ok, "soap_smd_init() failed");
}
int main(int argc, char **argv)
{
if (argc < 4)
{ fprintf(stderr, "Usage: [add|sub|mul|div|pow] num num\n");
exit(0);
}
double a, b, result;
a = strtod(argv[2], NULL);
b = strtod(argv[3], NULL);
calcProxy calc;
calc.soap_endpoint = server;
#ifdef WITH_OPENSSL
soap_ssl_init();
if (soap_ssl_client_context(&calc,
//SOAP_SSL_DEFAULT, /* use SOAP_SSL_DEFAULT in production code, we don't want the host name checks since these will change from machine to machine */
SOAP_SSL_DEFAULT | SOAP_SSL_SKIP_HOST_CHECK, /* use SOAP_SSL_DEFAULT in production code, we don't want the host name checks since these will change from machine to machine */
NULL, /* keyfile: required only when client must authenticate to server (see SSL docs on how to obtain this file) */
NULL, /* password to read the keyfile */
"cacert.pem", /* optional cacert file to store trusted certificates, use cacerts.pem for all public certificates issued by common CAs */
NULL, /* optional capath to directory with trusted certificates */
NULL /* if randfile!=NULL: use a file with random data to seed randomness */
))
{
soap_print_fault(&calc, stderr);
exit(1);
}
calc.connect_timeout = 60; /* try to connect for 1 minute */
calc.send_timeout = calc.recv_timeout = 30; /* if I/O stalls, then timeout after 30 seconds */
#endif
switch (*argv[1])
{
case 'a':
printf("start add \n");
calc.add(a, b, &result);
printf("stop add \n");
break;
case 's':
calc.sub(a, b, &result);
break;
case 'm':
calc.mul(a, b, &result);
break;
case 'd':
calc.div(a, b, &result);
break;
case 'p':
calc.pow(a, b, &result);
break;
default:
fprintf(stderr, "Unknown command\n");
exit(0);
}
if (calc.error){
printf("soap_stream_fault \n", result);
calc.soap_stream_fault(std::cerr);
}
else{
printf("result = %g\n", result);
}
return 0;
}
int main(int argc, char **argv)
{
FILE *fd;
BIGNUM *bn = BN_new();
/* init OpenSSL before any OpenSSL and crypto operations */
soap_ssl_init();
/* server's RSA private key for signing */
if ((fd = fopen("serverWCF.pem", "r")))
{ srv_privk = PEM_read_PrivateKey(fd, NULL, NULL, (void*)"password");
fclose(fd);
if (!srv_privk)
{ fprintf(stderr, "Could not read private RSA key from server.pem\n");
exit(1);
}
}
else
fprintf(stderr, "Could not read server.pem\n");
/* server's certificate with public key for encryption and signature verification */
if ((fd = fopen("servercertWCF.pem", "r")))
{ srv_cert = PEM_read_X509(fd, NULL, NULL, NULL);
fclose(fd);
if (!srv_cert)
{ fprintf(stderr, "Could not read certificate from clientcert.pem\n");
exit(1);
}
}
else
fprintf(stderr, "Could not read server.pem\n");
/* server's RSA public key from the certificate */
srv_pubk = X509_get_pubkey(srv_cert);
if (!srv_pubk)
{ fprintf(stderr, "Could not get public key from certificate\n");
exit(1);
}
/* server's certificate subject, issuer and serial number */
X509_NAME_oneline(X509_get_subject_name(srv_cert), srv_subject, sizeof(srv_subject));
X509_NAME_oneline(X509_get_issuer_name(srv_cert), srv_issuer, sizeof(srv_issuer));
ASN1_INTEGER_to_BN(X509_get_serialNumber(srv_cert), bn);
srv_serial = BN_bn2dec(bn);
fprintf(stderr, "Server certificate issuer = \"%s\"\n", srv_issuer);
fprintf(stderr, "Server certificate serial = %s (%s)\n", BN_bn2hex(bn), srv_serial);
/* client's RSA private key for signing */
if ((fd = fopen("clientWCF.pem", "r")))
{ clt_privk = PEM_read_PrivateKey(fd, NULL, NULL, (void*)"password");
fclose(fd);
if (!clt_privk)
{ fprintf(stderr, "Could not read private RSA key from server.pem\n");
exit(1);
}
}
else
fprintf(stderr, "Could not read server.pem\n");
/* client's certificate with public key for encryption and signature verification */
if ((fd = fopen("clientcertWCF.pem", "r")))
{ clt_cert = PEM_read_X509(fd, NULL, NULL, NULL);
fclose(fd);
if (!clt_cert)
{ fprintf(stderr, "Could not read certificate from clientcert.pem\n");
exit(1);
}
}
else
fprintf(stderr, "Could not read server.pem\n");
/* client's RSA public key from the certificate */
clt_pubk = X509_get_pubkey(clt_cert);
if (!clt_pubk)
{ fprintf(stderr, "Could not get public key from certificate\n");
exit(1);
}
/* client's certificate subject, issuer and serial number */
X509_NAME_oneline(X509_get_subject_name(clt_cert), clt_subject, sizeof(clt_subject));
X509_NAME_oneline(X509_get_issuer_name(clt_cert), clt_issuer, sizeof(clt_issuer));
ASN1_INTEGER_to_BN(X509_get_serialNumber(clt_cert), bn);
clt_serial = BN_bn2dec(bn);
fprintf(stderr, "Client certificate issuer = \"%s\"\n", clt_issuer);
fprintf(stderr, "Client certificate serial = %s (%s)\n", BN_bn2hex(bn), clt_serial);
OPENSSL_free(bn);
if (argc >= 2)
{
// Service sample application
int port = atoi(argv[1]);
BasicHttpBinding_USCOREICalculatorService service(SOAP_XML_INDENT | SOAP_XML_CANONICAL);
soap_register_plugin_arg(service.soap, soap_wsse, (void*)token_handler);
service.soap->send_timeout = service.soap->recv_timeout = 10; // 10 sec
/* need cacert to verify certificates */
service.soap->cafile = "clientcertWCF.pem";
service.soap->fsslverify = ssl_verify;
if (!soap_valid_socket(service.bind(NULL, port, 100)))
{
service.soap_stream_fault(std::cerr);
exit(1);
}
std::cerr << "Server running" << std::endl;
for (;;)
{
soap_wsse_verify_auto(service.soap, SOAP_WSSE_IGNORE_EXTRA_REFS, NULL, 0);
soap_wsse_decrypt_auto(service.soap, SOAP_MEC_ENV_DEC_AES256_CBC, srv_privk, 0);
if (!soap_valid_socket(service.accept())
|| service.serve())
service.soap_stream_fault(std::cerr);
service.destroy();
}
}
else
{
// Client sample application
BasicHttpBinding_USCOREICalculatorProxy proxy(endpoint, SOAP_XML_INDENT | SOAP_XML_CANONICAL);
soap_register_plugin_arg(proxy.soap, soap_wsse, (void*)token_handler);
proxy.soap->send_timeout = proxy.soap->recv_timeout = 10; // 10 sec
/* need cacert to verify certificates */
proxy.soap->cafile = "servercertWCF.pem";
proxy.soap->fsslverify = ssl_verify;
double n1 = 3.14, n2 = 1.41;
if (set_clt_security(proxy.soap))
proxy.soap_stream_fault(std::cerr);
else
{
_mssamm__Add areq;
_mssamm__AddResponse ares;
areq.n1 = &n1;
areq.n2 = &n2;
if (proxy.Add(&areq, &ares) == SOAP_OK && ares.AddResult && chk_security(proxy.soap) == SOAP_OK)
printf("Add(%g, %g) = %g\n", *areq.n1, *areq.n2, *ares.AddResult);
else
proxy.soap_stream_fault(std::cerr);
proxy.destroy();
}
if (set_clt_security(proxy.soap))
proxy.soap_stream_fault(std::cerr);
else
{
_mssamm__Subtract sreq;
_mssamm__SubtractResponse sres;
sreq.n1 = &n1;
sreq.n2 = &n2;
if (proxy.Subtract(&sreq, &sres) == SOAP_OK && sres.SubtractResult && chk_security(proxy.soap) == SOAP_OK)
printf("Subtract(%g, %g) = %g\n", *sreq.n1, *sreq.n2, *sres.SubtractResult);
else
proxy.soap_stream_fault(std::cerr);
proxy.destroy();
}
if (set_clt_security(proxy.soap))
proxy.soap_stream_fault(std::cerr);
else
{
_mssamm__Multiply mreq;
_mssamm__MultiplyResponse mres;
mreq.n1 = &n1;
mreq.n2 = &n2;
if (proxy.Multiply(&mreq, &mres) == SOAP_OK && mres.MultiplyResult && chk_security(proxy.soap) == SOAP_OK)
printf("Multiply(%g, %g) = %g\n", *mreq.n1, *mreq.n2, *mres.MultiplyResult);
else
proxy.soap_stream_fault(std::cerr);
proxy.destroy();
}
if (set_clt_security(proxy.soap))
proxy.soap_stream_fault(std::cerr);
else
{
_mssamm__Divide dreq;
_mssamm__DivideResponse dres;
dreq.n1 = &n1;
dreq.n2 = &n2;
if (proxy.Divide(&dreq, &dres) == SOAP_OK && dres.DivideResult && chk_security(proxy.soap) == SOAP_OK)
printf("Divide(%g, %g) = %g\n", *dreq.n1, *dreq.n2, *dres.DivideResult);
else
proxy.soap_stream_fault(std::cerr);
proxy.destroy();
}
}
OPENSSL_free(clt_serial);
OPENSSL_free(srv_serial);
return 0;
}
