api2captcha.hpp

#ifndef API2CAPTCHA_HPP
#define API2CAPTCHA_HPP

#include <cassert>

#include <string>
#include <map>
#include <chrono>
#include <stdexcept>
#include <thread>
#include <vector>

namespace api2captcha
{

   typedef std::map<std::string, std::string> params_t;
   typedef std::map<std::string, std::string> files_t;

   class exception_t : public std::runtime_error
   {
   public:
      exception_t(const std::string &s) : std::runtime_error(s) {}
   };

   class api_exception_t : public exception_t
   {
   public:
      api_exception_t(const std::string &s) : exception_t(s) {}
   };

   class timeout_exception_t : public exception_t
   {
   public:
      timeout_exception_t(const std::string &s) : exception_t(s) {}
   };

   class network_exception_t : public exception_t
   {
   public:
      network_exception_t(const std::string &s) : exception_t(s) {}
   };

   struct http_client_i
   {
      virtual ~http_client_i() {};
      virtual int status() const = 0;
      virtual std::string get(
          const std::string &url, const int timeout, const params_t &params) = 0;
      virtual std::string post(
          const std::string &url, const int timeout,
          const params_t &params, const files_t &files) = 0;
   };

   class captcha_t
   {
      std::string id_;
      std::string code_;

      mutable params_t params_;
      files_t files_;

   protected:
      void set_param(const std::string &name, const std::string &value)
      {
         params_[name] = value;
      }

      void set_file(const std::string &name, const std::string &value)
      {
         files_[name] = value;
      }

      captcha_t() {};

   public:
      // make polymorphic
      virtual ~captcha_t() {}

      const std::string &id() const { return id_; }
      const std::string &code() const { return code_; }

      void set_id(const std::string &s) { id_ = s; }
      void set_code(const std::string &s) { code_ = s; }

      void set_proxy(const std::string &type, const std::string &url)
      {
         params_["proxytype"] = type;
         params_["proxy"] = url;
      }

      void set_soft_id(const int soft_id) { params_["soft_id"] = std::to_string(soft_id); }
      void set_callback(const std::string &url) { params_["pingback"] = url; }

      const params_t &params() const
      {
         if (params_["method"].empty())
         {
            if (!params_["body"].empty())
               params_["method"] = "base64";
            else
               params_["method"] = "post";
         }
         return params_;
      }

      const files_t &files() const { return files_; }
   };

   class canvas_t : public captcha_t
   {
   public:
      canvas_t()
      {
         set_param("canvas", "1");
         set_param("recaptcha", "1");
      }

      void set_file(const std::string &path) { captcha_t::set_file("file", path); }
      void set_base64(const std::string &base64) { set_param("body", base64); }
      void set_previous_id(const int id) { set_param("previousID", std::to_string(id)); }
      void set_can_skip(const bool can) { set_param("can_no_answer", can ? "1" : "0"); }
      void set_lang(const std::string &lang) { set_param("lang", lang); }
      void set_hint_text(const std::string &text) { set_param("textinstructions", text); }
      void set_hint_img(const std::string &base64) { set_param("imginstructions", base64); }
      void set_hint_img_file(const std::string &path) { captcha_t::set_file("imginstructions", path); }
   };

   class capy_t : public captcha_t
   {
   public:
      capy_t()
      {
         set_param("method", "capy");
      }

      void set_site_key(const std::string &s) { set_param("captchakey", s); };
      void set_url(const std::string &s) { set_param("pageurl", s); };
      void set_api_server(const std::string &s) { set_param("api_server", s); };
   };

   class coordinates_t : public captcha_t
   {
   public:
      coordinates_t()
      {
         set_param("coordinatescaptcha", "1");
      }

      coordinates_t(const std::string &path)
          : coordinates_t()
      {
         set_file(path);
      }

      void set_file(const std::string &path) { captcha_t::set_file("file", path); };
      void set_base64(const std::string &base64) { set_param("body", base64); }
      void set_lang(const std::string &lang) { set_param("lang", lang); }
      void set_hint_text(const std::string &text) { set_param("textinstructions", text); }
      void set_hint_img(const std::string &base64) { set_param("imginstructions", base64); }
      void set_hint_img_file(const std::string &path) { captcha_t::set_file("imginstructions", path); }
   };

   class funcaptcha_t : public captcha_t
   {
   public:
      funcaptcha_t()
      {
         set_param("method", "funcaptcha");
      }

      void set_site_key(const std::string &s) { set_param("publickey", s); };
      void set_url(const std::string &s) { set_param("pageurl", s); };
      void set_surl(const std::string &s) { set_param("surl", s); };
      void set_user_agent(const std::string &s) { set_param("userAgent", s); };
      void set_data(const std::string &key, const std::string &value)
      {
         set_param("data[" + key + "]", value);
      }
   };

   class geetest_t : public captcha_t
   {
   public:
      geetest_t()
      {
         set_param("method", "geetest");
      }

      void set_gt(const std::string &s) { set_param("gt", s); };
      void set_challenge(const std::string &s) { set_param("challenge", s); };
      void set_url(const std::string &s) { set_param("pageurl", s); };
      void set_api_server(const std::string &s) { set_param("api_server", s); };
   };

   class grid_t : public captcha_t
   {
   public:
      grid_t() {}

      grid_t(const std::string &path)
      {
         set_file(path);
      }

      void set_file(const std::string &path) { captcha_t::set_file("file", path); };
      void set_base64(const std::string &base64) { set_param("body", base64); }
      void set_rows(const int rows) { set_param("recaptcharows", std::to_string(rows)); }
      void set_cols(const int cols) { set_param("recaptchacols", std::to_string(cols)); }
      void set_previous_id(const int id) { set_param("previousID", std::to_string(id)); }
      void set_can_skip(const bool can) { set_param("can_no_answer", can ? "1" : "0"); }
      void set_lang(const std::string &lang) { set_param("lang", lang); }
      void set_hint_text(const std::string &text) { set_param("textinstructions", text); }
      void set_hint_img(const std::string &base64) { set_param("imginstructions", base64); }
      void set_hint_img_file(const std::string &path) { captcha_t::set_file("imginstructions", path); }
   };

   class hcaptcha_t : public captcha_t
   {
   public:
      hcaptcha_t()
      {
         set_param("method", "hcaptcha");
      }

      void set_site_key(const std::string &s) { set_param("sitekey", s); };
      void set_url(const std::string &s) { set_param("pageurl", s); };
   };

   class keycaptcha_t : public captcha_t
   {
   public:
      keycaptcha_t()
      {
         set_param("method", "keycaptcha");
      }

      void set_user_id(const int user_id) { set_user_id(std::to_string(user_id)); };
      void set_user_id(const std::string &user_id) { set_param("s_s_c_user_id", user_id); };
      void set_session_id(const std::string &session_id)
      {
         set_param("s_s_c_session_id", session_id);
      }
      void set_web_server_sign(const std::string &sign)
      {
         set_param("s_s_c_web_server_sign", sign);
      }
      void set_web_server_sign2(const std::string &sign)
      {
         set_param("s_s_c_web_server_sign2", sign);
      }
      void set_url(const std::string &s) { set_param("pageurl", s); };
   };

   class normal_t : public captcha_t
   {
   public:
      normal_t() {}

      normal_t(const std::string &path)
      {
         set_file(path);
      }

      void set_file(const std::string &path) { captcha_t::set_file("file", path); };
      void set_base64(const std::string &base64) { set_param("body", base64); }

      void set_phrase(const bool ph) { set_param("phrase", ph ? "1" : "0"); }
      void set_case_sensitive(const bool cs) { set_param("regsense", cs ? "1" : "0"); }
      void set_calc(const bool calc) { set_param("calc", calc ? "1" : "0"); }
      void set_numeric(const int n) { set_param("numeric", std::to_string(n)); }
      void set_min_len(const int l) { set_param("min_len", std::to_string(l)); }
      void set_max_len(const int l) { set_param("max_len", std::to_string(l)); }

      void set_lang(const std::string &lang) { set_param("lang", lang); }
      void set_hint_text(const std::string &text) { set_param("textinstructions", text); }
      void set_hint_img(const std::string &base64) { set_param("imginstructions", base64); }
      void set_hint_img_file(const std::string &path) { captcha_t::set_file("imginstructions", path); }
   };

   class recaptcha_t : public captcha_t
   {
   public:
      recaptcha_t()
      {
         set_param("method", "userrecaptcha");
      }

      void set_site_key(const std::string &s) { set_param("googlekey", s); };
      void set_url(const std::string &s) { set_param("pageurl", s); };
      void set_invisible(const bool inv) { set_param("invisible", inv ? "1" : "0"); }
      void set_version(const std::string &s) { set_param("version", s); };
      void set_action(const std::string &s) { set_param("action", s); };
      void set_score(const double s) { set_param("min_score", std::to_string(s)); };
   };

   class rotate_t : public captcha_t
   {
   public:
      rotate_t()
      {
         set_param("method", "rotatecaptcha");
      }

      rotate_t(const std::string &path)
          : rotate_t()
      {
         set_file(path);
      }

      rotate_t(const std::vector<std::string> &paths)
          : rotate_t()
      {
         set_files(paths);
      }

      void set_file(const std::string &path) { captcha_t::set_file("file_1", path); };
      void set_files(const std::vector<std::string> &paths)
      {
         for (size_t i = 0; i < paths.size(); ++i)
            captcha_t::set_file("file_" + std::to_string(i + 1), paths[i]);
      }

      void set_angle(const int a) { set_param("angle", std::to_string(a)); }

      void set_lang(const std::string &lang) { set_param("lang", lang); }
      void set_hint_text(const std::string &text) { set_param("textinstructions", text); }
      void set_hint_img(const std::string &base64) { set_param("imginstructions", base64); }
      void set_hint_img_file(const std::string &path) { captcha_t::set_file("imginstructions", path); }
   };

   class text_t : public captcha_t
   {
   public:
      text_t()
      {
         set_param("method", "post");
      }
      text_t(const std::string &text)
          : text_t()
      {
         set_text(text);
      }

      void set_text(const std::string &s) { set_param("textcaptcha", s); };
      void set_lang(const std::string &s) { set_param("lang", s); };
   };

   class lemin : public captcha_t
   {
   public:
      lemin()
      {
         set_param("method", "lemin");
      }

      void setApiServer(const std::string &s) { set_param("api_server", s); };
      void setCaptchaid(const std::string &s) { set_param("captcha_id", s); };
      void setUrl(const std::string &s) { set_param("pageurl", s); };
   };

   class client_t
   {
      class impl_t
      {
         static const constexpr char *HOST = "2captcha.com";

         std::string api_key_;
         int soft_id_ = 4586;
         std::string callback_;
         int default_timeout_ = 120;    // sec
         int recaptcha_timeout_ = 600; // sec
         int polling_interval_ = 10;   // sec
         bool last_captcha_has_callback_ = false;
         http_client_i *http_ = nullptr;

         void check_http_response(const std::string &r)
         {
            const auto status = http_->status();
            if (status == 0)
               throw network_exception_t("Failed to send captcha");
            if (status != 200)
               throw api_exception_t("Bad captcha api status: " + std::to_string(status));
            if (r.substr(0, 6) == "ERROR_")
               throw api_exception_t("Captcha api error: " + r);
         }

         std::string do_http_in(
             const params_t &params,
             const files_t &files,
             const int timeout)
         {
            assert(is_valid());
            const auto url = std::string("https://") + HOST + "/in.php";
            const auto response = http_->post(url, timeout, params, files);
            check_http_response(response);
            return response;
         }

         std::string do_http_res(
             const params_t &params, const int timeout)
         {
            assert(is_valid());
            const auto url = std::string("https://") + HOST + "/res.php";
            const auto response = http_->get(url, timeout, params);
            check_http_response(response);
            return response;
         }

         std::string res(params_t &params, int timeout = 0)
         {
            params["key"] = api_key_;

            if (timeout <= 0)
               timeout = default_timeout_;

            return do_http_res(params, timeout);
         }

         std::string res(const std::string &action)
         {
            params_t params;
            params["action"] = action;
            return res(params);
         }

         void attach_default_params(params_t &params)
         {
            params["key"] = api_key_;

            if (!callback_.empty())
            {
               if (params.count("pingback") == 0)
               {
                  params["pingback"] = callback_;
               }
               else if (params["pingback"].empty())
               {
                  params.erase("pingback");
               }
            }

            last_captcha_has_callback_ = params.count("pingback");

            if (soft_id_ && !params.count("soft_id"))
               params["soft_id"] = std::to_string(soft_id_);
         }

         static std::string extract_ok_response(const std::string &response)
         {
            if (response.substr(0, 3) != "OK|")
               throw api_exception_t("Cannot recognize api response (" + response + ")");

            return response.substr(3);
         }

      public:
         impl_t() {}

         bool is_valid() const { return http_; }

         void set_http_client(http_client_i *http)
         {
            assert(http);
            http_ = http;
         }
         void set_api_key(const std::string &s) { api_key_ = s; }
         void set_soft_id(const int id) { soft_id_ = id; }
         void set_callback(const std::string &url) { callback_ = url; }
         void set_default_timeout(const int sec) { default_timeout_ = sec; }
         void set_recaptcha_timeout(const int sec) { recaptcha_timeout_ = sec; }
         void set_polling_interval(const int sec) { polling_interval_ = sec; }

         void solve(captcha_t &captcha)
         {
            std::map<std::string, int> wait_options;
            if (dynamic_cast<recaptcha_t *>(&captcha))
               wait_options["timeout"] = recaptcha_timeout_;

            solve(captcha, wait_options);
         }

         /* Can set 'timeout' and 'pollingInterval' options
          */
         void solve(captcha_t &captcha, const std::map<std::string, int> &wait_options)
         {
            int timeout = default_timeout_;
            auto i = wait_options.find("timeout");
            if (i != std::end(wait_options))
               timeout = i->second;

            const auto id = send(captcha, timeout);
            captcha.set_id(id);

            if (!last_captcha_has_callback_)
               wait_for_result(captcha, wait_options);
         }

         void wait_for_result(
             captcha_t &captcha, const std::map<std::string, int> &wait_options)
         {
            const auto started_at = std::chrono::steady_clock::now();

            int timeout = default_timeout_;
            auto i = wait_options.find("timeout");
            if (i != std::end(wait_options))
               timeout = i->second;

            int polling_interval = polling_interval_;
            i = wait_options.find("pollingInterval");
            if (i != std::end(wait_options))
               polling_interval = i->second;

            typedef std::chrono::duration<double> duration_t;
            double interval = 0;
            do
            {
               std::this_thread::sleep_for(std::chrono::seconds(polling_interval));

               try
               {
                  const auto result = get_result(captcha.id(), timeout);
                  if (!result.empty())
                  {
                     captcha.set_code(result);
                     return;
                  }
               }
               catch (network_exception_t &e)
               {
                  // ignore network errors
               }

               const auto now = std::chrono::steady_clock::now();

               const auto dur = std::chrono::duration_cast<duration_t>(now - started_at);
               interval = dur.count();
            } while (interval < (double)timeout);

            throw timeout_exception_t(
                "Timeout " + std::to_string(timeout) + " seconds reached");
         }

         std::string send(captcha_t &captcha, int timeout = 0)
         {
            const auto &files = captcha.files();

            // copy params
            auto params = captcha.params();

            attach_default_params(params);

            if (timeout <= 0)
               timeout = default_timeout_;

            const auto response = do_http_in(params, files, timeout);
            return extract_ok_response(response);
         }

         /**
          * Returns result of captcha if it was solved or empty string if result is not ready
          */
         std::string get_result(const std::string &id, int timeout = 0)
         {
            params_t params;
            params["action"] = "get";
            params["id"] = id;

            const auto response = res(params, timeout);

            if (response == "CAPCHA_NOT_READY")
               return "";

            return extract_ok_response(response);
         }

         double get_balance()
         {
            const auto response = res("getbalance");
            try
            {
               return std::stold(response, nullptr);
            }
            catch (...)
            {
               throw api_exception_t("Bad balance response (" + response + ")");
            }
         }

         void report(const std::string &id, const bool correct)
         {
            params_t params;
            params["id"] = id;

            if (correct)
            {
               params["action"] = "reportgood";
            }
            else
            {
               params["action"] = "reportbad";
            }

            res(params);
         }
      };

      impl_t *i_ = nullptr;

      client_t(const client_t &other);
      client_t &operator=(const client_t &other);

   public:
      client_t() : i_(new impl_t()) {}
      client_t(client_t &&other) : i_(other.i_) { other.i_ = nullptr; }
      client_t &operator=(client_t &&other)
      {
         client_t tmp(std::move(other));
         std::swap(i_, tmp.i_);
         return *this;
      }
      ~client_t() { delete i_; }

      bool is_valid() const { return i_->is_valid(); }
      void set_http_client(http_client_i *http) { return i_->set_http_client(http); }

      void set_api_key(const std::string &s) { return i_->set_api_key(s); }
      void set_soft_id(const int id) { return i_->set_soft_id(id); }
      void set_callback(const std::string &url) { return i_->set_callback(url); }
      void set_default_timeout(const int sec) { return i_->set_default_timeout(sec); }
      void set_recaptcha_timeout(const int sec) { return i_->set_recaptcha_timeout(sec); }
      void set_polling_interval(const int sec) { return i_->set_polling_interval(sec); }

      void solve(captcha_t &captcha) { return i_->solve(captcha); }

      void solve(captcha_t &captcha, const std::map<std::string, int> &wait_options)
      {
         return i_->solve(captcha, wait_options);
      }

      void wait_for_result(
          captcha_t &captcha, const std::map<std::string, int> &wait_options)
      {
         return i_->wait_for_result(captcha, wait_options);
      }

      std::string send(captcha_t &captcha, int timeout = 0)
      {
         return i_->send(captcha, timeout);
      }

      std::string get_result(const std::string &id, int timeout = 0)
      {
         return i_->get_result(id, timeout);
      }

      double get_balance()
      {
         return i_->get_balance();
      }

      void report(const std::string &id, const bool correct)
      {
         return i_->report(id, correct);
      }
   };

};

#endif /* API2CAPTCHA_HPP */