Proxy-Server

#include <iostream>
#include <winsock.h> //note that this requires a linked .lib
#include <fstream>

using namespace std;

WSADATA wsadata;

string password;
bool pass_recieved = false;

string MESSAGE;

int TCP_PORT = 5721;
char* TCP_IP;

bool CloseConnection (SOCKET s)
{
    //Close the socket if it exists
    if(s){
        closesocket(s);
        return true;
    }
    return false;
}

char* get_local_address(){
    char ac[80];
    gethostname(ac, sizeof(ac));

    struct hostent *phe = gethostbyname(ac);
    if (phe == 0) {
        cerr << "Yow! Bad host lookup." << endl;
        return NULL;
    }

    struct in_addr addr;
    memcpy(&addr, phe->h_addr_list[0], sizeof(struct in_addr));
    return inet_ntoa(addr);
}

//CONNECTTOHOST – Connects to a remote host
bool ConnectToHost(char* IPAddress, int PortNo)
{
    //Fill out the information needed to initialize a socket…
    SOCKADDR_IN target; //Socket address information

    target.sin_family = AF_INET; // address family Internet
    target.sin_port = htons (PortNo); //Port to connect on
    target.sin_addr.s_addr = inet_addr (IPAddress); //Target IP

    SOCKET s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); //Create socket
    if (s == INVALID_SOCKET)
    {
        return false; //Couldn't create the socket
    }

    //Try connecting...

    if (connect(s, (SOCKADDR *)&target, sizeof(target)) == SOCKET_ERROR)
    {
        return false; //Couldn't connect
    }
    else
        send(s, MESSAGE.c_str(), (int)(MESSAGE).size(), 0);
        return true; //Success
    CloseConnection(s);
}

void handshake_send(char* ip_addr, int port){
    ConnectToHost(ip_addr, port);
}

SOCKET SetUpListener(const char* pcAddress, int nPort)
{
    u_long nInterfaceAddr = inet_addr(pcAddress);
    if (nInterfaceAddr != INADDR_NONE) {
        SOCKET sd = socket(AF_INET, SOCK_STREAM, 0);
        if (sd != INVALID_SOCKET) {
            sockaddr_in sinInterface;
            sinInterface.sin_family = AF_INET;
            sinInterface.sin_addr.s_addr = nInterfaceAddr;
            sinInterface.sin_port = nPort;
            if (bind(sd, (sockaddr*)&sinInterface,
                    sizeof(sockaddr_in)) != SOCKET_ERROR) {
                listen(sd, 1);
                return sd;
            }
        }
    }

    return INVALID_SOCKET;
}

SOCKET AcceptConnection(SOCKET ListeningSocket, sockaddr_in& sinRemote)
{
    int nAddrSize = sizeof(sinRemote);
    return accept(ListeningSocket, (sockaddr*)&sinRemote, &nAddrSize);
}

SOCKET SetUpListener(const char* pcAddress, int nPort);
SOCKET AcceptConnection(SOCKET ListeningSocket, sockaddr_in& sinRemote);

char acReadBuffer[5000];
string url_request;
bool get_url_request = false;
bool url_request_recieved = false;

bool read_sock(SOCKET sd)
{
    // Read data from client
    int nReadBytes = 1;
    while(nReadBytes != 0){
        nReadBytes = recv(sd, acReadBuffer, 5000, 0);
        if((string)acReadBuffer == password){
            pass_recieved = true;
            return true;
        }
        if(strlen(acReadBuffer) > 0 && (string)acReadBuffer != "kill" && get_url_request){
            url_request = (string)acReadBuffer;
            url_request_recieved = true;
            return true;
        }
        else if((string)acReadBuffer == "kill"){
            exit(-1);
        }
        if (nReadBytes == SOCKET_ERROR) {
            return false;
        }
    }
    return false;
}

WSADATA w;

bool exit_server;

int handshake_receive()
{
    string TCP_IP_str = get_local_address();
    cout << TCP_IP_str << endl;
    int TCP_PORT_OWN = 5721;

    //SOCKET ListeningSocket = SetUpListener(TCP_IP_str.c_str(), htons(TCP_PORT_OWN));
    //if (ListeningSocket == INVALID_SOCKET) {
    //    cout << "Error with listener1" << endl;
    //    cout << WSAGetLastError() << endl;
    //    return -1;
    //}
    // Spin forever handling clients
    while (1) {
        SOCKET ListeningSocket = SetUpListener(TCP_IP_str.c_str(), htons(TCP_PORT_OWN));
        if (ListeningSocket == INVALID_SOCKET) {
            cout << "Error with listener1" << endl;
            cout << WSAGetLastError() << endl;
            return -1;
        }
        // Wait for a connection, and accepting it when one arrives.
        cout << "Waiting for a connection..." << flush;
        sockaddr_in sinRemote;
        SOCKET sd = AcceptConnection(ListeningSocket, sinRemote);
        if (sd != INVALID_SOCKET) {
            cout << "Accepted connection from " <<
                    inet_ntoa(sinRemote.sin_addr) << ":" <<
                    ntohs(sinRemote.sin_port) << "." << endl;
            TCP_IP = inet_ntoa(sinRemote.sin_addr);
        }
        else {
            cout << "Error with accepter" << endl;
            cout << WSAGetLastError() << endl;
            return -1;
        }
        if(read_sock(sd)){
            if(pass_recieved && !get_url_request){
                MESSAGE = "got";
                //if(CloseConnection(sd) && CloseConnection(ListeningSocket)){}
                //else{
                //    cout << "Error disconnecting" << endl;
                //    return -1;
                //}
                handshake_send(TCP_IP, TCP_PORT);
                get_url_request = true;
                //SOCKET ListeningSocket = SetUpListener(TCP_IP_str.c_str(), htons(TCP_PORT_OWN));
                //if (ListeningSocket == INVALID_SOCKET) {
                //    cout << "Error with listener2" << endl;
                //    cout << WSAGetLastError() << endl;
                //    return -1;
                //}
            }
            else if(get_url_request){
                if(url_request_recieved){
                    exit_server = true;
                }
            }
            else{
                MESSAGE = "password";
                //if(CloseConnection(sd) && CloseConnection(ListeningSocket)){}
                //else{
                //    cout << "Error disconnecting" << endl;
                //    return -1;
                //}
                handshake_send(TCP_IP, TCP_PORT);
                //SOCKET ListeningSocket = SetUpListener(TCP_IP_str.c_str(), htons(TCP_PORT_OWN));
                //if (ListeningSocket == INVALID_SOCKET) {
                //    cout << "Error with listener3" << endl;
                //    cout << WSAGetLastError() << endl;
                //    return -1;
                //}
            }
        }
        if(exit_server){
            break;
        }
        if(CloseConnection(sd) && CloseConnection(ListeningSocket)){}
        else{
            cout << "Error disconnecting" << endl;
            return -1;
        }
    }
    return 0;
}

void set_char_string(string str){
    const char* str_char = str.c_str();
    for(unsigned int iter = 0; iter < strlen(str_char); iter++){
        MESSAGE[iter] = str_char[iter];
    }
}

void server(){
    cout << "Password? ";
    cin >> password;
    cout << "Setting up server." << endl;
    while(true){
        if(handshake_receive() == -1){
            cout << "Error occured. Restarting server." << endl;
            return;
        }
        //call python program to grab web page
        ShellExecute(GetDesktopWindow(), "open", "ProxyWebScrape.exe", url_request.c_str(), NULL, SW_SHOWNORMAL);

        fstream bigFile;
        string name = "page.html";
        bigFile.open(name.c_str(),ios::in | ios::binary);
        bigFile.seekg(0, ios::end);
        const int size = bigFile.tellg();
        char full_file[size];
        bigFile.seekg(0, ios::beg);
        bigFile.read(full_file,size);

        string full_file_str = (string)full_file;

        int bytes_read = 0;
        while(bytes_read < size){
            set_char_string(full_file_str.substr(bytes_read, 1024));
            handshake_send(TCP_IP, TCP_PORT);
            bytes_read += 1024;
        }
    }
}

int main(int argc, char* argv[])
{
    //Start up Winsock…
    WSADATA wsadata;

    int error = WSAStartup(0x0202, &wsadata);

    //Did something happen?
    if (error)
        return false;

    //Did we get the right Winsock version?
    if(wsadata.wVersion != 0x0202)
    {
        WSACleanup(); //Clean up Winsock
        return false;
    }

    while(true){
        server();
    }
    return 0;
}