#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <ctype.h>
#include <netdb.h>
//#include <winsock2.h>
#include <netinet/in.h>
#include <memory.h>
#include <arpa/inet.h>
#include "buffer.h"
#include <errno.h>
#include <pthread.h>
#include <signal.h>

typedef unsigned long DWORD;
//#pragma comment(lib, "Ws2_32.lib")

SOCKET input = INVALID_SOCKET;
int portIndex =  8100 ;
bool running = true;

const char* proxyAddr = "80.82.32.27";//"cache.vsi.ru";
const int proxyPort =  3128 ;
/*const char* proxyAddr = "128.0.0.1";
const int proxyPort = 8080;*/


inline bool strCmp(const char* str1, const char* str2){
        if (!str1||!str2) return false;
        while ((*str1)&&(*str2)){
                if ((*(str1++))!=(*(str2++)))
                        return false;
        }
        if (*str1 != *str2) return false;
        return true;
}

void sigHandler (int sigNum){
        //fprintf(stderr, "shutting
        running = false;
}

SOCKET bindPort(int port){
    SOCKET result;
    struct sockaddr_in addr;

    if((result = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET){
        fprintf(stderr, "Create socket failed.\n");
        return INVALID_SOCKET;
    }

    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = INADDR_ANY;

    if(bind(result, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR){
        fprintf(stderr, "bind() failed.\nreason: %s\n\n", strerror(errno));
        return INVALID_SOCKET;
    }

    if(listen(result, 1) == SOCKET_ERROR){
        fprintf(stderr, "listen() failed.\nreason: %s\n\n", strerror(errno));
        return INVALID_SOCKET;
    }

    return result;
}

struct TunnelData{
        SOCKET src;
        SOCKET dest;
        TunnelData(void){
                src = dest = INVALID_SOCKET;
        }
        TunnelData(const SOCKET _src, const SOCKET _dest)
                :src(_src), dest(_dest){
        }
};

//DWORD WINAPI TunnelThread(void* p){
void* tunnelThread(void* p){
        TunnelData* tunnelData = (TunnelData*)p;
        SOCKET src = tunnelData->src;
        SOCKET dest = tunnelData->dest;
        char tmp[4096];
        while(true){
                //int size = recv(src, tmp, sizeof(tmp), 0);
                int size = read(src, tmp, sizeof(tmp));
                if (size == 0){
                        write(dest, 0, 0);
                        //send(dest, 0, 0, 0);
                        break;//connection closed;
                }
                
                if (size < 0)
                        break;
                /*if (size == SOCKET_ERROR){
                        if (WSAGetLastError() == WSAECONNRESET)
                                continue;
                        break;
                }*/

                int offset = 0;
                while(offset < size){
                        //int sent = send(dest, &tmp[offset], size - offset, 0);
                        int sent = write(dest, &tmp[offset], size - offset);
                        
                        if ((sent == SOCKET_ERROR)||(sent == 0))
                                break;

                        offset += sent;
                }

                if (offset < size)
                        break;
        }

        shutdown(src, SHUT_RD);//SD_RECEIVE);
        shutdown(dest, SHUT_WR);//SD_SEND);
//      delete tunnelData;
        return 0;
}

struct ConnectionData{
        SOCKET socket;
        sockaddr_in srcAddr;
        sockaddr_in destAddr;
        ConnectionData(const SOCKET _socket, const sockaddr_in& _srcAddr, const sockaddr_in& _destAddr){
                socket = _socket;
                srcAddr = _srcAddr;
                destAddr = _destAddr;
        }
};

void printAddress(const sockaddr_in& addr){
        union{
                DWORD dw;
                unsigned char c[4];
        } from;
        from.dw = ntohl(addr.sin_addr.s_addr);
        fprintf(stderr, "access from %d.%d.%d.%d\n", from.c[3], from.c[2], from.c[1], from.c[0]);
}

struct Filter{
        const char* oldStr;
        const char* newStr;
};

const Filter filters[] = {
        {"CONNECT vir1a.toonel.net:8081 HTTP/1.1\r\n\r\n", "CONNECT vir1a.toonel.net:443 HTTP/1.1\r\n\r\n"},
        {"CONNECT dub1.toonel.net:8081 HTTP/1.1\r\n\r\n", "CONNECT vir1a.toonel.net:443 HTTP/1.1\r\n\r\n"},
        {"CONNECT vir1b.toonel.net:8081 HTTP/1.1\r\n\r\n", "CONNECT vir1a.toonel.net:443 HTTP/1.1\r\n\r\n"},
        {"CONNECT vir1a.toonel.net:8081 HTTP/1.1\n\n", "CONNECT vir1a.toonel.net:443 HTTP/1.1\r\n\r\n"},
        {"CONNECT dub1.toonel.net:8081 HTTP/1.1\n\n", "CONNECT vir1a.toonel.net:443 HTTP/1.1\r\n\r\n"},
        {"CONNECT vir1b.toonel.net:8081 HTTP/1.1\n\n", "CONNECT vir1a.toonel.net:443 HTTP/1.1\r\n\r\n"},
        {0, 0}
};

void processConnection(const SOCKET srcSock, const sockaddr_in& srcAddr, const sockaddr_in& destAddr){
        printAddress(srcAddr);

        fprintf(stderr, "creating proxy socket\n");
        SOCKET destSock = socket(AF_INET, SOCK_STREAM, 0);
        if (destSock == INVALID_SOCKET){
                fprintf(stderr, "can't create proxy socket!\n");
                shutdown(srcSock, SHUT_RD);//SD_BOTH);
                //closesocket(srcSock);
                close(srcSock);
                return;
        }

        fprintf(stderr, "connecting dest socket\n");
        if (connect(destSock, (const sockaddr*)&destAddr, sizeof(destAddr)) != 0){
                fprintf(stderr, "can't connect dest proxy!\n");
                shutdown(srcSock, SHUT_RDWR);//SD_BOTH);
                //closesocket(srcSock);
                //closesocket(destSock);
                return;
        }

        fprintf(stderr, "reading http data\n");
        Buffer buf;
        buf.appendHttp(srcSock);
        buf.append('\0');
        
        for (const Filter* filter = filters; filter->oldStr; filter++){
                if (strCmp(filter->oldStr, buf.getData())==0){
                        buf.clear();
                        buf.append(filter->newStr);
                        buf.append('\0');
                        fprintf(stderr, "filter found\n");
                        break;
                }
        }
        fprintf(stderr, "client said:\n%s\nretrasmitting to proxy\n", buf.getData());

        //send(destSock, buf.getData(), buf.getSize()-1, 0);
        write(destSock, buf.getData(), buf.getSize()-1);

        buf.clear();
        buf.appendHttp(destSock);
        buf.append('\0');

        fprintf(stderr, "proxy answered:\n%s\nretrasmitting to client\n", buf.getData());

        write(srcSock, buf.getData(), buf.getSize()-1);
        //send(srcSock, buf.getData(), buf.getSize()-1, 0);

        fprintf(stderr, "starting tunnels\n");

        /*HANDLE threads[2];
        threads[0] = CreateThread(0, 0, TunnelThread, new TunnelData(srcSock, destSock), 0, 0);
        threads[1] = CreateThread(0, 0, TunnelThread, new TunnelData(destSock, srcSock), 0, 0);
        WaitForMultipleObjects(2, threads, TRUE, INFINITE);

        CloseHandle(threads[0]);
        CloseHandle(threads[1]);*/

        pthread_t threads[2];
        TunnelData tunnelData[2];
        tunnelData[0].src = srcSock;
        tunnelData[0].dest = destSock;
        tunnelData[1].src = destSock;
        tunnelData[1].dest = srcSock;
        
        pthread_create(&threads[0], 0, tunnelThread, &tunnelData[0]);
        pthread_create(&threads[1], 0, tunnelThread, &tunnelData[1]);
        pthread_join(threads[0], 0);
        pthread_join(threads[1], 0);

        //closesocket(destSock);
        close(destSock);
        //closesocket(srcSock);
        close(srcSock);
}

void* /*DWORD WINAPI*/ threadProc(void* p){
        ConnectionData* connectionData = (ConnectionData*)p;
        processConnection(connectionData->socket, connectionData->srcAddr, connectionData->destAddr);
        delete connectionData;
        //return 0;
}

void mainLoop(const sockaddr_in& proxyAddr){
        fprintf(stderr, "main loop started\n");
        while (running){
                sockaddr_in srcAddr;
                //int len = sizeof(srcAddr);
                socklen_t len = sizeof(srcAddr);
                SOCKET incoming = accept(input, (sockaddr*)&srcAddr, &len);
                if (incoming == INVALID_SOCKET){
                        //int wsaError = WSAGetLastError();
                        //if (wsaError == WSAEINTR)
                        int errorNum = errno;
                        if (errorNum == EINTR)
                                continue;
                        fprintf(stderr, "Cannot accept request, error index: %d\n", errorNum);//wsaError);
                        break;
                }

                fprintf(stderr, "new connection.\n");
                
                ConnectionData* connectionData = new ConnectionData(incoming, srcAddr, proxyAddr);
                //DWORD threadId;
                //HANDLE thread = CreateThread(0, 0, threadProc, (void*)connectionData, 0, &threadId);
                //CloseHandle(thread);
                pthread_t thread;
                pthread_create(&thread, 0, threadProc, (void*)connectionData);//TODO very dangerous
                //threadProc(connectionData);
        }
        fprintf(stderr, "main loop completed\n");
}

/*BOOL WINAPI ctrlHandler(DWORD ctrlType){
        fprintf("shutting down the app\n");
        running = false;
        
        closesocket(input);
        input = INVALID_SOCKET;
        
        return TRUE;
}*/

bool isAddr(const char* p){
        for (;*p; p++){
                char c = *p;
                if (isdigit(c) == 0)
                        if (c != '.')
                                return false;
        }
        return true;
}

bool getProxyAddr(sockaddr_in& saddr, const char* addr, const int port){
        hostent* host;
        if (isAddr(addr)){
                unsigned long inetAddr = inet_addr(addr);
                host = gethostbyaddr((char*)&inetAddr, 4, AF_INET);
        }
        else
                host = gethostbyname(addr);
        if (!host) return false;
        saddr.sin_family = AF_INET;
        saddr.sin_port = htons(port);
        memcpy(&saddr.sin_addr.s_addr, host->h_addr, host->h_length);
        /*saddr.sin_addr.S_un.S_un_b.s_b1 = host->h_addr[0];
        saddr.sin_addr.S_un.S_un_b.s_b2 = host->h_addr[1];
        saddr.sin_addr.S_un.S_un_b.s_b3 = host->h_addr[2];
        saddr.sin_addr.S_un.S_un_b.s_b4 = host->h_addr[3];*/
        return true;
}

int main(void){
        fprintf(stderr, "this is a simple windows redirector\n");
        //WSADATA wsaData;
        //WSAStartup(MAKEWORD(2, 2), &wsaData);
        
        sockaddr_in proxySAddr;
        if (!getProxyAddr(proxySAddr, proxyAddr, proxyPort)){
                fprintf(stderr, "getProxyAddr(\"%s\") failed.\n", proxyAddr);
                //WSACleanup();
                return 0;
        }

        input = bindPort(portIndex);
        //SetConsoleCtrlHandler(ctrlHandler, true);
        struct sigaction sa;
        memset(&sa, 0, sizeof(sa));
        sa.sa_handler = sigHandler;
        sigaction(SIGINT, &sa, 0);
        sigaction(SIGTERM, &sa, 0);

        if (input != INVALID_SOCKET){
                mainLoop(proxySAddr);
                if (input != INVALID_SOCKET)
                        close/*socket*/(input);
                fprintf(stderr, "closing down app...\n");
        }
        else
                fprintf(stderr, "an error has occured\n");

        //WSACleanup();
        return  0 ;
}

//#pragma once
#ifndef _BUFFER_H_
#define _BUFFER_H_

typedef unsigned long dword;

typedef int SOCKET;
#define SOCKET_ERROR - 1 
#define INVALID_SOCKET - 1 

class Buffer{
protected:
        char* data;
        dword size;
        dword capacity;
        dword  increment;

public:
        inline dword getSize(void){return size;}
        inline const char* getData(void) const {return data;}

        void clear(void);
        void grow(void);
        void append(const char* src, dword size);
        void append(const char* src);
        void append(const char c);
        bool appendHttp(SOCKET src);//true if succesful
        Buffer(dword capacity = 0x1000, dword increment =  0 );
        ~Buffer(void);
};

#endif //_BUFFER_H_

//#include <winsock2.h>
//#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include "buffer.h"
#include <memory.h>
#include <errno.h>
//#include <string.h>

void Buffer::grow(void){
        dword newCapacity = increment ? capacity + increment: capacity *  2 ;
        char* newData = new char[newCapacity];
        memcpy(newData, data, size);
        delete[] data;
        data = newData;
}

Buffer::Buffer(dword _capacity, dword _increment)
:size( 0 ), capacity(_capacity), increment(_increment), data( 0 ){
        data = new char[capacity];
}

void Buffer::clear(void){
        size =  0 ;
}

Buffer::~Buffer(void){
        delete[] data;
}

void Buffer::append(const char* src, dword srcsize){
        while (size + srcsize > capacity)
                grow();//TODO НОЮЯМН.
        memcpy(&data[size], src, srcsize);
        size += srcsize;
}

void Buffer::append(const char* src){
        dword size = (dword)strlen(src);
        append(src, size);
}

void Buffer::append(const char c){
        append(&c,  1 );
}

bool Buffer::appendHttp(SOCKET src){
        int startSize = size;
        for (int dataSize =  0 ; true;){
                char tmp[ 4096 ];
                if ((size-startSize) >=  4 )
                        if (memcmp(&data[size- 4 ], "\r\n\r\n",  4 )== 0 )
                                break;

                if ((size-startSize) >=  2 )
                        //if (*((dword*)&data[size-4]) == 0x0a0d0a0d)
                        if (memcmp(&data[size- 2 ], "\n\n",  2 )== 0 )
                                break;

                //dataSize = read(src, tmp, sizeof(tmp));
                dataSize = recv(src, tmp, sizeof(tmp),  0 );
                if (dataSize ==  0 )
                        break;

                if (dataSize == SOCKET_ERROR)
                    return false;
                    /*if (WSAGetLastError() == WSAECONNRESET)
                        if (errno == ECONNRESET
                                continue;
                        else{
                                //TODO: size = startSize?
                                return false;
                        }*/
                
                
                append(tmp, dataSize);
        }
        return true;
}

CXXFLAGS=-O2

redirector: main.o buffer.o
        g++ -o redirector -g main.o buffer.o -lpthread

clean: 
        rm -f main.o buffer.o redirector