winhttp 与wininet的区别(一)

wininet为http、ftp提供了统一的函数集，也就是win32 api接口，简化了http、ftp协议的编程，可轻松的将Internet集成到应用程序中。

winhttp工作与应用层，提供了http协议的实现，winhttp替换了wininet中的http部分，更加稳定健壮，而且还为http服务器端开发提供了库函数。

winnet封装层次太高，不能进行底层控制。

wininet = http,ftp....

winhttp = http

实现http访问的流程

1 首先需要打开一个Session获得一个HINTERNET session 句柄

2 然后使用这个Session句柄与服务器连接得到一个HINTERNET connect句柄

3 然后使用这个connect句柄来打开http请求得到一个HINTERNET request句柄

4 这时我们就可以使用request句柄来发送数据与读取从服务器返回的数据

5 最后依次关闭request，connect ,session句柄

 

实例

首先需要提供字符串转换的函数，以接收网络来的utf8编码数据，然后将给定的url头解析出来，解析出服务器的地址，然后进行http的请求以及解析。

字符串转换函数：

wchar_t * ANSIToUnicode( const char* str )

{

     int textlen ;

     wchar_t * result;

     textlen = MultiByteToWideChar( CP_ACP, 0, str,-1, NULL,0 );

     result = (wchar_t *)malloc((textlen+1)*sizeof(wchar_t));

     memset(result,0,(textlen+1)*sizeof(wchar_t));

     MultiByteToWideChar(CP_ACP, 0,str,-1,(LPWSTR)result,textlen );

     return result;

}

  

char * UnicodeToANSI( const wchar_t* str )

{

     char* result;

     int textlen;

     textlen = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );

     result =(char *)malloc((textlen+1)*sizeof(char));

     memset( result, 0, sizeof(char) * ( textlen + 1 ) );

     WideCharToMultiByte( CP_ACP, 0, str, -1, result, textlen, NULL, NULL );

     return result;

}

  

wchar_t * UTF8ToUnicode( const char* str )

{

     int textlen ;

     wchar_t * result;

     textlen = MultiByteToWideChar( CP_UTF8, 0, str,-1, NULL,0 );

     result = (wchar_t *)malloc((textlen+1)*sizeof(wchar_t));

     memset(result,0,(textlen+1)*sizeof(wchar_t));

     MultiByteToWideChar(CP_UTF8, 0,str,-1,(LPWSTR)result,textlen );

     return result;

}

  

char * UnicodeToUTF8( const wchar_t* str )

{

     char* result;

     int textlen;

     textlen = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL );

     result =(char *)malloc((textlen+1)*sizeof(char));

     memset(result, 0, sizeof(char) * ( textlen + 1 ) );

     WideCharToMultiByte( CP_UTF8, 0, str, -1, result, textlen, NULL, NULL );

     return result;

}

/*宽字符转换为多字符Unicode - ANSI*/

char* w2m(const wchar_t* wcs)

{

      int len;

      char* buf;

      len =wcstombs(NULL,wcs,0);

      if (len == 0)

          return NULL;

      buf = (char *)malloc(sizeof(char)*(len+1));

      memset(buf, 0, sizeof(char) *(len+1));

      len =wcstombs(buf,wcs,len+1);

      return buf;

}

/*多字符转换为宽字符ANSI - Unicode*/

wchar_t* m2w(const char* mbs)

{

      int len;

      wchar_t* buf;

      len =mbstowcs(NULL,mbs,0);

      if (len == 0)

          return NULL;

      buf = (wchar_t *)malloc(sizeof(wchar_t)*(len+1));

      memset(buf, 0, sizeof(wchar_t) *(len+1));

      len =mbstowcs(buf,mbs,len+1);

      return buf;

}

  

char* ANSIToUTF8(const char* str)

{

     return UnicodeToUTF8(ANSIToUnicode(str));

}

  

char* UTF8ToANSI(const char* str)

{

     return UnicodeToANSI(UTF8ToUnicode(str));

}

url地址解析：

class CrackedUrl

{

             int m_scheme;

             std::string m_host;

             int m_port;

             std::string m_path;

public:

 CrackedUrl(LPCWSTR url)
{
        URL_COMPONENTS uc = { 0};
        uc.dwStructSize = sizeof(uc);

        const DWORD BUF_LEN = 256;

        WCHAR host[BUF_LEN];
        uc.lpszHostName = host;
        uc.dwHostNameLength = BUF_LEN;

        WCHAR path[BUF_LEN];
        uc.lpszUrlPath = path;
        uc.dwUrlPathLength = BUF_LEN;

        WCHAR extra[BUF_LEN];
        uc.lpszExtraInfo = extra;
        uc.dwExtraInfoLength = BUF_LEN;

#ifdef USE_WINHTTP
        if (!WinHttpCrackUrl(url, 0, ICU_ESCAPE, &uc)) {
            printf("Error:WinHttpCrackUrl failed!\n");
        }

#else
        if (!InternetCrackUrl(url, 0, ICU_ESCAPE, &uc)) {
            printf("Error:InternetCrackUrl failed!\n");
        }
#endif
        m_scheme = uc.nScheme;
        m_host = host;
        m_port = uc.nPort;
        m_path = path;
    }

    int GetScheme() const
    {
        return m_scheme;
    }

    LPCWSTR GetHostName() const
    {
        return m_host;
    }

    int GetPort() const
    {
        return m_port;
    }

    LPCWSTR GetPath() const
    {
        return m_path;
    }

    static CStringA UrlEncode(const char* p)
    {
        if (p == 0) {
            return CStringA();
        }

        CStringA buf;

        for (;;) {
            int ch = (BYTE) (*(p++));
            if (ch == '\0') {
                break;
            }

            if (isalnum(ch) || ch == '_' || ch == '-' || ch == '.') {
                buf += (char)ch;
            }
            else if (ch == ' ') {
                buf += '+';
            }
            else {
                char c[16];
                wsprintfA(c, "%%%02X", ch);
                buf += c;
            }
        }

        return buf;
    }
};