utils/http.c

 
#include <freerdp/config.h>
#include <freerdp/utils/http.h>
 
#include <winpr/assert.h>
#include <winpr/string.h>
 
#include <openssl/bio.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
 
#include <freerdp/log.h>
#define TAG FREERDP_TAG("utils.http")
 
static const char get_header_fmt[] = "GET %s HTTP/1.1\r\n"
                                     "Host: %s\r\n"
                                     "\r\n";
 
static const char post_header_fmt[] = "POST %s HTTP/1.1\r\n"
                                      "Host: %s\r\n"
                                      "Content-Type: application/x-www-form-urlencoded\r\n"
                                      "Content-Length: %lu\r\n"
                                      "\r\n";
 
#define log_errors(log, msg) log_errors_(log, msg, __FILE__, __func__, __LINE__)
static void log_errors_(wLog* log, const char* msg, const char* file, const char* fkt, size_t line)
{
  const DWORD level = WLOG_ERROR;
  unsigned long ec = 0;
 
  if (!WLog_IsLevelActive(log, level))
    return;
 
  BOOL error_logged = FALSE;
  while ((ec = ERR_get_error()))
  {
    error_logged = TRUE;
    WLog_PrintTextMessage(log, level, line, file, fkt, "%s: %s", msg,
                          ERR_error_string(ec, NULL));
  }
  if (!error_logged)
    WLog_PrintTextMessage(log, level, line, file, fkt, "%s (no details available)", msg);
}
 
static int get_line(BIO* bio, char* buffer, size_t size)
{
#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
  if (size <= 1)
    return -1;
 
  size_t pos = 0;
  do
  {
    int rc = BIO_read(bio, &buffer[pos], 1);
    if (rc <= 0)
      return rc;
    char cur = buffer[pos];
    pos += rc;
    if ((cur == '\n') || (pos >= size - 1))
    {
      buffer[pos] = '\0';
      return (int)pos;
    }
  } while (1);
#else
  if (size > INT32_MAX)
    return -1;
  return BIO_get_line(bio, buffer, (int)size);
#endif
}
 
BOOL freerdp_http_request(const char* url, const char* body, long* status_code, BYTE** response,
                          size_t* response_length)
{
  BOOL ret = FALSE;
  char* hostname = NULL;
  const char* path = NULL;
  char* headers = NULL;
  size_t size = 0;
  int status = 0;
  char buffer[1024] = { 0 };
  BIO* bio = NULL;
  SSL_CTX* ssl_ctx = NULL;
  SSL* ssl = NULL;
 
  WINPR_ASSERT(status_code);
  WINPR_ASSERT(response);
  WINPR_ASSERT(response_length);
 
  wLog* log = WLog_Get(TAG);
  WINPR_ASSERT(log);
 
  *response = NULL;
 
  if (!url || strnlen(url, 8) < 8 || strncmp(url, "https://", 8) != 0 ||
      !(path = strchr(url + 8, '/')))
  {
    WLog_Print(log, WLOG_ERROR, "invalid url provided");
    goto out;
  }
 
  {
    const size_t len = WINPR_ASSERTING_INT_CAST(size_t, path - (url + 8));
    hostname = strndup(&url[8], len);
  }
  if (!hostname)
    return FALSE;
 
  {
    size_t blen = 0;
    if (body)
    {
      blen = strlen(body);
      if (winpr_asprintf(&headers, &size, post_header_fmt, path, hostname, blen) < 0)
      {
        free(hostname);
        return FALSE;
      }
    }
    else
    {
      if (winpr_asprintf(&headers, &size, get_header_fmt, path, hostname) < 0)
      {
        free(hostname);
        return FALSE;
      }
    }
 
    ssl_ctx = SSL_CTX_new(TLS_client_method());
 
    if (!ssl_ctx)
    {
      log_errors(log, "could not set up ssl context");
      goto out;
    }
 
    if (!SSL_CTX_set_default_verify_paths(ssl_ctx))
    {
      log_errors(log, "could not set ssl context verify paths");
      goto out;
    }
 
    SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
 
    bio = BIO_new_ssl_connect(ssl_ctx);
    if (!bio)
    {
      log_errors(log, "could not set up connection");
      goto out;
    }
 
    if (BIO_set_conn_port(bio, "https") <= 0)
    {
      log_errors(log, "could not set port");
      goto out;
    }
 
    if (!BIO_set_conn_hostname(bio, hostname))
    {
      log_errors(log, "could not set hostname");
      goto out;
    }
 
    BIO_get_ssl(bio, &ssl);
    if (!ssl)
    {
      log_errors(log, "could not get ssl");
      goto out;
    }
 
    if (!SSL_set_tlsext_host_name(ssl, hostname))
    {
      log_errors(log, "could not set sni hostname");
      goto out;
    }
 
    WLog_Print(log, WLOG_DEBUG, "headers:\n%s", headers);
    ERR_clear_error();
 
    {
      const size_t hlen = strnlen(headers, size);
      if (hlen > INT32_MAX)
        goto out;
 
      if (BIO_write(bio, headers, (int)hlen) < 0)
      {
        log_errors(log, "could not write headers");
        goto out;
      }
 
      if (body)
      {
        WLog_Print(log, WLOG_DEBUG, "body:\n%s", body);
 
        if (blen > INT_MAX)
        {
          WLog_Print(log, WLOG_ERROR, "body too long!");
          goto out;
        }
 
        ERR_clear_error();
        if (BIO_write(bio, body, (int)blen) < 0)
        {
          log_errors(log, "could not write body");
          goto out;
        }
      }
    }
  }
 
  status = get_line(bio, buffer, sizeof(buffer));
  if (status <= 0)
  {
    log_errors(log, "could not read response");
    goto out;
  }
 
  // NOLINTNEXTLINE(cert-err34-c)
  if (sscanf(buffer, "HTTP/1.1 %li %*[^\r\n]\r\n", status_code) < 1)
  {
    WLog_Print(log, WLOG_ERROR, "invalid HTTP status line");
    goto out;
  }
 
  do
  {
    status = get_line(bio, buffer, sizeof(buffer));
    if (status <= 0)
    {
      log_errors(log, "could not read response");
      goto out;
    }
 
    char* val = NULL;
    char* name = strtok_s(buffer, ":", &val);
    if (name && (_stricmp(name, "content-length") == 0))
    {
      errno = 0;
      *response_length = strtoul(val, NULL, 10);
      if (errno)
      {
        char ebuffer[256] = { 0 };
        WLog_Print(log, WLOG_ERROR, "could not parse content length (%s): %s [%d]", val,
                   winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
        goto out;
      }
    }
  } while (strcmp(buffer, "\r\n") != 0);
 
  if (*response_length > 0)
  {
    if (*response_length > INT_MAX)
    {
      WLog_Print(log, WLOG_ERROR, "response too long!");
      goto out;
    }
 
    *response = calloc(1, *response_length + 1);
    if (!*response)
      goto out;
 
    BYTE* p = *response;
    size_t left = *response_length;
    while (left > 0)
    {
      const int rd = (left < INT32_MAX) ? (int)left : INT32_MAX;
      status = BIO_read(bio, p, rd);
      if (status <= 0)
      {
        log_errors(log, "could not read response");
        goto out;
      }
      p += status;
      if ((size_t)status > left)
        break;
      left -= (size_t)status;
    }
  }
 
  WLog_Print(log, WLOG_DEBUG, "response[%" PRIuz "]:\n%s", *response_length,
             (const char*)(*response));
  ret = TRUE;
 
out:
  if (!ret)
  {
    free(*response);
    *response = NULL;
    *response_length = 0;
  }
  free(hostname);
  free(headers);
  BIO_free_all(bio);
  SSL_CTX_free(ssl_ctx);
  return ret;
}
 
const char* freerdp_http_status_string(long status)
{
  switch (status)
  {
    case HTTP_STATUS_CONTINUE:
      return "HTTP_STATUS_CONTINUE";
    case HTTP_STATUS_SWITCH_PROTOCOLS:
      return "HTTP_STATUS_SWITCH_PROTOCOLS";
    case HTTP_STATUS_OK:
      return "HTTP_STATUS_OK";
    case HTTP_STATUS_CREATED:
      return "HTTP_STATUS_CREATED";
    case HTTP_STATUS_ACCEPTED:
      return "HTTP_STATUS_ACCEPTED";
    case HTTP_STATUS_PARTIAL:
      return "HTTP_STATUS_PARTIAL";
    case HTTP_STATUS_NO_CONTENT:
      return "HTTP_STATUS_NO_CONTENT";
    case HTTP_STATUS_RESET_CONTENT:
      return "HTTP_STATUS_RESET_CONTENT";
    case HTTP_STATUS_PARTIAL_CONTENT:
      return "HTTP_STATUS_PARTIAL_CONTENT";
    case HTTP_STATUS_WEBDAV_MULTI_STATUS:
      return "HTTP_STATUS_WEBDAV_MULTI_STATUS";
    case HTTP_STATUS_AMBIGUOUS:
      return "HTTP_STATUS_AMBIGUOUS";
    case HTTP_STATUS_MOVED:
      return "HTTP_STATUS_MOVED";
    case HTTP_STATUS_REDIRECT:
      return "HTTP_STATUS_REDIRECT";
    case HTTP_STATUS_REDIRECT_METHOD:
      return "HTTP_STATUS_REDIRECT_METHOD";
    case HTTP_STATUS_NOT_MODIFIED:
      return "HTTP_STATUS_NOT_MODIFIED";
    case HTTP_STATUS_USE_PROXY:
      return "HTTP_STATUS_USE_PROXY";
    case HTTP_STATUS_REDIRECT_KEEP_VERB:
      return "HTTP_STATUS_REDIRECT_KEEP_VERB";
    case HTTP_STATUS_BAD_REQUEST:
      return "HTTP_STATUS_BAD_REQUEST";
    case HTTP_STATUS_DENIED:
      return "HTTP_STATUS_DENIED";
    case HTTP_STATUS_PAYMENT_REQ:
      return "HTTP_STATUS_PAYMENT_REQ";
    case HTTP_STATUS_FORBIDDEN:
      return "HTTP_STATUS_FORBIDDEN";
    case HTTP_STATUS_NOT_FOUND:
      return "HTTP_STATUS_NOT_FOUND";
    case HTTP_STATUS_BAD_METHOD:
      return "HTTP_STATUS_BAD_METHOD";
    case HTTP_STATUS_NONE_ACCEPTABLE:
      return "HTTP_STATUS_NONE_ACCEPTABLE";
    case HTTP_STATUS_PROXY_AUTH_REQ:
      return "HTTP_STATUS_PROXY_AUTH_REQ";
    case HTTP_STATUS_REQUEST_TIMEOUT:
      return "HTTP_STATUS_REQUEST_TIMEOUT";
    case HTTP_STATUS_CONFLICT:
      return "HTTP_STATUS_CONFLICT";
    case HTTP_STATUS_GONE:
      return "HTTP_STATUS_GONE";
    case HTTP_STATUS_LENGTH_REQUIRED:
      return "HTTP_STATUS_LENGTH_REQUIRED";
    case HTTP_STATUS_PRECOND_FAILED:
      return "HTTP_STATUS_PRECOND_FAILED";
    case HTTP_STATUS_REQUEST_TOO_LARGE:
      return "HTTP_STATUS_REQUEST_TOO_LARGE";
    case HTTP_STATUS_URI_TOO_LONG:
      return "HTTP_STATUS_URI_TOO_LONG";
    case HTTP_STATUS_UNSUPPORTED_MEDIA:
      return "HTTP_STATUS_UNSUPPORTED_MEDIA";
    case HTTP_STATUS_RETRY_WITH:
      return "HTTP_STATUS_RETRY_WITH";
    case HTTP_STATUS_SERVER_ERROR:
      return "HTTP_STATUS_SERVER_ERROR";
    case HTTP_STATUS_NOT_SUPPORTED:
      return "HTTP_STATUS_NOT_SUPPORTED";
    case HTTP_STATUS_BAD_GATEWAY:
      return "HTTP_STATUS_BAD_GATEWAY";
    case HTTP_STATUS_SERVICE_UNAVAIL:
      return "HTTP_STATUS_SERVICE_UNAVAIL";
    case HTTP_STATUS_GATEWAY_TIMEOUT:
      return "HTTP_STATUS_GATEWAY_TIMEOUT";
    case HTTP_STATUS_VERSION_NOT_SUP:
      return "HTTP_STATUS_VERSION_NOT_SUP";
    default:
      return "HTTP_STATUS_UNKNOWN";
  }
}
 
const char* freerdp_http_status_string_format(long status, char* buffer, size_t size)
{
  const char* code = freerdp_http_status_string(status);
  (void)_snprintf(buffer, size, "%s [%ld]", code, status);
  return buffer;
}