static void free_msg( struct msg *msg ) { if (!msg) return; WsFreeWriter( msg->writer ); WsFreeHeap( msg->heap ); heap_free( msg->addr.chars ); heap_free( msg ); }
WCF::~WCF() { if (proxy){ WsCloseServiceProxy(proxy, NULL, NULL); WsFreeServiceProxy(proxy); } if (heap){ WsFreeHeap(heap); } if (error){ WsFreeError(error); } }
// // Close service proxy and clean up // void FlickrUploader::CloseWebProxy (WS_HEAP** heap, WS_SERVICE_PROXY** proxy, WS_ERROR** error) { if (proxy != nullptr && *proxy != nullptr) { WsCloseServiceProxy(*proxy, nullptr, nullptr); WsFreeServiceProxy(*proxy); } if (heap != nullptr && *heap != nullptr) { WsFreeHeap(*heap); } if (error != nullptr && *error != nullptr) { WsFreeError(*error); } }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_SERVICE_PROXY* serviceProxy = NULL; int result = 0; WS_ENDPOINT_ADDRESS address = {}; static const WS_STRING url = WS_STRING_VALUE(L"https://localhost:8443/example"); address.url = url; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create the proxy hr = DefaultBinding_ICalculator_CreateServiceProxy( NULL, NULL, 0, &serviceProxy, error); if (FAILED(hr)) { goto Exit; } hr = WsOpenServiceProxy(serviceProxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } hr = DefaultBinding_ICalculator_Add(serviceProxy, 1, 2, &result, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf(L"%d + %d = %d\n", 1, 2, result); Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (serviceProxy != NULL) { WsCloseServiceProxy(serviceProxy, NULL, NULL); WsFreeServiceProxy(serviceProxy); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_XML_WRITER* writer = NULL; WS_XML_READER* reader = NULL; WS_HEAP* heap = NULL; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create an XML writer hr = WsCreateWriter( NULL, 0, &writer, error); if (FAILED(hr)) { goto Exit; } // Setup the output WS_XML_WRITER_BUFFER_OUTPUT bufferOutput; ZeroMemory(&bufferOutput, sizeof(bufferOutput)); bufferOutput.output.outputType = WS_XML_WRITER_OUTPUT_TYPE_BUFFER; // Setup the encoding WS_XML_WRITER_BINARY_ENCODING writerEncoding; ZeroMemory(&writerEncoding, sizeof(writerEncoding)); writerEncoding.encoding.encodingType = WS_XML_WRITER_ENCODING_TYPE_BINARY; writerEncoding.staticDictionary = &objectsDictionary.dictionary; writerEncoding.dynamicStringCallback = DynamicStringCallback; writerEncoding.dynamicStringCallbackState = NULL; // Setup the writer hr = WsSetOutput( writer, &writerEncoding.encoding, &bufferOutput.output, NULL, 0, error); if (FAILED(hr)) { goto Exit; } hr = WsWriteStartElement( writer, NULL, &objectsDictionary.objects, &objectsDictionary.ns, error); if (FAILED(hr)) { goto Exit; } // Write some xml using strings from all the dictionaries static const WS_XML_STRING* shapes[3] = { &shapeDictionary.triangle, &shapeDictionary.square, &shapeDictionary.circle }; static const WS_XML_STRING* colors[3] = { &colorDictionary.green, &colorDictionary.blue, &colorDictionary.red }; for (ULONG i = 0; i < 3; i++) { hr = WsWriteStartElement( writer, NULL, shapes[i], &objectsDictionary.ns, error); if (FAILED(hr)) { goto Exit; } hr = WsWriteStartAttribute( writer, NULL, &objectsDictionary.color, &objectsDictionary.ns, FALSE, error); if (FAILED(hr)) { goto Exit; } hr = WsWriteType( writer, WS_ATTRIBUTE_TYPE_MAPPING, WS_XML_STRING_TYPE, NULL, WS_WRITE_REQUIRED_VALUE, colors[i], sizeof(*colors[i]), error); if (FAILED(hr)) { goto Exit; } hr = WsWriteEndAttribute( writer, error); if (FAILED(hr)) { goto Exit; } hr = WsWriteEndElement( writer, error); if (FAILED(hr)) { goto Exit; } } hr = WsWriteEndElement( writer, error); if (FAILED(hr)) { goto Exit; } WS_BYTES bytes; hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, sizeof(bytes), error); if (FAILED(hr)) { goto Exit; } // Create an XML reader hr = WsCreateReader( NULL, 0, &reader, error); if (FAILED(hr)) { goto Exit; } // Setup the input WS_XML_READER_BUFFER_INPUT bufferInput; ZeroMemory(&bufferInput, sizeof(bufferInput)); bufferInput.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER; bufferInput.encodedData = bytes.bytes; bufferInput.encodedDataSize = bytes.length; // Setup the encoding WS_XML_READER_BINARY_ENCODING readerEncoding; ZeroMemory( &readerEncoding, sizeof(readerEncoding)); readerEncoding.encoding.encodingType = WS_XML_READER_ENCODING_TYPE_BINARY; readerEncoding.staticDictionary = &objectsDictionary.dictionary; readerEncoding.dynamicDictionary = &mergedDictionary.dictionary; // Setup the reader hr = WsSetInput( reader, &readerEncoding.encoding, &bufferInput.input, NULL, 0, error); if (FAILED(hr)) { goto Exit; } hr = WsReadToStartElement( reader, &objectsDictionary.objects, &objectsDictionary.ns, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsReadStartElement( reader, error); if (FAILED(hr)) { goto Exit; } for (;;) { BOOL found; hr = WsReadToStartElement( reader, NULL, NULL, &found, error); if (FAILED(hr)) { goto Exit; } if (!found) { break; } const WS_XML_NODE* node; hr = WsGetReaderNode( reader, &node, error); if (FAILED(hr)) { goto Exit; } const WS_XML_ELEMENT_NODE* elementNode = (WS_XML_ELEMENT_NODE*)node; printf("%.*s: ", elementNode->localName->length, elementNode->localName->bytes); ULONG index; hr = WsFindAttribute( reader, &objectsDictionary.color, &objectsDictionary.ns, TRUE, &index, error); if (FAILED(hr)) { goto Exit; } hr = WsReadStartAttribute( reader, index, error); if (FAILED(hr)) { goto Exit; } WS_XML_STRING color; hr = WsReadType( reader, WS_ATTRIBUTE_TYPE_MAPPING, WS_XML_STRING_TYPE, NULL, WS_READ_REQUIRED_VALUE, heap, &color, sizeof(color), error); if (FAILED(hr)) { goto Exit; } printf( "%.*s\n", color.length, color.bytes); hr = WsReadEndAttribute( reader, error); if (FAILED(hr)) { goto Exit; } hr = WsSkipNode( reader, error); if (FAILED(hr)) { goto Exit; } } hr = WsReadEndElement( reader, error); if (FAILED(hr)) { goto Exit; } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (writer != NULL) { WsFreeWriter(writer); } if (reader != NULL) { WsFreeReader(reader); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_SERVICE_PROXY* proxy = NULL; // declare and initialize a username credential WS_STRING_USERNAME_CREDENTIAL usernameCredential = {}; // zero out the struct static const WS_STRING userName = WS_STRING_VALUE(L"usr1"); static const WS_STRING passWord = WS_STRING_VALUE(L"pwd1"); usernameCredential.credential.credentialType = WS_STRING_USERNAME_CREDENTIAL_TYPE; // set the credential type usernameCredential.username = userName; usernameCredential.password = passWord; // declare and initialize a username message security binding WS_USERNAME_MESSAGE_SECURITY_BINDING usernameBinding = {}; // zero out the struct usernameBinding.binding.bindingType = WS_USERNAME_MESSAGE_SECURITY_BINDING_TYPE; // set the binding type usernameBinding.bindingUsage = WS_SUPPORTING_MESSAGE_SECURITY_USAGE; // set the binding usage usernameBinding.clientCredential = &usernameCredential.credential; // declare and initialize an SSL transport security binding WS_SSL_TRANSPORT_SECURITY_BINDING sslBinding = {}; // zero out the struct sslBinding.binding.bindingType = WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE; // set the binding type // declare and initialize the array of all security bindings WS_SECURITY_BINDING* securityBindings[2] = { &sslBinding.binding, &usernameBinding.binding }; // declare and initialize the security description WS_SECURITY_DESCRIPTION securityDescription = {}; // zero out the struct securityDescription.securityBindings = securityBindings; securityDescription.securityBindingCount = WsCountOf(securityBindings); int result = 0; WS_ENDPOINT_ADDRESS address = {}; static const WS_STRING url = WS_STRING_VALUE(L"https://localhost:8443/example"); address.url = url; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create the proxy hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &securityDescription, NULL, 0, NULL, 0, &proxy, error); if (FAILED(hr)) { goto Exit; } hr = WsOpenServiceProxy( proxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } hr = DefaultBinding_ICalculator_Add( proxy, 1, 2, &result, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf(L"%d + %d = %d\n", 1, 2, result); Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (proxy != NULL) { WsCloseServiceProxy( proxy, NULL, NULL); WsFreeServiceProxy( proxy); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_METADATA* metadata = NULL; WS_CHANNEL* channel = NULL; WS_XML_READER* reader = NULL; WS_HEAP* heap = NULL; // Declare constraints on what policy is acceptable // Require HTTP WS_CHANNEL_BINDING channelBinding = WS_HTTP_CHANNEL_BINDING; // Set up channel property contraints that override the default constraints WS_CHANNEL_PROPERTY_CONSTRAINT channelPropertyConstraints[3]; // Allow text encodings WS_ENCODING allowedEncodings[] = { WS_ENCODING_XML_UTF8, WS_ENCODING_XML_UTF16LE, WS_ENCODING_XML_UTF16BE }; channelPropertyConstraints[0].id = WS_CHANNEL_PROPERTY_ENCODING; channelPropertyConstraints[0].allowedValues = allowedEncodings; channelPropertyConstraints[0].allowedValuesSize = sizeof(allowedEncodings); // Allow addressing 1.0 WS_ADDRESSING_VERSION allowedAddressingVersions[] = { WS_ADDRESSING_VERSION_1_0, }; channelPropertyConstraints[1].id = WS_CHANNEL_PROPERTY_ADDRESSING_VERSION; channelPropertyConstraints[1].allowedValues = allowedAddressingVersions; channelPropertyConstraints[1].allowedValuesSize = sizeof(allowedAddressingVersions); // Allow SOAP 1.1 or SOAP 1.2 WS_ENVELOPE_VERSION allowedEnvelopeVersions[] = { WS_ENVELOPE_VERSION_SOAP_1_1, WS_ENVELOPE_VERSION_SOAP_1_2, }; channelPropertyConstraints[2].id = WS_CHANNEL_PROPERTY_ENVELOPE_VERSION; channelPropertyConstraints[2].allowedValues = allowedEnvelopeVersions; channelPropertyConstraints[2].allowedValuesSize = sizeof(allowedEnvelopeVersions); // Set up security property contraints that override the default constraints WS_SECURITY_PROPERTY_CONSTRAINT securityPropertyConstraints[1]; // Allow with/without a timestamp WS_SECURITY_TIMESTAMP_USAGE allowedTimestampValues[] = { WS_SECURITY_TIMESTAMP_USAGE_NEVER, WS_SECURITY_TIMESTAMP_USAGE_ALWAYS, }; securityPropertyConstraints[0].id = WS_SECURITY_PROPERTY_TIMESTAMP_USAGE; securityPropertyConstraints[0].allowedValues = allowedTimestampValues; securityPropertyConstraints[0].allowedValuesSize = sizeof(allowedTimestampValues); // Set up the ssl security binding constraint structure WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT sslSecurityBindingConstraint = { }; sslSecurityBindingConstraint.bindingConstraint.type = WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE; // Set up the X.509 security binding constraint structure WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT certSecurityBindingConstraint = { }; certSecurityBindingConstraint.bindingConstraint.type = WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE; certSecurityBindingConstraint.bindingUsage = WS_SUPPORTING_MESSAGE_SECURITY_USAGE; // Set up the set of security binding constraints WS_SECURITY_BINDING_CONSTRAINT* securityBindingConstraints[] = { &sslSecurityBindingConstraint.bindingConstraint, &certSecurityBindingConstraint.bindingConstraint }; // Set up the security constraint structure WS_SECURITY_CONSTRAINTS securityConstraints = { }; securityConstraints.securityPropertyConstraints = securityPropertyConstraints; securityConstraints.securityPropertyConstraintCount = WsCountOf(securityPropertyConstraints); securityConstraints.securityBindingConstraints = securityBindingConstraints; securityConstraints.securityBindingConstraintCount = WsCountOf(securityBindingConstraints); // Set up the policy constraint structure WS_POLICY_CONSTRAINTS policyConstraints = { }; policyConstraints.channelBinding = channelBinding; policyConstraints.channelPropertyConstraints = channelPropertyConstraints; policyConstraints.channelPropertyConstraintCount = WsCountOf(channelPropertyConstraints); policyConstraints.securityConstraints = &securityConstraints; // Set up port type to match static const WS_XML_STRING desiredPortTypeName = WS_XML_STRING_VALUE("IPingService"); static const WS_XML_STRING desiredPortTypeNs = WS_XML_STRING_VALUE("http://example.com"); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create object that will hold metadata documents hr = WsCreateMetadata(NULL, 0, &metadata, error); if (FAILED(hr)) { goto Exit; } // Create an XML reader hr = WsCreateReader( NULL, 0, &reader, error); if (FAILED(hr)) { goto Exit; } // Set the input of the reader to the policy text WS_XML_READER_BUFFER_INPUT bufferInput; ZeroMemory(&bufferInput, sizeof(bufferInput)); bufferInput.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER; bufferInput.encodedData = wsdlXml.bytes; bufferInput.encodedDataSize = wsdlXml.length; WS_XML_READER_TEXT_ENCODING textEncoding; ZeroMemory(&textEncoding, sizeof(textEncoding)); textEncoding.encoding.encodingType = WS_XML_READER_ENCODING_TYPE_TEXT; textEncoding.charSet = WS_CHARSET_AUTO; hr = WsSetInput(reader, &textEncoding.encoding, &bufferInput.input, NULL, 0, error); if (FAILED(hr)) { goto Exit; } // Read the metadata into the metadata object. hr = WsReadMetadata(metadata, reader, &wsdlUrl, error); if (FAILED(hr)) { goto Exit; } // After adding a document to the metadata object, it can be queried // to determine the address of any documents which have been referenced // but have not yet been added. WS_ENDPOINT_ADDRESS* missingAddress; hr = WsGetMissingMetadataDocumentAddress(metadata, &missingAddress, error); if (FAILED(hr)) { goto Exit; } if (missingAddress != NULL) { // We only support one document in this example hr = E_FAIL; goto Exit; } // Get the endpoints from the metadata object WS_METADATA_ENDPOINTS endpoints; hr = WsGetMetadataEndpoints(metadata, &endpoints, error); if (FAILED(hr)) { goto Exit; } BOOL foundEndpoint = FALSE; WS_METADATA_ENDPOINT* endpoint = NULL; // Search for port types for (ULONG i = 0; i < endpoints.endpointCount; i++) { // Get the endpoint from the array of endpoints endpoint = &endpoints.endpoints[i]; // See if the port type name matches hr = WsXmlStringEquals(endpoint->portTypeName, &desiredPortTypeName, error); if (FAILED(hr)) { goto Exit; } if (hr == S_FALSE) { continue; } // See if the port type namespace matches hr = WsXmlStringEquals(endpoint->portTypeNs, &desiredPortTypeNs, error); if (FAILED(hr)) { goto Exit; } if (hr == S_FALSE) { continue; } foundEndpoint = TRUE; break; } if (!foundEndpoint) { // No matching port types hr = E_FAIL; goto Exit; } // Get the policy for the endpoint WS_POLICY* policy; policy = endpoint->endpointPolicy; // Get the number of policy alternatives available in the policy object ULONG alternativeCount; hr = WsGetPolicyAlternativeCount( policy, &alternativeCount, error); if (FAILED(hr)) { goto Exit; } // Create a heap used to allocate fields of initialized values hr = WsCreateHeap(/* maxSize */ 16*1024, /* trimSize */ 2*1024, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } BOOL matchFound = FALSE; // For each alternative in the policy object for (ULONG alternativeIndex = 0; alternativeIndex < alternativeCount; alternativeIndex++) { // This example uses FALSE for the matchRequired parameter to WsMatchPolicyAlternative // which means that the function will return S_FALSE if there is not a match. // If diagnosing why a policy can not be matched, it may be useful to instead set // matchRequired to TRUE meaning an error will be returned (and the error object // will contain information about why the policy did not match). BOOL matchRequired = FALSE; // Try to match policy given the constraints hr = WsMatchPolicyAlternative( policy, alternativeIndex, &policyConstraints, matchRequired, heap, error); if (FAILED(hr)) { goto Exit; } if (hr == S_OK) { // The policy met the constraints matchFound = TRUE; break; } } if (!matchFound) { // None of the policy alternatives matched hr = E_FAIL; goto Exit; } // Initialize channel properties based on the values found in the policy WS_CHANNEL_PROPERTY channelProperties[4]; channelProperties[0] = channelPropertyConstraints[0].out.channelProperty; channelProperties[1] = channelPropertyConstraints[1].out.channelProperty; channelProperties[2] = channelPropertyConstraints[2].out.channelProperty; // Initialize additional channel properties that specify local behavior // that is not part of policy. WS_TRANSFER_MODE transferMode = WS_BUFFERED_TRANSFER_MODE; channelProperties[3].id = WS_CHANNEL_PROPERTY_TRANSFER_MODE; channelProperties[3].value = &transferMode; channelProperties[3].valueSize = sizeof(transferMode); // Initialize security properties based on values extracted from policy WS_SECURITY_PROPERTY securityProperties[1]; securityProperties[0] = securityPropertyConstraints[0].out.securityProperty; // Set up SSL security binding WS_SSL_TRANSPORT_SECURITY_BINDING sslSecurityBinding; ZeroMemory(&sslSecurityBinding, sizeof(sslSecurityBinding)); sslSecurityBinding.binding.bindingType = WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE; if (sslSecurityBindingConstraint.out.clientCertCredentialRequired) { // Server wants a client cert, but this example does not have one hr = E_FAIL; goto Exit; } else { sslSecurityBinding.localCertCredential = NULL; } // The runtime does not support X.509 binding hence use a WS_XML_TOKEN_MESSAGE_SECURITY_BINDING to create a channel WS_XML_TOKEN_MESSAGE_SECURITY_BINDING xmlTokenSecurityBinding; ZeroMemory(&xmlTokenSecurityBinding, sizeof(xmlTokenSecurityBinding)); xmlTokenSecurityBinding.binding.bindingType = WS_XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE; xmlTokenSecurityBinding.bindingUsage = certSecurityBindingConstraint.bindingUsage; // To obtain a security token to specify for the xmlToken field, use the following steps: // - Find the appropriate certificate and create a X.509 token // - Use WsCreateXmlSecurityToken and to create a security token with the keys from the above X.509 token xmlTokenSecurityBinding.xmlToken = NULL; // Set up security bindings WS_SECURITY_BINDING* securityBindings[2]; securityBindings[0] = &sslSecurityBinding.binding; securityBindings[1] = &xmlTokenSecurityBinding.binding; // Set up security description WS_SECURITY_DESCRIPTION securityDescription; securityDescription.securityBindings = securityBindings; securityDescription.securityBindingCount = WsCountOf(securityBindings); securityDescription.properties = securityProperties; securityDescription.propertyCount = WsCountOf(securityProperties); // Create a channel or proxy to the service using the accumulated binding information: // - channelBinding // - channelProperties // - securityDecription Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (metadata != NULL) { WsFreeMetadata(metadata); } if (channel != NULL) { WsFreeChannel(channel); } if (reader != NULL) { WsFreeReader(reader); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_CHANNEL* channel = NULL; WS_LISTENER* listener = NULL; WS_HEAP* heap = NULL; WS_MESSAGE* message = NULL; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a listener hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_NAMEDPIPE_CHANNEL_BINDING, NULL, 0, NULL, &listener, error); if (FAILED(hr)) { goto Exit; } // Create a channel suitable for the listener hr = WsCreateChannelForListener( listener, NULL, 0, &channel, error); if (FAILED(hr)) { goto Exit; } // Open listener using named pipe duplex session WS_STRING uri; uri.chars = L"net.pipe://localhost/example"; uri.length = (ULONG)::wcslen(uri.chars); hr = WsOpenListener( listener, &uri, NULL, error); if (FAILED(hr)) { goto Exit; } // Accept a channel from the client hr = WsAcceptChannel(listener, channel, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &message, error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Receive messages for (;;) { // Receive the message start (headers) hr = WsReadMessageStart( channel, message, NULL, error); if (FAILED(hr)) { goto Exit; } if (hr == WS_S_END) { // No more messages break; } // Get action value WS_XML_STRING receivedAction; hr = WsGetHeader( message, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_READ_REQUIRED_VALUE, NULL, &receivedAction, sizeof(receivedAction), error); if (FAILED(hr)) { goto Exit; } // Make sure action is what we expect hr = WsXmlStringEquals( &receivedAction, PurchaseOrder_wsdl.messages.PurchaseOrder.action, error); if (hr != S_OK) { hr = WS_E_ENDPOINT_ACTION_NOT_SUPPORTED; goto Exit; } // Get the reader for the body WS_XML_READER* reader; hr = WsGetMessageProperty( message, WS_MESSAGE_PROPERTY_BODY_READER, &reader, sizeof(reader), error); if (FAILED(hr)) { goto Exit; } // Stream in the body data for (;;) { // Read purchase order into heap, if there are any more. _PurchaseOrderType* purchaseOrder; hr = WsReadElement( reader, &PurchaseOrder_wsdl.globalElements.PurchaseOrderType, WS_READ_OPTIONAL_POINTER, heap, &purchaseOrder, sizeof(purchaseOrder), error); if (FAILED(hr)) { goto Exit; } // NULL indicates no more purchase orders if (purchaseOrder == NULL) { break; } // Print out purchase order contents wprintf(L"%ld, %s\n", purchaseOrder->quantity, purchaseOrder->productName); // Free purchase order hr = WsResetHeap( heap, error); if (FAILED(hr)) { goto Exit; } } // Read the end of the message hr = WsReadMessageEnd( channel, message, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsResetMessage( message, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } if (listener != NULL) { // Close the listener if it was opened WsCloseListener(listener, NULL, error); } if (channel != NULL) { WsFreeChannel(channel); } if (listener != NULL) { WsFreeListener(listener); } if (message != NULL) { WsFreeMessage(message); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_ASYNC_STATE asyncState; RECEIVE_STATE receiveState; receiveState.listener = NULL; receiveState.channel = NULL; receiveState.message = NULL; receiveState.heap = NULL; receiveState.reader = NULL; THREAD_INFO threadInfo; threadInfo.hr = S_OK; threadInfo.handle = NULL; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to hold body data, with a max size to limit size of purchase order read hr = WsCreateHeap(/*maxSize*/ 1024, /*trimSize*/ 1024, NULL, 0, &receiveState.heap, error); if (FAILED(hr)) { goto Exit; } threadInfo.handle = CreateEvent(NULL, TRUE, FALSE, NULL); if (threadInfo.handle == NULL) { goto Exit; } WS_ASYNC_CONTEXT receiveComplete; receiveComplete.callback = OnReceiveComplete; receiveComplete.callbackState = &threadInfo; hr = WsAsyncExecute(&asyncState, Receive1, WS_LONG_CALLBACK, &receiveState, &receiveComplete, error); if (FAILED(hr)) { goto Exit; } if (hr == WS_S_ASYNC) { WaitForSingleObject(threadInfo.handle, INFINITE); hr = threadInfo.hr; if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (receiveState.channel != NULL) { // Close the channel WsCloseChannel(receiveState.channel, NULL, error); } if (receiveState.channel != NULL) { WsFreeChannel(receiveState.channel); } if (receiveState.listener != NULL) { // Close the listener if it was opened WsCloseListener(receiveState.listener, NULL, error); } if (receiveState.listener != NULL) { WsFreeListener(receiveState.listener); } if (receiveState.message != NULL) { WsFreeMessage(receiveState.message); } if (receiveState.heap != NULL) { WsFreeHeap(receiveState.heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_XML_BUFFER* buffer = NULL; WS_XML_WRITER* writer = NULL; WS_XML_READER* reader = NULL; void* xml = NULL; ULONG xmlLength = 0; WS_XML_NODE_POSITION securityEndElementPosition; static const WS_XML_STRING soapNs = WS_XML_STRING_VALUE("http://schemas.xmlsoap.org/soap/envelope/"); static const WS_XML_STRING wsseNs = WS_XML_STRING_VALUE("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"); static const WS_XML_STRING envelope = WS_XML_STRING_VALUE("Envelope"); static const WS_XML_STRING header = WS_XML_STRING_VALUE("Header"); static const WS_XML_STRING security = WS_XML_STRING_VALUE("Security"); static const WS_XML_STRING dsNs = WS_XML_STRING_VALUE("http://www.w3.org/2000/09/xmldsig#"); static const WS_XML_STRING signature = WS_XML_STRING_VALUE("Signature"); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create an XML writer hr = WsCreateWriter( NULL, 0, &writer, error); if (FAILED(hr)) { goto Exit; } // Create an XML reader hr = WsCreateReader( NULL, 0, &reader, error); if (FAILED(hr)) { goto Exit; } // Create an XML buffer on the specified heap hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, error); if (FAILED(hr)) { goto Exit; } // Set the writer to output to the XML buffer hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, error); if (FAILED(hr)) { goto Exit; } // Write the envelope element hr = WsWriteStartElement(writer, NULL, &envelope, &soapNs, error); if (FAILED(hr)) { goto Exit; } // Write the header element hr = WsWriteStartElement(writer, NULL, &header, &soapNs, error); if (FAILED(hr)) { goto Exit; } // Write the security element hr = WsWriteStartElement(writer, NULL, &security, &wsseNs, error); if (FAILED(hr)) { goto Exit; } // Force the security element start tag to be written so the position obtained // is "after" the security element hr = WsWriteEndStartElement(writer, error); if (FAILED(hr)) { goto Exit; } hr = WsGetWriterPosition(writer, &securityEndElementPosition, error); if (FAILED(hr)) { goto Exit; } // Close the security element hr = WsWriteEndElement(writer, error); if (FAILED(hr)) { goto Exit; } // Close the header element hr = WsWriteEndElement(writer, error); if (FAILED(hr)) { goto Exit; } // Close the envelope element hr = WsWriteEndElement(writer, error); if (FAILED(hr)) { goto Exit; } // Move the write back hr = WsSetWriterPosition(writer, &securityEndElementPosition, error); if (FAILED(hr)) { goto Exit; } // Write the "signature" element hr = WsWriteStartElement(writer, NULL, &signature, &dsNs, error); if (FAILED(hr)) { goto Exit; } // Close the signature element hr = WsWriteEndElement(writer, error); if (FAILED(hr)) { goto Exit; } // Generate the bytes of the document ULONG indent = 4; WS_XML_WRITER_PROPERTY properties[1]; properties[0].id = WS_XML_WRITER_PROPERTY_INDENT; properties[0].value = &indent; properties[0].valueSize = sizeof(indent); hr = WsWriteXmlBufferToBytes(writer, buffer, NULL, properties, WsCountOf(properties), heap, &xml, &xmlLength, error); if (FAILED(hr)) { goto Exit; } printf("%.*s\n", xmlLength, (char*)xml); Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (writer != NULL) { WsFreeWriter(writer); } if (reader != NULL) { WsFreeReader(reader); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_SERVICE_PROXY* proxy = NULL; int result = 0; WS_ENDPOINT_ADDRESS address = {}; static const WS_STRING url= WS_STRING_VALUE(L"http://localhost/example"); address.url = url; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // In order to use the custom channel through Service Model, // we need to configure it to disable all timeouts. WS_CHANNEL_PROPERTY channelPropertyArray[1]; BOOL enableTimeouts = FALSE; channelPropertyArray[0].id = WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS; channelPropertyArray[0].value = &enableTimeouts; channelPropertyArray[0].valueSize = sizeof(enableTimeouts); // Set up channel properties for the custom channel WS_CHANNEL_PROPERTY customChannelPropertyArray[2]; // Set up channel property that specifies the callbacks that implement the custom channel customChannelPropertyArray[0].id = WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS; customChannelPropertyArray[0].value = &layeredChannelCallbacks; customChannelPropertyArray[0].valueSize = sizeof(layeredChannelCallbacks); // Initialize parameters to pass to the layered channel. // Note that the parameters structure and it's contents must // remain valid until the proxy object has been freed. In this // example, the parameters are declared on the stack for // simplicity, but in other scenarios they may need to be // allocated from the heap. LayeredChannelParameters layeredChannelParameters; layeredChannelParameters.channelBinding = WS_HTTP_CHANNEL_BINDING; layeredChannelParameters.channelProperties = channelPropertyArray; layeredChannelParameters.channelPropertyCount = WsCountOf(channelPropertyArray); layeredChannelParameters.securityDescription = NULL; // Specify the channel parameters as a channel property customChannelPropertyArray[1].id = WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS; customChannelPropertyArray[1].value = &layeredChannelParameters; customChannelPropertyArray[1].valueSize = sizeof(layeredChannelParameters); // Create the proxy hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_CUSTOM_CHANNEL_BINDING, NULL, NULL, 0, customChannelPropertyArray, WsCountOf(customChannelPropertyArray), &proxy, error); if (FAILED(hr)) { goto Exit; } hr = WsOpenServiceProxy( proxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } hr = DefaultBinding_ICalculator_Add( proxy, 1, 2, &result, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf(L"%d + %d = %d\n", 1, 2, result); Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (proxy != NULL) { WsCloseServiceProxy( proxy, NULL, NULL); WsFreeServiceProxy( proxy); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_XML_BUFFER* xmlBuffer = NULL; WS_HEAP* heap = NULL; WS_XML_READER* xmlReader = NULL; WS_XML_WRITER* xmlWriter = NULL; PayloadBaseType* baseType = NULL; Payload1Type* payload1Type = NULL; static const WS_XML_STRING dataElement = WS_XML_STRING_VALUE("data"); static const WS_XML_STRING emptyNamespace = WS_XML_STRING_VALUE(""); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 4096, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create an XML reader hr = WsCreateReader( NULL, 0, &xmlReader, error); if (FAILED(hr)) { goto Exit; } // Create an XML writer hr = WsCreateWriter( NULL, 0, &xmlWriter, error); if (FAILED(hr)) { goto Exit; } // Create an XML buffer on the specified heap hr = WsCreateXmlBuffer( heap, NULL, 0, &xmlBuffer, error); if (FAILED(hr)) { goto Exit; } // Set the writer to output to the XML buffer hr = WsSetOutputToBuffer( xmlWriter, xmlBuffer, NULL, 0, error); if (FAILED(hr)) { goto Exit; } // Create a wrapper element for the two embedded elements hr = WsWriteStartElement( xmlWriter, NULL, &dataElement, &emptyNamespace, error); if (FAILED(hr)) { goto Exit; } baseType = new(std::nothrow) PayloadBaseType(); if (baseType == NULL) { goto Exit; } baseType->Id = 1; payload1Type = new(std::nothrow) Payload1Type(); if (payload1Type == NULL) { goto Exit; } payload1Type->Id = 2; payload1Type->BoolValue = FALSE; payload1Type->StringValue = L"hello world"; // Write the base type using the element description of the base type. // An xsi:type attribute will be added to the XML document for the element // indicating this is the base type. hr = WsWriteElement( xmlWriter, &DerivedType_xsd.globalElements.PayloadBase, WS_WRITE_REQUIRED_VALUE, baseType, sizeof(PayloadBaseType), error); if (FAILED(hr)) { goto Exit; } // Write the derived type using the element description of the base type. // An xsi:type attribute will be added to the XML document for the element // indicating this is the derived type. hr = WsWriteElement( xmlWriter, &DerivedType_xsd.globalElements.PayloadBase, WS_WRITE_REQUIRED_VALUE, payload1Type, sizeof(Payload1Type), error); if (FAILED(hr)) { goto Exit; } hr = WsWriteEndElement( xmlWriter, error); if (FAILED(hr)) { goto Exit; } // Flush writer so all XML content is put in the buffer hr = WsFlushWriter(xmlWriter, 0, NULL, error); if (FAILED(hr)) { goto Exit; } // Set the reader input to current position of XML buffer hr = WsSetInputToBuffer(xmlReader, xmlBuffer, NULL, 0, error); if (FAILED(hr)) { goto Exit; } // Read pass the wrapper element hr = WsReadToStartElement( xmlReader, &dataElement, &emptyNamespace, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsReadStartElement( xmlReader, error); if (FAILED(hr)) { goto Exit; } PayloadBaseType* outBaseType = NULL; // Read the first element using element description for the base // type. The type of returning structure is that of that base type. hr = WsReadElement( xmlReader, &DerivedType_xsd.globalElements.PayloadBase, WS_READ_REQUIRED_POINTER, heap, &outBaseType, sizeof(PayloadBaseType*), error); if (FAILED(hr)) { goto Exit; } PrintPayloadType(outBaseType); // Read the second element using element description for the base // type. The type of returning structure is that of the derived type. hr = WsReadElement( xmlReader, &DerivedType_xsd.globalElements.PayloadBase, WS_READ_REQUIRED_POINTER, heap, &outBaseType, sizeof(PayloadBaseType*), error); if (FAILED(hr)) { goto Exit; } PrintPayloadType(outBaseType); hr = WsReadEndElement( xmlReader, error); if (FAILED(hr)) { goto Exit; } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } delete baseType; delete payload1Type; if (xmlReader != NULL) { WsFreeReader(xmlReader); } if (xmlWriter != NULL) { WsFreeWriter(xmlWriter); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_SERVICE_PROXY* proxy = NULL; // declare and initialize a Windows credential WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL windowsCredential = {}; // zero out the struct windowsCredential.credential.credentialType = WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE; // set the credential type // for illustration only; usernames and passwords should never be included in source files windowsCredential.username.chars = L".\\TestUserForBasicAuth"; windowsCredential.username.length = (ULONG)wcslen(windowsCredential.username.chars); windowsCredential.password.chars = L"TstPWD@*4Bsic"; windowsCredential.password.length = (ULONG)wcslen(windowsCredential.password.chars); // declare and initialize properties to set the authentication scheme to Basic ULONG scheme = WS_HTTP_HEADER_AUTH_SCHEME_BASIC; WS_SECURITY_BINDING_PROPERTY httpAuthBindingProperties[1] = { { WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_SCHEME, &scheme, sizeof(scheme) } }; // declare and initialize an HTTP header authentication security binding WS_HTTP_HEADER_AUTH_SECURITY_BINDING httpAuthBinding = {}; // zero out the struct httpAuthBinding.binding.bindingType = WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE; // set the binding type httpAuthBinding.binding.properties = httpAuthBindingProperties; httpAuthBinding.binding.propertyCount = WsCountOf(httpAuthBindingProperties); httpAuthBinding.clientCredential = &windowsCredential.credential; // declare and initialize an SSL transport security binding WS_SSL_TRANSPORT_SECURITY_BINDING sslBinding = {}; // zero out the struct sslBinding.binding.bindingType = WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE; // set the binding type // declare and initialize the array of all security bindings WS_SECURITY_BINDING* securityBindings[2] = { &sslBinding.binding, &httpAuthBinding.binding }; // declare and initialize the security description WS_SECURITY_DESCRIPTION securityDescription = {}; // zero out the struct securityDescription.securityBindings = securityBindings; securityDescription.securityBindingCount = WsCountOf(securityBindings); int result = 0; WS_ENDPOINT_ADDRESS address = {}; static const WS_STRING url = WS_STRING_VALUE(L"https://localhost:8443/example"); address.url = url; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create the proxy hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &securityDescription, NULL, 0, NULL, 0, &proxy, error); if (FAILED(hr)) { goto Exit; } hr = WsOpenServiceProxy( proxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } hr = DefaultBinding_ICalculator_Add( proxy, 1, 2, &result, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf(L"%d + %d = %d\n", 1, 2, result); Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (proxy != NULL) { WsCloseServiceProxy( proxy, NULL, NULL); WsFreeServiceProxy( proxy); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_SERVICE_PROXY* serviceProxy = NULL; WS_HEAP* heap = NULL; WS_ENDPOINT_ADDRESS address = {}; static const WS_STRING serviceUrl = WS_STRING_VALUE(L"http://terraservice.net/TerraService2.asmx"); WS_CHANNEL_PROPERTY channelPropertyArray[4]; WS_ADDRESSING_VERSION addressingVersion = WS_ADDRESSING_VERSION_TRANSPORT; WS_ENVELOPE_VERSION envelopeVersion = WS_ENVELOPE_VERSION_SOAP_1_1; WCHAR* place = NULL; WS_HTTP_PROXY_SETTING_MODE proxySettingMode = WS_HTTP_PROXY_SETTING_MODE_CUSTOM; WS_CUSTOM_HTTP_PROXY customProxy = {}; address.url = serviceUrl; WINHTTP_AUTOPROXY_OPTIONS autoProxyOptions = {}; WINHTTP_PROXY_INFO proxyInfo = {}; HINTERNET session = NULL; channelPropertyArray[0].id = WS_CHANNEL_PROPERTY_ADDRESSING_VERSION; channelPropertyArray[0].value = &addressingVersion; channelPropertyArray[0].valueSize = sizeof(addressingVersion); channelPropertyArray[1].id = WS_CHANNEL_PROPERTY_ENVELOPE_VERSION; channelPropertyArray[1].value = &envelopeVersion; channelPropertyArray[1].valueSize = sizeof(envelopeVersion); channelPropertyArray[2].id = WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE; channelPropertyArray[2].value = &proxySettingMode; channelPropertyArray[2].valueSize = sizeof(proxySettingMode); channelPropertyArray[3].id = WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY; channelPropertyArray[3].value = &customProxy; channelPropertyArray[3].valueSize = sizeof(customProxy); // This part illustrates how to setup a HTTP header authentication security binding // against the HTTP proxy server in case it requires authentication. // declare and initialize a default windows credential WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL windowsCredential = {}; // zero out the struct windowsCredential.credential.credentialType = WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE; // set the credential type // for illustration only; usernames and passwords should never be included in source files windowsCredential.username.chars = L"domain\\user"; windowsCredential.username.length = (ULONG)wcslen(windowsCredential.username.chars); windowsCredential.password.chars = L"password"; windowsCredential.password.length = (ULONG)wcslen(windowsCredential.password.chars); // declare and initialize properties to set the authentication scheme to Basic ULONG scheme = WS_HTTP_HEADER_AUTH_SCHEME_NEGOTIATE; ULONG target = WS_HTTP_HEADER_AUTH_TARGET_PROXY; WS_SECURITY_BINDING_PROPERTY httpProxyAuthBindingProperties[2] = { { WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_SCHEME, &scheme, sizeof(scheme) }, { WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_TARGET, &target, sizeof(target) } }; // declare and initialize an HTTP header authentication security binding for the HTTP proxy server WS_HTTP_HEADER_AUTH_SECURITY_BINDING httpProxyAuthBinding = {}; // zero out the struct httpProxyAuthBinding.binding.bindingType = WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE; // set the binding type httpProxyAuthBinding.binding.properties = httpProxyAuthBindingProperties; httpProxyAuthBinding.binding.propertyCount = WsCountOf(httpProxyAuthBindingProperties); httpProxyAuthBinding.clientCredential = &windowsCredential.credential; // declare and initialize the array of all security bindings WS_SECURITY_BINDING* securityBindings[1] = { &httpProxyAuthBinding.binding }; // declare and initialize the security description WS_SECURITY_DESCRIPTION securityDescription = {}; // zero out the struct securityDescription.securityBindings = securityBindings; securityDescription.securityBindingCount = WsCountOf(securityBindings); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } session = WinHttpOpen(L"NWS Example", WINHTTP_ACCESS_TYPE_NO_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, WINHTTP_FLAG_ASYNC); if (!session) { hr = HRESULT_FROM_WIN32(GetLastError()); goto Exit; } autoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_RUN_INPROCESS | WINHTTP_AUTOPROXY_AUTO_DETECT; autoProxyOptions.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A; autoProxyOptions.fAutoLogonIfChallenged = FALSE; WinHttpGetProxyForUrl( session, serviceUrl.chars, &autoProxyOptions, &proxyInfo); if (proxyInfo.dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY) { if (proxyInfo.lpszProxy) { customProxy.servers.chars = proxyInfo.lpszProxy; customProxy.servers.length = (ULONG)wcslen(proxyInfo.lpszProxy); } if (proxyInfo.lpszProxyBypass) { customProxy.bypass.chars = proxyInfo.lpszProxyBypass; customProxy.bypass.length = (ULONG)wcslen(proxyInfo.lpszProxyBypass); } } hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &securityDescription, NULL, 0, channelPropertyArray, WsCountOf(channelPropertyArray), &serviceProxy, error); if (FAILED(hr)) { goto Exit; } // Open channel to address hr = WsOpenServiceProxy( serviceProxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } for (int i = 0; i < 100; i++) { LonLatPt point = {10.0, 10.0}; hr = TerraServiceSoap_ConvertLonLatPtToNearestPlace( serviceProxy, &point, &place, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } if (place != NULL) { wprintf(L"Place @ Lattitude=%f, Longitutde=%f is %s\n", point.Lon, point.Lat, place); } else { wprintf(L"Could not find any place for Lattitude=%f, Longitutde=%f\n", point.Lon, point.Lat); } fflush(stdout); hr = WsResetHeap( heap, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (proxyInfo.lpszProxy) { ::GlobalFree(proxyInfo.lpszProxy); } if (proxyInfo.lpszProxyBypass) { ::GlobalFree(proxyInfo.lpszProxyBypass); } if (serviceProxy != NULL) { WsCloseServiceProxy(serviceProxy, NULL, NULL); WsFreeServiceProxy(serviceProxy); } if (!session) { WinHttpCloseHandle(session); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_SERVICE_HOST* host = NULL; WS_SERVICE_ENDPOINT* serviceEndpoint = NULL; const WS_SERVICE_ENDPOINT* serviceEndpoints[1]; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; const WS_STRING url = WS_STRING_VALUE(L"https://localhost:8443/example"); WS_SERVICE_PROPERTY_CLOSE_CALLBACK closeCallbackProperty = {CloseChannelCallback}; WS_SERVICE_ENDPOINT_PROPERTY serviceProperties[1]; serviceProperties[0].id = WS_SERVICE_ENDPOINT_PROPERTY_CLOSE_CHANNEL_CALLBACK; serviceProperties[0].value = &closeCallbackProperty; serviceProperties[0].valueSize = sizeof(closeCallbackProperty); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } hr = DefaultBinding_ICalculator_CreateServiceEndpoint( NULL, &url, (DefaultBinding_ICalculatorFunctionTable*)&calculatorFunctions, NULL, serviceProperties, WsCountOf(serviceProperties), heap, &serviceEndpoint, error); if (FAILED(hr)) { goto Exit; } serviceEndpoints[0] = serviceEndpoint; hr = WsCreateServiceHost(serviceEndpoints, 1, NULL, 0, &host, error); if (FAILED(hr)) { goto Exit; } // WsOpenServiceHost to start the listeners in the service host hr = WsOpenServiceHost(host, NULL, error); if (FAILED(hr)) { goto Exit; } // Create Event object for closing the server closeServer = CreateEvent( NULL, TRUE, FALSE, NULL); if (closeServer == NULL) { hr = HRESULT_FROM_WIN32(GetLastError()); goto Exit; } WaitForSingleObject(closeServer, INFINITE); // Close the service host hr = WsCloseServiceHost(host, NULL, error); if (FAILED(hr)) { goto Exit; } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (host != NULL) { WsFreeServiceHost(host); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } if (closeServer != NULL) { CloseHandle(closeServer); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_SERVICE_PROXY* serviceProxy = NULL; WS_ENDPOINT_ADDRESS address = {}; const WS_ASYNC_CONTEXT asyncContext = {BlockMethodComplete, NULL}; static const WS_STRING serviceUrl = WS_STRING_VALUE(L"net.tcp://localhost/example"); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateServiceProxy(WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, NULL, 0, NULL, 0, &serviceProxy, error); if (FAILED(hr)) { goto Exit; } // Initialize address of service address.url = serviceUrl; hr = WsOpenServiceProxy(serviceProxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf(L"Calling blocking method async\n"); hr = BlockServiceBinding_Block(serviceProxy, heap, NULL, 0, &asyncContext, error); if (FAILED(hr)) { goto Exit; } wprintf(L"Waiting...\n"); Sleep(5000L); wprintf(L"Now aborting service proxy\n"); hr = WsAbortServiceProxy(serviceProxy, error); if (FAILED(hr)) { goto Exit; } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (serviceProxy != NULL) { WsCloseServiceProxy(serviceProxy, NULL, NULL); WsFreeServiceProxy(serviceProxy); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_LISTENER* listener = NULL; WS_CHANNEL* channel = NULL; WS_MESSAGE* requestMessage = NULL; WS_MESSAGE* replyMessage = NULL; WS_HEAP* heap = NULL; WCHAR* certSubjectName = NULL; PCCERT_CONTEXT certContext = NULL; BOOL requireClientCert = TRUE; WS_SECURITY_BINDING_PROPERTY requireClientCertProperty = {}; requireClientCertProperty.id = WS_SECURITY_BINDING_PROPERTY_REQUIRE_SSL_CLIENT_CERT; requireClientCertProperty.value = &requireClientCert; requireClientCertProperty.valueSize = sizeof(requireClientCert); // declare and initialize an SSL transport security binding WS_SSL_TRANSPORT_SECURITY_BINDING sslBinding = {}; // zero out the struct sslBinding.binding.bindingType = WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE; // set the binding type sslBinding.binding.properties = &requireClientCertProperty; sslBinding.binding.propertyCount = 1; // NOTE: At the server, the SSL certificate for the listen URI must be // registered with http.sys using a tool such as httpcfg.exe. // declare and initialize the array of all security bindings WS_SECURITY_BINDING* securityBindings[1] = { &sslBinding.binding }; // declare and initialize the security description WS_SECURITY_DESCRIPTION securityDescription = {}; // zero out the struct securityDescription.securityBindings = securityBindings; securityDescription.securityBindingCount = WsCountOf(securityBindings); static const WS_STRING uri = WS_STRING_VALUE(L"https://localhost:8443/example"); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create a listener hr = WsCreateListener( WS_CHANNEL_TYPE_REPLY, WS_HTTP_CHANNEL_BINDING, NULL, 0, &securityDescription, &listener, error); if (FAILED(hr)) { goto Exit; } // Open listener hr = WsOpenListener(listener, &uri, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateChannelForListener( listener, NULL, 0, &channel, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &requestMessage, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &replyMessage, error); if (FAILED(hr)) { goto Exit; } // Receive requests / send replies for (int i = 0; i < 300; i++) { // Accept a request from the client hr = WsAcceptChannel(listener, channel, NULL, error); if (FAILED(hr)) { goto Exit; } // Set up the descriptions of the expected messages. We expect either a purchase order // or a request for order status. const WS_MESSAGE_DESCRIPTION* requestMessageDescriptions[] = { &PurchaseOrder_wsdl.messages.PurchaseOrder, // contains a _PurchaseOrderType in the body &PurchaseOrder_wsdl.messages.GetOrderStatus, // contains a GetOrderStatus in the body }; // Receive the message and deserialize the element of the body into the appropriate // structure, based on the message descriptions. The value of the body will be // allocated in the specified WS_HEAP, and are valid until WsResetHeap is called. void* requestBodyPointer; ULONG indexOfMatchedMessageDescription; hr = WsReceiveMessage(channel, requestMessage, requestMessageDescriptions, WsCountOf(requestMessageDescriptions), WS_RECEIVE_REQUIRED_MESSAGE, WS_READ_REQUIRED_POINTER, heap, &requestBodyPointer, sizeof(requestBodyPointer), &indexOfMatchedMessageDescription, NULL, error); // Validate the client certificate. if (SUCCEEDED(hr)) { // Another way to do client cert validation is to use // WS_MESSAGE_PROPERTY_TRANSPORT_SECURITY_WINDOWS_TOKEN here, assuming http.sys // is configured to map the cert into a windows token and was able to map the // cert to a user account. WS_BYTES encodedCert = {}; hr = WsGetMessageProperty( requestMessage, WS_MESSAGE_PROPERTY_ENCODED_CERT, &encodedCert, sizeof(encodedCert), error); if (FAILED(hr)) { goto Exit; } _Analysis_assume_(encodedCert.bytes != NULL); certContext = CertCreateCertificateContext( X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, encodedCert.bytes, encodedCert.length); if (certContext == NULL) { hr = HRESULT_FROM_WIN32(GetLastError()); goto Exit; } ULONG subjectNameLength = CertNameToStr( certContext->dwCertEncodingType, &certContext->pCertInfo->Subject, CERT_SIMPLE_NAME_STR, NULL, 0); if (subjectNameLength == 0) { hr = HRESULT_FROM_WIN32(GetLastError()); goto Exit; } certSubjectName = new WCHAR[subjectNameLength]; if (certSubjectName == NULL) { hr = E_OUTOFMEMORY; goto Exit; } subjectNameLength = CertNameToStr( certContext->dwCertEncodingType, &certContext->pCertInfo->Subject, CERT_SIMPLE_NAME_STR, certSubjectName, subjectNameLength); if (subjectNameLength == 0) { hr = HRESULT_FROM_WIN32(GetLastError()); goto Exit; } static const WCHAR expectedCertName[] = L"client.com"; wprintf(L"Expected client cert name: %s\n", expectedCertName); wprintf(L"Received client cert name: %s\n", certSubjectName); if (CompareString( LOCALE_INVARIANT, NORM_IGNORECASE, expectedCertName, (int)::wcslen(expectedCertName), certSubjectName, (int)::wcslen(certSubjectName)) != CSTR_EQUAL) { hr = WS_E_SECURITY_VERIFICATION_FAILURE; goto Exit; } } // Process the request, and generate the reply const WS_MESSAGE_DESCRIPTION* replyMessageDescription = NULL; const void* replyBodyPointer = NULL; ULONG replyBodySize = 0; _OrderConfirmationType orderConfirmation; _GetOrderStatusResponseType getOrderStatusResponse; if (SUCCEEDED(hr)) { // Get the message description that matched const WS_MESSAGE_DESCRIPTION* requestMessageDescription = requestMessageDescriptions[indexOfMatchedMessageDescription]; if (requestMessageDescription == &PurchaseOrder_wsdl.messages.PurchaseOrder) { // The message was a purchase order. Get the pointer to the deserialized value. _PurchaseOrderType* purchaseOrder = (_PurchaseOrderType*)requestBodyPointer; // Print out purchase order contents wprintf(L"%d, %s\n", purchaseOrder->quantity, purchaseOrder->productName); // Initialize order confirmation data orderConfirmation.expectedShipDate = L"1/1/2006"; orderConfirmation.orderID = 123; // Setup up reply message replyMessageDescription = &PurchaseOrder_wsdl.messages.OrderConfirmation; replyBodyPointer = &orderConfirmation; replyBodySize = sizeof(orderConfirmation); } else if (requestMessageDescription == &PurchaseOrder_wsdl.messages.GetOrderStatus) { // The message was a order status request. Get the pointer to the deserialized value. _GetOrderStatusType* getOrderStatus = (_GetOrderStatusType*)requestBodyPointer; // Generate a fault if we don't recognize the order ID if (getOrderStatus->orderID != 123) { // Fill out details about the fault _OrderNotFoundFaultType orderNotFound; orderNotFound.orderID = getOrderStatus->orderID; static const WS_XML_STRING _faultDetailName = WS_XML_STRING_VALUE("OrderNotFound"); static const WS_XML_STRING _faultDetailNs = WS_XML_STRING_VALUE("http://example.com"); static const WS_XML_STRING _faultAction = WS_XML_STRING_VALUE("http://example.com/fault"); static const WS_ELEMENT_DESCRIPTION _faultElementDescription = { (WS_XML_STRING*)&_faultDetailName, (WS_XML_STRING*)&_faultDetailNs, WS_UINT32_TYPE, NULL }; static const WS_FAULT_DETAIL_DESCRIPTION orderNotFoundFaultTypeDescription = { (WS_XML_STRING*)&_faultAction, (WS_ELEMENT_DESCRIPTION*)&_faultElementDescription }; // Set fault detail information in the error object hr = WsSetFaultErrorDetail( error, &orderNotFoundFaultTypeDescription, WS_WRITE_REQUIRED_VALUE, &orderNotFound, sizeof(orderNotFound)); if (FAILED(hr)) { goto Exit; } // Add an error string to the error object. This string will // be included in the fault that is sent. static const WS_STRING errorMessage = WS_STRING_VALUE(L"Invalid order ID"); hr = WsAddErrorString(error, &errorMessage); if (FAILED(hr)) { goto Exit; } // Use a failure code to indicate that a fault should be sent hr = E_FAIL; } else { // Initialize the order status response getOrderStatusResponse.orderID = getOrderStatus->orderID; getOrderStatusResponse.status = L"Pending"; // Specify which message description to use for reply replyMessageDescription = &PurchaseOrder_wsdl.messages.GetOrderStatusResponse; replyBodyPointer = &getOrderStatusResponse; replyBodySize = sizeof(getOrderStatusResponse); } } } // If there was an error receiving the message if (FAILED(hr)) { // Send a fault in the body of the reply message. The information // accumulated in the error object is used to populate the fault. // The error code is not transmitted but instead is used to // generate an error string if no error strings are present in the // error object. hr = WsSendFaultMessageForError( channel, replyMessage, error, hr, WS_FULL_FAULT_DISCLOSURE, requestMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Reset the error so it can be used again hr = WsResetError(error); if (FAILED(hr)) { goto Exit; } // Reset the reply message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } } else { // Send a reply message hr = WsSendReplyMessage( channel, replyMessage, replyMessageDescription, WS_WRITE_REQUIRED_VALUE, replyBodyPointer, replyBodySize, requestMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Reset the reply message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } } // Reset the request message so it can be used again hr = WsResetMessage(requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the heap, which will free any allocations made on it hr = WsResetHeap(heap, error); if (FAILED(hr)) { goto Exit; } // Close the request hr = WsCloseChannel(channel, NULL, error); if (FAILED(hr)) { goto Exit; } // Prepare channel for reuse hr = WsResetChannel(channel, error); if (FAILED(hr)) { goto Exit; } // Delete the certificate name string if needed. if (certSubjectName != NULL) { delete[] certSubjectName; certSubjectName = NULL; } // Delete cert context if needed if (certContext != NULL) { CertFreeCertificateContext(certContext); certContext = NULL; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } if (channel != NULL) { WsFreeChannel(channel); } if (requestMessage != NULL) { WsFreeMessage(requestMessage); } if (replyMessage != NULL) { WsFreeMessage(replyMessage); } if (listener != NULL) { // Close the listener if it was opened WsCloseListener(listener, NULL, error); } if (listener != NULL) { WsFreeListener(listener); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } if (certSubjectName != NULL) { delete[] certSubjectName; } if (certContext != NULL) { CertFreeCertificateContext(certContext); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_MESSAGE* message = NULL; WS_CHANNEL* channel = NULL; WS_LISTENER* listener = NULL; WS_HEAP* heap = NULL; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create a listener hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX, WS_UDP_CHANNEL_BINDING, NULL, 0, NULL, &listener, error); if (FAILED(hr)) { goto Exit; } // Open listener at address WS_STRING uri; uri.chars = L"soap.udp://localhost:809"; uri.length = (ULONG)wcslen(uri.chars); hr = WsOpenListener( listener, &uri, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateChannelForListener( listener, NULL, 0, &channel, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &message, error); if (FAILED(hr)) { goto Exit; } for (ULONG i = 0; i < 5; i++) { // Accept a channel from the client hr = WsAcceptChannel(listener, channel, NULL, error); if (FAILED(hr)) { goto Exit; } // Set up the descriptions of the expected messages. In this case, we only expect purchase orders. const WS_MESSAGE_DESCRIPTION* messageDescriptions[] = {&PurchaseOrder_wsdl.messages.PurchaseOrder}; // Receive the message and deserialize the element of the body into a _PurchaseOrderType structure. // The values of the fields of the _PurchaseOrderType structure are allocated in the specified // WS_HEAP, and are valid until WsResetHeap is called. _PurchaseOrderType purchaseOrder; hr = WsReceiveMessage(channel, message, messageDescriptions, WsCountOf(messageDescriptions), WS_RECEIVE_OPTIONAL_MESSAGE, WS_READ_REQUIRED_VALUE, heap, &purchaseOrder, sizeof(purchaseOrder), NULL, NULL, error); if (hr == WS_S_END) { // No more messages on channel break; } if (FAILED(hr)) { goto Exit; } // Print out purchase order contents wprintf(L"%ld, %s\n", purchaseOrder.quantity, purchaseOrder.productName); // Reset the message so it can be used again hr = WsResetMessage( message, error); if (FAILED(hr)) { goto Exit; } // Reset the heap, which will free any allocations made on it hr = WsResetHeap( heap, error); if (FAILED(hr)) { goto Exit; } hr = WsCloseChannel(channel, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsResetChannel(channel, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } if (channel != NULL) { WsFreeChannel(channel); } if (listener != NULL) { // Close the listener if it was opened WsCloseListener(listener, NULL, error); } if (listener != NULL) { WsFreeListener(listener); } if (message != NULL) { WsFreeMessage(message); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Messages arrive on this thread from the relay thread DWORD WINAPI ReceiverThread(void* parameter) { HRESULT hr; THREADINFO* threadInfo = (THREADINFO*) parameter; HANDLE receiverReadyEvent = threadInfo->event; WS_ERROR* error = NULL; WS_CHANNEL* receiveChannel = NULL; WS_MESSAGE* receiveMessage = NULL; WS_LISTENER* listener = NULL; WS_HEAP* heap = NULL; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create a listener hr = WsCreateListener(WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, &listener, error); if (FAILED(hr)) { goto Exit; } // Open listener using TCP duplex session hr = WsOpenListener(listener, &serviceUrl, NULL, error); if (FAILED(hr)) { goto Exit; } // Create a channel hr = WsCreateChannelForListener(listener, NULL, 0, &receiveChannel, error); if (FAILED(hr)) { goto Exit; } // Notify that thread is ready threadInfo->hr = NOERROR; SetEvent(receiverReadyEvent); // Accept a channel from the client hr = WsAcceptChannel(listener, receiveChannel, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( receiveChannel, NULL, 0, &receiveMessage, error); if (FAILED(hr)) { goto Exit; } // Receive all messages for (;;) { // Receive start of message (headers) hr = WsReadMessageStart(receiveChannel, receiveMessage, NULL, error); if (FAILED(hr)) { goto Exit; } if (hr == WS_S_END) { // No more messages on this channel break; } // Get action value WS_XML_STRING receivedAction; hr = WsGetHeader( receiveMessage, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_READ_REQUIRED_VALUE, NULL, &receivedAction, sizeof(receivedAction), error); if (FAILED(hr)) { goto Exit; } // Make sure action is what we expect if (WsXmlStringEquals(&receivedAction, PurchaseOrder_wsdl.messages.PurchaseOrder.action, error) != S_OK) { hr = WS_E_ENDPOINT_ACTION_NOT_SUPPORTED; goto Exit; } // Read the body of the message as a purchase order _PurchaseOrderType* purchaseOrder; hr = WsReadBody(receiveMessage, &PurchaseOrder_wsdl.globalElements.PurchaseOrderType, WS_READ_REQUIRED_POINTER, heap, &purchaseOrder, sizeof(purchaseOrder), error); if (FAILED(hr)) { goto Exit; } // Print out purchase order wprintf(L"%ld, %s\n", purchaseOrder->quantity, purchaseOrder->productName); // Receive message end hr = WsReadMessageEnd(receiveChannel, receiveMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Reset message so we can use it again hr = WsResetMessage(receiveMessage, error); if (FAILED(hr)) { goto Exit; } // Reset heap hr = WsResetHeap(heap, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } fflush( stdout); if (receiveChannel != NULL) { // Close the channel WsCloseChannel(receiveChannel, NULL, error); } if (receiveChannel != NULL) { WsFreeChannel(receiveChannel); } if (listener != NULL) { // Close the listener if it was opened WsCloseListener(listener, NULL, error); } if (listener != NULL) { WsFreeListener(listener); } if (receiveMessage != NULL) { WsFreeMessage(receiveMessage); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } if (FAILED(hr)) { // Notify that thread is ready SetEvent(receiverReadyEvent); threadInfo->hr = hr; } return 1; }
HRESULT CreateXmlSecurityToken( __deref_out WS_SECURITY_TOKEN** xmlSecurityToken, __in_opt WS_ERROR* error) { HRESULT hr = S_OK; WS_HEAP* heap = NULL; WS_XML_READER* reader = NULL; WS_XML_BUFFER* buffer = NULL; // The username/password are included in code for the simplicity // of the sample. This should NOT be done for real applications. char* securityTokenWireXmlForm = "<x:UsernameToken xmlns:x='http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd'><x:Username>usr1</x:Username><x:Password>pwd1</x:Password></x:UsernameToken>"; // create an XML reader hr = WsCreateReader( NULL, 0, &reader, error); if (FAILED(hr)) { goto Exit; } // define the input and encoding for the XML reader WS_XML_READER_BUFFER_INPUT readerInput; ZeroMemory(&readerInput, sizeof(readerInput)); readerInput.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER; readerInput.encodedData = securityTokenWireXmlForm; readerInput.encodedDataSize = (ULONG)strlen(securityTokenWireXmlForm); WS_XML_READER_TEXT_ENCODING readerEncoding; ZeroMemory(&readerEncoding, sizeof(readerEncoding)); readerEncoding.encoding.encodingType = WS_XML_READER_ENCODING_TYPE_TEXT; readerEncoding.charSet = WS_CHARSET_UTF8; // set the input and encoding for the XML reader hr = WsSetInput( reader, &readerEncoding.encoding, &readerInput.input, NULL, 0, error); if (FAILED(hr)) { goto Exit; } // create a heap to read the security token XML form into an XML buffer allocated on that heap hr = WsCreateHeap( 2048, 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // read the security token XML form into an XML buffer hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_XML_BUFFER_TYPE, NULL, WS_READ_REQUIRED_POINTER, heap, &buffer, sizeof(buffer), error); if (FAILED(hr)) { goto Exit; } // create an XML security token from the token's wire form available in the XML buffer hr = WsCreateXmlSecurityToken( buffer, NULL, NULL, 0, xmlSecurityToken, error); Exit: // The heap, and the XML buffer allocated on it, need not be kept // alive once the token creation call returns. Note that the XML // buffer allocated on the heap is automatically freed along with // the heap, and is never freed directly. if (heap != NULL) { WsFreeHeap( heap); } if (reader != NULL) { WsFreeReader( reader); } return hr; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_SECURITY_TOKEN* securityToken = NULL; WS_SERVICE_PROXY* proxy = NULL; // declare and initialize an XML security token message security binding WS_XML_TOKEN_MESSAGE_SECURITY_BINDING xmlTokenBinding = {}; // zero out the struct xmlTokenBinding.binding.bindingType = WS_XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE; // set the binding type xmlTokenBinding.bindingUsage = WS_SUPPORTING_MESSAGE_SECURITY_USAGE; // set the binding usage // declare and initialize an SSL transport security binding WS_SSL_TRANSPORT_SECURITY_BINDING sslBinding = {}; // zero out the struct sslBinding.binding.bindingType = WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE; // set the binding type // declare and initialize the array of all security bindings WS_SECURITY_BINDING* securityBindings[2] = { &sslBinding.binding, &xmlTokenBinding.binding }; // declare and initialize the security description WS_SECURITY_DESCRIPTION securityDescription = {}; // zero out the struct securityDescription.securityBindings = securityBindings; securityDescription.securityBindingCount = WsCountOf(securityBindings); int result = 0; WS_ENDPOINT_ADDRESS address = {}; static const WS_STRING url = WS_STRING_VALUE(L"https://localhost:8443/example"); address.url = url; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // create an XML security token and set it on the relevant security binding hr = CreateXmlSecurityToken(&securityToken, error); if (FAILED(hr)) { goto Exit; } xmlTokenBinding.xmlToken = securityToken; // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create the proxy hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &securityDescription, NULL, 0, NULL, 0, &proxy, error); if (FAILED(hr)) { goto Exit; } // after the proxy is created, the security token handle can be freed if (securityToken != NULL) { WsFreeSecurityToken(securityToken); securityToken = NULL; } hr = WsOpenServiceProxy( proxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } hr = DefaultBinding_ICalculator_Add( proxy, 1, 2, &result, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf(L"%d + %d = %d\n", 1, 2, result); Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (proxy != NULL) { WsCloseServiceProxy( proxy, NULL, NULL); WsFreeServiceProxy( proxy); } if (securityToken != NULL) { WsFreeSecurityToken( securityToken); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_SERVICE_PROXY* serviceProxy = NULL; static const WS_STRING serviceUrl = WS_STRING_VALUE(L"http://localhost/example"); // In this sample, wsutil is used with the /string:WS_STRING command line option // to compile the schema files. When /string:WS_STRING is used, wsutil generates stubs // using WS_STRING (instead of WCHAR*) type for strings. WS_STRING productName; WS_STRING expectedShipDate; WS_STRING orderStatus; WS_ENDPOINT_ADDRESS address = {}; address.url = serviceUrl; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, NULL, 0, NULL, 0, &serviceProxy, error); if (FAILED(hr)) { goto Exit; } hr = WsOpenServiceProxy( serviceProxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } productName.chars = L"Pencil"; productName.length = 6; for (int i = 0; i < 100; i++) { unsigned int orderID; // Submit an order, and get expected ship date hr = PurchaseOrderBinding_Order( serviceProxy, 100, productName, &orderID, &expectedShipDate, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } // Print out confirmation contents wprintf(L"Expected ship date for order %lu is %.*s\n", orderID, expectedShipDate.length, expectedShipDate.chars); WsResetHeap(heap, NULL); // Get the current status of the order hr = PurchaseOrderBinding_OrderStatus( serviceProxy, &orderID, &orderStatus, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } // Print out order status wprintf(L"Order status for order %lu is: %.*s\n", orderID, orderStatus.length, orderStatus.chars); WsResetHeap( heap, NULL); // Get the current status of the order using an invalid order ID orderID = 321; hr = PurchaseOrderBinding_OrderStatus( serviceProxy, &orderID, &orderStatus, heap, NULL, 0, NULL, error); // Check to see if we got a fault if (hr == WS_E_ENDPOINT_FAULT_RECEIVED) { // Print the strings in the error object PrintError(hr, error); static const WS_XML_STRING _faultDetailName = WS_XML_STRING_VALUE("OrderNotFound"); static const WS_XML_STRING _faultDetailNs = WS_XML_STRING_VALUE("http://example.com"); static const WS_XML_STRING _faultAction = WS_XML_STRING_VALUE("http://example.com/fault"); static const WS_ELEMENT_DESCRIPTION _faultElementDescription = { (WS_XML_STRING*)&_faultDetailName, (WS_XML_STRING*)&_faultDetailNs, WS_UINT32_TYPE, NULL }; static const WS_FAULT_DETAIL_DESCRIPTION orderNotFoundFaultTypeDescription = { (WS_XML_STRING*)&_faultAction, (WS_ELEMENT_DESCRIPTION*)&_faultElementDescription }; // Try to get the fault detail from the error object _OrderNotFoundFaultType* orderNotFound; hr = WsGetFaultErrorDetail( error, &orderNotFoundFaultTypeDescription, WS_READ_OPTIONAL_POINTER, heap, &orderNotFound, sizeof(orderNotFound)); if (FAILED(hr)) { goto Exit; } if (orderNotFound != NULL) { // Print out the fault detail wprintf(L"Order %lu was not found\n", orderNotFound->orderID); } // Reset error so it can be used again hr = WsResetError(error); if (FAILED(hr)) { goto Exit; } } if (FAILED(hr)) { goto Exit; } WsResetHeap(heap, NULL); wprintf(L"\n"); } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (serviceProxy != NULL) { WsCloseServiceProxy(serviceProxy, NULL, NULL); WsFreeServiceProxy(serviceProxy); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_CHANNEL* channel = NULL; WS_LISTENER* listener = NULL; WS_HEAP* heap = NULL; WS_MESSAGE* requestMessage = NULL; WS_MESSAGE* replyMessage = NULL; static const WS_STRING uri = WS_STRING_VALUE(L"http://+:80/example"); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a listener hr = WsCreateListener( WS_CHANNEL_TYPE_REPLY, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL, &listener, error); if (FAILED(hr)) { goto Exit; } // Open listener hr = WsOpenListener( listener, &uri, NULL, error); if (FAILED(hr)) { goto Exit; } // Set up a property indicating streamined input and output WS_TRANSFER_MODE transferMode = WS_STREAMED_TRANSFER_MODE; WS_CHANNEL_PROPERTY transferModeProperty; transferModeProperty.id = WS_CHANNEL_PROPERTY_TRANSFER_MODE; transferModeProperty.value = &transferMode; transferModeProperty.valueSize = sizeof(transferMode); // Create a channel suitable for accepting from the listener hr = WsCreateChannelForListener( listener, &transferModeProperty, 1, &channel, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &requestMessage, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &replyMessage, error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Receive messages and send replies for (int i = 0; i < 10; i++) { // Accept a channel from the client hr = WsAcceptChannel(listener, channel, NULL, error); if (FAILED(hr)) { goto Exit; } // Receive the message start (headers) hr = WsReadMessageStart( channel, requestMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Get action value WS_XML_STRING receivedAction; hr = WsGetHeader( requestMessage, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_READ_REQUIRED_VALUE, NULL, &receivedAction, sizeof(receivedAction), error); if (FAILED(hr)) { goto Exit; } // Make sure action is what we expect hr = WsXmlStringEquals( &receivedAction, PurchaseOrder_wsdl.messages.PurchaseOrder.action, error); if (hr != S_OK) { hr = WS_E_ENDPOINT_ACTION_NOT_SUPPORTED; goto Exit; } // Initialize the reply message based on the request hr = WsInitializeMessage( replyMessage, WS_REPLY_MESSAGE, requestMessage, error); if (FAILED(hr)) { goto Exit; } // Write the start of the reply message (headers) hr = WsWriteMessageStart( channel, replyMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Read the contents of the request body, and send response body for (;;) { // Make sure we have at least one purchase order buffered in the request message. // Each purchase order may be up to 1024 bytes in size. hr = WsFillBody( requestMessage, 1024, NULL, error); if (FAILED(hr)) { goto Exit; } // Deserialize purchase order into heap (if any more) _PurchaseOrderType* purchaseOrder; hr = WsReadBody( requestMessage, &PurchaseOrder_wsdl.globalElements.PurchaseOrderType, WS_READ_OPTIONAL_POINTER, heap, &purchaseOrder, sizeof(purchaseOrder), error); if (FAILED(hr)) { goto Exit; } // NULL indicates no more purchase orders if (purchaseOrder == NULL) { break; } // Print out purchase order contents wprintf(L"%ld, %s\n", purchaseOrder->quantity, purchaseOrder->productName); // Serialize a confirmation into the reply message _OrderConfirmationType orderConfirmation; orderConfirmation.expectedShipDate = L"1/1/2006"; orderConfirmation.orderID = 123; hr = WsWriteBody( replyMessage, &PurchaseOrder_wsdl.globalElements.OrderConfirmationType, WS_WRITE_REQUIRED_VALUE, &orderConfirmation, sizeof(orderConfirmation), error); if (FAILED(hr)) { goto Exit; } // Flush the confirmation data if at least 4096 bytes have been accumulated hr = WsFlushBody( replyMessage, 4096, NULL, error); if (FAILED(hr)) { goto Exit; } // Free purchase order hr = WsResetHeap( heap, error); if (FAILED(hr)) { goto Exit; } } // Read the end of the message hr = WsReadMessageEnd( channel, requestMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Write the end of the message hr = WsWriteMessageEnd( channel, replyMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage( requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage( replyMessage, error); if (FAILED(hr)) { goto Exit; } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } // Reset the channel so it can be used again hr = WsResetChannel( channel, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } if (listener != NULL) { // Close the listener if it was opened WsCloseListener(listener, NULL, error); } if (channel != NULL) { WsFreeChannel(channel); } if (listener != NULL) { WsFreeListener(listener); } if (requestMessage != NULL) { WsFreeMessage(requestMessage); } if (replyMessage != NULL) { WsFreeMessage(replyMessage); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_CHANNEL* channel = NULL; WS_MESSAGE* requestMessage = NULL; WS_MESSAGE* replyMessage = NULL; WS_HEAP* heap = NULL; WS_ENDPOINT_ADDRESS address; static const WS_STRING serviceUrl = WS_STRING_VALUE(L"http://localhost/example"); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create a channel hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL, &channel, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &requestMessage, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &replyMessage, error); if (FAILED(hr)) { goto Exit; } // Initialize address of service address.url = serviceUrl; address.headers = NULL; address.extensions = NULL; address.identity = NULL; // Open channel to address hr = WsOpenChannel(channel, &address, NULL, error); if (FAILED(hr)) { goto Exit; } // Send some request-replies for (int i = 0; i < 100; i++) { // Initialize purchase order _PurchaseOrderType purchaseOrder; purchaseOrder.quantity = 100; purchaseOrder.productName = L"Pencil"; _OrderConfirmationType orderConfirmation; // Send purchase order, get order confirmation hr = WsRequestReply( channel, requestMessage, &PurchaseOrder_wsdl.messages.PurchaseOrder, WS_WRITE_REQUIRED_VALUE, &purchaseOrder, sizeof(purchaseOrder), replyMessage, &PurchaseOrder_wsdl.messages.OrderConfirmation, WS_READ_REQUIRED_VALUE, heap, &orderConfirmation, sizeof(orderConfirmation), NULL, error); if (FAILED(hr)) { goto Exit; } // Print out confirmation contents wprintf(L"Expected ship date for order %lu is %s\n", orderConfirmation.orderID, orderConfirmation.expectedShipDate); // Reset the message so it can be used again hr = WsResetMessage(requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } // Initialize request for order status _GetOrderStatusType getOrderStatus; getOrderStatus.orderID = orderConfirmation.orderID; _GetOrderStatusResponseType getOrderStatusResponse; // Send order status request, get order status reply hr = WsRequestReply( channel, requestMessage, &PurchaseOrder_wsdl.messages.GetOrderStatus, WS_WRITE_REQUIRED_VALUE, &getOrderStatus, sizeof(getOrderStatus), replyMessage, &PurchaseOrder_wsdl.messages.GetOrderStatusResponse, WS_READ_REQUIRED_VALUE, heap, &getOrderStatusResponse, sizeof(getOrderStatusResponse), NULL, error); if (FAILED(hr)) { goto Exit; } // Print out order status wprintf(L"Order status for order %lu is: %s\n", getOrderStatusResponse.orderID, getOrderStatusResponse.status); // Reset the message so it can be used again hr = WsResetMessage(requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } // Make same request, but this time with an invalid order ID getOrderStatus.orderID = 321; hr = WsRequestReply( channel, requestMessage, &PurchaseOrder_wsdl.messages.GetOrderStatus, WS_WRITE_REQUIRED_VALUE, &getOrderStatus, sizeof(getOrderStatus), replyMessage, &PurchaseOrder_wsdl.messages.GetOrderStatusResponse, WS_READ_REQUIRED_VALUE, heap, &getOrderStatusResponse, sizeof(getOrderStatusResponse), NULL, error); // Check to see if we got a fault if (hr == WS_E_ENDPOINT_FAULT_RECEIVED) { // Print the strings in the error object PrintError(hr, error); static const WS_XML_STRING _faultDetailName = WS_XML_STRING_VALUE("OrderNotFound"); static const WS_XML_STRING _faultDetailNs = WS_XML_STRING_VALUE("http://example.com"); static const WS_XML_STRING _faultAction = WS_XML_STRING_VALUE("http://example.com/fault"); static const WS_ELEMENT_DESCRIPTION _faultElementDescription = { (WS_XML_STRING*)&_faultDetailName, (WS_XML_STRING*)&_faultDetailNs, WS_UINT32_TYPE, NULL }; static const WS_FAULT_DETAIL_DESCRIPTION orderNotFoundFaultTypeDescription = { (WS_XML_STRING*)&_faultAction, (WS_ELEMENT_DESCRIPTION*)&_faultElementDescription }; // Try to get the fault detail from the error object _OrderNotFoundFaultType* orderNotFound; hr = WsGetFaultErrorDetail( error, &orderNotFoundFaultTypeDescription, WS_READ_OPTIONAL_POINTER, heap, &orderNotFound, sizeof(orderNotFound)); if (FAILED(hr)) { goto Exit; } if (orderNotFound != NULL) { // Print out the fault detail wprintf(L"Order %lu was not found\n", orderNotFound->orderID); } // Reset error so it can be used again hr = WsResetError(error); if (FAILED(hr)) { goto Exit; } } if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage(requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } wprintf(L"\n"); // Reset the heap hr = WsResetHeap(heap, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } if (requestMessage != NULL) { WsFreeMessage(requestMessage); } if (replyMessage != NULL) { WsFreeMessage(replyMessage); } if (channel != NULL) { WsFreeChannel(channel); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_MESSAGE* requestMessage = NULL; WS_MESSAGE* replyMessage = NULL; WS_CHANNEL* channel = NULL; WS_LISTENER* listener = NULL; WS_HEAP* heap = NULL; // declare and initialize an Windows SSPI transport security binding WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING sspiBinding = {}; // zero out the struct sspiBinding.binding.bindingType = WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE; // set the binding type // declare and initialize the array of all security bindings WS_SECURITY_BINDING* securityBindings[1] = { &sspiBinding.binding }; // declare and initialize the security description WS_SECURITY_DESCRIPTION securityDescription = {}; // zero out the struct securityDescription.securityBindings = securityBindings; securityDescription.securityBindingCount = WsCountOf(securityBindings); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create a listener hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, &securityDescription, &listener, error); if (FAILED(hr)) { goto Exit; } // Create a channel suitable for the listener hr = WsCreateChannelForListener( listener, NULL, 0, &channel, error); if (FAILED(hr)) { goto Exit; } // Open listener using TCP duplex session WS_STRING uri; uri.chars = L"net.tcp://localhost/example"; uri.length = (ULONG)::wcslen(uri.chars); hr = WsOpenListener( listener, &uri, NULL, error); if (FAILED(hr)) { goto Exit; } // Accept a channel from the client hr = WsAcceptChannel(listener, channel, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &requestMessage, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &replyMessage, error); if (FAILED(hr)) { goto Exit; } // Receive requests / send replies for (;;) { // Set up the descriptions of the expected messages. We expect either a purchase order // or a request for order status. const WS_MESSAGE_DESCRIPTION* requestMessageDescriptions[] = { &PurchaseOrder_wsdl.messages.PurchaseOrder, // contains a _PurchaseOrderType in the body &PurchaseOrder_wsdl.messages.GetOrderStatus, // contains a GetOrderStatus in the body }; // Receive the message and deserialize the element of the body into the appropriate // structure, based on the message descriptions. The value of the body will be // allocated in the specified WS_HEAP, and are valid until WsResetHeap is called. void* requestBodyPointer; ULONG indexOfMatchedMessageDescription; hr = WsReceiveMessage(channel, requestMessage, requestMessageDescriptions, WsCountOf(requestMessageDescriptions), WS_RECEIVE_OPTIONAL_MESSAGE, WS_READ_REQUIRED_POINTER, heap, &requestBodyPointer, sizeof(requestBodyPointer), &indexOfMatchedMessageDescription, NULL, error); if (hr == WS_S_END) { // No more messages on channel break; } // Process the request, and generate the reply const WS_MESSAGE_DESCRIPTION* replyMessageDescription = NULL; const void* replyBodyPointer = NULL; ULONG replyBodySize = 0; _OrderConfirmationType orderConfirmation; _GetOrderStatusResponseType getOrderStatusResponse; if (SUCCEEDED(hr)) { // Get the message description that matched const WS_MESSAGE_DESCRIPTION* requestMessageDescription = requestMessageDescriptions[indexOfMatchedMessageDescription]; if (requestMessageDescription == &PurchaseOrder_wsdl.messages.PurchaseOrder) { // The message was a purchase order. Get the pointer to the deserialized value. _PurchaseOrderType* purchaseOrder = (_PurchaseOrderType*)requestBodyPointer; // Print out purchase order contents wprintf(L"%d, %s\n", purchaseOrder->quantity, purchaseOrder->productName); // Initialize order confirmation data orderConfirmation.expectedShipDate = L"1/1/2006"; orderConfirmation.orderID = 123; // Setup up reply message replyMessageDescription = &PurchaseOrder_wsdl.messages.OrderConfirmation; replyBodyPointer = &orderConfirmation; replyBodySize = sizeof(orderConfirmation); } else if (requestMessageDescription == &PurchaseOrder_wsdl.messages.GetOrderStatus) { // The message was a order status request. Get the pointer to the deserialized value. _GetOrderStatusType* getOrderStatus = (_GetOrderStatusType*)requestBodyPointer; // Generate a fault if we don't recognize the order ID if (getOrderStatus->orderID != 123) { // Fill out details about the fault _OrderNotFoundFaultType orderNotFound; orderNotFound.orderID = getOrderStatus->orderID; static const WS_XML_STRING _faultDetailName = WS_XML_STRING_VALUE("OrderNotFound"); static const WS_XML_STRING _faultDetailNs = WS_XML_STRING_VALUE("http://example.com"); static const WS_XML_STRING _faultAction = WS_XML_STRING_VALUE("http://example.com/fault"); static const WS_ELEMENT_DESCRIPTION _faultElementDescription = { (WS_XML_STRING*)&_faultDetailName, (WS_XML_STRING*)&_faultDetailNs, WS_UINT32_TYPE, NULL }; static const WS_FAULT_DETAIL_DESCRIPTION orderNotFoundFaultTypeDescription = { (WS_XML_STRING*)&_faultAction, (WS_ELEMENT_DESCRIPTION*)&_faultElementDescription }; // Set fault detail information in the error object hr = WsSetFaultErrorDetail( error, &orderNotFoundFaultTypeDescription, WS_WRITE_REQUIRED_VALUE, &orderNotFound, sizeof(orderNotFound)); if (FAILED(hr)) { goto Exit; } // Add an error string to the error object. This string will // be included in the fault that is sent. static const WS_STRING errorMessage = WS_STRING_VALUE(L"Invalid order ID"); hr = WsAddErrorString(error, &errorMessage); if (FAILED(hr)) { goto Exit; } // Use a failure code to indicate that a fault should be sent hr = E_FAIL; } else { // Initialize the order status response getOrderStatusResponse.orderID = getOrderStatus->orderID; getOrderStatusResponse.status = L"Pending"; // Specify which message description to use for reply replyMessageDescription = &PurchaseOrder_wsdl.messages.GetOrderStatusResponse; replyBodyPointer = &getOrderStatusResponse; replyBodySize = sizeof(getOrderStatusResponse); } } } // If there was an error receiving the message if (FAILED(hr)) { // Send a fault in the body of the reply message. The information // accumulated in the error object is used to populate the fault. // The error code is not transmitted but instead is used to // generate an error string if no error strings are present in the // error object. hr = WsSendFaultMessageForError( channel, replyMessage, error, hr, WS_FULL_FAULT_DISCLOSURE, requestMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Reset the error so it can be used again hr = WsResetError(error); if (FAILED(hr)) { goto Exit; } // Reset the reply message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } } else { // Send a reply message hr = WsSendReplyMessage( channel, replyMessage, replyMessageDescription, WS_WRITE_REQUIRED_VALUE, replyBodyPointer, replyBodySize, requestMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Reset the reply message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } } // Reset the request message so it can be used again hr = WsResetMessage(requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the heap, which will free any allocations made on it hr = WsResetHeap(heap, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (listener != NULL) { // Close the listener if it was opened WsCloseListener(listener, NULL, error); } if (listener != NULL) { WsFreeListener(listener); } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } if (channel != NULL) { WsFreeChannel(channel); } if (requestMessage != NULL) { WsFreeMessage(requestMessage); } if (replyMessage != NULL) { WsFreeMessage(replyMessage); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_SERVICE_PROXY* serviceProxy = NULL; WS_HEAP* heap = NULL; WS_ENDPOINT_ADDRESS address = {0}; static const WS_STRING serviceUrl = WS_STRING_VALUE(L"http://localhost/example"); address.url = serviceUrl; WS_CALL_PROPERTY callProperties[2]; _OrderSession orderSession; orderSession.sessionId = L"ExampleSession"; WS_PROXY_MESSAGE_CALLBACK_CONTEXT inputMessageContext = {0}; WS_PROXY_MESSAGE_CALLBACK_CONTEXT outputMessageContext = {0}; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, NULL, 0, NULL, 0, &serviceProxy, error); if (FAILED(hr)) { goto Exit; } // Open channel to address hr = WsOpenServiceProxy( serviceProxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } inputMessageContext.callback = AddSessionHeader; inputMessageContext.state = &orderSession; outputMessageContext.callback = RetrieveSessionHeader; outputMessageContext.state = &orderSession; callProperties[0].id = WS_CALL_PROPERTY_SEND_MESSAGE_CONTEXT; callProperties[0].value = &inputMessageContext; callProperties[0].valueSize = sizeof(inputMessageContext); callProperties[1].id = WS_CALL_PROPERTY_RECEIVE_MESSAGE_CONTEXT; callProperties[1].value = &outputMessageContext; callProperties[1].valueSize = sizeof(outputMessageContext); for (int i = 0; i < 100; i++) { static const WCHAR* productName = L"Pencil"; WCHAR* expectedShipDate = {0}; unsigned int orderID; hr = PurchaseOrderBinding_Order( serviceProxy, 100, (WCHAR*)productName, &orderID, &expectedShipDate, heap, callProperties, WsCountOf(callProperties), NULL, error); if (FAILED(hr)) { goto Exit; } // Print out confirmation contents wprintf(L"Expected ship date for order %lu is %s\n", orderID, expectedShipDate); hr = WsResetHeap(heap, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (serviceProxy != NULL) { WsCloseServiceProxy(serviceProxy, NULL, NULL); WsFreeServiceProxy(serviceProxy); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// This thread is used to recieve reply messages DWORD WINAPI ReceiverThread( __in void* parameter) { HRESULT hr = S_OK; THREAD_INFO* threadInfo = (THREAD_INFO*)parameter; WS_CHANNEL* channel = threadInfo->channel; WS_MESSAGE* message = NULL; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &message, error); if (FAILED(hr)) { goto Exit; } // Go into a receive loop. The loop terminates when the // main thread aborts the channel (causing subsequent receives // to fail). for (;;) { // Receive start of reply message (headers) hr = WsReadMessageStart(channel, message, NULL, error); if (FAILED(hr)) { goto Exit; } // Get action value WS_XML_STRING receivedAction; hr = WsGetHeader( message, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_READ_REQUIRED_VALUE, NULL, &receivedAction, sizeof(receivedAction), error); if (FAILED(hr)) { goto Exit; } // Make sure action is what we expect if (WsXmlStringEquals(&receivedAction, PurchaseOrder_wsdl.messages.OrderConfirmation.action, error) != S_OK) { hr = WS_E_ENDPOINT_ACTION_NOT_SUPPORTED; goto Exit; } // Read the order confirmation from the body _OrderConfirmationType* orderConfirmation; hr = WsReadBody(message, &PurchaseOrder_wsdl.globalElements.OrderConfirmationType, WS_READ_REQUIRED_POINTER, heap, &orderConfirmation, sizeof(orderConfirmation), error); if (FAILED(hr)) { goto Exit; } // Receive end of message hr = WsReadMessageEnd(channel, message, NULL, error); if (FAILED(hr)) { goto Exit; } // Print out confirmation contents wprintf(L"%s\n", orderConfirmation->expectedShipDate); // Reset message so it can used again hr = WsResetMessage(message, error); if (FAILED(hr)) { goto Exit; } // Reset heap hr = WsResetHeap(heap, error); if (FAILED(hr)) { goto Exit; } } Exit: // Print out the error. Ignore aborted errors, which are // caused by the client thread aborting the channel. if (FAILED(hr) && hr != WS_E_OPERATION_ABORTED) { PrintError(hr, error); } if (message != NULL) { WsFreeMessage(message); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } return hr; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_CHANNEL* channel = NULL; WS_MESSAGE* requestMessage = NULL; WS_MESSAGE* replyMessage = NULL; WS_HEAP* heap = NULL; static const WS_STRING serviceUrl = WS_STRING_VALUE(L"http://localhost/example"); WS_ENDPOINT_ADDRESS address = {}; // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Set up a property indicating streamined input and output WS_TRANSFER_MODE transferMode = WS_STREAMED_TRANSFER_MODE; WS_CHANNEL_PROPERTY transferModeProperty; transferModeProperty.id = WS_CHANNEL_PROPERTY_TRANSFER_MODE; transferModeProperty.value = &transferMode; transferModeProperty.valueSize = sizeof(transferMode); // Create a HTTP request channel hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &transferModeProperty, 1, NULL, &channel, error); if (FAILED(hr)) { goto Exit; } // Initialize address of service address.url = serviceUrl; // Open channel to address hr = WsOpenChannel( channel, &address, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &requestMessage, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &replyMessage, error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Send request messages and receive reply messages for (int i = 0; i < 10; i++) { // Initialize message headers of the request message hr = WsInitializeMessage( requestMessage, WS_BLANK_MESSAGE, NULL, error); if (FAILED(hr)) { goto Exit; } // Add the action header to the request message hr = WsSetHeader( requestMessage, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, PurchaseOrder_wsdl.messages.PurchaseOrder.action, sizeof(*PurchaseOrder_wsdl.messages.PurchaseOrder.action), error); if (FAILED(hr)) { goto Exit; } // Generate a unique message ID that will be used for the request message WS_UNIQUE_ID messageID; ZeroMemory( &messageID, sizeof(messageID)); DWORD status = UuidCreate( &messageID.guid); if (status != RPC_S_OK) { hr = E_FAIL; goto Exit; } // Add the message ID to the request message hr = WsSetHeader( requestMessage, WS_MESSAGE_ID_HEADER, WS_UNIQUE_ID_TYPE, WS_WRITE_REQUIRED_VALUE, &messageID, sizeof(messageID), error); if (FAILED(hr)) { goto Exit; } // Send the message headers of the request message hr = WsWriteMessageStart( channel, requestMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Stream out some purchase orders for (int j = 0; j < 10; j++) { // Initialize body data _PurchaseOrderType purchaseOrder; purchaseOrder.quantity = 1; purchaseOrder.productName = L"Pencil"; // Serialize body data into message hr = WsWriteBody( requestMessage, &PurchaseOrder_wsdl.globalElements.PurchaseOrderType, WS_WRITE_REQUIRED_VALUE, &purchaseOrder, sizeof(purchaseOrder), error); if (FAILED(hr)) { goto Exit; } // Send accumulated message data once at least 4096 bytes have been accumulated hr = WsFlushBody( requestMessage, 4096, NULL, error); if (FAILED(hr)) { goto Exit; } } // Send the end of the request message hr = WsWriteMessageEnd( channel, requestMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Receive the headers of the reply message hr = WsReadMessageStart( channel, replyMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Stream in all the confirmations for (;;) { // Make sure we have at least once confirmation buffered. Each confirmation // may be up to 1024 bytes in size. hr = WsFillBody( replyMessage, 1024, NULL, error); if (FAILED(hr)) { goto Exit; } // Try to deserialize a confirmation into the heap _OrderConfirmationType* orderConfirmation; hr = WsReadBody( replyMessage, &PurchaseOrder_wsdl.globalElements.OrderConfirmationType, WS_READ_OPTIONAL_POINTER, heap, &orderConfirmation, sizeof(orderConfirmation), error); if (FAILED(hr)) { goto Exit; } // If there are no more confirmations, break out of the loop if (orderConfirmation == NULL) { break; } // Print out confirmation contents wprintf(L"%s\n", orderConfirmation->expectedShipDate); // Reset the heap which frees the confirmation data that was deserialized hr = WsResetHeap( heap, error); if (FAILED(hr)) { goto Exit; } } // Receive the end of the reply message hr = WsReadMessageEnd( channel, replyMessage, NULL, error); if (FAILED(hr)) { goto Exit; } // Reset message so it can be used again hr = WsResetMessage( replyMessage, error); if (FAILED(hr)) { goto Exit; } // Reset message so it can be used again hr = WsResetMessage( requestMessage, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } if (requestMessage != NULL) { WsFreeMessage(requestMessage); } if (replyMessage != NULL) { WsFreeMessage(replyMessage); } if (channel != NULL) { WsFreeChannel(channel); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_HEAP* heap = NULL; WS_SERVICE_PROXY* proxy = NULL; int result = 0; WS_ENDPOINT_ADDRESS address = {}; static const WS_STRING serviceUrl = WS_STRING_VALUE(L"net.tcp://localhost/example"); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, NULL, 0, NULL, 0, &proxy, error); if (FAILED(hr)) { goto Exit; } // Initialize address of service address.url = serviceUrl; hr = WsOpenServiceProxy( proxy, &address, NULL, error); if (FAILED(hr)) { goto Exit; } hr = CalculatorBinding_Add( proxy, 1, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf( L"+1\n"); hr = CalculatorBinding_Add( proxy, 2, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf( L"+2\n"); hr = CalculatorBinding_Add( proxy, 3, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf( L"+3\n"); hr = CalculatorBinding_Add( proxy, 4, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf( L"+4\n"); hr = CalculatorBinding_Subtract( proxy, 5, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf( L"-5\n"); hr = CalculatorBinding_Total( proxy, &result, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } wprintf( L"====\n"); wprintf( L"%d\n", result); hr = CalculatorBinding_Clear( proxy, heap, NULL, 0, NULL, error); if (FAILED(hr)) { goto Exit; } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (proxy != NULL) { WsCloseServiceProxy( proxy, NULL, NULL); WsFreeServiceProxy( proxy); } if (heap != NULL) { WsFreeHeap(heap); } if (error != NULL) { WsFreeError(error); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }
// Main entry point int __cdecl wmain() { HRESULT hr = S_OK; WS_ERROR* error = NULL; WS_CHANNEL* channel = NULL; WS_MESSAGE* requestMessage = NULL; WS_MESSAGE* replyMessage = NULL; WS_HEAP* heap = NULL; // declare and initialize a windows credential WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL windowsCredential = {}; // zero out the struct windowsCredential.credential.credentialType = WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE; // set the credential type ULONG impersonation = SecurityImpersonation; // declare and initialize properties to change the impersonation level from the default WS_SECURITY_BINDING_PROPERTY tcpSspiBindingProperties[1] = { { WS_SECURITY_BINDING_PROPERTY_ALLOWED_IMPERSONATION_LEVEL, &impersonation, sizeof(impersonation) } }; // declare and initialize an Windows SSPI transport security binding WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING tcpSspiBinding = {}; // zero out the struct tcpSspiBinding.binding.bindingType = WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE; // set the binding type tcpSspiBinding.binding.properties = tcpSspiBindingProperties; tcpSspiBinding.binding.propertyCount = WsCountOf(tcpSspiBindingProperties); tcpSspiBinding.clientCredential = &windowsCredential.credential; // declare and initialize the array of all security bindings WS_SECURITY_BINDING* securityBindings[1] = { &tcpSspiBinding.binding }; // declare and initialize the security description WS_SECURITY_DESCRIPTION securityDescription = {}; // zero out the struct securityDescription.securityBindings = securityBindings; securityDescription.securityBindingCount = WsCountOf(securityBindings); // Create an error object for storing rich error information hr = WsCreateError( NULL, 0, &error); if (FAILED(hr)) { goto Exit; } // Create a heap to store deserialized data hr = WsCreateHeap( /*maxSize*/ 2048, /*trimSize*/ 512, NULL, 0, &heap, error); if (FAILED(hr)) { goto Exit; } // Create a TCP duplex session channel hr = WsCreateChannel( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, &securityDescription, &channel, error); if (FAILED(hr)) { goto Exit; } // Initialize address of service WS_ENDPOINT_ADDRESS address; address.url.chars = L"net.tcp://localhost/example"; address.url.length = (ULONG)::wcslen(address.url.chars); address.headers = NULL; address.extensions = NULL; address.identity = NULL; // Open channel to address hr = WsOpenChannel( channel, &address, NULL, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &requestMessage, error); if (FAILED(hr)) { goto Exit; } hr = WsCreateMessageForChannel( channel, NULL, 0, &replyMessage, error); if (FAILED(hr)) { goto Exit; } // Send some request-replies for (int i = 0; i < 100; i++) { // Initialize purchase order _PurchaseOrderType purchaseOrder; purchaseOrder.quantity = 100; purchaseOrder.productName = L"Pencil"; _OrderConfirmationType orderConfirmation; // Send purchase order, get order confirmation hr = WsRequestReply( channel, requestMessage, &PurchaseOrder_wsdl.messages.PurchaseOrder, WS_WRITE_REQUIRED_VALUE, &purchaseOrder, sizeof(purchaseOrder), replyMessage, &PurchaseOrder_wsdl.messages.OrderConfirmation, WS_READ_REQUIRED_VALUE, heap, &orderConfirmation, sizeof(orderConfirmation), NULL, error); if (FAILED(hr)) { goto Exit; } // Print out confirmation contents wprintf(L"Expected ship date for order %lu is %s\n", orderConfirmation.orderID, orderConfirmation.expectedShipDate); // Reset the message so it can be used again hr = WsResetMessage(requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } // Initialize request for order status _GetOrderStatusType getOrderStatus; getOrderStatus.orderID = orderConfirmation.orderID; _GetOrderStatusResponseType getOrderStatusResponse; // Send order status request, get order status reply hr = WsRequestReply( channel, requestMessage, &PurchaseOrder_wsdl.messages.GetOrderStatus, WS_WRITE_REQUIRED_VALUE, &getOrderStatus, sizeof(getOrderStatus), replyMessage, &PurchaseOrder_wsdl.messages.GetOrderStatusResponse, WS_READ_REQUIRED_VALUE, heap, &getOrderStatusResponse, sizeof(getOrderStatusResponse), NULL, error); if (FAILED(hr)) { goto Exit; } // Print out order status wprintf(L"Order status for order %lu is: %s\n", getOrderStatusResponse.orderID, getOrderStatusResponse.status); // Reset the message so it can be used again hr = WsResetMessage(requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } // Make same request, but this time with an invalid order ID getOrderStatus.orderID = 321; hr = WsRequestReply( channel, requestMessage, &PurchaseOrder_wsdl.messages.GetOrderStatus, WS_WRITE_REQUIRED_VALUE, &getOrderStatus, sizeof(getOrderStatus), replyMessage, &PurchaseOrder_wsdl.messages.GetOrderStatusResponse, WS_READ_REQUIRED_VALUE, heap, &getOrderStatusResponse, sizeof(getOrderStatusResponse), NULL, error); // Check to see if we got a fault if (hr == WS_E_ENDPOINT_FAULT_RECEIVED) { // Print the strings in the error object PrintError(hr, error); static const WS_XML_STRING _faultDetailName = WS_XML_STRING_VALUE("OrderNotFound"); static const WS_XML_STRING _faultDetailNs = WS_XML_STRING_VALUE("http://example.com"); static const WS_XML_STRING _faultAction = WS_XML_STRING_VALUE("http://example.com/fault"); static const WS_ELEMENT_DESCRIPTION _faultElementDescription = { (WS_XML_STRING*)&_faultDetailName, (WS_XML_STRING*)&_faultDetailNs, WS_UINT32_TYPE, NULL }; static const WS_FAULT_DETAIL_DESCRIPTION orderNotFoundFaultTypeDescription = { (WS_XML_STRING*)&_faultAction, (WS_ELEMENT_DESCRIPTION*)&_faultElementDescription }; // Try to get the fault detail from the error object _OrderNotFoundFaultType* orderNotFound; hr = WsGetFaultErrorDetail( error, &orderNotFoundFaultTypeDescription, WS_READ_OPTIONAL_POINTER, heap, &orderNotFound, sizeof(orderNotFound)); if (FAILED(hr)) { goto Exit; } if (orderNotFound != NULL) { // Print out the fault detail wprintf(L"Order %lu was not found\n", orderNotFound->orderID); } // Reset error so it can be used again hr = WsResetError(error); if (FAILED(hr)) { goto Exit; } } if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage(requestMessage, error); if (FAILED(hr)) { goto Exit; } // Reset the message so it can be used again hr = WsResetMessage(replyMessage, error); if (FAILED(hr)) { goto Exit; } wprintf(L"\n"); // Reset the heap hr = WsResetHeap(heap, error); if (FAILED(hr)) { goto Exit; } } Exit: if (FAILED(hr)) { // Print out the error PrintError(hr, error); } if (channel != NULL) { // Close the channel WsCloseChannel(channel, NULL, error); } if (requestMessage != NULL) { WsFreeMessage(requestMessage); } if (replyMessage != NULL) { WsFreeMessage(replyMessage); } if (channel != NULL) { WsFreeChannel(channel); } if (error != NULL) { WsFreeError(error); } if (heap != NULL) { WsFreeHeap(heap); } fflush(stdout); return SUCCEEDED(hr) ? 0 : -1; }