Реализовать ограничения в программе через ее серверную часть

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;
}
 
int s2i(const std::string &s)
{
    int res;
    sscanf(s.c_str(), "%i", &res);
    return res;
}
 
std::string get(const std::string &host_name, const int host_port, const std::string &host_doc, const std::string &key, std::string * const ret, int timeout_ms)
{
    SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (s == INVALID_SOCKET)
    {
        printf("socket error (%i)\n", WSAGetLastError());
        return "socket error";
    }
 
    SOCKADDR_IN sa;
    sa.sin_family = AF_INET;
    sa.sin_port = htons(host_port);
    sa.sin_addr.S_un.S_addr = get_addr((char *)host_name.c_str());
 
    printf("wait for server...\n");
 
    DWORD t = GetTickCount();
    while (true)
    {
        if (GetTickCount() - t > timeout_ms)
        {
            closesocket(s);
            printf("connect timeout\n");
            return "connect timeout";
        }
 
        int connect_res = connect(s, (SOCKADDR *)&sa, sizeof(sa));
        if (!connect_res) break;
 
        Sleep(250);
    }
 
    printf("connected\n");
 
    std::strstream message;
 
    message <<
    "GET http://" << host_name << ":" << host_port << host_doc << "?key=" << key << " "
    "HTTP/1.0\r\n"
    "Host: " << host_name << ":" << host_port << "\r\n"
    "Connection: Close\r\n"
    "\r\n";
 
    if (send(s, message.str(), message.pcount(), 0) == SOCKET_ERROR)
    {
        closesocket(s);
        printf("send error (%i)\n", WSAGetLastError());
        return "send error";
    }
 
    std::string res;
 
    std::string len_tag = "Content-Length: ";
 
    t = GetTickCount();
    while (true)
    {
        if (GetTickCount() - t > timeout_ms)
        {
            closesocket(s);
            printf("recv timeout\n");
            return "recv timeout";
        }
 
        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)
        {
            closesocket(s);
            printf("select error (%i)\n", WSAGetLastError());
            return "select error";
        }
        if (!select_res)
        {
            continue;
        }
 
        char buffer[100000];
        int buffer_size = sizeof(buffer);
        buffer_size = recv(s, buffer, buffer_size, 0);
        if (buffer_size == SOCKET_ERROR)
        {
            closesocket(s);
            printf("recv error (%i)\n", WSAGetLastError());
            return "recv error";
        }
        if (!buffer_size) break;
 
        res.append(buffer, buffer_size);
        int sep_pos = res.find("\r\n\r\n");
        if (sep_pos != std::string::npos)
        {
            int len_pos = res.find(len_tag);
            if (len_pos != std::string::npos)
            {
                int pos = res.find("\r\n", len_pos);
                if (pos != std::string::npos)
                {
                    std::string len_str = res.substr(len_pos + len_tag.size(), pos - len_pos - len_tag.size());
                    int len = s2i(len_str);
                    if (sep_pos + 4 /* \r\n\r\n */ + len == res.size())
                    {
                        res = res.substr(sep_pos + 4 /* \r\n\r\n */);
 
                        printf("********************\n%s\n", res.c_str());
 
                        *ret = res;
                        closesocket(s);
                        return "ok";
                    }
                }
            }
        }
    }
 
    closesocket(s);
    printf("unknown error\n");
    return "unknown error";
}