src/libgame/http.c

   1 // ============================================================================
   2 // Artsoft Retro-Game Library
   3 // ----------------------------------------------------------------------------
   4 // (c) 1995-2021 by Artsoft Entertainment
   5 //                  Holger Schemel
   6 //                  info@artsoft.org
   7 //                  https://www.artsoft.org/
   8 // ----------------------------------------------------------------------------
   9 // http.c
  10 // ============================================================================
  11
  12 #include <sys/stat.h>
  13
  14 #include "platform.h"
  15
  16 #include "http.h"
  17 #include "misc.h"
  18
  19
  20 static char http_error[MAX_HTTP_ERROR_SIZE];
  21
  22 static void SetHttpError(char *format, ...)
  23 {
  24   va_list ap;
  25
  26   va_start(ap, format);
  27   vsnprintf(http_error, MAX_HTTP_ERROR_SIZE, format, ap);
  28   va_end(ap);
  29 }
  30
  31 char *GetHttpError(void)
  32 {
  33   return http_error;
  34 }
  35
  36 void ConvertHttpRequestBodyToServerEncoding(struct HttpRequest *request)
  37 {
  38   char *body_utf8 = getUTF8FromLatin1(request->body);
  39
  40   strncpy(request->body, body_utf8, MAX_HTTP_BODY_SIZE);
  41   request->body[MAX_HTTP_BODY_SIZE] = '\0';
  42
  43   checked_free(body_utf8);
  44 }
  45
  46 void ConvertHttpResponseBodyToClientEncoding(struct HttpResponse *response)
  47 {
  48   char *body_latin1 = getLatin1FromUTF8(response->body);
  49
  50   strncpy(response->body, body_latin1, MAX_HTTP_BODY_SIZE);
  51   response->body[MAX_HTTP_BODY_SIZE] = '\0';
  52
  53   response->body_size = strlen(response->body);
  54
  55   checked_free(body_latin1);
  56 }
  57
  58 static void SetHttpResponseToDefaults(struct HttpResponse *response)
  59 {
  60   response->head[0] = '\0';
  61   response->body[0] = '\0';
  62   response->body_size = 0;
  63
  64   response->status_code = 0;
  65   response->status_text[0] = '\0';
  66 }
  67
  68 struct HttpResponse *GetHttpResponseFromBuffer(void *buffer, int size)
  69 {
  70   if (size > MAX_HTTP_BODY_SIZE)
  71     return NULL;
  72
  73   struct HttpResponse *response = checked_calloc(sizeof(struct HttpResponse));
  74
  75   SetHttpResponseToDefaults(response);
  76
  77   strncpy(response->body, buffer, MAX_HTTP_BODY_SIZE);
  78   response->body[MAX_HTTP_BODY_SIZE] = '\0';
  79   response->body_size = MIN(size, MAX_HTTP_BODY_SIZE);
  80
  81   return response;
  82 }
  83
  84 static boolean SetHTTPResponseCode(struct HttpResponse *response, char *buffer)
  85 {
  86   char *prefix = "HTTP/1.1 ";
  87   char *prefix_start = strstr(buffer, prefix);
  88
  89   if (prefix_start == NULL)
  90     return FALSE;
  91
  92   char *status_code_start = prefix_start + strlen(prefix);
  93   char *status_code_end = strstr(status_code_start, " ");
  94
  95   if (status_code_end == NULL)
  96     return FALSE;
  97
  98   int status_code_size = status_code_end - status_code_start;
  99
 100   if (status_code_size != 3)    // status code must have three digits
 101     return FALSE;
 102
 103   char status_code[status_code_size + 1];
 104
 105   strncpy(status_code, status_code_start, status_code_size);
 106   status_code[status_code_size] = '\0';
 107
 108   response->status_code = atoi(status_code);
 109
 110   char *status_text_start = status_code_end + 1;
 111   char *status_text_end = strstr(status_text_start, "\r\n");
 112
 113   if (status_text_end == NULL)
 114     return FALSE;
 115
 116   int status_text_size = status_text_end - status_text_start;
 117
 118   if (status_text_size > MAX_HTTP_ERROR_SIZE)
 119     return FALSE;
 120
 121   strncpy(response->status_text, status_text_start, status_text_size);
 122   response->status_text[status_text_size] = '\0';
 123
 124   return TRUE;
 125 }
 126
 127 static boolean SetHTTPResponseHead(struct HttpResponse *response, char *buffer)
 128 {
 129   char *separator = "\r\n\r\n";
 130   char *separator_start = strstr(buffer, separator);
 131
 132   if (separator_start == NULL)
 133     return FALSE;
 134
 135   int head_size = separator_start - buffer;
 136
 137   if (head_size > MAX_HTTP_HEAD_SIZE)
 138     return FALSE;
 139
 140   strncpy(response->head, buffer, head_size);
 141   response->head[head_size] = '\0';
 142
 143   return TRUE;
 144 }
 145
 146 static boolean SetHTTPResponseBody(struct HttpResponse *response, char *buffer,
 147                                    int buffer_size)
 148 {
 149   char *separator = "\r\n\r\n";
 150   char *separator_start = strstr(buffer, separator);
 151
 152   if (separator_start == NULL)
 153     return FALSE;
 154
 155   int separator_size = strlen(separator);
 156   int full_head_size = separator_start + separator_size - buffer;
 157   int body_size = buffer_size - full_head_size;
 158
 159   if (body_size > MAX_HTTP_BODY_SIZE)
 160     return FALSE;
 161
 162   memcpy(response->body, buffer + full_head_size, body_size);
 163   response->body[body_size] = '\0';
 164   response->body_size = body_size;
 165
 166   return TRUE;
 167 }
 168
 169 static boolean DoHttpRequestExt(struct HttpRequest *request,
 170                                 struct HttpResponse *response,
 171                                 char *send_buffer,
 172                                 char *recv_buffer,
 173                                 int max_http_buffer_size,
 174                                 SDLNet_SocketSet *socket_set,
 175                                 TCPsocket *socket)
 176 {
 177   IPaddress ip;
 178   int server_host;
 179
 180   SetHttpResponseToDefaults(response);
 181
 182   *socket_set = SDLNet_AllocSocketSet(1);
 183
 184   if (*socket_set == NULL)
 185   {
 186     SetHttpError("cannot allocate socket set");
 187
 188     return FALSE;
 189   }
 190
 191   SDLNet_ResolveHost(&ip, request->hostname, request->port);
 192
 193   if (ip.host == INADDR_NONE)
 194   {
 195     SetHttpError("cannot resolve hostname '%s'", request->hostname);
 196
 197     return FALSE;
 198   }
 199
 200   server_host = SDLNet_Read32(&ip.host);
 201
 202   Debug("network:http", "trying to connect to server at %d.%d.%d.%d ...",
 203         (server_host >> 24) & 0xff,
 204         (server_host >> 16) & 0xff,
 205         (server_host >>  8) & 0xff,
 206         (server_host >>  0) & 0xff);
 207
 208   *socket = SDLNet_TCP_Open(&ip);
 209
 210   if (*socket == NULL)
 211   {
 212     SetHttpError("cannot connect to host '%s': %s", request->hostname,
 213                  SDLNet_GetError());
 214
 215     return FALSE;
 216   }
 217
 218   if (SDLNet_TCP_AddSocket(*socket_set, *socket) == -1)
 219   {
 220     SetHttpError("cannot add socket to socket set");
 221
 222     return FALSE;
 223   }
 224
 225   Debug("network:http", "successfully connected to server");
 226
 227   snprintf(request->head, MAX_HTTP_HEAD_SIZE,
 228            "%s %s HTTP/1.1\r\n"
 229            "Host: %s\r\n"
 230            "X-Requested-With: XMLHttpRequest\r\n"
 231            "Content-Type: application/json\r\n"
 232            "Connection: close\r\n"
 233            "Content-Length: %d\r\n",
 234            request->method,
 235            request->uri,
 236            request->hostname,
 237            (int)strlen(request->body));
 238
 239   snprintf(send_buffer, max_http_buffer_size,
 240            "%s\r\n%s", request->head, request->body);
 241
 242   Debug("network:http", "client request:\n--- snip ---\n%s\n--- snip ---",
 243         send_buffer);
 244
 245   int send_bytes = SDLNet_TCP_Send(*socket, send_buffer, strlen(send_buffer));
 246
 247   if (send_bytes != strlen(send_buffer))
 248   {
 249     SetHttpError("sending request to server failed");
 250
 251     return FALSE;
 252   }
 253
 254   int recv_bytes = SDLNet_TCP_Recv(*socket, recv_buffer, max_http_buffer_size);
 255
 256   if (recv_bytes <= 0)
 257   {
 258     SetHttpError("receiving response from server failed");
 259
 260     return FALSE;
 261   }
 262
 263   recv_buffer[recv_bytes] = '\0';
 264
 265   Debug("network:http", "server response:\n--- snip ---\n%s\n--- snip ---",
 266         recv_buffer);
 267
 268   if (!SetHTTPResponseCode(response, recv_buffer))
 269   {
 270     SetHttpError("malformed HTTP response");
 271
 272     return FALSE;
 273   }
 274
 275   if (!SetHTTPResponseHead(response, recv_buffer))
 276   {
 277     SetHttpError("invalid HTTP response header");
 278
 279     return FALSE;
 280   }
 281
 282   if (!SetHTTPResponseBody(response, recv_buffer, recv_bytes))
 283   {
 284     SetHttpError("invalid HTTP response body");
 285
 286     return FALSE;
 287   }
 288
 289   Debug("network:http", "server response: %d %s",
 290         response->status_code,
 291         response->status_text);
 292
 293   return TRUE;
 294 }
 295
 296 boolean DoHttpRequest(struct HttpRequest *request,
 297                       struct HttpResponse *response)
 298 {
 299   int max_http_buffer_size = MAX_HTTP_HEAD_SIZE + MAX_HTTP_BODY_SIZE;
 300   char *send_buffer = checked_malloc(max_http_buffer_size + 1);
 301   char *recv_buffer = checked_malloc(max_http_buffer_size + 1);
 302   SDLNet_SocketSet socket_set = NULL;
 303   TCPsocket socket = NULL;
 304
 305   boolean success = DoHttpRequestExt(request, response,
 306                                      send_buffer, recv_buffer,
 307                                      max_http_buffer_size,
 308                                      &socket_set, &socket);
 309   if (socket_set != NULL)
 310   {
 311     if (socket != NULL)
 312     {
 313       SDLNet_TCP_DelSocket(socket_set, socket);
 314       SDLNet_TCP_Close(socket);
 315     }
 316
 317     SDLNet_FreeSocketSet(socket_set);
 318   }
 319
 320   checked_free(send_buffer);
 321   checked_free(recv_buffer);
 322
 323   runtime.use_api_server = success;
 324
 325   return success;
 326 }