// <StubDefinitions>
HRESULT __stdcall
Stub_GetLastTradePrice
( IUnknown* server
, IWSDServiceMessaging* service
, WSD_EVENT* event
)
{
HRESULT hr = S_OK;
IStockQuote* pServer = NULL;
REQUESTBODY_StockQuotePortType_GetLastTradePrice* p = reinterpret_cast<REQUESTBODY_StockQuotePortType_GetLastTradePrice*>(event->Soap->Body);
RESPONSEBODY_StockQuotePortType_GetLastTradePrice result;
::ZeroMemory(&result,sizeof(result));
hr = server->QueryInterface( __uuidof(IStockQuote), (void**)&pServer );
if( S_OK == hr )
{
hr =
pServer->GetLastTradePrice
( p->body
, &result.body
);
pServer->Release();
pServer = NULL;
}
if (SUCCEEDED(hr))
{
hr = service->SendResponse(&result,event->Operation,event->MessageParameters);
}
if (FAILED(hr))
{
hr = service->FaultRequest(&event->Soap->Header,event->MessageParameters, NULL);
}
// Clean up memory from outparams
if (NULL != result.body)
{
WSDFreeLinkedMemory( (void*) (result.body) );
}
return hr;
}
// <StubDefinitions>
HRESULT __stdcall
Stub_GetFileList
( IUnknown* server
, IWSDServiceMessaging* service
, WSD_EVENT* event
)
{
HRESULT hr = S_OK;
IFileService* pServer = NULL;
RESPONSEBODY_FileService_GetFileList result;
::ZeroMemory(&result,sizeof(result));
hr = server->QueryInterface( __uuidof(IFileService), (void**)&pServer );
if( S_OK == hr )
{
hr =
pServer->GetFileList
( &result.parameters
);
pServer->Release();
pServer = NULL;
}
if (SUCCEEDED(hr))
{
hr = service->SendResponse(&result,event->Operation,event->MessageParameters);
}
if (FAILED(hr))
{
hr = service->FaultRequest(&event->Soap->Header,event->MessageParameters, NULL);
}
// Clean up memory from outparams
if (NULL != result.parameters)
{
WSDFreeLinkedMemory( (void*) (result.parameters) );
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////
// GetFileList - Invoke the GetFileList (i.e., "dir") service method
//////////////////////////////////////////////////////////////////////////////
HRESULT GetFileList(
IFileServiceSecureProxy* pFileServiceSecureProxy)
{
GET_FILE_LIST_RESPONSE* pResponse = NULL;
HRESULT hr = S_OK;
if( NULL == pFileServiceSecureProxy )
{
return E_INVALIDARG;
}
// Invoke GetFileList method on service
_cwprintf(L"Invoking GetFileList method on service... ");
hr = pFileServiceSecureProxy->GetFileList( &pResponse );
print_result( hr );
// Print results
if( S_OK == hr && NULL != pResponse )
{
PWCHAR_LIST *pList = pResponse->FileList;
while( pList )
{
_cwprintf(L"%s\r\n", (NULL == pList->Element ? L"(null)" : pList->Element));
pList = pList->Next;
}
}
// cleanup
if( NULL != pResponse )
{
WSDFreeLinkedMemory( pResponse );
pResponse = NULL;
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////
// AsyncOperationComplete - Called when the GetFile operation is complete
//////////////////////////////////////////////////////////////////////////////
HRESULT STDMETHODCALLTYPE CGetFileAsyncCallback::AsyncOperationComplete(
IWSDAsyncResult* pAsyncResult,
IUnknown* pAsyncState)
{
UNREFERENCED_PARAMETER(pAsyncState);
GET_FILE_RESPONSE* pResponse = NULL;
HRESULT hr = S_OK;
//
// When the GetFile operation completes, we enter this callback. It's
// then our responsibility to call EndGetFile to actually retrieve
// the results.
//
_cwprintf(L"Asynchronous GetFile operation completed.\r\n");
hr = m_pFileServiceSecureProxy->EndGetFile( pAsyncResult, &pResponse );
// Call into our helper method to save the attachment to disk
if( S_OK == hr && NULL != pResponse )
{
hr = ReceiveBinary( pResponse->Attachment, m_szFile );
}
else
{
_cwprintf(L" GetFile operation failed or returned NULL response: ");
print_result( hr );
}
// cleanup
if( NULL != pResponse )
{
WSDFreeLinkedMemory( pResponse );
pResponse = NULL;
}
return hr;
}
static void UnPublish_tests(void)
{
IWSDiscoveryPublisher *publisher = NULL;
IWSDiscoveryPublisherNotify *sink1 = NULL;
char endpoint_reference_string[MAX_PATH], app_sequence_string[MAX_PATH];
LPWSTR publisherIdW = NULL, sequenceIdW = NULL;
messageStorage *msg_storage;
WSADATA wsa_data;
BOOL message_ok, hello_message_seen = FALSE, endpoint_reference_seen = FALSE, app_sequence_seen = FALSE;
BOOL wine_ns_seen = FALSE, body_hello_seen = FALSE, any_body_seen = FALSE;
int ret, i;
HRESULT rc;
ULONG ref;
char *msg;
WSDXML_ELEMENT *body_any_element;
WSDXML_NAME body_any_name;
WSDXML_NAMESPACE ns;
WCHAR body_any_name_text[] = {'B','e','e','r',0};
static const WCHAR body_any_text[] = {'B','o','d','y','T','e','s','t',0};
static const WCHAR uri[] = {'h','t','t','p',':','/','/','w','i','n','e','.','t','e','s','t','/',0};
static const WCHAR prefix[] = {'w','i','n','e',0};
rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV4);
ok(rc == S_OK, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV4) failed: %08x\n", rc);
/* Create notification sink */
ok(create_discovery_publisher_notify(&sink1) == TRUE, "create_discovery_publisher_notify failed\n");
rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink1);
ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
/* Set up network listener */
publisherIdW = utf8_to_wide(publisherId);
if (publisherIdW == NULL) goto after_unpublish_test;
sequenceIdW = utf8_to_wide(sequenceId);
if (sequenceIdW == NULL) goto after_unpublish_test;
msg_storage = heap_alloc_zero(sizeof(messageStorage));
if (msg_storage == NULL) goto after_unpublish_test;
msg_storage->running = TRUE;
InitializeCriticalSection(&msg_storage->criticalSection);
ret = WSAStartup(MAKEWORD(2, 2), &wsa_data);
ok(ret == 0, "WSAStartup failed (ret = %d)\n", ret);
ret = start_listening_on_all_addresses(msg_storage, AF_INET);
ok(ret == TRUE, "Unable to listen on IPv4 addresses (ret == %d)\n", ret);
/* Create "any" elements for header */
ns.Uri = uri;
ns.PreferredPrefix = prefix;
body_any_name.LocalName = body_any_name_text;
body_any_name.Space = &ns;
rc = WSDXMLBuildAnyForSingleElement(&body_any_name, body_any_text, &body_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
/* Unpublish the service */
rc = IWSDiscoveryPublisher_UnPublish(publisher, publisherIdW, 1, 1, sequenceIdW, body_any_element);
WSDFreeLinkedMemory(body_any_element);
ok(rc == S_OK, "Unpublish failed: %08x\n", rc);
/* Wait up to 2 seconds for messages to be received */
if (WaitForMultipleObjects(msg_storage->numThreadHandles, msg_storage->threadHandles, TRUE, 2000) == WAIT_TIMEOUT)
{
/* Wait up to 1 more second for threads to terminate */
msg_storage->running = FALSE;
WaitForMultipleObjects(msg_storage->numThreadHandles, msg_storage->threadHandles, TRUE, 1000);
}
DeleteCriticalSection(&msg_storage->criticalSection);
/* Verify we've received a message */
ok(msg_storage->messageCount >= 1, "No messages received\n");
sprintf(endpoint_reference_string, "<wsa:EndpointReference><wsa:Address>%s</wsa:Address></wsa:EndpointReference>",
publisherId);
sprintf(app_sequence_string, "<wsd:AppSequence InstanceId=\"1\" SequenceId=\"%s\" MessageNumber=\"1\"></wsd:AppSequence>",
sequenceId);
message_ok = FALSE;
/* Check we're received the correct message */
for (i = 0; i < msg_storage->messageCount; i++)
{
msg = msg_storage->messages[i];
message_ok = FALSE;
hello_message_seen = (strstr(msg, "<wsa:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Bye</wsa:Action>") != NULL);
endpoint_reference_seen = (strstr(msg, endpoint_reference_string) != NULL);
app_sequence_seen = (strstr(msg, app_sequence_string) != NULL);
wine_ns_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\"") != NULL);
body_hello_seen = (strstr(msg, "<soap:Body><wsd:Bye") != NULL);
any_body_seen = (strstr(msg, "<wine:Beer>BodyTest</wine:Beer>") != NULL);
message_ok = hello_message_seen && endpoint_reference_seen && app_sequence_seen && wine_ns_seen &&
body_hello_seen && any_body_seen;
if (message_ok) break;
}
for (i = 0; i < msg_storage->messageCount; i++)
{
heap_free(msg_storage->messages[i]);
}
heap_free(msg_storage);
ok(hello_message_seen == TRUE, "Bye message not received\n");
ok(endpoint_reference_seen == TRUE, "EndpointReference not received\n");
ok(app_sequence_seen == TRUE, "AppSequence not received\n");
ok(message_ok == TRUE, "Bye message metadata not received\n");
ok(wine_ns_seen == TRUE, "Wine namespace not received\n");
ok(body_hello_seen == TRUE, "Body and Bye elements not received\n");
ok(any_body_seen == TRUE, "Custom body element not received\n");
after_unpublish_test:
heap_free(publisherIdW);
heap_free(sequenceIdW);
ref = IWSDiscoveryPublisher_Release(publisher);
ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
/* Release the sinks */
IWSDiscoveryPublisherNotify_Release(sink1);
WSACleanup();
}
static void Publish_tests(void)
{
IWSDiscoveryPublisher *publisher = NULL;
IWSDiscoveryPublisherNotify *sink1 = NULL, *sink2 = NULL;
IWSDiscoveryPublisherNotifyImpl *sink1Impl = NULL, *sink2Impl = NULL;
char endpointReferenceString[MAX_PATH], app_sequence_string[MAX_PATH];
LPWSTR publisherIdW = NULL, sequenceIdW = NULL;
messageStorage *msgStorage;
WSADATA wsaData;
BOOL messageOK, hello_message_seen = FALSE, endpoint_reference_seen = FALSE, app_sequence_seen = FALSE;
BOOL metadata_version_seen = FALSE, any_header_seen = FALSE, wine_ns_seen = FALSE, body_hello_seen = FALSE;
BOOL any_body_seen = FALSE, types_seen = FALSE, xml_namespaces_seen = FALSE, scopes_seen = FALSE;
BOOL xaddrs_seen = FALSE;
int ret, i;
HRESULT rc;
ULONG ref;
char *msg;
WSDXML_ELEMENT *header_any_element, *body_any_element, *endpoint_any_element, *ref_param_any_element;
WSDXML_NAME header_any_name, another_name;
WSDXML_NAMESPACE ns, ns2;
WCHAR header_any_name_text[] = {'B','e','e','r',0};
static const WCHAR header_any_text[] = {'P','u','b','l','i','s','h','T','e','s','t',0};
static const WCHAR body_any_text[] = {'B','o','d','y','T','e','s','t',0};
static const WCHAR endpoint_any_text[] = {'E','n','d','P','T','e','s','t',0};
static const WCHAR ref_param_any_text[] = {'R','e','f','P','T','e','s','t',0};
static const WCHAR uri[] = {'h','t','t','p',':','/','/','w','i','n','e','.','t','e','s','t','/',0};
static const WCHAR prefix[] = {'w','i','n','e',0};
static const WCHAR uri3[] = {'h','t','t','p',':','/','/','t','h','i','r','d','.','u','r','l','/',0};
WSD_NAME_LIST types_list;
WSD_URI_LIST scopes_list, xaddrs_list;
unsigned char *probe_uuid_str;
rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
/* Test SetAddressFamily */
rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, 12345);
ok(rc == E_INVALIDARG, "IWSDiscoveryPublisher_SetAddressFamily(12345) returned unexpected result: %08x\n", rc);
rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV4);
ok(rc == S_OK, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV4) failed: %08x\n", rc);
/* Try to update the address family after already setting it */
rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV6);
ok(rc == STG_E_INVALIDFUNCTION, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV6) returned unexpected result: %08x\n", rc);
/* Create notification sinks */
ok(create_discovery_publisher_notify(&sink1) == TRUE, "create_discovery_publisher_notify failed\n");
ok(create_discovery_publisher_notify(&sink2) == TRUE, "create_discovery_publisher_notify failed\n");
/* Get underlying implementation so we can check the ref count */
sink1Impl = impl_from_IWSDiscoveryPublisherNotify(sink1);
sink2Impl = impl_from_IWSDiscoveryPublisherNotify(sink2);
/* Attempt to unregister sink before registering it */
rc = IWSDiscoveryPublisher_UnRegisterNotificationSink(publisher, sink1);
ok(rc == E_FAIL, "IWSDiscoveryPublisher_UnRegisterNotificationSink returned unexpected result: %08x\n", rc);
/* Register notification sinks */
rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink1);
ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
ok(sink1Impl->ref == 2, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink2);
ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
ok(sink2Impl->ref == 2, "Ref count for sink 2 is not as expected: %d\n", sink2Impl->ref);
/* Unregister the first sink */
rc = IWSDiscoveryPublisher_UnRegisterNotificationSink(publisher, sink1);
ok(rc == S_OK, "IWSDiscoveryPublisher_UnRegisterNotificationSink failed: %08x\n", rc);
ok(sink1Impl->ref == 1, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
/* Set up network listener */
publisherIdW = utf8_to_wide(publisherId);
if (publisherIdW == NULL) goto after_publish_test;
sequenceIdW = utf8_to_wide(sequenceId);
if (sequenceIdW == NULL) goto after_publish_test;
msgStorage = heap_alloc_zero(sizeof(messageStorage));
if (msgStorage == NULL) goto after_publish_test;
msgStorage->running = TRUE;
InitializeCriticalSection(&msgStorage->criticalSection);
ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
ok(ret == 0, "WSAStartup failed (ret = %d)\n", ret);
ret = start_listening_on_all_addresses(msgStorage, AF_INET);
ok(ret == TRUE, "Unable to listen on IPv4 addresses (ret == %d)\n", ret);
/* Create "any" elements for header */
ns.Uri = uri;
ns.PreferredPrefix = prefix;
header_any_name.LocalName = header_any_name_text;
header_any_name.Space = &ns;
rc = WSDXMLBuildAnyForSingleElement(&header_any_name, header_any_text, &header_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
rc = WSDXMLBuildAnyForSingleElement(&header_any_name, body_any_text, &body_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
rc = WSDXMLBuildAnyForSingleElement(&header_any_name, endpoint_any_text, &endpoint_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
rc = WSDXMLBuildAnyForSingleElement(&header_any_name, ref_param_any_text, &ref_param_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
/* Create types list */
ns2.Uri = uri_more_tests;
ns2.PreferredPrefix = prefix_grog;
another_name.LocalName = (WCHAR *) name_cider;
another_name.Space = &ns2;
types_list.Next = malloc(sizeof(WSD_NAME_LIST));
types_list.Element = &another_name;
types_list.Next->Next = NULL;
types_list.Next->Element = &header_any_name;
/* Create scopes and xaddrs lists */
scopes_list.Next = malloc(sizeof(WSD_URI_LIST));
scopes_list.Element = uri;
scopes_list.Next->Next = NULL;
scopes_list.Next->Element = uri_more_tests;
xaddrs_list.Next = malloc(sizeof(WSD_URI_LIST));
xaddrs_list.Element = uri_more_tests;
xaddrs_list.Next->Next = NULL;
xaddrs_list.Next->Element = uri3;
/* Publish the service */
rc = IWSDiscoveryPublisher_PublishEx(publisher, publisherIdW, 1, 1, 1, sequenceIdW, &types_list, &scopes_list,
&xaddrs_list, header_any_element, ref_param_any_element, NULL, endpoint_any_element, body_any_element);
WSDFreeLinkedMemory(header_any_element);
WSDFreeLinkedMemory(body_any_element);
WSDFreeLinkedMemory(endpoint_any_element);
WSDFreeLinkedMemory(ref_param_any_element);
free(types_list.Next);
free(scopes_list.Next);
free(xaddrs_list.Next);
ok(rc == S_OK, "Publish failed: %08x\n", rc);
/* Wait up to 2 seconds for messages to be received */
if (WaitForMultipleObjects(msgStorage->numThreadHandles, msgStorage->threadHandles, TRUE, 2000) == WAIT_TIMEOUT)
{
/* Wait up to 1 more second for threads to terminate */
msgStorage->running = FALSE;
WaitForMultipleObjects(msgStorage->numThreadHandles, msgStorage->threadHandles, TRUE, 1000);
}
DeleteCriticalSection(&msgStorage->criticalSection);
/* Verify we've received a message */
ok(msgStorage->messageCount >= 1, "No messages received\n");
sprintf(endpointReferenceString, "<wsa:EndpointReference><wsa:Address>%s</wsa:Address><wsa:ReferenceParameters>"
"<wine:Beer>RefPTest</wine:Beer></wsa:ReferenceParameters><wine:Beer>EndPTest</wine:Beer>"
"</wsa:EndpointReference>", publisherId);
sprintf(app_sequence_string, "<wsd:AppSequence InstanceId=\"1\" SequenceId=\"%s\" MessageNumber=\"1\"></wsd:AppSequence>",
sequenceId);
messageOK = FALSE;
/* Check we're received the correct message */
for (i = 0; i < msgStorage->messageCount; i++)
{
msg = msgStorage->messages[i];
messageOK = FALSE;
hello_message_seen = (strstr(msg, "<wsa:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Hello</wsa:Action>") != NULL);
endpoint_reference_seen = (strstr(msg, endpointReferenceString) != NULL);
app_sequence_seen = (strstr(msg, app_sequence_string) != NULL);
metadata_version_seen = (strstr(msg, "<wsd:MetadataVersion>1</wsd:MetadataVersion>") != NULL);
any_header_seen = (strstr(msg, "<wine:Beer>PublishTest</wine:Beer>") != NULL);
wine_ns_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\"") != NULL);
body_hello_seen = (strstr(msg, "<soap:Body><wsd:Hello") != NULL);
any_body_seen = (strstr(msg, "<wine:Beer>BodyTest</wine:Beer>") != NULL);
types_seen = (strstr(msg, "<wsd:Types>grog:Cider wine:Beer</wsd:Types>") != NULL);
scopes_seen = (strstr(msg, "<wsd:Scopes>http://wine.test/ http://more.tests/</wsd:Scopes>") != NULL);
xaddrs_seen = (strstr(msg, "<wsd:XAddrs>http://more.tests/ http://third.url/</wsd:XAddrs>") != NULL);
xml_namespaces_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\" xmlns:grog=\"http://more.tests/\"") != NULL);
messageOK = hello_message_seen && endpoint_reference_seen && app_sequence_seen && metadata_version_seen &&
any_header_seen && wine_ns_seen && body_hello_seen && any_body_seen && types_seen && xml_namespaces_seen &&
scopes_seen && xaddrs_seen;
if (messageOK) break;
}
for (i = 0; i < msgStorage->messageCount; i++)
{
heap_free(msgStorage->messages[i]);
}
heap_free(msgStorage);
ok(hello_message_seen == TRUE, "Hello message not received\n");
ok(endpoint_reference_seen == TRUE, "EndpointReference not received\n");
ok(app_sequence_seen == TRUE, "AppSequence not received\n");
ok(metadata_version_seen == TRUE, "MetadataVersion not received\n");
ok(messageOK == TRUE, "Hello message metadata not received\n");
ok(any_header_seen == TRUE, "Custom header not received\n");
ok(wine_ns_seen == TRUE, "Wine namespace not received\n");
ok(body_hello_seen == TRUE, "Body and Hello elements not received\n");
ok(any_body_seen == TRUE, "Custom body element not received\n");
ok(types_seen == TRUE, "Types not received\n");
ok(xml_namespaces_seen == TRUE, "XML namespaces not received\n");
ok(scopes_seen == TRUE, "Scopes not received\n");
ok(xaddrs_seen == TRUE, "XAddrs not received\n");
after_publish_test:
heap_free(publisherIdW);
heap_free(sequenceIdW);
/* Test the receiving of a probe message */
probe_event = CreateEventW(NULL, TRUE, FALSE, NULL);
UuidCreate(&probe_message_id);
UuidToStringA(&probe_message_id, &probe_uuid_str);
ok(probe_uuid_str != NULL, "Failed to create UUID for probe message\n");
if (probe_uuid_str != NULL)
{
char probe_message[sizeof(testProbeMessage) + 50];
sprintf(probe_message, testProbeMessage, probe_uuid_str);
ok(send_udp_multicast_of_type(probe_message, strlen(probe_message), AF_INET) == TRUE, "Sending Probe message failed\n");
todo_wine ok(WaitForSingleObject(probe_event, 2000) == WAIT_OBJECT_0, "Probe message not received\n");
RpcStringFreeA(&probe_uuid_str);
}
CloseHandle(probe_event);
ref = IWSDiscoveryPublisher_Release(publisher);
ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
/* Check that the sinks have been released by the publisher */
ok(sink1Impl->ref == 1, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
ok(sink2Impl->ref == 1, "Ref count for sink 2 is not as expected: %d\n", sink2Impl->ref);
/* Release the sinks */
IWSDiscoveryPublisherNotify_Release(sink1);
IWSDiscoveryPublisherNotify_Release(sink2);
WSACleanup();
}
//////////////////////////////////////////////////////////////////////////////
// CStockQuoteService::GetLastTradePrice
// Service method which can be called by remote clients. This method
// takes the stock quote listed in the parameters structure and returns
// a structure with a stock price.
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CStockQuoteService::GetLastTradePrice(
TRADE_PRICE_REQUEST* parameters,
TRADE_PRICE** ppTradePrice)
{
TRADE_PRICE* pTradePrice = NULL;
HRESULT hr = S_OK;
_cwprintf(L"Client invoking GetLastTradePrice method\r\n");
// Validate parameters
if( NULL == parameters )
{
return E_INVALIDARG;
}
if( NULL == parameters->tickerSymbol )
{
return E_INVALIDARG;
}
if( NULL == ppTradePrice )
{
return E_POINTER;
}
*ppTradePrice = NULL;
// Allocate response structure with WSDAllocateLinkedMemory. The
// Deallocator for this port type's stub functions is WSDFreeLinkedMemory.
_cwprintf(L" Allocating response structure... ");
pTradePrice = (TRADE_PRICE*)WSDAllocateLinkedMemory( NULL,
sizeof(TRADE_PRICE) );
if( NULL == pTradePrice )
{
hr = E_OUTOFMEMORY;
}
print_result( hr );
// Fill response structure
if( S_OK == hr )
{
_cwprintf(L" Calling into StockLookup function... ");
pTradePrice->price = StockLookup(parameters->tickerSymbol);
print_result( hr );
}
if( S_OK == hr )
{
*ppTradePrice = pTradePrice;
pTradePrice = NULL;
_cwprintf(L" Response has been prepared.\r\n");
}
_cwprintf(L" Service method exit code: ");
print_result( hr );
// cleanup
if( NULL != pTradePrice )
{
WSDFreeLinkedMemory( pTradePrice );
pTradePrice = NULL;
}
return hr;
}
HRESULT STDMETHODCALLTYPE
CStockQuoteProxy::EndGetLastTradePrice
( /* [in] */ IWSDAsyncResult* AsyncResult
, /* [out] */ TRADE_PRICE** bodyOut
)
{
WSD_EVENT ev;
HRESULT hr = S_OK;
// Initialize Output Pointers
if( NULL != bodyOut )
{
*bodyOut = NULL;
}
if( NULL == AsyncResult )
{
hr = E_INVALIDARG;
return hr;
}
// Validate Response Parameters
if( NULL == bodyOut )
{
hr = E_POINTER;
return hr;
}
::ZeroMemory(&ev, sizeof(ev));
hr = AsyncResult->GetEvent( &ev );
if( S_OK != hr )
{
return hr;
}
if( ev.EventType == WSDET_INCOMING_MESSAGE )
{
void* results = ev.Soap->Body;
if( NULL != results )
{
RESPONSEBODY_StockQuotePortType_GetLastTradePrice* response = reinterpret_cast<RESPONSEBODY_StockQuotePortType_GetLastTradePrice*>(results);
WSDDetachLinkedMemory( (void*) response->body );
*bodyOut = response->body;
WSDFreeLinkedMemory( (void*) response );
}
}
else if( ev.EventType == WSDET_INCOMING_FAULT )
{
void* results = ev.Soap->Body;
if( NULL == m_genericProxy )
{
hr = E_ABORT;
return hr;
}
IWSDEndpointProxy* ep = NULL;
hr = m_genericProxy->GetEndpointProxy(&ep);
if( FAILED(hr) || NULL == ep )
{
hr = E_ABORT;
return hr;
}
hr = E_FAIL;
if( results )
{
ep->ProcessFault( (const WSD_SOAP_FAULT*)results );
}
ep->Release();
}
else
{
hr = ( (S_OK == ev.Hr) ? E_FAIL : ev.Hr );
}
return hr;
}
// <ProxyFunctionImplementations>
HRESULT STDMETHODCALLTYPE
CStockQuoteProxy::GetLastTradePrice
( /* [in] */ TRADE_PRICE_REQUEST* body
, /* [out] */ TRADE_PRICE** bodyOut
)
{
HRESULT hr = S_OK;
// Initialize Output Pointers
if( NULL != bodyOut )
{
*bodyOut = NULL;
}
// Validate Request Parameters
if( NULL == body )
{
hr = E_INVALIDARG;
return hr;
}
// Validate Response Parameters
if( NULL == bodyOut )
{
hr = E_POINTER;
return hr;
}
REQUESTBODY_StockQuotePortType_GetLastTradePrice request;
request.body = body;
if( NULL == m_genericProxy )
{
hr = E_ABORT;
return hr;
}
IWSDEndpointProxy* ep = NULL;
hr = m_genericProxy->GetEndpointProxy(&ep);
if( FAILED(hr) || NULL == ep )
{
hr = E_ABORT;
return hr;
}
WSD_SYNCHRONOUS_RESPONSE_CONTEXT context;
::ZeroMemory(&context, sizeof(context));
context.eventHandle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
if (NULL == context.eventHandle)
{
DWORD dw = ::GetLastError();
hr = HRESULT_FROM_WIN32(dw);
ep->Release();
return hr;
}
hr =
ep->SendTwoWayRequest
( &request
, &Operations_StockQuotePortType[0]
, &context
);
if (SUCCEEDED(hr))
{
if ( WAIT_FAILED == ::WaitForSingleObject(context.eventHandle, INFINITE) )
{
DWORD dw = ::GetLastError();
hr = HRESULT_FROM_WIN32(dw);
}
}
::CloseHandle(context.eventHandle);
context.eventHandle = NULL;
if (SUCCEEDED(hr))
{
if (SUCCEEDED(context.hr))
{
if( NULL != context.results )
{
RESPONSEBODY_StockQuotePortType_GetLastTradePrice* response = reinterpret_cast<RESPONSEBODY_StockQuotePortType_GetLastTradePrice*>(context.results);
WSDDetachLinkedMemory( (void*) response->body );
*bodyOut = response->body;
WSDFreeLinkedMemory( context.results );
context.results = NULL;
}
else
{
hr = E_FAIL;
}
}
else
{
hr = context.hr;
if( context.results )
{
ep->ProcessFault( (const WSD_SOAP_FAULT*)context.results );
}
}
}
if ( NULL != context.messageParameters )
{
context.messageParameters->Release();
context.messageParameters = NULL;
}
ep->Release();
return hr;
}
// <ProxyFunctionImplementations>
HRESULT STDMETHODCALLTYPE
CFileServiceProxy::GetFileList
( /* [out] */ GET_FILE_LIST_RESPONSE** parametersOut
)
{
HRESULT hr = S_OK;
// Initialize Output Pointers
if( NULL != parametersOut )
{
*parametersOut = NULL;
}
// Validate Response Parameters
if( NULL == parametersOut )
{
hr = E_POINTER;
return hr;
}
if( NULL == m_genericProxy )
{
hr = E_ABORT;
return hr;
}
IWSDEndpointProxy* ep = NULL;
hr = m_genericProxy->GetEndpointProxy(&ep);
if( FAILED(hr) || NULL == ep )
{
hr = E_ABORT;
return hr;
}
WSD_SYNCHRONOUS_RESPONSE_CONTEXT context;
::ZeroMemory(&context, sizeof(context));
context.eventHandle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
if (NULL == context.eventHandle)
{
DWORD dw = ::GetLastError();
hr = HRESULT_FROM_WIN32(dw);
ep->Release();
return hr;
}
hr =
ep->SendTwoWayRequest
( NULL
, &Operations_FileService[0]
, &context
);
if (SUCCEEDED(hr))
{
if ( WAIT_FAILED == ::WaitForSingleObject(context.eventHandle, INFINITE) )
{
DWORD dw = ::GetLastError();
hr = HRESULT_FROM_WIN32(dw);
}
}
::CloseHandle(context.eventHandle);
context.eventHandle = NULL;
if (SUCCEEDED(hr))
{
if (SUCCEEDED(context.hr))
{
if( NULL != context.results )
{
RESPONSEBODY_FileService_GetFileList* response = reinterpret_cast<RESPONSEBODY_FileService_GetFileList*>(context.results);
WSDDetachLinkedMemory( (void*) response->parameters );
*parametersOut = response->parameters;
WSDFreeLinkedMemory( context.results );
context.results = NULL;
}
else
{
hr = E_FAIL;
}
}
else
{
hr = context.hr;
if( context.results )
{
ep->ProcessFault( (const WSD_SOAP_FAULT*)context.results );
}
}
}
if ( NULL != context.messageParameters )
{
context.messageParameters->Release();
context.messageParameters = NULL;
}
ep->Release();
return hr;
}
