Home arrow Embedded Tools arrow Page 3 - HTTP Requesting with eVC++ 3.0 on Windows CE 3.0

HTTP Requesting with eVC++ 3.0 on Windows CE 3.0

Ever wanted to know how HTTP requests are done on a Windows CE device? If so, read this article by me, Ben Shepherd, to find out how.

Author Info:
By: Ben Shepherd
Rating: 5 stars5 stars5 stars5 stars5 stars / 20
May 20, 2003
  1. · HTTP Requesting with eVC++ 3.0 on Windows CE 3.0
  2. · Protocols and Packets
  3. · Creating your HTTP Request
  4. · Conclusion

print this article

HTTP Requesting with eVC++ 3.0 on Windows CE 3.0 - Creating your HTTP Request
(Page 3 of 4 )

HTTP uses sockets for communicating, as well as specifying the content and formatting details of the data being transferred. Now it is time to create the HTTP Handler. Letís view the system we are working with.

To create the trivial HTTP program we need to use the following functions:

  • InternetOpen
  • InternetConnect
  • InternetCrackUrl
  • HttpOpenRequest
  • HttpSendRequest
  • InternetReadFile
  • InternetCloseHandle


This function has the following prototype.

HANDLE InternetOpen(LPCTSTR lpszAgent,
                              DWORD dwAccessType,
                              LPCTSTR lpszProxy,
                              LPCTSTR lpszProxyByPass,
                              DWORD dwFlags);

Note: the fourth parameter LPCTSTR lpszProxyByPass should be set to NULL in Windows CE 3.0 because it is not supported.

The function is called once, usually at the moment when the application begins or when the first HTTP request is made. This function is used to initialise Windows CE Internet functions located in the wininet.h and wininet.lib.

This function when called will create a handle to give access to this functions. Once the Window CE Internet functions have completed their tasks, the HTTP handle must be closed.

Initially, the handle will be set to NULL.


When it is required, you'd call the InternetOpen function.

hHttpOpen = InternetOpen(_T("Application Id"),                 // Application identification
                                     INTERNET_OPEN_TYPE_DIRECT,  // No proxy server access
                                     NULL,                                    // No name for proxy server
                                     NULL,                                    // No bypass addresses
                                     0);                                       // No flags - Typical

This now initialises the HTTP handler for the proxy-less application.


This function is disigned to retrieve information contained in the URL and has the following prototype.

BOOL InternetCrackUrl(LPCTSTR lpszUrl,
                               DWORD dwUrlLength,
                               DWORD dwFlags,
                               LPURL_COMPONENTS lpUrlComponents);

To initialise the crackedURL variable, it is good practise to call the function memset to set each element of the variable to 0.

memset(&crackedUrl, 0, sizeof(crackedUrl));

Now the variable is initialised, let's implement it using the following variables,

  • dwStructSize
  • lpszHostName
  • dwHostNameLength
  • lpszUrlPath
  • dwUrlPathLength
TCHAR szServer[1024];
TCHAR szPath[1024];
crackedUrl.dwStructSize = sizeof(crackedUrl);
crackedUrl.lpszHostName = szServer;
crackedUrl.dwHostNameLength = 1024;
crackedUrl.lpszUrlPath = szPath;
crackedUrl.dwUrlPathLength = 1024;

Note: In the code below szUrl is the URL.

Say, www.devarticles.com/mynewpda/winCE/index.asp.

InternetCrackUrl(szUrl, 0, 0, &crackedUrl);

The result is lpszHostName would be valued at www.devarticles.com, while lpszUrlPath would be valued at /mynewpda/winCE/index.asp.


When the programmer wishes to connect to a server. This function has the following prototype.

HANDLE InternetConnect(HINTERNET hInternet,
                                  LPCTSTR lpszServerName,
                                  INTERNET_PORT nServerPort,
                                  LPCTSTR lpszUserName,
                                  LPCTSTR lpszPassword,
                                  DWORD dwService,
                                  DWORD dwFlags,
                                  DWORD dwContext);

If your server do not require a username and password, simply set the fourth and fifth parameters to NULL values. Let's implement this InternetConnect function. Firstly, create a connection object hHttpSession.

HINTERNET hHttpSession = NULL;

Now, the programmer should connect to the server using the handle that was created using the InternetOpen function as well as the Server name retieved via the crackedUrl function.

hHttpSession = InternetConnect(hHttpOpen,                              // Handle
                                            crackedURL.lpszHostName,          // Server name
                                            INTERNET_DEFAULT_HTTP_PORT,// HTTP Port number
                                            NULL,                                     // No username
                                            NULL,                                     // No password
                                            INTERNET_SERVICE_HTTP,         // Service or protocol
                                            0,                                          // No flags
                                            0);                                        // No context

Now there is a connection the the server, let's create a HTTP Request handle.


This function is Http protocol specific and has the following prototype.

HANDLE HttpOpenRequest(HINTERNET hHttpSession,
                                    LPCTSTR lpszVerb,
                                    LPCTSTR lpszObjectName,
                                    LPCTSTR lpszVersion,
                                    LPCTSTR lpszReferrer,
                                    LPCTSTR *lplpszAcceptTypes,
                                    DWORD dwFlags,
                                    DWORD dwContext);

Obtaining a Http Request handle can be done in the following way.

HINTERNET hHttpRequest = NULL;
hHttpRequest = HttpOpenRequest(httpSession,          // Handle from InternetConnect
                                              NULL,                   // HTTP verb is 'GET'
                                              crackedUrl.lpszPath,// CrackedUrl path
                                              NULL,                   // Default version is 'HTTP/1.0'
                                              NULL,                   // No referrer
                                              NULL,                   // Only 'text/*' files are accepted
                                              0,                        // No flags
                                              0);                      // No context

Once we have a HTTP handle we can make a request. This is done by calling the HttpSendRequest function.


This function is called when the programmer wishes to make a HTTP request. The function has the following prototype.

BOOL HttpSendRequest(HINTERNET hRequest,
                                 LPCTSTR lpszHeaders,
                                 DWORD dwHeadersLength,
                                 LPVOID lpOptional,
                                 DWORD dwOptionalLength);

So, to send a request to the server the programmer should type the following code,

HttpSendRequest(hHttpRequest,             // Using the handle that was just created
                        NULL,                         // No additional headers
                        0,                              // No length required
                        0,                              // No optional data
                        0);                             // No length required

Now the HTTP request is sent, it is time to retrieve the data.


This function retrieves the data returned from the HTTP request. The function has the following prototype.

BOOL InternetReadFile(HINTERNET hFile,
                               LPVOID lpBuffer,
                               DWORD dwNumberOfBytesToRead,
                               LPDWORD lpdwNumberOfBytesRead);

This function is called repeatly. Each time the function is called a chunk of data, either binary or text, is read into a buffer. Let make the chunksize 201, where the extra element represents the null character. 

#define CHUNKSIZE 201

Here is some code to get you on the right track.

char charBuffer[CHUNKSIZE];
DWORD dwRead;
                             CHUNKSIZE - 1,
            cout << _T("ERROR: ") << GetLastError();
      charBuffer[dwRead] = '\0';
      mbstowcs(szBuffer, charBurred, dwRead);
      szBuffer[dwRead] = '\0';
      cout << szBuffer;
} while(dwRead > 0);

Note: the function mbstowcs is used to convert a multibyte ANSI string to a wide character UNICODE string.

Now the request has been successful, it is now time to close the HTTP handle.


This function must be called so that all of the handles to be returned from their use in the Internet functions.

Note: InternetCloseHandle is called opposed the the CloseHandle function because it is not a kernel object. This function has the following prototype.

BOOL InternetCloseHandle(HINTERNET hInternet);

This simply suggests that the function is used to close a handle. The function may be implemented as follows.

if(hHttpRequest != NULL)
if(hHttpOpen != NULL)

Note: With the HANDLE type functions, the return value on failure is NULL. For the BOOL type functions, the return value on failure is FALSE.

blog comments powered by Disqus

- A New Toolbar Can Boost Your Web Site Traffi...
- Programming Custom Hardware for Windows
- Developing Embedded Systems - A Tools Introd...
- WAP for Fun and Profit - Part 1 - Basic WML ...
- HTTP Requesting with eVC++ 3.0 on Windows CE...

Watch our Tech Videos 
Dev Articles Forums 
 RSS  Articles
 RSS  Forums
 RSS  All Feeds
Write For Us 
Weekly Newsletter
Developer Updates  
Free Website Content 
Contact Us 
Site Map 
Privacy Policy 

Developer Shed Affiliates


© 2003-2018 by Developer Shed. All rights reserved. DS Cluster - Follow our Sitemap
Popular Web Development Topics
All Web Development Tutorials