C++ multi-process proxy

void HTTPProxy::CreateServerSocket(int port){

    proxy_fd = socket(AF_INET, SOCK_STREAM, 0);
    
    const int optval = 1;
    // allow other sockets to bind to this port, "Address already in use" error 
    setsockopt(proxy_fd, SOL_SOCKET, SO_REUSEADDR, &optval , sizeof(int)); 
    
    struct sockaddr_in serverAddr;
    bzero(&serverAddr, sizeof(serverAddr)); // memset
    serverAddr.sin_family = AF_INET;
    // automatically be filled with current host's IP address
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); 
    serverAddr.sin_port = htons(port);
    struct sockaddr *sa = (struct sockaddr *) &serverAddr;
    
    ::bind(proxy_fd, sa, sizeof(serverAddr)); // c libs instead of std::bind
    
    const size_t kMaxQueuedRequests = 128;
    listen(proxy_fd, kMaxQueuedRequests);
    cout << "listening on port: " << port << endl;    
}

void HTTPProxy::ProxyRequest(){
    struct sockaddr_in clientAddr;
    socklen_t clientAddrSize = sizeof(clientAddr);
    // write incoming client's connection to sockaddr
    int client_fd = accept(proxy_fd, (struct sockaddr *) &clientAddr, &clientAddrSize);
    
    const char *clientIPAddress = inet_ntoa(clientAddr.sin_addr);
    uint16_t clientPort = ntohs(clientAddr.sin_port);    
    cout << "server got connection from client:" << clientIPAddress << clientPort << endl;



    // forward client request to google
    int MAX_BUFFER_SIZE = 5000;
    char buf[MAX_BUFFER_SIZE];
    char *request_message = (char *) malloc(MAX_BUFFER_SIZE); 
    request_message[0] = '\0';
	int total_received_bits = 0;
    
    // receive n copy client request from stream to buf
    while (strstr(request_message, "\r\n\r\n") == NULL) {
        int byte_recvd = recv(client_fd, buf, MAX_BUFFER_SIZE, 0);
        total_received_bits += byte_recvd;
        buf[byte_recvd] = '\0';
	  	if (total_received_bits > MAX_BUFFER_SIZE) {
			MAX_BUFFER_SIZE *= 2;
			request_message = (char *) realloc(request_message, MAX_BUFFER_SIZE);
        }
        strcat(request_message, buf);
    }
    cout << "request_message : " << request_message << endl;
    


    struct ParsedRequest *req;    // contains parsed request
    req = ParsedRequest_create();    
    
    if(ParsedRequest_parse(req, request_message, strlen(request_message))<0){
        cout << "request message format not supported yet" << endl;
        
    } else {
        if (req->port == NULL) {
            req->port = (char *) "80";
        }		 
        char* req_string = RequestToString(req);	
        cout << "req_string : " << req_string << endl;


        cout << "client host n port: " << req->host << req->port << endl;
        // remote socket: connection to remote host e.g. google
        int remote_socket = CreateRemoteSocket(req->host, req->port);
        
        cout << "SendRequestRemote: " << remote_socket << " total received bits" << total_received_bits << endl;
        SendRequestRemote(req_string, remote_socket, total_received_bits);

        cout << "ProxyBackClient" << endl;
        ProxyBackClient(client_fd, remote_socket);
        
        ParsedRequest_destroy(req);		
        close(client_fd);   
        close(remote_socket);
    }
}

void HTTPProxy::SendRequestRemote(const char *req_string, int remote_socket, int buff_length){
    string temp;
    temp.append(req_string);
    int totalsent = 0;
    int senteach;
    cout << "SendRequestRemote : "<< totalsent << " , " << buff_length << endl;
    while (totalsent < buff_length) {
        cout << "about to send to remote" << endl;
        if ((senteach = send(remote_socket, (void *) (req_string + totalsent), buff_length - totalsent, 0)) < 0) {
            cout << "error sending ot remote" << endl;
        }        
        // senteach = send(remote_socket, (void *) (req_string + totalsent), buff_length - totalsent, 0);
        cout << "sent to remote" << senteach <<  endl;
        totalsent += senteach;
        cout << "total sent to remote: " << totalsent << endl;
    }   
}

void HTTPProxy::ProxyBackClient(int client_fd, int remote_socket){
    int MAX_BUF_SIZE = 5000;
    int buff_length;
    char received_buf[MAX_BUF_SIZE];

    // receive from remote's response, send back to client
    while ((buff_length = recv(remote_socket, received_buf, MAX_BUF_SIZE, 0)) > 0) {
        
        cout << "received from remote: "<< buff_length << endl;
        string temp;
        temp.append(received_buf);
        int totalsent = 0;
        int senteach;
        while (totalsent < buff_length) {       
            if ((senteach = send(client_fd, (void *) (received_buf + totalsent), buff_length - totalsent, 0)) < 0) {                
                fprintf (stderr," Error in sending to server ! \n");                
            }
            totalsent += senteach;
            cout << "sending back to client" << totalsent << endl;          
        }      
        memset(received_buf,0,sizeof(received_buf));
    }
}

int main(int argc, char *argv[]){
    
    struct sockaddr_in clientAddr;
    socklen_t clientAddrSize = sizeof(clientAddr);
    HTTPProxy httpproxy(3500);
    int proxy_fd = httpproxy.getProxyfd();
    
    while(true){

        int client_fd = accept(proxy_fd, (struct sockaddr *) &clientAddr, &clientAddrSize);
        
        int pid = fork();
        if(pid==0){            
            cout << "mp with a common client_fd" << endl;
            httpproxy.ProxyRequest(client_fd, clientAddr, clientAddrSize);
        }else{
            close(client_fd);
        }
    }

    return 0;
}

HTTPBlacklist::HTTPBlacklist(const char* file_name){
    ifstream infile(file_name);
    while(true){
        string line;
        getline(infile, line);
        regex re(line);
        blacklist_websites.push_back(re);
    }    
}

bool HTTPBlacklist::is_blacklisted(const char* website){
    for (const regex& re: blacklist_websites){
        if (regex_match(website,re)){
            return true;
        }
    }
    return false;
}