static void test_WsCreateServiceProxy(void) { HRESULT hr; WS_SERVICE_PROXY *proxy; WS_SERVICE_PROXY_STATE state; ULONG size, value; hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, NULL, 0, NULL, 0, NULL, NULL ); ok( hr == E_INVALIDARG, "got %08x\n", hr ); proxy = NULL; hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, NULL, 0, NULL, 0, &proxy, NULL ); ok( hr == S_OK, "got %08x\n", hr ); ok( proxy != NULL, "proxy not set\n" ); /* write-only property */ value = 0xdeadbeef; size = sizeof(value); hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_CALL_TIMEOUT, &value, size, NULL ); ok( hr == E_INVALIDARG, "got %08x\n", hr ); state = 0xdeadbeef; size = sizeof(state); hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_STATE, &state, size, NULL ); ok( hr == S_OK, "got %08x\n", hr ); ok( state == WS_SERVICE_PROXY_STATE_CREATED, "got %u\n", state ); WsFreeServiceProxy( proxy ); }
// 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_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* 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_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; }
// 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; } // Create the proxy hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 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_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_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_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; }
// // Create web service proxy // HRESULT FlickrUploader:: CreateWebProxy (WS_HEAP** heap, WS_SERVICE_PROXY** proxy, WS_ERROR** error) { WS_ENVELOPE_VERSION soapVersion = WS_ENVELOPE_VERSION_SOAP_1_2; WS_ADDRESSING_VERSION addressingVersion = WS_ADDRESSING_VERSION_TRANSPORT; // The Flickr API expects all data to be UTF-8 encoded. WS_ENCODING encoding = WS_ENCODING_XML_UTF8; WS_CHANNEL_PROPERTY channelProperties[3] = { { WS_CHANNEL_PROPERTY_ENVELOPE_VERSION, &soapVersion, sizeof(WS_ENVELOPE_VERSION) }, { WS_CHANNEL_PROPERTY_ADDRESSING_VERSION, &addressingVersion , sizeof(WS_ADDRESSING_VERSION) }, { WS_CHANNEL_PROPERTY_ENCODING, &encoding, sizeof(WS_ENCODING) } }; WS_ENDPOINT_ADDRESS address = { { static_cast<unsigned long>(wcslen(flickr_soap_endpoint_url)), const_cast<wchar_t*>(flickr_soap_endpoint_url) } }; // Create an error object for storing rich error information HRESULT hr = WsCreateError(nullptr, 0, error); if(SUCCEEDED(hr)) { // Create a heap to store deserialized data hr = WsCreateHeap(/*maxSize*/ 4096, /*trimSize*/ 512, nullptr, 0, heap, *error); } if(SUCCEEDED(hr)) { // Create the proxy hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, nullptr, nullptr, 0, channelProperties, ARRAYSIZE(channelProperties), proxy, *error); } if(SUCCEEDED(hr)) { hr = WsOpenServiceProxy(*proxy, &address, nullptr, *error); } return hr; }
// 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; }