Скачивание из интернета

//------------------------------------------------------------------------------
#include <winsock>
#include <stdio.h>
#include <string>
#include <fstream>
#include <strstream>
//------------------------------------------------------------------------------
int get_addr(char *host_name)
{
    int res = -1;
 
    HOSTENT *phe = gethostbyname(host_name);
    if (phe)
        for (int i = 0; i < 4; i++)
            ((BYTE *)&res)[i] = phe->h_addr_list[0][i];
 
    return res;
}
//------------------------------------------------------------------------------
static const std::string base64_chars =
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
             "abcdefghijklmnopqrstuvwxyz"
             "0123456789+/";
 
std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
  std::string ret;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];
 
  while (in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);
    if (i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;
 
      for(i = 0; (i <4) ; i++)
        ret += base64_chars[char_array_4[i]];
      i = 0;
    }
  }
 
  if (i)
  {
    for(j = i; j < 3; j++)
      char_array_3[j] = '\0';
 
    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;
 
    for (j = 0; (j < i + 1); j++)
      ret += base64_chars[char_array_4[j]];
 
    while((i++ < 3))
      ret += '=';
 
  }
 
  return ret;
 
}
//------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    WSADATA wsa_data;
    if (WSAStartup(0x101, &wsa_data))
    {
        printf("WSAStartup error (%i)\n", WSAGetLastError());
        system("pause");
        return -1;
    }
 
    if (wsa_data.wVersion != 0x101)
    {
        printf("Bad WSA version (%i)\n", wsa_data.wVersion);
        system("pause");
        return -1;
    }
 
    SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (s == INVALID_SOCKET)
    {
        printf("socket error (%i)\n", WSAGetLastError());
        system("pause");
        return -1;
    }
 
    int use_host_name;
    char host_name[256];
    char host_ip[256];
    int host_port;
    char doc[256];
 
    printf("use_host_name (0 for host_ip or 1 for host_name): ");
    scanf("%i", &use_host_name);
 
    if (use_host_name)
    {
        printf("host_name: ");
        scanf("%s", host_name);
    }
    else
    {
        printf("host_ip: ");
        scanf("%s", host_ip);
    }
 
    printf("host_port: ");
    scanf("%i", &host_port);
 
    printf("doc (for example /index.htm or /): ");
    scanf("%s", doc);
 
    int use_proxy;
    char proxy_ip[256];
    int proxy_port;
    char proxy_login[256];
    char proxy_password[256];
 
    printf("use_proxy (0 or 1): ");
    scanf("%i", &use_proxy);
 
    if (use_proxy)
    {
        printf("proxy_ip: ");
        scanf("%s", proxy_ip);
 
        printf("proxy_port: ");
        scanf("%i", &proxy_port);
 
        printf("proxy_login: ");
        scanf("%s", proxy_login);
 
        printf("proxy_password: ");
        scanf("%s", proxy_password);
    }
 
    SOCKADDR_IN sa;
    sa.sin_family = AF_INET;
    sa.sin_port = htons(use_proxy? proxy_port : host_port);
    sa.sin_addr.S_un.S_addr = use_proxy? inet_addr(proxy_ip) : (use_host_name? get_addr(host_name) : inet_addr(host_ip));
 
    printf("wait for server...\n");
 
    while (true)
    {
        int connect_res = connect(s, (SOCKADDR *)&sa, sizeof(sa));
        if (!connect_res) break;
 
        Sleep(250);
    }
 
    printf("connected\n");
 
    std::strstream message;
 
    message <<
    "GET http://" << (use_host_name? host_name : host_ip) << ":" << host_port << doc << " HTTP/1.1\r\n"
    "Host: " << (use_host_name? host_name : host_ip) << ":" << host_port << "\r\n";
 
    if (use_proxy)
    {
        std::string _authentication = std::string() + proxy_login + ":" + proxy_password;
        std::string authentication = base64_encode(_authentication.c_str(), _authentication.size());
 
        message <<
        "Proxy-Authorization: Basic " << authentication << "\r\n";
    }
 
    message <<
    "Connection: Close\r\n"
    "\r\n";
 
    std::ofstream _os("to_server", std::ios::binary);
    _os.write(message.str(), message.pcount());
    _os.close();
 
    if (send(s, message.str(), message.pcount(), 0) == SOCKET_ERROR)
    {
        printf("send error (%i)\n", WSAGetLastError());
        system("pause");
        return -1;
    }
 
    char buffer[100000];
    int buffer_size = sizeof(buffer);
    buffer_size = recv(s, buffer, buffer_size, 0);
    if (buffer_size == SOCKET_ERROR)
    {
        printf("recv error (%i)\n", WSAGetLastError());
        system("pause");
        return -1;
    }
    printf("from_server: %s\n", buffer);
 
    std::ofstream os("from_server", std::ios::binary);
    os.write(buffer, buffer_size);
    os.close();
 
    closesocket(s);
 
    WSACleanup();
 
    system("pause");
    return 0;
}

//подключаем необходимые заголовочные файлы
#include <string>
#include <iostream>
#include "curl/curl.h"
//подключаем стандартное пространство имен
using namespace std;
//объявляем буфер, для хранения возможной ошибки, размер определяется в самой библиотеке
static char errorBuffer[CURL_ERROR_SIZE];
//объялвяем буфер принимаемых данных
static string buffer;
//функция обратного вызова
static int writer(char *data, size_t size, size_t nmemb, string *buffer)
{
  //переменная - результат, по умолчанию нулевая
  int result = 0;
  //проверяем буфер
  if (buffer != NULL)
  {
    //добавляем к буферу строки из data, в количестве nmemb
    buffer->append(data, size * nmemb);
    //вычисляем объем принятых данных
    result = size * nmemb;
  }
  //вовзращаем результат
  return result;
}
//--------------главная функция----------------------------
int main()
{
  //необходимые CURL объекты
  CURL *curl;
  CURLcode result;
  //инициализируем curl
  curl = curl_easy_init();
  //проверяем результат инициализации
  if (curl)
    {
      //задаем все необходимые опции
      //определяем, куда выводить ошибки
      curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);
      //задаем опцию - получить страницу по адресу [url]http://google.com[/url]
      curl_easy_setopt(curl, CURLOPT_URL, "google.com");
      //указываем прокси сервер
      curl_easy_setopt(curl, CURLOPT_PROXY, "proxy:8080");
      //задаем опцию отображение заголовка страницы
      curl_easy_setopt(curl, CURLOPT_HEADER, 1);
      //указываем функцию обратного вызова для записи получаемых данных
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writer);
      //указываем куда записывать принимаемые данные
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
      //запускаем выполнение задачи
      result = curl_easy_perform(curl);
      //проверяем успешность выполнения операции
      if (result == CURLE_OK)      
      //выводим полученные данные на стандартный вывод (консоль)
        cout << buffer << "\n";              
      else      
        //выводим сообщение об ошибке
        cout << "Ошибка! " << errorBuffer << endl;        
     }
  //завершаем сессию
  curl_easy_cleanup(curl);
  return 0;
}

//подключаем необходимые заголовочные файлы
#include <string>
#include <iostream>
#include <fstream>
#include "curl/curl.h"
//подключаем стандартное пространство имен
using namespace std;
//объявляем буфер, для хранения возможной ошибки, размер определяется в самой библиотеке
static char errorBuffer[CURL_ERROR_SIZE];
//объялвяем буфер принимаемых данных
static string buffer;
//функция обратного вызова
static int writer(char *data, size_t size, size_t nmemb, string *buffer)
{
  //переменная - результат, по умолчанию нулевая
  int result = 0;
  //проверяем буфер
  if (buffer != NULL)
  {
    //добавляем к буферу строки из data, в количестве nmemb
    buffer->append(data, size * nmemb);
    //вычисляем объем принятых данных
    result = size * nmemb;
  }
  //вовзращаем результат
  return result;
}
//--------------главная функция----------------------------
int main()
{
  //необходимые CURL объекты
  CURL *curl;
  CURLcode result;
  //инициализируем curl
  curl = curl_easy_init();
  //проверяем результат инициализации
  if (curl)
    {
      //задаем все необходимые опции
      //определяем, куда выводить ошибки
      curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);
      //задаем опцию - получить страницу по адресу [url]http://google.com[/url]
      curl_easy_setopt(curl, CURLOPT_URL, "google.com");
      //указываем прокси сервер
      //curl_easy_setopt(curl, CURLOPT_PROXY, "proxy:8080");
      //задаем опцию отображение заголовка страницы
      //curl_easy_setopt(curl, CURLOPT_HEADER, 1);
      //curl_easy_setopt(curl, CURLOPT_RETURNTRANSFER, 1);   // возвращает веб-страницу
      curl_easy_setopt(curl, CURLOPT_HEADER, 0);           // не возвращает заголовки
      curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);   // переходит по редиректам
      curl_easy_setopt(curl, CURLOPT_ENCODING, "");        // обрабатывает все кодировки
      //curl_easy_setopt(curl, CURLOPT_USERAGENT, $uagent);  // useragent
      curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 120); // таймаут соединения
      curl_easy_setopt(curl, CURLOPT_TIMEOUT, 120);        // таймаут ответа
      curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 10);       // останавливаться после 10-ого редиректа
 
      //указываем функцию обратного вызова для записи получаемых данных
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writer);
      //указываем куда записывать принимаемые данные
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
      //запускаем выполнение задачи
      result = curl_easy_perform(curl);
      //проверяем успешность выполнения операции
      if (result == CURLE_OK)      
        {
         ofstream f("google.html");
         if(!f) { cout<<"Can't create file google.html"<<endl;return 0;}
         else   { f<<buffer<<endl; f.close();}  
        }
      else      
        //выводим сообщение об ошибке
        cout << "Ошибка! " << errorBuffer << endl;        
     }
  //завершаем сессию
  curl_easy_cleanup(curl);
  cout<<"Ok"<<endl;
  return 0;
}