SyncHTTP Sources

/* all files copied together */
#ifndef SOCKET_H
#define SOCKET_H

#include <WinSock2.h>

#include <string>

enum TypeSocket {BlockingSocket, NonBlockingSocket};

class Socket {
public:

  virtual ~Socket();
  Socket(const Socket&);
  Socket& operator=(Socket&);

  std::string ReceiveLine();
  int Socket::ReceiveContent(std::string & result);
  std::string ReceiveBytes();

  void   Close();
  void   SendLine (std::string);
  void   SendBytes(const std::string&);

protected:
  friend class SocketServer;
  friend class SocketSelect;

  Socket(SOCKET s);
  Socket();


  SOCKET s_;

  int* refCounter_;

private:
  static void Start();
  static void End();
  static int  nofSockets_;
};

class SocketClient : public Socket {
public:
  SocketClient(const std::string& host, int port);
};

class SocketServer : public Socket {
public:
  SocketServer(int port, int connections, TypeSocket type=BlockingSocket);

  Socket* Accept();
};

class SocketSelect {
  public:
    SocketSelect(Socket const * const s1, Socket const * const s2=NULL, TypeSocket type=BlockingSocket);

    bool Readable(Socket const * const s);

  private:
    fd_set fds_;
};
#endif



#include "socket.h"
#include <iostream>

using namespace std;

int Socket::nofSockets_= 0;

void Socket::Start() {
  if (!nofSockets_) {
    WSADATA info;
    if (WSAStartup(MAKEWORD(2,0), &info)) {
      throw "Could not start WSA";
    }
  }
  ++nofSockets_;
}

void Socket::End() {
  WSACleanup();
}

Socket::Socket() : s_(0) {
  Start();
  s_ = socket(AF_INET,SOCK_STREAM,0);

  if (s_ == INVALID_SOCKET) {
      return;
  }

  refCounter_ = new int(1);
}

Socket::Socket(SOCKET s) : s_(s) {
  Start();
  refCounter_ = new int(1);
};

Socket::~Socket() {
  if (! --(*refCounter_)) {
    Close();
    delete refCounter_;
  }

  --nofSockets_;
  if (!nofSockets_) End();
}

Socket::Socket(const Socket& o) {
  refCounter_=o.refCounter_;
  (*refCounter_)++;
  s_         =o.s_;

  nofSockets_++;
}

Socket& Socket::operator=(Socket& o) {
  (*o.refCounter_)++;

  refCounter_=o.refCounter_;
  s_         =o.s_;

  nofSockets_++;

  return *this;
}

void Socket::Close() {
  closesocket(s_);
}

std::string Socket::ReceiveBytes() {
  std::string ret;
  char buf[1024];

  while (1) {
    u_long arg = 0;
    if (ioctlsocket(s_, FIONREAD, &arg) != 0)
      break;

    if (arg == 0)
      break;

    if (arg > 1024) arg = 1024;

    int rv = recv (s_, buf, arg, 0);
    if (rv <= 0) break;

    std::string t;

    t.assign (buf, rv);
    ret += t;
  }

  return ret;
}


int Socket::ReceiveContent(std::string & result) {
    std::string firstLine = Socket::ReceiveLine();
    if (firstLine.find("302 Found") != std::string::npos)   //redirect
    {
        std::string lineBytes;
        while(true)
        {
            while (true)
            {
                char r;
                if(!recv(s_, &r, 1, 0))
                    break;
                lineBytes += r;
                if (r == '\n')
                    break;
            }
            if(lineBytes.empty())
            {
                result = "";
                return 302;
            }
            if (lineBytes.find("Location:") != std::string::npos)
                break;
        }
        result = lineBytes.substr(10);
        return 302;
    }
    else if (firstLine.find("200 OK") != std::string::npos)
    {
        while(true)
        {
            std::string lineBytes;
            while (true)
            {
                char r;
                if(!recv(s_, &r, 1, 0))
                    break;
                lineBytes += r;
                if (r == '\n')
                    break;
            }
            if(lineBytes.empty())
                break;
            if(lineBytes.find("wbb_resp:") != std::string::npos)
            {
                result = lineBytes.substr(10);
                break;
            }
        }
        return 200;
    }
    else
    {
        result = "none";
        return 0;
    }
}

std::string Socket::ReceiveLine() {
  std::string ret;
  while (1) {
    char r;

    switch(recv(s_, &r, 1, 0)) {
      case 0:
        return ret;
      case -1:
        return "";
    }

    ret += r;
    if (r == '\n')
        return ret;
  }
}

void Socket::SendLine(std::string s) {
  s += '\n';
  send(s_,s.c_str(),s.length(),0);
}

void Socket::SendBytes(const std::string& s) {
  send(s_,s.c_str(),s.length(),0);
}

SocketServer::SocketServer(int port, int connections, TypeSocket type) {
  sockaddr_in sa;

  memset(&sa, 0, sizeof(sa));

  sa.sin_family = PF_INET;
  sa.sin_port = htons(port);
  s_ = socket(AF_INET, SOCK_STREAM, 0);
  if (s_ == INVALID_SOCKET) {
    return;
  }

  if(type==NonBlockingSocket) {
    u_long arg = 1;
    ioctlsocket(s_, FIONBIO, &arg);
  }

  if (bind(s_, (sockaddr *)&sa, sizeof(sockaddr_in)) == SOCKET_ERROR) {
    closesocket(s_);
    return;
  }

  listen(s_, connections);
}

Socket* SocketServer::Accept() {
  SOCKET new_sock = accept(s_, 0, 0);
  if (new_sock == INVALID_SOCKET) {
    int rc = WSAGetLastError();
    if(rc==WSAEWOULDBLOCK) {
      return 0;
    }
    else {
      throw "Invalid Socket";
    }
  }

  Socket* r = new Socket(new_sock);
  return r;
}

SocketClient::SocketClient(const std::string& host, int port) : Socket() {
  std::string error;

  hostent *he;
  if ((he = gethostbyname(host.c_str())) == 0) {
    error = strerror(errno);
    throw error;
  }

  sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(port);
  addr.sin_addr = *((in_addr *)he->h_addr);
  memset(&(addr.sin_zero), 0, 8);

  if (::connect(s_, (sockaddr *) &addr, sizeof(sockaddr))) {
    error = strerror(WSAGetLastError());
    throw error;
  }
}

SocketSelect::SocketSelect(Socket const * const s1, Socket const * const s2, TypeSocket type) {
  FD_ZERO(&fds_);
  FD_SET(const_cast<Socket*>(s1)->s_,&fds_);
  if(s2) {
    FD_SET(const_cast<Socket*>(s2)->s_,&fds_);
  }

  TIMEVAL tval;
  tval.tv_sec  = 0;
  tval.tv_usec = 1;

  TIMEVAL *ptval;
  if(type==NonBlockingSocket) {
    ptval = &tval;
  }
  else {
    ptval = 0;
  }

  if (select (0, &fds_, (fd_set*) 0, (fd_set*) 0, ptval) == SOCKET_ERROR)
    return;
}

bool SocketSelect::Readable(Socket const* const s) {
  if (FD_ISSET(s->s_,&fds_)) return true;
  return false;
}




static cell AMX_NATIVE_CALL n_SynchronizedHTTP( AMX* amx, cell* params )
{
    /*
    params[1]       char array          URL
    params[2]       char array          Post data
    params[3]       ref char array      Result string
    params[4]       int                 Result string lenght
    params[5]       int                 Method (1 = GET, 2 = POST)
    params[6]       int                 Timeout in seconds
    params[7]       bool                Debug
    */

    std::string
        paramURL = GetAMXString(amx, params[1]),
        paramData = GetAMXString(amx, params[2]);

    int
        method = params[5],
        timeout = params[6];

    bool
        debug = params[7];

    if(paramURL.length() < 3)
        return 0;

    if(paramURL.find("http://") != 0)
        paramURL = "http://" + paramURL;

    CURL *curlSession;
    clock_t timeBegin, timeEnd;
    double timeSpent;
    curlSession = curl_easy_init();
    if(curlSession)
    {
        CURLcode response;
        std::string readBuffer;
        long httpCode = 0;
        timeBegin = clock();

        if(method == 1)
        {
            if(!paramData.empty())
            {
                if(paramURL.find("?"))
                    paramURL.append("&");
                else
                    paramURL.append("?");
            }
            paramURL.append(paramData.data());
            curl_easy_setopt(curlSession, CURLOPT_URL, paramURL);
        }
        else if(method == 2)
        {
            curl_easy_setopt(curlSession, CURLOPT_URL, paramURL.data());
            curl_easy_setopt(curlSession, CURLOPT_POST, 1);
            curl_easy_setopt(curlSession, CURLOPT_POSTFIELDS, paramData.data());
        }
        else
        {
            if(debug)
                logprintf(">> SyncHTTP Plugin Error: Unknown method");
            return -1;
        }

        curl_easy_setopt(curlSession, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curlSession, CURLOPT_WRITEDATA, &readBuffer);
        curl_easy_setopt(curlSession, CURLOPT_FORBID_REUSE, false);
        curl_easy_setopt(curlSession, CURLOPT_TIMEOUT, timeout);
        curl_easy_setopt(curlSession, CURLOPT_FOLLOWLOCATION, true);
        curl_easy_setopt(curlSession, CURLOPT_MAXREDIRS, 50);

        response = curl_easy_perform(curlSession);

        curl_easy_getinfo (curlSession, CURLINFO_RESPONSE_CODE, &httpCode);

        if(response != CURLE_OK)
        {
            if(debug)
                logprintf(">> SyncHTTP Plugin Error: %s", curl_easy_strerror(response));
            return -1;
        }
        if(debug)
        {
            timeEnd = clock();
            timeSpent = (double)(timeEnd - timeBegin) / CLOCKS_PER_SEC;
            logprintf(">> SyncHTTP Plugin\nRequest sent to: \"%s\"\nStatus: %d\nPost: \"%s\"\nTime spent to perform request: %f sec\nResponse: \"%s\"", paramURL.c_str(), (int)httpCode, method == 2 ? paramData.c_str() : "", timeSpent, readBuffer.c_str());
        }

        SetAMXString(amx, params[3], (int)params[4], readBuffer);

        curl_easy_cleanup(curlSession);
        return (int)httpCode;
    }
    return -1;
}