sCurl.h

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef S_CURL_H
#define S_CURL_H
 
#include <scolPlugin.h>
#include <string>
#include <vector>
#ifdef _WIN32
# include <ws2tcpip.h>
#endif
 
#include <boost/thread.hpp>
 
#include "curl/curl.h"
#include "sService.h"
 
#include <string>
#include <algorithm>    // find
 
struct Uri
{
public:
  std::string QueryString, Path, Protocol, Host, Port;
 
  static Uri Parse(const std::string &uri)
  {
    Uri result;
 
    typedef std::string::const_iterator iterator_t;
 
    if (uri.length() == 0)
      return result;
 
    iterator_t uriEnd = uri.end();
 
    // get query start
    iterator_t queryStart = std::find(uri.begin(), uriEnd, '?');
 
    // protocol
    iterator_t protocolStart = uri.begin();
    iterator_t protocolEnd = std::find(protocolStart, uriEnd, ':');            //"://");
 
    if (protocolEnd != uriEnd)
    {
      std::string prot = &*(protocolEnd);
      if ((prot.length() >= 3) && (prot.substr(0, 3) == "://"))
      {
        result.Protocol = std::string(protocolStart, protocolEnd);
        protocolEnd += 3;   //      ://
      }
      else
        protocolEnd = uri.begin();  // no protocol
    }
    else
      protocolEnd = uri.begin();  // no protocol
 
    // host
    iterator_t hostStart = protocolEnd;
    iterator_t pathStart = std::find(hostStart, uriEnd, '/');  // get pathStart
 
    iterator_t hostEnd = std::find(protocolEnd,
      (pathStart != uriEnd) ? pathStart : queryStart,
      ':');  // check for port
 
    result.Host = std::string(hostStart, hostEnd);
 
    // port
    if ((hostEnd != uriEnd) && ((&*(hostEnd))[0] == ':'))  // we have a port
    {
      hostEnd++;
      iterator_t portEnd = (pathStart != uriEnd) ? pathStart : queryStart;
      result.Port = std::string(hostEnd, portEnd);
    }
 
    // path
    if (pathStart != uriEnd)
      result.Path = std::string(pathStart, queryStart);
 
    // query
    if (queryStart != uriEnd)
      result.QueryString = std::string(queryStart, uri.end());
 
    return result;
 
  }   // Parse
};  // uri
 
class SCbData
{
public:
  char* data;
  unsigned int size;
  int code;
protected:
private:
 
public:
        SCbData()
        {
    data = 0;
                size = 0;
    code = -1;
        };
  SCbData(char* mdata, const unsigned int& msize, const int& mcode)
        {
    data = (char*) malloc(msize + 1);
    memcpy(data, mdata, msize);
    data[msize] = 0;
                size = msize;
                code = mcode;
        };
 
  ~SCbData()
  {
    if(data)
      free(data);
  };
protected:
private:
};
 
class SFormField
{
public:
  std::string name;
  std::string value;
  bool file;
protected:
private:
 
public:
        SFormField()
        {
                name = "";
                value = "";
                file = false;
        };
  SFormField(const std::string& mname, const std::string& mvalue, const bool& mfile)
        {
                name = mname;
                value = mvalue;
                file = mfile;
        };
 
  ~SFormField()
  {
  };
protected:
private:
};
 
class SCurlOption
{
public:
typedef struct {
        char *buf;
        int len;
        int pos;
} readArg;
  
  CURLoption option;
  std::string svalue;
  long lvalue;
  std::vector<std::string> values;
  readArg uploadData;
  int type;
  int lines_read;
protected:
private:
 
public:
        SCurlOption()
        {
                lvalue = 0;
    uploadData.buf = 0;
        };
 
  SCurlOption(const CURLoption& moption, const long& mvalue)
        {
                option = moption;
                lvalue = mvalue;
    uploadData.buf = 0;
    type = 0;
        };
 
  SCurlOption(const CURLoption& moption, const std::string& mvalue)
        {
                option = moption;
                svalue = mvalue;
    uploadData.buf = 0;
    type = 1;
        };
 
  SCurlOption(const CURLoption& moption, const std::vector<std::string>& mvalue)
        {
                option = moption;
                values = mvalue;
    uploadData.buf = 0;
    type = 2;
        };
 
  SCurlOption(const CURLoption& moption, const char* mvalue, const unsigned int size)
        {
                option = moption;
 
    uploadData.buf = (char*)malloc(size + 1);
    memcpy(uploadData.buf, mvalue, size);
    uploadData.len = size;
    uploadData.pos = 0;
    type = 3;
        };
 
  ~SCurlOption()
  {
  };
 
  static size_t payloadSource(void *ptr, size_t size, size_t nmemb, void *userp)
  {
    SCurlOption* curOpt = (SCurlOption *)userp;
 
          unsigned int len = curOpt->uploadData.len - curOpt->uploadData.pos;
          if (len > size * nmemb)
                  len = size * nmemb;
          memcpy(ptr, curOpt->uploadData.buf + curOpt->uploadData.pos, len);
          curOpt->uploadData.pos += len;
 
    if (curOpt->uploadData.pos >= curOpt->uploadData.len)
    {
             free(curOpt->uploadData.buf);
       curOpt->uploadData.buf = 0;
    }
    //printf("readcb: %d bytes\n", len);
          return len;
  }
protected:
private:
};
 
class SCurl
{
public:
protected:
  bool m_terminate;
private:
  CURL* m_curl;
  std::string m_url;
  boost::mutex m_terminateMutex;
  boost::mutex m_mutex;
  boost::mutex m_thread_lock;
 
  /* Options */
  std::vector<SCurlOption> m_options;
 
  /* Forms */
  std::vector<SFormField> m_formFields;
public:
  static bool CheckUrl(const std::string& url_s);
 
        SCurl(const std::string& url);
        
        ~SCurl();
 
  void CallAsync();
  void CallSync();
 
  void SetHeader(const std::vector<std::string>& header);
  void SetOption(const CURLoption& opt, const std::string& value);
  void SetOption(const CURLoption& opt, const int& value);
  void SetOption(const CURLoption& opt, const std::vector<std::string>& value);
  void SetOption(const CURLoption& opt, const char* mvalue, const unsigned int size);
 
  void AddFormField(const std::string& name, const std::string& value, const bool& file);
protected:
private:
  static size_t Write_data(char* ptr, size_t size, size_t nmemb, void* userdata);
  int Progress(void *userdata, double dltotal, double dlnow, double ultotal, double ulnow);
  void ExecSync();
};
 
#endif