1 files changed, 264 insertions, 0 deletions

@@ -0,0 +1,264 @@
+#include "request.h"
+#include <json.hpp>
+#include "codes.h"
+
+// These are here for debugging curl stuff
+
+static
+void dump(const char *text,
+          FILE *stream, unsigned char *ptr, size_t size)
+{
+  size_t i;
+  size_t c;
+  unsigned int width=80;
+
+  fprintf(stream, "%s, %10.10ld bytes (0x%8.8lx)\n",
+          text, (long)size, (long)size);
+
+  for(i=0; i<size; i+= width) {
+    fprintf(stream, "%4.4lx: ", (long)i);
+
+    /* show hex to the left
+    for(c = 0; c < width; c++) {
+      if(i+c < size)
+        fprintf(stream, "%02x ", ptr[i+c]);
+      else
+        fputs("   ", stream);
+    }*/
+
+    /* show data on the right */
+    for(c = 0; (c < width) && (i+c < size); c++) {
+      char x = (ptr[i+c] >= 0x20 && ptr[i+c] < 0x80) ? ptr[i+c] : '.';
+      fputc(x, stream);
+    }
+
+    fputc('\n', stream); /* newline */
+  }
+}
+
+static
+int my_trace(CURL *handle, curl_infotype type,
+             char *data, size_t size,
+             void *userp)
+{
+  const char *text;
+  (void)handle; /* prevent compiler warning */
+
+  switch (type) {
+  case CURLINFO_TEXT:
+    fprintf(stderr, "== Info: %s", data);
+  default: /* in case a new one is introduced to shock us */
+    return 0;
+
+  case CURLINFO_HEADER_OUT:
+    text = "=> Send header";
+    break;
+  case CURLINFO_DATA_OUT:
+    text = "=> Send data";
+    break;
+  case CURLINFO_SSL_DATA_OUT:
+    text = "=> Send SSL data";
+    break;
+  case CURLINFO_HEADER_IN:
+    text = "<= Recv header";
+    break;
+  case CURLINFO_DATA_IN:
+    text = "<= Recv data";
+    break;
+  case CURLINFO_SSL_DATA_IN:
+    text = "<= Recv SSL data";
+    break;
+  }
+
+  dump(text, stderr, (unsigned char *)data, size);
+  return 0;
+}
+
+namespace twitter {
+
+  request::request(
+    std::string url) try :
+      ios_(output_),
+      conn_(ios_)
+  {
+    conn_.add<CURLOPT_URL>(url.c_str());
+  } catch (const curl::curl_easy_exception& error)
+  {
+    std::throw_with_nested(connection_error());
+  }
+
+  std::string request::perform()
+  {
+    try
+    {
+      conn_.perform();
+    } catch (const curl::curl_easy_exception& error)
+    {
+      std::throw_with_nested(connection_error());
+    }
+
+    int response_code = conn_.get_info<CURLINFO_RESPONSE_CODE>().get();
+    std::string result = output_.str();
+
+    if (response_code / 100 != 2)
+    {
+      nlohmann::json response_json;
+
+      try
+      {
+        response_json = nlohmann::json::parse(result);
+      } catch (const std::invalid_argument& e)
+      {
+        std::throw_with_nested(invalid_response(result));
+      }
+
+      for (nlohmann::json& error : response_json["errors"])
+      {
+        int error_code;
+        std::string error_message;
+
+        try
+        {
+          error_code = error["code"].get<int>();
+          error_message = error["message"].get<std::string>();
+        } catch (const std::domain_error& e)
+        {
+          std::throw_with_nested(invalid_response(result));
+        }
+
+        switch (error_code)
+        {
+        case 32:
+        case 135:
+        case 215:
+          throw bad_auth(error_message);
+
+        case 44:
+          throw invalid_media(error_message);
+
+        case 64:
+          throw account_suspended(error_message);
+
+        case 88:
+          throw rate_limit_exceeded(error_message);
+
+        case 89:
+          throw bad_token(error_message);
+
+        case 130:
+          throw server_overloaded(error_message);
+
+        case 131:
+          throw server_error(error_message);
+
+        case 185:
+          throw update_limit_exceeded(error_message);
+
+        case 186:
+          throw bad_length(error_message);
+
+        case 187:
+          throw duplicate_status(error_message);
+
+        case 226:
+          throw suspected_spam(error_message);
+
+        case 261:
+          throw write_restricted(error_message);
+        }
+      }
+
+      if (response_code == 429)
+      {
+        throw rate_limit_exceeded("HTTP 429 Too Many Requests");
+      } else if (response_code == 500)
+      {
+        throw server_error("HTTP 500 Internal Server Error");
+      } else if (response_code == 502)
+      {
+        throw server_unavailable("HTTP 502 Bad Gateway");
+      } else if (response_code == 503)
+      {
+        throw server_overloaded("HTTP 503 Service Unavailable");
+      } else if (response_code == 504)
+      {
+        throw server_timeout("HTTP 504 Gateway Timeout");
+      }
+
+      throw unknown_error(response_code, result);
+    }
+
+    return result;
+  }
+
+  get::get(
+    const auth& tauth,
+    std::string url) try :
+      request(url)
+  {
+    std::string oauthHeader =
+      tauth.getClient().getFormattedHttpHeader(OAuth::Http::Get, url, "");
+
+    if (!oauthHeader.empty())
+    {
+      headers_.add(std::move(oauthHeader));
+    }
+
+    conn_.add<CURLOPT_HTTPHEADER>(headers_.get());
+  } catch (const OAuth::ParseError& error)
+  {
+    std::throw_with_nested(connection_error());
+  } catch (const curl::curl_easy_exception& error)
+  {
+    std::throw_with_nested(connection_error());
+  }
+
+  post::post(
+    const auth& tauth,
+    std::string url,
+    std::string datastr) try :
+      request(url)
+  {
+    std::string oauthHeader =
+      tauth.getClient().getFormattedHttpHeader(OAuth::Http::Post, url, datastr);
+
+    if (!oauthHeader.empty())
+    {
+      headers_.add(std::move(oauthHeader));
+    }
+
+    conn_.add<CURLOPT_HTTPHEADER>(headers_.get());
+    conn_.add<CURLOPT_COPYPOSTFIELDS>(datastr.c_str());
+  } catch (const OAuth::ParseError& error)
+  {
+    std::throw_with_nested(connection_error());
+  } catch (const curl::curl_easy_exception& error)
+  {
+    std::throw_with_nested(connection_error());
+  }
+
+  multipost::multipost(
+    const auth& tauth,
+    std::string url,
+    const curl_httppost* fields) try :
+      request(url)
+  {
+    std::string oauthHeader =
+      tauth.getClient().getFormattedHttpHeader(OAuth::Http::Post, url, "");
+
+    if (!oauthHeader.empty())
+    {
+      headers_.add(std::move(oauthHeader));
+    }
+
+    conn_.add<CURLOPT_HTTPHEADER>(headers_.get());
+    conn_.add<CURLOPT_HTTPPOST>(fields);
+  } catch (const OAuth::ParseError& error)
+  {
+    std::throw_with_nested(connection_error());
+  } catch (const curl::curl_easy_exception& error)
+  {
+    std::throw_with_nested(connection_error());
+  }
+
+}