纯C++的Socket访问Http封装类 .

 

纯C++的Socket访问Http封装类

1.项目中要使用c++++来访问Web服务器，从网上找了个C++的封装类，其中调用了MFC，在VC2005上用能用，但是移植到VC2003就出问题了，干脆修改成了纯C++的，不敢独享，share之。 2.以下是调用方法：

01.#include "stdafx.h"    
02.#include <iostream>    
03.#include <string>    
04.#include "http/request.h"    
05.   
06.using namespace std;   
07.   
08.int _tmain(int argc, _TCHAR* argv[])   
09.{   
10.    Request myRequest;      //初始化类    
11.    string sHeaderSend;     //定义http头    
12.    string sHeaderReceive;  //返回头    
13.    string sMessage="";     //返回页面内容    
14.    bool IsPost=false;  //是否Post提交    
15.   
16.    int i =myRequest.SendRequest(IsPost, "http://sungard.com", sHeaderSend,   
17.                                 sHeaderReceive, sMessage);   
18.    if (i)   
19.    {      
20.        cout<<"Http头:"<<endl;   
21.        cout<< sHeaderSend <<endl;   
22.        cout<<"响应头"<<endl;   
23.        cout<< sHeaderReceive <<endl;   
24.        cout<<"网页内容"<<endl;   
25.        cout<< sMessage <<endl;   
26.    }else   
27.    {   
28.        cout<<"网络不可到达"<<endl;   
29.    }   
30.    system("pause");   
31.    return 0;   
32.}   

类代码如下

01.//******************************************     
02.//纯C++的socket访问Http封装类     
03.//http://sungard.com     
04.//2011-08-22     
05.//******************************************    
06.  
07.#if !defined(AFX_REQUEST_H__9F2C9BB6_CBA7_40AF_80A4_09A1CE1CE220__INCLUDED_)    
08.#define AFX_REQUEST_H__9F2C9BB6_CBA7_40AF_80A4_09A1CE1CE220__INCLUDED_    
09.  
10.#if _MSC_VER > 1000    
11.#pragma once    
12.#endif // _MSC_VER > 1000    
13.  
14.  
15.#include <stdio.h>    
16.#include <stdlib.h>    
17.#include <string.h>    
18.#include <winsock2.h>    
19.#pragma comment(lib, "WS2_32")      
20.   
21.using namespace std;    
22.#define MEM_BUFFER_SIZE 10     
23.   
24./*     
25.    HTTPRequest: Structure that returns the HTTP headers and message    
26.                    from the request    
27.*/    
28.typedef struct   
29.{     
30.    LPSTR headerSend;                               // Pointer to HTTP header Send      
31.    LPSTR headerReceive;                            // Pointer to HTTP headers Receive     
32.    LPSTR message;                                  // Pointer to the HTTP message      
33.    long messageLength;                             // Length of the message      
34.} HTTPRequest;    
35.   
36./*    
37.    MemBuffer:  Structure used to implement a memory buffer, which is a   
38.                buffer of memory that will grow to hold variable sized   
39.                parts of the HTTP message.    
40.*/   
41.typedef struct   
42.{    
43.    unsigned    char *buffer;    
44.    unsigned    char *position;    
45.    size_t      size;    
46.} MemBuffer;    
47.   
48.   
49.class Request      
50.{    
51.public:    
52.    Request();    
53.    virtual ~Request();    
54.   
55.private:    
56.    void        MemBufferCreate(MemBuffer *b);    
57.    void        MemBufferGrow(MemBuffer *b);    
58.    void        MemBufferAddByte(MemBuffer *b, unsigned char byt);    
59.    void        MemBufferAddBuffer(MemBuffer *b, unsigned char *buffer, size_t size);    
60.    DWORD       GetHostAddress(LPCSTR host);    
61.    void        SendString(SOCKET sock,LPCSTR str);    
62.    BOOL        ValidHostChar(char ch);    
63.    void        ParseURL(string url,LPSTR protocol,int lprotocol, LPSTR host,int lhost,LPSTR request,int lrequest,int *port);    
64.   
65.    int         SendHTTP(string url,LPCSTR headerReceive,BYTE *post, DWORD postLength,HTTPRequest *req);    
66.   
67.public:    
68.    int     SendRequest(bool IsPost, string url, string& psHeaderSend, string& pszHeaderReceive,string& pszMessage);    
69.};    
70.  
71.#endif // !defined(AFX_REQUEST_H__9F2C9BB6_CBA7_40AF_80A4_09A1CE1CE220__INCLUDED_)     
72.Request.cpp  
73.   
74.//******************************************     
75.//纯C++的Socket访问Http封装类     
76.//  
77.//     
78.//******************************************    
79.  
80.  
81.#include "stdafx.h"    
82.#include "Request.h"    
83.#include <string>    
84.#ifdef _DEBUG    
85.#undef THIS_FILE     
86.static char THIS_FILE[]=__FILE__;    
87.#define new DEBUG_NEW    
88.#endif     
89.   
90.   
91.//////////////////////////////////////////////////////////////////////     
92.// Construction/Destruction     
93.//////////////////////////////////////////////////////////////////////     
94.   
95.Request::Request()    
96.{    
97.   
98.}    
99.   
100.Request::~Request()    
101.{    
102.   
103.}    
104.   
105.   
106.//*******************************************************************************************************     
107.//MemBufferCreate:      
108.//                  Passed a MemBuffer structure, will allocate a memory buffer      
109.//                   of MEM_BUFFER_SIZE.  This buffer can then grow as needed.     
110.//*******************************************************************************************************     
111.void Request::MemBufferCreate(MemBuffer *b)    
112.{    
113.    b->size = MEM_BUFFER_SIZE;    
114.    b->buffer =(unsigned    char *) malloc( b->size );    
115.    b->position = b->buffer;    
116.}    
117.   
118.//*******************************************************************************************************     
119.// MemBufferGrow:       
120.//                  Double the size of the buffer that was passed to this function.      
121.//*******************************************************************************************************     
122.void Request::MemBufferGrow(MemBuffer *b)    
123.{    
124.    size_t sz;    
125.    sz = b->position - b->buffer;    
126.    b->size = b->size *2;    
127.    b->buffer =(unsigned    char *) realloc(b->buffer,b->size);    
128.    b->position = b->buffer + sz;   // readjust current position     
129.}    
130.   
131.//*******************************************************************************************************     
132.// MemBufferAddByte:      
133.//                  Add a single byte to the memory buffer, grow if needed.     
134.//*******************************************************************************************************     
135.void Request::MemBufferAddByte(MemBuffer *b,unsigned char byt)    
136.{    
137.    if( (size_t)(b->position-b->buffer) >= b->size )    
138.        MemBufferGrow(b);    
139.   
140.    *(b->position++) = byt;    
141.}    
142.   
143.//*******************************************************************************************************     
144.// MemBufferAddBuffer:     
145.//                  Add a range of bytes to the memory buffer, grow if needed.     
146.//*******************************************************************************************************     
147.void Request::MemBufferAddBuffer(MemBuffer *b,    
148.                                 unsigned char *buffer, size_t size)    
149.{    
150.    while( ((size_t)(b->position-b->buffer)+size) >= b->size )    
151.        MemBufferGrow(b);    
152.   
153.    memcpy(b->position,buffer,size);    
154.    b->position+=size;    
155.}    
156.   
157.//*******************************************************************************************************     
158.// GetHostAddress:      
159.//                  Resolve using DNS or similar(WINS,etc) the IP      
160.//                   address for a domain name such as www.wdj.com.      
161.//*******************************************************************************************************     
162.DWORD Request::GetHostAddress(LPCSTR host)    
163.{    
164.    struct hostent *phe;    
165.    char *p;    
166.   
167.    phe = gethostbyname( host );    
168.   
169.    if(phe==NULL)    
170.        return 0;    
171.   
172.    p = *phe->h_addr_list;    
173.    return *((DWORD*)p);    
174.}    
175.   
176.//*******************************************************************************************************     
177.// SendString:      
178.//                  Send a string(null terminated) over the specified socket.     
179.//*******************************************************************************************************     
180.void Request::SendString(SOCKET sock,LPCSTR str)    
181.{    
182.    send(sock,str,strlen(str),0);    
183.}    
184.   
185.//*******************************************************************************************************     
186.// ValidHostChar:      
187.//                  Return TRUE if the specified character is valid     
188.//                      for a host name, i.e. A-Z or 0-9 or -.:      
189.//*******************************************************************************************************     
190.BOOL Request::ValidHostChar(char ch)    
191.{    
192.    return( isalpha(ch) || isdigit(ch)    
193.        || ch=='-' || ch=='.' || ch==':' );    
194.}    
195.   
196.   
197.//*******************************************************************************************************     
198.// ParseURL:      
199.//                  Used to break apart a URL such as      
200.//                      http://www.localhost.com:80/TestPost.htm into protocol, port, host and request.     
201.//*******************************************************************************************************     
202.void Request::ParseURL(string url,LPSTR protocol,int lprotocol,LPSTR host,int lhost,LPSTR request,int lrequest,int *port)    
203.{    
204.    char *work,*ptr,*ptr2;    
205.   
206.    *protocol = *host = *request = 0;    
207.    *port=80;    
208.   
209.    work = strdup(url.c_str());    
210.    strupr(work);    
211.   
212.    ptr = strchr(work,':');                         // find protocol if any     
213.    if(ptr!=NULL)    
214.    {    
215.        *(ptr++) = 0;    
216.        lstrcpyn(protocol,work,lprotocol);    
217.    }    
218.    else   
219.    {    
220.        lstrcpyn(protocol,"HTTP",lprotocol);    
221.        ptr = work;    
222.    }    
223.   
224.    if( (*ptr=='/') && (*(ptr+1)=='/') )            // skip past opening /'s      
225.        ptr+=2;    
226.   
227.    ptr2 = ptr;                                     // find host     
228.    while( ValidHostChar(*ptr2) && *ptr2 )    
229.        ptr2++;    
230.   
231.    *ptr2=0;    
232.    lstrcpyn(host,ptr,lhost);    
233.   
234.    lstrcpyn(request,url.c_str() + (ptr2-work),lrequest);   // find the request     
235.   
236.    ptr = strchr(host,':');                         // find the port number, if any     
237.    if(ptr!=NULL)    
238.    {    
239.        *ptr=0;    
240.        *port = atoi(ptr+1);    
241.    }    
242.   
243.    free(work);    
244.}    
245.   
246.//*******************************************************************************************************     
247.// SendHTTP:      
248.//                  Main entry point for this code.       
249.//                    url           - The URL to GET/POST to/from.     
250.//                    headerSend        - Headers to be sent to the server.     
251.//                    post          - Data to be posted to the server, NULL if GET.     
252.//                    postLength    - Length of data to post.     
253.//                    req           - Contains the message and headerSend sent by the server.     
254.//     
255.//                    returns 1 on failure, 0 on success.     
256.//*******************************************************************************************************     
257.int Request::SendHTTP(string url,LPCSTR headerReceive,BYTE *post,    
258.                      DWORD postLength,HTTPRequest *req)    
259.{    
260.    WSADATA         WsaData;    
261.    SOCKADDR_IN     sin;    
262.    SOCKET          sock;    
263.    char            buffer[512];    
264.    char            protocol[20],host[256],request[1024];    
265.    int             l,port,chars,err;    
266.    MemBuffer       headersBuffer,messageBuffer;    
267.    char            headerSend[1024];    
268.    BOOL            done;    
269.   
270.   
271.   
272.   
273.    ParseURL(url,protocol,sizeof(protocol),host,sizeof(host),       // Parse the URL     
274.        request,sizeof(request),&port);    
275.    if(strcmp(protocol,"HTTP"))    
276.        return 1;    
277.   
278.    err = WSAStartup (0x0101, &WsaData);                            // Init Winsock     
279.    if(err!=0)    
280.        return 1;    
281.   
282.    sock = socket (AF_INET, SOCK_STREAM, 0);    
283.    //if (socket == INVALID_SOCKET)     
284.    if (sock == INVALID_SOCKET)    
285.    {    
286.        return 1;    
287.    }    
288.   
289.    sin.sin_family = AF_INET;                                       //Connect to web sever     
290.    sin.sin_port = htons( (unsigned short)port );    
291.    sin.sin_addr.s_addr = GetHostAddress(host);    
292.   
293.    if( connect (sock,(LPSOCKADDR)&sin, sizeof(SOCKADDR_IN) ) )    
294.    {    
295.   
296.        return 1;    
297.    }    
298.   
299.   
300.    if( !*request )    
301.        lstrcpyn(request,"/",sizeof(request));    
302.   
303.    if( post == NULL )    
304.    {    
305.        SendString(sock,"GET ");    
306.        strcpy(headerSend, "GET ");    
307.    }    
308.    else     
309.    {    
310.        SendString(sock,"POST ");    
311.        strcpy(headerSend, "POST ");    
312.    }    
313.    SendString(sock,request);    
314.    strcat(headerSend, request);    
315.   
316.    SendString(sock," HTTP/1.0/r/n");    
317.    strcat(headerSend, " HTTP/1.0/r/n");    
318.   
319.    SendString(sock,"Accept: image/gif, image/x-xbitmap,"   
320.        " image/jpeg, image/pjpeg, application/vnd.ms-excel,"   
321.        " application/msword, application/vnd.ms-powerpoint,"   
322.        " */*/r/n");    
323.    strcat(headerSend, "Accept: image/gif, image/x-xbitmap,"   
324.        " image/jpeg, image/pjpeg, application/vnd.ms-excel,"   
325.        " application/msword, application/vnd.ms-powerpoint,"   
326.        " */*/r/n");    
327.   
328.    SendString(sock,"Accept-Language: en-us/r/n");    
329.    strcat(headerSend, "Accept-Language: en-us/r/n");    
330.   
331.    SendString(sock,"Accept-Encoding: gzip, default/r/n");    
332.    strcat(headerSend, "Accept-Encoding: gzip, default/r/n");    
333.   
334.    SendString(sock,"User-Agent: sungard/4.0/r/n");    
335.    strcat(headerSend, "User-Agent: sungard/4.0/r/n");    
336.   
337.    if(postLength)    
338.    {    
339.        sprintf(buffer,"Content-Length: %ld/r/n",postLength);    
340.        SendString(sock,buffer);    
341.        strcat(headerSend, buffer);    
342.    }    
343.    //SendString(sock,"Cookie: mycookie=blablabla/r/n");     
344.    //  printf("Cookie: mycookie=blablabla/r/n");     
345.    SendString(sock,"Host: ");    
346.    strcat(headerSend, "Host: ");    
347.   
348.    SendString(sock,host);    
349.    strcat(headerSend, host);    
350.   
351.    SendString(sock,"/r/n");    
352.    strcat(headerSend, "/r/n");    
353.   
354.    if( (headerReceive!=NULL) && *headerReceive )    
355.    {    
356.        SendString(sock,headerReceive);    
357.        strcat(headerSend, headerReceive);    
358.    }    
359.   
360.    SendString(sock,"/r/n");                                // Send a blank line to signal end of HTTP headerReceive     
361.    strcat(headerSend, "/r/n");    
362.   
363.    if( (post!=NULL) && postLength )    
364.    {    
365.        send(sock,(const char*)post,postLength,0);    
366.        post[postLength]    = '/0';    
367.   
368.        strcat(headerSend, (const char*)post);    
369.    }    
370.   
371.    //strcpy(req->headerSend, headerSend);     
372.    req->headerSend     = (char*) malloc( sizeof(char*) * strlen(headerSend));    
373.    strcpy(req->headerSend, (char*) headerSend );    
374.   
375.   
376.    MemBufferCreate(&headersBuffer );    
377.    chars = 0;    
378.    done = FALSE;    
379.   
380.    while(!done)    
381.    {    
382.        l = recv(sock,buffer,1,0);    
383.        if(l<0)    
384.            done=TRUE;    
385.   
386.        switch(*buffer)    
387.        {    
388.        case '/r':    
389.            break;    
390.        case '/n':    
391.            if(chars==0)    
392.                done = TRUE;    
393.            chars=0;    
394.            break;    
395.        default:    
396.            chars++;    
397.            break;    
398.        }    
399.   
400.        MemBufferAddByte(&headersBuffer,*buffer);    
401.    }    
402.   
403.    req->headerReceive  = (char*) headersBuffer.buffer;    
404.    *(headersBuffer.position) = 0;    
405.   
406.   
407.   
408.    MemBufferCreate(&messageBuffer);                            // Now read the HTTP body     
409.   
410.    do   
411.    {    
412.        l = recv(sock,buffer,sizeof(buffer)-1,0);    
413.        if(l<0)    
414.            break;    
415.        *(buffer+l)=0;    
416.        MemBufferAddBuffer(&messageBuffer, (unsigned char*)&buffer, l);    
417.    } while(l>0);    
418.    *messageBuffer.position = 0;    
419.    req->message = (char*) messageBuffer.buffer;    
420.    req->messageLength = (messageBuffer.position - messageBuffer.buffer);    
421.   
422.   
423.    closesocket(sock);                                          // Cleanup     
424.   
425.    return 0;    
426.}    
427.   
428.   
429.//*******************************************************************************************************     
430.// SendRequest     
431.//     
432.//*******************************************************************************************************     
433.int Request::SendRequest(bool IsPost, string url, string& psHeaderSend, string& psHeaderReceive, string& psMessage)    
434.{    
435.    HTTPRequest         req;    
436.    int                 i,rtn;    
437.    LPSTR               buffer;    
438.   
439.    req.headerSend                          = NULL;    
440.    req.headerReceive                       = NULL;    
441.    req.message                             = NULL;    
442.   
443.    //Read in arguments     
444.   
445.   
446.    if(IsPost)    
447.    {                                                   /* POST */    
448.        i       = psHeaderSend.length();    
449.        buffer  = (char*) malloc(i+1);    
450.        strcpy(buffer, psHeaderSend.c_str());    
451.   
452.        rtn             = SendHTTP( url,    
453.            "Content-Type: application/x-www-form-urlencoded/r/n",    
454.            (unsigned char*)buffer,    
455.            i,    
456.            &req);    
457.   
458.        free(buffer);    
459.    }    
460.    else/* GET */   
461.    {    
462.        rtn = SendHTTP(url,NULL,NULL,0,&req);    
463.    }    
464.   
465.   
466.   
467.    if(!rtn)                                            //Output message and/or headerSend      
468.    {    
469.        psHeaderSend        = req.headerSend;    
470.        psHeaderReceive     = req.headerReceive;    
471.        psMessage           = req.message;    
472.   
473.   
474.        free(req.headerSend);    
475.        free(req.headerReceive);    
476.        free(req.message);    
477.        return 1;    
478.    }    
479.    else   
480.    {    
481.        return 0;    
482.    }    
483.}   
//******************************************  
//纯C++的socket访问Http封装类， 
////25  
//******************************************  
 
#if !defined(AFX_REQUEST_H__9F2C9BB6_CBA7_40AF_80A4_09A1CE1CE220__INCLUDED_)  
#define AFX_REQUEST_H__9F2C9BB6_CBA7_40AF_80A4_09A1CE1CE220__INCLUDED_  
 
#if _MSC_VER > 1000  
#pragma once  
#endif // _MSC_VER > 1000  
 
 
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <winsock2.h>  
#pragma comment(lib, "WS2_32")   
 
using namespace std;  
#define MEM_BUFFER_SIZE 10  
 
/*   
    HTTPRequest: Structure that returns the HTTP headers and message  
                    from the request  
*/  
typedef struct 
{   
    LPSTR headerSend;                               // Pointer to HTTP header Send   
    LPSTR headerReceive;                            // Pointer to HTTP headers Receive  
    LPSTR message;                                  // Pointer to the HTTP message   
    long messageLength;                             // Length of the message   
} HTTPRequest;  
 
/*   
    MemBuffer:  Structure used to implement a memory buffer, which is a  
                buffer of memory that will grow to hold variable sized  
                parts of the HTTP message.   
*/ 
typedef struct 
{  
    unsigned    char *buffer;  
    unsigned    char *position;  
    size_t      size;  
} MemBuffer;  
 
 
class Request    
{  
public:  
    Request();  
    virtual ~Request();  
 
private:  
    void        MemBufferCreate(MemBuffer *b);  
    void        MemBufferGrow(MemBuffer *b);  
    void        MemBufferAddByte(MemBuffer *b, unsigned char byt);  
    void        MemBufferAddBuffer(MemBuffer *b, unsigned char *buffer, size_t size);  
    DWORD       GetHostAddress(LPCSTR host);  
    void        SendString(SOCKET sock,LPCSTR str);  
    BOOL        ValidHostChar(char ch);  
    void        ParseURL(string url,LPSTR protocol,int lprotocol, LPSTR host,int lhost,LPSTR request,int lrequest,int *port);  
 
    int         SendHTTP(string url,LPCSTR headerReceive,BYTE *post, DWORD postLength,HTTPRequest *req);  
 
public:  
    int     SendRequest(bool IsPost, string url, string& psHeaderSend, string& pszHeaderReceive,string& pszMessage);  
};  
 
#endif // !defined(AFX_REQUEST_H__9F2C9BB6_CBA7_40AF_80A4_09A1CE1CE220__INCLUDED_)  
Request.cpp
 
//******************************************  
//纯C++的Socket访问Http封装类 
////-25  
//******************************************  
 
 
#include "stdafx.h"  
#include "Request.h"  
#include <string>  
#ifdef _DEBUG  
#undef THIS_FILE  
static char THIS_FILE[]=__FILE__;  
#define new DEBUG_NEW  
#endif  
 
 
//////////////////////////////////////////////////////////////////////  
// Construction/Destruction  
//////////////////////////////////////////////////////////////////////  
 
Request::Request()  
{  
 
}  
 
Request::~Request()  
{  
 
}  
 
 
//*******************************************************************************************************  
//MemBufferCreate:   
//                  Passed a MemBuffer structure, will allocate a memory buffer   
//                   of MEM_BUFFER_SIZE.  This buffer can then grow as needed.  
//*******************************************************************************************************  
void Request::MemBufferCreate(MemBuffer *b)  
{  
    b->size = MEM_BUFFER_SIZE;  
    b->buffer =(unsigned    char *) malloc( b->size );  
    b->position = b->buffer;  
}  
 
//*******************************************************************************************************  
// MemBufferGrow:    
//                  Double the size of the buffer that was passed to this function.   
//*******************************************************************************************************  
void Request::MemBufferGrow(MemBuffer *b)  
{  
    size_t sz;  
    sz = b->position - b->buffer;  
    b->size = b->size *2;  
    b->buffer =(unsigned    char *) realloc(b->buffer,b->size);  
    b->position = b->buffer + sz;   // readjust current position  
}  
 
//*******************************************************************************************************  
// MemBufferAddByte:   
//                  Add a single byte to the memory buffer, grow if needed.  
//*******************************************************************************************************  
void Request::MemBufferAddByte(MemBuffer *b,unsigned char byt)  
{  
    if( (size_t)(b->position-b->buffer) >= b->size )  
        MemBufferGrow(b);  
 
    *(b->position++) = byt;  
}  
 
//*******************************************************************************************************  
// MemBufferAddBuffer:  
//                  Add a range of bytes to the memory buffer, grow if needed.  
//*******************************************************************************************************  
void Request::MemBufferAddBuffer(MemBuffer *b,  
                                 unsigned char *buffer, size_t size)  
{  
    while( ((size_t)(b->position-b->buffer)+size) >= b->size )  
        MemBufferGrow(b);  
 
    memcpy(b->position,buffer,size);  
    b->position+=size;  
}  
 
//*******************************************************************************************************  
// GetHostAddress:   
//                  Resolve using DNS or similar(WINS,etc) the IP   
//                   address for a domain name such as www.wdj.com.   
//*******************************************************************************************************  
DWORD Request::GetHostAddress(LPCSTR host)  
{  
    struct hostent *phe;  
    char *p;  
 
    phe = gethostbyname( host );  
 
    if(phe==NULL)  
        return 0;  
 
    p = *phe->h_addr_list;  
    return *((DWORD*)p);  
}  
 
//*******************************************************************************************************  
// SendString:   
//                  Send a string(null terminated) over the specified socket.  
//*******************************************************************************************************  
void Request::SendString(SOCKET sock,LPCSTR str)  
{  
    send(sock,str,strlen(str),0);  
}  
 
//*******************************************************************************************************  
// ValidHostChar:   
//                  Return TRUE if the specified character is valid  
//                      for a host name, i.e. A-Z or 0-9 or -.:   
//*******************************************************************************************************  
BOOL Request::ValidHostChar(char ch)  
{  
    return( isalpha(ch) || isdigit(ch)  
        || ch=='-' || ch=='.' || ch==':' );  
}  
 
 
//*******************************************************************************************************  
// ParseURL:   
//                  Used to break apart a URL such as   
//                      http://www.localhost.com:80/TestPost.htm into protocol, port, host and request.  
//*******************************************************************************************************  
void Request::ParseURL(string url,LPSTR protocol,int lprotocol,LPSTR host,int lhost,LPSTR request,int lrequest,int *port)  
{  
    char *work,*ptr,*ptr2;  
 
    *protocol = *host = *request = 0;  
    *port=80;  
 
    work = strdup(url.c_str());  
    strupr(work);  
 
    ptr = strchr(work,':');                         // find protocol if any  
    if(ptr!=NULL)  
    {  
        *(ptr++) = 0;  
        lstrcpyn(protocol,work,lprotocol);  
    }  
    else 
    {  
        lstrcpyn(protocol,"HTTP",lprotocol);  
        ptr = work;  
    }  
 
    if( (*ptr=='/') && (*(ptr+1)=='/') )            // skip past opening /'s   
        ptr+=2;  
 
    ptr2 = ptr;                                     // find host  
    while( ValidHostChar(*ptr2) && *ptr2 )  
        ptr2++;  
 
    *ptr2=0;  
    lstrcpyn(host,ptr,lhost);  
 
    lstrcpyn(request,url.c_str() + (ptr2-work),lrequest);   // find the request  
 
    ptr = strchr(host,':');                         // find the port number, if any  
    if(ptr!=NULL)  
    {  
        *ptr=0;  
        *port = atoi(ptr+1);  
    }  
 
    free(work);  
}  
 
//*******************************************************************************************************  
// SendHTTP:   
//                  Main entry point for this code.    
//                    url           - The URL to GET/POST to/from.  
//                    headerSend        - Headers to be sent to the server.  
//                    post          - Data to be posted to the server, NULL if GET.  
//                    postLength    - Length of data to post.  
//                    req           - Contains the message and headerSend sent by the server.  
//  
//                    returns 1 on failure, 0 on success.  
//*******************************************************************************************************  
int Request::SendHTTP(string url,LPCSTR headerReceive,BYTE *post,  
                      DWORD postLength,HTTPRequest *req)  
{  
    WSADATA         WsaData;  
    SOCKADDR_IN     sin;  
    SOCKET          sock;  
    char            buffer[512];  
    char            protocol[20],host[256],request[1024];  
    int             l,port,chars,err;  
    MemBuffer       headersBuffer,messageBuffer;  
    char            headerSend[1024];  
    BOOL            done;  
 
 
 
 
    ParseURL(url,protocol,sizeof(protocol),host,sizeof(host),       // Parse the URL  
        request,sizeof(request),&port);  
    if(strcmp(protocol,"HTTP"))  
        return 1;  
 
    err = WSAStartup (0x0101, &WsaData);                            // Init Winsock  
    if(err!=0)  
        return 1;  
 
    sock = socket (AF_INET, SOCK_STREAM, 0);  
    //if (socket == INVALID_SOCKET)  
    if (sock == INVALID_SOCKET)  
    {  
        return 1;  
    }  
 
    sin.sin_family = AF_INET;                                       //Connect to web sever  
    sin.sin_port = htons( (unsigned short)port );  
    sin.sin_addr.s_addr = GetHostAddress(host);  
 
    if( connect (sock,(LPSOCKADDR)&sin, sizeof(SOCKADDR_IN) ) )  
    {  
 
        return 1;  
    }  
 
 
    if( !*request )  
        lstrcpyn(request,"/",sizeof(request));  
 
    if( post == NULL )  
    {  
        SendString(sock,"GET ");  
        strcpy(headerSend, "GET ");  
    }  
    else   
    {  
        SendString(sock,"POST ");  
        strcpy(headerSend, "POST ");  
    }  
    SendString(sock,request);  
    strcat(headerSend, request);  
 
    SendString(sock," HTTP/1.0/r/n");  
    strcat(headerSend, " HTTP/1.0/r/n");  
 
    SendString(sock,"Accept: image/gif, image/x-xbitmap," 
        " image/jpeg, image/pjpeg, application/vnd.ms-excel," 
        " application/msword, application/vnd.ms-powerpoint," 
        " */*/r/n");  
    strcat(headerSend, "Accept: image/gif, image/x-xbitmap," 
        " image/jpeg, image/pjpeg, application/vnd.ms-excel," 
        " application/msword, application/vnd.ms-powerpoint," 
        " */*/r/n");  
 
    SendString(sock,"Accept-Language: en-us/r/n");  
    strcat(headerSend, "Accept-Language: en-us/r/n");  
 
    SendString(sock,"Accept-Encoding: gzip, default/r/n");  
    strcat(headerSend, "Accept-Encoding: gzip, default/r/n");  
 
    SendString(sock,"User-Agent: sungard/4.0/r/n");  
    strcat(headerSend, "User-Agent: sungard/4.0/r/n");  
 
    if(postLength)  
    {  
        sprintf(buffer,"Content-Length: %ld/r/n",postLength);  
        SendString(sock,buffer);  
        strcat(headerSend, buffer);  
    }  
    //SendString(sock,"Cookie: mycookie=blablabla/r/n");  
    //  printf("Cookie: mycookie=blablabla/r/n");  
    SendString(sock,"Host: ");  
    strcat(headerSend, "Host: ");  
 
    SendString(sock,host);  
    strcat(headerSend, host);  
 
    SendString(sock,"/r/n");  
    strcat(headerSend, "/r/n");  
 
    if( (headerReceive!=NULL) && *headerReceive )  
    {  
        SendString(sock,headerReceive);  
        strcat(headerSend, headerReceive);  
    }  
 
    SendString(sock,"/r/n");                                // Send a blank line to signal end of HTTP headerReceive  
    strcat(headerSend, "/r/n");  
 
    if( (post!=NULL) && postLength )  
    {  
        send(sock,(const char*)post,postLength,0);  
        post[postLength]    = '/0';  
 
        strcat(headerSend, (const char*)post);  
    }  
 
    //strcpy(req->headerSend, headerSend);  
    req->headerSend     = (char*) malloc( sizeof(char*) * strlen(headerSend));  
    strcpy(req->headerSend, (char*) headerSend );  
 
 
    MemBufferCreate(&headersBuffer );  
    chars = 0;  
    done = FALSE;  
 
    while(!done)  
    {  
        l = recv(sock,buffer,1,0);  
        if(l<0)  
            done=TRUE;  
 
        switch(*buffer)  
        {  
        case '/r':  
            break;  
        case '/n':  
            if(chars==0)  
                done = TRUE;  
            chars=0;  
            break;  
        default:  
            chars++;  
            break;  
        }  
 
        MemBufferAddByte(&headersBuffer,*buffer);  
    }  
 
    req->headerReceive  = (char*) headersBuffer.buffer;  
    *(headersBuffer.position) = 0;  
 
 
 
    MemBufferCreate(&messageBuffer);                            // Now read the HTTP body  
 
    do 
    {  
        l = recv(sock,buffer,sizeof(buffer)-1,0);  
        if(l<0)  
            break;  
        *(buffer+l)=0;  
        MemBufferAddBuffer(&messageBuffer, (unsigned char*)&buffer, l);  
    } while(l>0);  
    *messageBuffer.position = 0;  
    req->message = (char*) messageBuffer.buffer;  
    req->messageLength = (messageBuffer.position - messageBuffer.buffer);  
 
 
    closesocket(sock);                                          // Cleanup  
 
    return 0;  
}  
 
 
//*******************************************************************************************************  
// SendRequest  
//  
//*******************************************************************************************************  
int Request::SendRequest(bool IsPost, string url, string& psHeaderSend, string& psHeaderReceive, string& psMessage)  
{  
    HTTPRequest         req;  
    int                 i,rtn;  
    LPSTR               buffer;  
 
    req.headerSend                          = NULL;  
    req.headerReceive                       = NULL;  
    req.message                             = NULL;  
 
    //Read in arguments  
 
 
    if(IsPost)  
    {                                                   /* POST */  
        i       = psHeaderSend.length();  
        buffer  = (char*) malloc(i+1);  
        strcpy(buffer, psHeaderSend.c_str());  
 
        rtn             = SendHTTP( url,  
            "Content-Type: application/x-www-form-urlencoded/r/n",  
            (unsigned char*)buffer,  
            i,  
            &req);  
 
        free(buffer);  
    }  
    else/* GET */ 
    {  
        rtn = SendHTTP(url,NULL,NULL,0,&req);  
    }  
 
 
 
    if(!rtn)                                            //Output message and/or headerSend   
    {  
        psHeaderSend        = req.headerSend;  
        psHeaderReceive     = req.headerReceive;  
        psMessage           = req.message;  
 
 
        free(req.headerSend);  
        free(req.headerReceive);  
        free(req.message);  
        return 1;  
    }  
    else 
    {  
        return 0;  
    }  
}