Приложение-клиент)

//------------------------------------------------------------------------------
static const std::string base64_chars =
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
             "abcdefghijklmnopqrstuvwxyz"
             "0123456789+/";
 
static 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;
 
}
//---------------------------------------------------------------------------
std::string get_a(const std::string &name, const std::string &password)
{
    return "Basic " + base64_encode((const unsigned char *)(name + ":" + password).c_str(), name.length() + 1 + password.length());
}
//---------------------------------------------------------------------------
static std::string get_boundary(const char *buffer, const int buffer_size)
{
    std::string res;
    if (!buffer_size)
    {
        res += 'A';
    }
    else
    {
        char c = buffer[0] + 1;
        if (('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') || ('0' <= c && c <= '9')) res += c;
        else res += 'A';
 
        for (int i = 0; i < buffer_size; i++)
        {
            if (res.size() > buffer_size - i) break;
 
            bool good = false;
            for (int j = 0; j < res.size(); j++)
            {
                if (res.at(j) != buffer[i + j])
                {
                    good = true;
                    break;
                }
            }
            if (!good)
            {
                if (res.size() == buffer_size - i)
                {
                    res += 'A';
                }
                else
                {
                    char c = buffer[i + res.size()] + 1;
                    if (('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') || ('0' <= c && c <= '9')) res += c;
                    else res += 'A';
                }
            }
        }
    }
    return res;
}
//---------------------------------------------------------------------------
static int post
(
    std::string login, std::string password,
    std::string host, unsigned short host_port, std::string host_doc,
    std::string ip, unsigned short port,
    SOCKET s,
    char *buffer, int package_size,
    unsigned long * const out,
    std::string name,
    std::string filename,
    std::string type
)
{
    std::stringstream part;
    part <<
    "Content-Disposition: form-data; name=\"" << name << "\"; filename=\"" << filename << "\"\r\n"
    "Content-Type: " << type << "\r\n"
    "\r\n";
    part.write(buffer, package_size);
    std::string part_str = part.str();
 
    std::string boundary = get_boundary(part_str.c_str(), part_str.size());
 
    std::stringstream content;
    content <<
    "--" + boundary + "\r\n";
    content.write(part_str.c_str(), part_str.size());
    content <<
    "\r\n"
    "--" + boundary + "--\r\n";
    std::string content_str = content.str();
 
    std::stringstream message;
    message <<
    "POST http://" << host << ":" << host_port << host_doc << " HTTP/1.0\r\n"
    "Host: " << ip << ":" << port << "\r\n"
    "Content-Type: multipart/form-data; boundary=" << boundary << "\r\n"
    "Content-Length: " << content_str.size() << "\r\n"
    "Connection: keep-alive\r\n";
    if (login.size() && password.size())
    {
        message << "Authorization: " << get_a(login, password) << "\r\n";
    }
    message << "\r\n";
    message.write(content_str.c_str(), content_str.size());
    std::string message_str = message.str();
 
    if (send(s, message_str.c_str(), message_str.size(), 0) != message_str.size())
    {
        return 0;
    }
 
    if (out) *out += message_str.size();
 
    char resp[4096];
    int resp_size = sizeof(resp);
 
    char *p = resp;
 
    DWORD t = GetTickCount();
    DWORD dt = upload_timeout_ms;
    bool closed = false;
    while (true)
    {
        if (GetTickCount() - t >= dt)
        {
            return 0;
        }
 
        fd_set s_set;
        FD_ZERO(&s_set);
        FD_SET(s, &s_set);
 
        timeval timeout = {0, 100000};
 
        int select_res = select(s + 1, &s_set, 0, 0, &timeout);
        if (select_res == SOCKET_ERROR)
        {
            return 0;
        }
        if (!select_res)
        {
            continue;
        }
 
        int package_size = recv(s, p, resp_size - (p - resp), 0);
        if (package_size == SOCKET_ERROR)
        {
            return 0;
        }
 
        p += package_size;
 
        if
        (
            p - resp >= 4 &&
            p[-4] == '\r' &&
            p[-3] == '\n' &&
            p[-2] == '\r' &&
            p[-1] == '\n'
        )
        {
            closed = !package_size;
            break;
        }
        if (!package_size)
        {
            return 0;
        }
        if (p - resp == resp_size)
        {
            return 0;
        }
    }
 
    resp_size = p - resp;
 
    if (resp_size < 15 || resp[13] != 'O' || resp[14] != 'K')
    {
        return 0;
    }
 
    return !closed? 1 : 2;
}
//как отрыть сокет должны знать