SOAP Client Using Visual C++

Section 1: Introduction

In this article, I'll show you how to build a SOAP client using Visual C++. This tutorial gives you a hands-on introduction to using the SOAP API. SOAP is emerging as a very popular protocol for exchanging information. It's relatively simple and designed to work with HTTP, SMTP, and other such protocols.

Prerequisites:

You should be familiar with using COM, specially using Smart Pointers in COM as I used an import directive to convert COM interfaces to Smart Pointers. You must have the Microsoft SOAP Toolkit installed on your system. For information on downloading the toolkit, see the Resources section later in this article.

Section 2: Fundamentals of SOAP Programming

Importing Type libraries:

All the objects and interfaces used in SOAP are found in mssoap1.dll. This file is installed with the Microsoft SOAP Toolkit 2.0. You can find this file in "C:\Program Files\Common Files\MSSoap\Binaries\MSSOAP1.dll". All you have to do is to import this file into your source using the #import directive, which is used to incorporate information from a type library. The contents of the type library are converted into COM smart pointers, describing the COM interfaces. Because SOAP relies completely on XML, the Microsoft XML Parser is also needed for XML processing. The Microsoft XML parser is included in msxml#.dll where # is the version number. Again, you need to import this file before importing mssoap1.dll.

#import "msxml3.dll"
using namespace MSXML2;
#import "C:\Program Files\Common Files\MSSoap\Binaries\MSSOAP1.dll" \
exclude("IStream", "ISequentialStream", "_LARGE_INTEGER", \
"_ULARGE_INTEGER", "tagSTATSTG", "_FILETIME")
using namespace MSSOAPLib;

That is all that is needed to include all class definitions required to develop a SOAP program. There are three steps that are necessary to make a SOAP client.

• Specify and connect with the Web Service
• Prepare and send the message
• Read the response back from the Service

Now, let's take a look at the classes involved. Following are the classes that are used to develop a basic SOAP client.

Class 1 -- SoapConnector:

The first thing that is required for any client in a client/ server application is to connect with the server. The SoapConnector class implements the protocol that is used as a transport between the client and the server. SoapConnector acts as an abstract class for defining the interface for implementing other protocols. That is because SOAP is not limited to a specific protocol; you'll see that some implementation supports MSMQ, MQ Series, SMTP, and TCP/IP Transports. For the sake of simplicity, I am demonstrating the use of HTTP Transport, which is implemented by the HttpConnector class available with the Microsoft SOAP Toolkit 2.0.

The steps involved in using SoapConnector class

a) Creating an object to SoapConnector:

ISoapConnectorPtr connector;
Connector.CreateInstance(__uuidof(HttpConnector)); 

b) Specifying the Web Service Address:

Next, we have to define the Web service that we are using as a client. The service is specified using the Property (an attribute of HttpConnector). There are two things to specify when dealing with this attribute:

• Which property are we referring to
• the value of the respective property type

Here, for specifying the Web service, we use the EndPointURL property.

Connector->Property ["EndPointURL"] = 
               "some url pointing to web service";

( The above table is taken from MSDN )

c) Connecting with the Web Service:

The connect method of HttpConnector is used to initialize the SoapConnector object and actually prepares a connection with the service.

Connector->Connect;();

d) Specifying the action:

After connecting with the server, we need to specify the action that we are going to perform on the Web service. To specify the Action, we again use the Property attribute of the soapConnector.

Connector->Property; ["SoapAction"] = "some uri";

e) Message handling:

After connecting with the service and specifying other details, we signal the start of a SOAP message being sent to the server. The function must be called before calling any other method of SoapSerializer ( which is used to prepare the message).

Connector->BeginMessage;();

After finishing the message, we must call the EndMessage() function to actually send the message to the service.

.
.
[ message preparation code ]
.
.
Connector->EndMessage;();

This is all that is needed to actually connect with the service. The next part shows you how to create and prepare a message.

SoapSerializer:

The SoapSerializer is used to build a SOAP message to be sent to the service. The SoapSerializer object must be connected with the SoapConnector object before communicating with the server. To interconnect these two objects, we need to call the Init method of the SoapSerializer object. This method takes a single argument, which is the InputStream (the stream the sends data to the server).

// creating a SoapSerializer object and initializing it 
// with InputSTream
ISoapSerializerPtr Serializer; 
Serializer.CreateInstance(_uuidof(SoapSerializer)); 
Serializer->Init;(_variant_t((IUnknown*)Connector->InputStream;));

Before looking into other functions of SoapSerializer, let's take a look at a sample SOAP request to get an idea of what we are building in our code.

Simple Soap Request:

<SOAP;: Envelope xmlns:SOAP="soap namespace">
<SOAP;:Body>
<m;:someMethodName xmlns:m="some namespace"> 
<someParameter;> </someParameter> </SOAP:Body></SOAP: Envelope> 
<SOAP: Envelope xmlns:SOAP="soap namespace">
<SOAP:Body>
<m:someMethodName xmlns:m="some namespace">
<someParameter> someParameterValue </someParameter>
<m:someMethodName>
</SOAP:Body>
</SOAP: Envelope>

A SOAP request is simply encapsulated into tags. The <Envelope> tag is the main tag of this SOAP Document. A SOAP message is always encapsulated in an envelope. The envelope contains a message body, which is specified by a <Body> Tag. The body contains the actual request. In C++, we have the appropriate methods to create these tags and specify any values in these. The following code piece demonstrates the use of these methods.

Serializer->startEnvelope;("SOAP","","");
  // Begins an <envelope;> element in a SOAP message, first 
  // the argument defines the namespace. If it is empty, SOAP-ENV
  // is used by default.
  // The second and the third argument define the URI and the
  // Encoding Type, respectively. Serialzier->startBody;("");
  // begins the <Body> element in the message. The first
  // argument defines the encoding style Uri; by default it is NONE.
Serializer->startElement;("someMethodName","","","m");
  // Begins a child element into the body element of a SOAP message.
  // The first parameter is the element name; the second parameter is
  // the Uri; the third is the encoding style; and the last element
  // is the namespace for the element.
Serializer->WriteString;("someParameterValue")
  // Writes the value of an element.

All the preceding startXXX functions have their equivalent endXXX function to end the element. After finishing the message, the connector's endMessage() method is called to actually send the message as described above.

Until here in this tutorial, we have connected with the service, prepared our request, and sent it to service. The next and the final step is to read the response from the server.

SoapReader:

This object reads the response from the service and parses the incoming message into DOM for further processing. Following is a sample SOAP Response from the service.

Simple SOAP Response:

  <SOAP: Envelope xmlns:SOAP="soap namespace">
  <SOAP:Body>
  <m:someMethodNameResponse xmlns:m="some namespace">
  <return> someResult </return>
  <m:someMethodNameResponse>
  </SOAP:Body>
  </SOAP: Envelope>

Before calling any functions to get the result, we connect with the OutputStream to actually read the response in a SoapReader object. ( An OutputStream receives data from the service ).

// code to create a SOAPReader object and connecting with
// the outputstream 
ISoapReaderPtr Reader; Reader.CreateInstance(_uuidof(SoapReader));
Reader->Load;(_variant_t((IUnknown*)Connector->OutputStream;)); 

// the load method can also accept a XML Document File or String

After loading the response into our SoapReader object, we get the result by calling the RPCResult property of SoapReader object. But RPCResult doesn't return the actual result; it returns the first child element of the first entry in the <Body> element. We get the result by calling the text property.

Reader->RPCResult-;>text;

Section 3: Demonstrating a Sample SOAP Client

For demonstrating the use of above SOAP classes, I used one of the services listed on www.xmethods.net. The service indicates Yahoo Messenger's online presence. You can find the required details by following this URL: http://www.xmethods.net/ve2/ViewListing.po?serviceid=156. The only thing it expects is a method parameter, such as the Yahoo user's login id. The result returned is a Boolean value indicating 0 for offline and 1 for online. Other details are available on the site or by viewing the wsdl at http://www.allesta.net:51110/webservices/wsdl/YahooUserPingService.xml.

Section 4: Resources

The SOAP specification Simple Object Access Protocol (SOAP) 1.1 - W3C Note

http://www.w3.org/TR/SOAP

Microsoft SOAP Toolkit Download

http://download.microsoft.com/download/xml/soap/2.0/w98nt42kme/EN-US/SoapToolkit20.exe

Source Code:

#include <stdio.h;>

#import "msxml3.dll" 
using namespace MSXML2;

#import "C:\Program Files\Common Files\MSSoap\Binaries\MSSOAP1.dll" \
exclude("IStream", "ISequentialStream", "_LARGE_INTEGER", \
"_ULARGE_INTEGER", "tagSTATSTG", "_FILETIME")
using namespace MSSOAPLib;

void main()
{
  CoInitialize(NULL);

  ISoapSerializerPtr Serializer;
  ISoapReaderPtr Reader;
  ISoapConnectorPtr Connector;

  // Connect to the service
  Connector.CreateInstance(__uuidof(HttpConnector));
  Connector->Property["EndPointURL"] = 
  "http://www.allesta.net:51110/webservices/soapx4/isuseronline.php";
  Connector->Connect;();

  // Begin message
  Connector->Property;["SoapAction"] = "uri:allesta-YahooUserPing";
  Connector->BeginMessage;();

  // Create the SoapSerializer
  Serializer.CreateInstance(__uuidof(SoapSerializer));

  // Connect the serializer to the input stream of the connector
  Serializer->Init;(_variant_t((IUnknown*)Connector->InputStream));

  // Build the SOAP Message
  Serializer->startEnvelope;("","","");
  Serializer->startBody;("");
  Serializer->startElement;("isuseronline",
                              "uri:allesta-YahooUserPing",
                              "",
                              "m");
 Serializer->startElement;("username","","","");
  Serializer->writeString;("laghari78");
  Serializer->endElement;();
  Serializer->endElement;();
  Serializer->endBody;();
  Serializer->endEnvelope;();
  
  // Send the message to the web service
  Connector->EndMessage;();      

  // Read the response
  Reader.CreateInstance(__uuidof(SoapReader));

  // Connect the reader to the output stream of the connector
  Reader->Load;(_variant_t((IUnknown*)Connector->OutputStream),
                  "");

  // Display the result
  printf("Answer: %s\n", (const char *)Reader->RPCResult->text);
    CoUninitialize();

}

Downloads

Download demo project -- 3.18 KB