1 files changed, 359 insertions, 0 deletions

@@ -0,0 +1,359 @@
+/*
+ * Copyright (C) 2008 Tantric
+ * Copyright (C) 2012 Pedro Aguiar
+ * Copyright (C) 2017 hatkirby
+ *
+ * Originally part of the WiiTweet project, which was distributed under the
+ * GPL.
+ */
+#include "http.h"
+#include <gccore.h>
+#include <network.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <ogcsys.h>
+#include <ogc/lwp_watchdog.h>
+#include <sys/errno.h>
+#include <string.h>
+#include <stdio.h>
+
+#define TCP_CONNECT_TIMEOUT       4000
+#define TCP_SEND_SIZE                 (32 * 1024)
+#define TCP_RECV_SIZE                 (32 * 1024)
+#define TCP_BLOCK_RECV_TIMEOUT  4000
+#define TCP_BLOCK_SEND_TIMEOUT  4000
+#define TCP_BLOCK_SIZE                1024
+#define HTTP_TIMEOUT                    10000
+#define IOS_O_NONBLOCK                0x04
+
+static int tcpWrite(
+  bool secure,
+  void* firstParam,
+  const u8* buffer,
+  u32 length)
+{
+  int left = length;
+  int sent = 0;
+  int step = 0;
+
+  u64 t = gettime();
+  while (left)
+  {
+    if (ticks_to_millisecs(diff_ticks(t, gettime())) > TCP_BLOCK_SEND_TIMEOUT)
+    {
+      return HTTPR_ERR_TIMEOUT;
+    }
+
+    int block = left;
+    if (block > TCP_SEND_SIZE)
+    {
+      block = TCP_SEND_SIZE;
+    }
+
+    int result;
+    if (secure)
+    {
+      result = wolfSSL_write(*(WOLFSSL**)firstParam, buffer, block);
+    } else {
+      result = net_write(*(s32*)firstParam, buffer, block);
+    }
+
+    if ((result == 0) || (result == -56))
+    {
+      usleep(20 * 1000);
+
+      continue;
+    }
+
+    if (result < 0)
+    {
+      break;
+    }
+
+    sent += result;
+    left -= result;
+    buffer += result;
+    usleep(100);
+
+    if ((sent / TCP_BLOCK_SIZE) > step)
+    {
+      t = gettime();
+      step++;
+    }
+  }
+
+  if (left == 0)
+  {
+    return HTTPR_OK;
+  } else {
+    return HTTPR_ERR_WRITE;
+  }
+}
+
+static int tcpRead(
+  bool secure,
+  void* firstParam,
+  char* buffer,
+  u16 maxLength)
+{
+  u64 startTime = gettime();
+  u16 cur = 0;
+
+  while (cur < maxLength)
+  {
+    if (ticks_to_millisecs(diff_ticks(startTime, gettime())) > HTTP_TIMEOUT)
+    {
+      return HTTPR_ERR_TIMEOUT;
+    }
+
+    u32 result;
+    if (secure)
+    {
+      result = wolfSSL_read(*(WOLFSSL**)firstParam, &buffer[cur], 1);
+    } else {
+      result = net_read(*(s32*)firstParam, &buffer[cur], 1);
+    }
+
+    if (result == -EAGAIN)
+    {
+      usleep(20 * 1000);
+
+      continue;
+    }
+
+    if (result <= 0)
+    {
+      break;
+    }
+
+    if ((cur > 0) && (buffer[cur-1] == '\r') && (buffer[cur] == '\n'))
+    {
+      buffer[cur-1] = 0;
+
+      return HTTPR_OK;
+    }
+
+    cur++;
+    startTime = gettime();
+    usleep(100);
+  }
+
+  return HTTPR_ERR_RECEIVE;
+}
+
+int submitToApi(
+  const char* endpoint,
+  WOLFSSL_CTX* sslContext,
+  cJSON* data,
+  const char* username,
+  const char* password)
+{
+  // Form request body.
+  cJSON* jRequestBody = cJSON_CreateObject();
+
+  cJSON_AddItemToObject(jRequestBody, "game", data);
+
+  cJSON_AddItemToObject(
+    jRequestBody,
+    "username",
+    cJSON_CreateString(username));
+
+  cJSON_AddItemToObject(
+    jRequestBody,
+    "password",
+    cJSON_CreateString(password));
+
+  const char* requestBody = cJSON_PrintUnformatted(jRequestBody);
+
+  // Gather data from endpoint URL.
+  char httpHost[64];
+  char httpPath[256];
+  int httpPort = 80;
+  bool secure = false;
+
+  if (!strncasecmp(endpoint, "https://", 8))
+  {
+    endpoint += 8;
+    secure = true;
+    httpPort = 443;
+  } else if (!strncasecmp(endpoint, "http://", 7))
+  {
+    endpoint += 7;
+  } else {
+    return 10;
+  }
+
+  char* solidus = strchr(endpoint, '/');
+  if ((solidus == NULL) || (solidus[0] == 0))
+  {
+    return 11;
+  }
+
+  char* colon = strchr(endpoint, ':');
+  if (colon != NULL)
+  {
+    snprintf(httpHost, colon - endpoint + 1, "%s", endpoint);
+    sscanf(colon + 1, "%d", &httpPort);
+  } else {
+    snprintf(httpHost, solidus - endpoint + 1, "%s", endpoint);
+  }
+
+  strcpy(httpPath, solidus);
+
+  // Connect to endpoint.
+  printf("Connecting...\n");
+
+  s32 socket = net_socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
+  if (socket < 0)
+  {
+    return HTTPR_ERR_CONNECT;
+  }
+
+  if (!secure)
+  {
+    int result = net_fcntl(socket, F_GETFL, 0);
+    if (result < 0)
+    {
+      net_close(socket);
+
+      return HTTPR_ERR_CONNECT;
+    }
+
+    if (net_fcntl(socket, F_SETFL, result | IOS_O_NONBLOCK))
+    {
+      net_close(socket);
+
+      return HTTPR_ERR_CONNECT;
+    }
+  }
+
+  struct sockaddr_in sa;
+  memset(&sa, 0, sizeof(struct sockaddr_in));
+  sa.sin_family = PF_INET;
+  sa.sin_len = sizeof(struct sockaddr_in);
+  sa.sin_port = htons(httpPort);
+
+  struct in_addr inAddr;
+  if ((strlen(httpHost) < 16) && (inet_aton(httpHost, &inAddr)))
+  {
+    sa.sin_addr.s_addr = inAddr.s_addr;
+  } else {
+    struct hostent* hp = net_gethostbyname(httpHost);
+    if (!hp || (hp->h_addrtype != PF_INET))
+    {
+      return HTTPR_ERR_CONNECT;
+    }
+
+    memcpy(
+      (char*) &sa.sin_addr,
+      hp->h_addr_list[0],
+      hp->h_length);
+  }
+
+  u64 time1 = ticks_to_secs(gettime());
+  s32 connectResult;
+  do
+  {
+    connectResult = net_connect(
+      socket,
+      (struct sockaddr*) &sa,
+      sizeof(sa));
+
+    if (ticks_to_secs(gettime()) - time1 > TCP_CONNECT_TIMEOUT*1000)
+    {
+      break;
+    }
+  } while (connectResult != -EISCONN);
+
+  if (connectResult != -EISCONN)
+  {
+    net_close(socket);
+
+    return HTTPR_ERR_CONNECT;
+  }
+
+  // Initialize SSL, if necessary.
+  WOLFSSL* sslHandle = 0;
+  if (secure)
+  {
+    sslHandle = wolfSSL_new(sslContext);
+    if (sslHandle == NULL)
+    {
+      net_close(socket);
+
+      return HTTPR_ERR_SSL;
+    }
+
+    wolfSSL_set_fd(sslHandle, socket);
+  }
+
+  // Send request.
+  printf("Sending...\n");
+
+  void* firstParam = 0;
+
+  if (secure)
+  {
+    firstParam = &sslHandle;
+  } else {
+    firstParam = &socket;
+  }
+
+  char requestHeader[1024];
+  char* r = requestHeader;
+  r += sprintf(r, "POST %s HTTP/1.1\r\n", httpPath);
+  r += sprintf(r, "Host: %s\r\n", httpHost);
+  r += sprintf(r, "Content-Type: application/json\r\n");
+  r += sprintf(r, "Content-Length: %d\r\n\r\n", strlen(requestBody));
+
+  int result = tcpWrite(
+    secure,
+    firstParam,
+    (u8*) requestHeader,
+    strlen(requestHeader));
+  if (result != HTTPR_OK)
+  {
+    return result;
+  }
+
+  result = tcpWrite(
+    secure,
+    firstParam,
+    (u8*) requestBody,
+    strlen(requestBody));
+
+  if (result != HTTPR_OK)
+  {
+    return result;
+  }
+
+  // Read response.
+  char line[1024];
+  int httpStatus = 404;
+  while (!tcpRead(secure, firstParam, line, 1024))
+  {
+    if (!line[0])
+    {
+      break;
+    }
+
+    sscanf(line, "HTTP/1.%*u %u", &httpStatus);
+  }
+
+  if (httpStatus != 200)
+  {
+    return HTTPR_ERR_STATUS;
+  }
+
+  // Clean up.
+  if (secure)
+  {
+    wolfSSL_free(sslHandle);
+  }
+
+  net_close(socket);
+
+  cJSON_Delete(jRequestBody);
+
+  return HTTPR_OK;
+}