dep/rcheevos: Bump to 9ade739

dep/rcheevos/CHANGELOG.md

@@ -1,3 +1,11 @@
+# v12.3.0
+* add rc_client_get_next_achievement_info
+* rc_client image functions will now return RC_INSUFFICENT_BUFFER instead of truncating if buffer is not large enough
+* fix race condition where rich presence from previous game may get associated to current game
+* fix rc_client_has_leaderboards returning true if the game only has hidden leaderboards
+* fix memory leak parsing large achievements
+* fix incomplete rich presence display condition affecting later display conditions
+
 # v12.2.1
 * fix parsing of leaderboards with comparisons in legacy-formatted values
 * fix validation warning on long AddSource chains

dep/rcheevos/include/rc_api_info.h

@@ -164,8 +164,26 @@ rc_api_fetch_games_list_request_t;
 typedef struct rc_api_game_list_entry_t {
   /* The unique identifier of the game */
   uint32_t id;
+  /* The number of achievements in the game */
+  uint32_t num_achievements;
+  /* The number of leaderboards in the game */
+  uint32_t num_leaderboards;
+  /* The number of points in the game */
+  uint32_t points;
   /* The name of the game */
   const char* name;
+  /* The image name for the game badge */
+  const char* image_name;
+  /* The URL for the game badge image */
+  const char* image_url;
+  /* An array of supported hashes */
+  const char** supported_hashes;
+  /* An array of unsupported hashes */
+  const char** unsupported_hashes;
+  /* The number of items in the supported_hashes array */
+  uint32_t num_supported_hashes;
+  /* The number of items in the unsupported_hashes array */
+  uint32_t num_unsupported_hashes;
 }
 rc_api_game_list_entry_t;
 

dep/rcheevos/include/rc_error.h

@@ -49,7 +49,8 @@ enum {
   RC_INSUFFICIENT_BUFFER = -36,
   RC_INVALID_VARIABLE_NAME = -37,
   RC_UNKNOWN_VARIABLE_NAME = -38,
-  RC_NOT_FOUND = -39
+  RC_NOT_FOUND = -39,
+  RC_INVALID_VALUE = -40
 };
 
 RC_EXPORT const char* RC_CCONV rc_error_str(int ret);

dep/rcheevos/src/rapi/rc_api_common.c

@@ -5,7 +5,9 @@
 #include "../rc_compat.h"
 
 #include <ctype.h>
+#include <inttypes.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -360,7 +362,7 @@ int rc_json_parse_server_response(rc_api_response_t* response, const rc_api_serv
   if (server_response->http_status_code == RC_API_SERVER_RESPONSE_CLIENT_ERROR ||
       server_response->http_status_code == RC_API_SERVER_RESPONSE_RETRYABLE_CLIENT_ERROR) {
     /* client provided error message is passed as the response body */
-    response->error_message = server_response->body;
+    response->error_message = rc_buffer_strncpy(&response->buffer, server_response->body, server_response->body_length);
     response->succeeded = 0;
     return RC_NO_RESPONSE;
   }
@@ -503,6 +505,57 @@ int rc_json_get_required_unum_array(uint32_t** entries, uint32_t* num_entries, r
   return RC_OK;
 }
 
+static int rc_json_get_string_array(const char*** entries, uint32_t* num_entries, rc_api_response_t* response, const rc_json_field_t* array, const char* field_name) {
+  if (*num_entries) {
+    rc_json_iterator_t iterator;
+    rc_json_field_t value;
+    const char** entry;
+
+    *entries = (const char**)rc_buffer_alloc(&response->buffer, *num_entries * sizeof(const char*));
+    if (!*entries)
+      return RC_OUT_OF_MEMORY;
+
+    value.name = field_name;
+
+    memset(&iterator, 0, sizeof(iterator));
+    iterator.json = array->value_start;
+    iterator.end = array->value_end;
+
+    entry = *entries;
+    while (rc_json_get_array_entry_value(&value, &iterator)) {
+      if (!rc_json_get_string(entry, &response->buffer, &value, field_name))
+        return RC_MISSING_VALUE;
+
+      ++entry;
+    }
+  }
+  else {
+    *entries = NULL;
+  }
+
+  return RC_OK;
+}
+
+int rc_json_get_required_string_array(const char*** entries, uint32_t* num_entries, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name) {
+  rc_json_field_t array;
+
+  memset(&array, 0, sizeof(array));
+  if (!rc_json_get_required_array(num_entries, &array, response, field, field_name))
+    return RC_MISSING_VALUE;
+
+  return rc_json_get_string_array(entries, num_entries, response, &array, field_name);
+}
+
+int rc_json_get_optional_string_array(const char*** entries, uint32_t* num_entries, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name) {
+  rc_json_field_t array;
+
+  memset(&array, 0, sizeof(array));
+  if (!rc_json_get_optional_array(num_entries, &array, field, field_name))
+    *num_entries = 0;
+
+  return rc_json_get_string_array(entries, num_entries, response, &array, field_name);
+}
+
 int rc_json_get_required_array(uint32_t* num_entries, rc_json_field_t* array_field, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name) {
 #ifndef NDEBUG
   if (strcmp(field->name, field_name) != 0)
@@ -623,6 +676,12 @@ int rc_json_get_string(const char** out, rc_buffer_t* buffer, const rc_json_fiel
     return 0;
   }
 
+  if (len == 0) {
+    /* simple optimization for empty string - don't allocate space */
+    *out = "";
+    return 1;
+  }
+
   if (len == 4 && memcmp(field->value_start, "null", 4) == 0) {
     *out = NULL;
     return 1;
@@ -658,7 +717,11 @@ int rc_json_get_string(const char** out, rc_buffer_t* buffer, const rc_json_fiel
 
         if (*src == 'u') {
           /* unicode character */
-          uint32_t ucs32_char = rc_json_decode_hex4(src + 1);
+          uint32_t ucs32_char;
+          if (src + 5 >= field->value_end) /* incomplete unicode character */
+            return 0;
+
+          ucs32_char = rc_json_decode_hex4(src + 1);
           src += 5;
 
           if (ucs32_char >= 0xD800 && ucs32_char < 0xE000) {
@@ -710,7 +773,7 @@ int rc_json_get_string(const char** out, rc_buffer_t* buffer, const rc_json_fiel
 int rc_json_field_string_matches(const rc_json_field_t* field, const char* text) {
   int is_quoted = 0;
   const char* ptr = field->value_start;
-  if (!ptr)
+  if (!ptr || !text)
     return 0;
 
   if (*ptr == '"') {
@@ -924,7 +987,7 @@ int rc_json_get_datetime(time_t* out, const rc_json_field_t* field, const char*
   (void)field_name;
 #endif
 
-  if (*field->value_start == '\"') {
+  if (field->value_start && *field->value_start == '\"') {
     memset(&tm, 0, sizeof(tm));
     if (sscanf_s(field->value_start + 1, "%d-%d-%d %d:%d:%d", /* DB format "2013-10-20 22:12:21" */
                  &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6 ||
@@ -963,6 +1026,61 @@ int rc_json_get_required_datetime(time_t* out, rc_api_response_t* response, cons
   return rc_json_missing_field(response, field);
 }
 
+int rc_json_get_timet(time_t* out, const rc_json_field_t* field, const char* field_name)
+{
+  const char* src = field->value_start;
+  int64_t value = 0;
+  int negative = 0;
+
+#ifndef NDEBUG
+  if (strcmp(field->name, field_name) != 0)
+    return 0;
+#else
+  (void)field_name;
+#endif
+
+  if (!src) {
+    *out = 0;
+    return 0;
+  }
+
+  /* assert: string contains only numerals and an optional sign per rc_json_parse_field */
+  if (*src == '-') {
+    negative = 1;
+    ++src;
+  } else if (*src == '+') {
+    ++src;
+  } else if (*src < '0' || *src > '9') {
+    *out = 0;
+    return 0;
+  }
+
+  while (src < field->value_end && *src != '.') {
+    value *= 10;
+    value += *src - '0';
+    ++src;
+  }
+
+  if (negative)
+    *out = (time_t)-value;
+  else
+    *out = (time_t)value;
+
+  return 1;
+}
+
+void rc_json_get_optional_timet(time_t* out, const rc_json_field_t* field, const char* field_name, time_t default_value) {
+  if (!rc_json_get_timet(out, field, field_name))
+    *out = default_value;
+}
+
+int rc_json_get_required_timet(time_t* out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name) {
+  if (rc_json_get_timet(out, field, field_name))
+    return 1;
+
+  return rc_json_missing_field(response, field);
+}
+
 int rc_json_get_bool(int* out, const rc_json_field_t* field, const char* field_name) {
   const char* src = field->value_start;
 
@@ -1004,23 +1122,25 @@ int rc_json_get_required_bool(int* out, rc_api_response_t* response, const rc_js
 }
 
 void rc_json_extract_filename(rc_json_field_t* field) {
-  if (field->value_end) {
+  if (field->value_end && field->value_end > field->value_start) {
     const char* str = field->value_end;
+    if (str[-1] == '"') {
+      /* ignore trailing quote */
+      field->value_end = --str;
 
-    /* remove the extension */
-    while (str > field->value_start && str[-1] != '/') {
-      --str;
-      if (*str == '.') {
-        field->value_end = str;
-        break;
+      while (str > field->value_start) {
+        const char c = *(--str);
+        if (c == '.') {
+          /* found an extension. remove it */
+          field->value_end = str;
+        }
+        else if (c == '/' || c == '"') {
+          /* found path separator or opening quote. stop */
+          field->value_start = str + 1;
+          break;
+        }
       }
     }
-
-    /* find the path separator */
-    while (str > field->value_start && str[-1] != '/')
-      --str;
-
-    field->value_start = str;
   }
 }
 
@@ -1296,12 +1416,15 @@ int rc_api_init_fetch_image_request(rc_api_request_t* request, const rc_api_fetc
 int rc_api_init_fetch_image_request_hosted(rc_api_request_t* request, const rc_api_fetch_image_request_t* api_params, const rc_api_host_t* host) {
   rc_api_url_builder_t builder;
 
+  if (!api_params->image_name || !api_params->image_name[0])
+    return RC_INVALID_STATE;
+
   rc_buffer_init(&request->buffer);
   rc_url_builder_init(&builder, &request->buffer, 64);
 
   if (host && host->media_host) {
     /* custom media host provided */
-    if (!strstr(host->host, "://"))
+    if (!strstr(host->media_host, "://"))
       rc_url_builder_append(&builder, "http://", 7);
     rc_url_builder_append(&builder, host->media_host, strlen(host->media_host));
   }
@@ -1358,6 +1481,7 @@ int rc_api_init_fetch_image_request_hosted(rc_api_request_t* request, const rc_a
 
   request->url = rc_url_builder_finalize(&builder);
   request->post_data = NULL;
+  request->content_type = NULL;
 
   return builder.result;
 }

dep/rcheevos/src/rapi/rc_api_common.h

@@ -49,21 +49,26 @@ int rc_json_get_num(int32_t* out, const rc_json_field_t* field, const char* fiel
 int rc_json_get_unum(uint32_t* out, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_float(float* out, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_bool(int* out, const rc_json_field_t* field, const char* field_name);
+int rc_json_get_timet(time_t* out, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_datetime(time_t* out, const rc_json_field_t* field, const char* field_name);
 void rc_json_get_optional_string(const char** out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name, const char* default_value);
 void rc_json_get_optional_num(int32_t* out, const rc_json_field_t* field, const char* field_name, int default_value);
 void rc_json_get_optional_unum(uint32_t* out, const rc_json_field_t* field, const char* field_name, uint32_t default_value);
 void rc_json_get_optional_float(float* out, const rc_json_field_t* field, const char* field_name, float default_value);
 void rc_json_get_optional_bool(int* out, const rc_json_field_t* field, const char* field_name, int default_value);
+void rc_json_get_optional_timet(time_t* out, const rc_json_field_t* field, const char* field_name, time_t default_value);
 int rc_json_get_optional_array(uint32_t* num_entries, rc_json_field_t* iterator, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_string(const char** out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_num(int32_t* out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_unum(uint32_t* out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_float(float* out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_bool(int* out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
+int rc_json_get_required_timet(time_t* out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_datetime(time_t* out, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_object(rc_json_field_t* fields, size_t field_count, rc_api_response_t* response, rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_unum_array(uint32_t** entries, uint32_t* num_entries, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
+int rc_json_get_required_string_array(const char*** entries, uint32_t* num_entries, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
+int rc_json_get_optional_string_array(const char*** entries, uint32_t* num_entries, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_required_array(uint32_t* num_entries, rc_json_field_t* array_field, rc_api_response_t* response, const rc_json_field_t* field, const char* field_name);
 int rc_json_get_array_entry_object(rc_json_field_t* fields, size_t field_count, rc_json_iterator_t* iterator);
 int rc_json_get_next_object_field(rc_json_iterator_t* iterator, rc_json_field_t* field);

dep/rcheevos/src/rapi/rc_api_info.c

@@ -56,7 +56,6 @@ int rc_api_process_fetch_achievement_info_server_response(rc_api_fetch_achieveme
   rc_api_achievement_awarded_entry_t* entry;
   rc_json_field_t array_field;
   rc_json_iterator_t iterator;
-  uint32_t timet;
   int result;
 
   rc_json_field_t fields[] = {
@@ -120,9 +119,8 @@ int rc_api_process_fetch_achievement_info_server_response(rc_api_fetch_achieveme
       if (!rc_json_get_required_string(&entry->username, &response->response, &entry_fields[0], "User"))
         return RC_MISSING_VALUE;
 
-      if (!rc_json_get_required_unum(&timet, &response->response, &entry_fields[1], "DateAwarded"))
+      if (!rc_json_get_required_timet(&entry->awarded, &response->response, &entry_fields[1], "DateAwarded"))
         return RC_MISSING_VALUE;
-      entry->awarded = (time_t)timet;
 
       rc_json_get_optional_string(&entry->avatar_url, &response->response, &entry_fields[2], "AvatarUrl", NULL);
       if (!entry->avatar_url)
@@ -185,7 +183,6 @@ int rc_api_process_fetch_leaderboard_info_server_response(rc_api_fetch_leaderboa
   rc_api_lboard_info_entry_t* entry;
   rc_json_field_t array_field;
   rc_json_iterator_t iterator;
-  uint32_t timet;
   int result;
   size_t len;
   char format[16];
@@ -289,9 +286,8 @@ int rc_api_process_fetch_leaderboard_info_server_response(rc_api_fetch_leaderboa
       if (!rc_json_get_required_num(&entry->score, &response->response, &entry_fields[3], "Score"))
         return RC_MISSING_VALUE;
 
-      if (!rc_json_get_required_unum(&timet, &response->response, &entry_fields[4], "DateSubmitted"))
+      if (!rc_json_get_required_timet(&entry->submitted, &response->response, &entry_fields[4], "DateSubmitted"))
         return RC_MISSING_VALUE;
-      entry->submitted = (time_t)timet;
 
       rc_json_get_optional_string(&entry->avatar_url, &response->response, &entry_fields[5], "AvatarUrl", NULL);
       if (!entry->avatar_url)
@@ -325,8 +321,8 @@ int rc_api_init_fetch_games_list_request_hosted(rc_api_request_t* request,
     return RC_INVALID_STATE;
 
   rc_url_builder_init(&builder, &request->buffer, 48);
-  rc_url_builder_append_str_param(&builder, "r", "gameslist");
-  rc_url_builder_append_unum_param(&builder, "c", api_params->console_id);
+  rc_url_builder_append_str_param(&builder, "r", "systemgames");
+  rc_url_builder_append_unum_param(&builder, "s", api_params->console_id);
 
   request->post_data = rc_url_builder_finalize(&builder);
   request->content_type = RC_CONTENT_TYPE_URLENCODED;
@@ -347,9 +343,8 @@ int rc_api_process_fetch_games_list_response(rc_api_fetch_games_list_response_t*
 int rc_api_process_fetch_games_list_server_response(rc_api_fetch_games_list_response_t* response, const rc_api_server_response_t* server_response) {
   rc_api_game_list_entry_t* entry;
   rc_json_iterator_t iterator;
-  rc_json_field_t field;
+  rc_json_field_t array_field;
   int result;
-  char* end;
 
   rc_json_field_t fields[] = {
     RC_JSON_NEW_FIELD("Success"),
@@ -357,6 +352,18 @@ int rc_api_process_fetch_games_list_server_response(rc_api_fetch_games_list_resp
     RC_JSON_NEW_FIELD("Response")
   };
 
+  rc_json_field_t game_fields[] = {
+    RC_JSON_NEW_FIELD("ID"),
+    RC_JSON_NEW_FIELD("Title"),
+    RC_JSON_NEW_FIELD("ImageIcon"),
+    RC_JSON_NEW_FIELD("ImageUrl"),
+    RC_JSON_NEW_FIELD("NumAchievements"),
+    RC_JSON_NEW_FIELD("NumLeaderboards"),
+    RC_JSON_NEW_FIELD("Points"),
+    RC_JSON_NEW_FIELD("SupportedHashes"), /* array */
+    RC_JSON_NEW_FIELD("UnsupportedHashes"), /* array */
+  };
+
   memset(response, 0, sizeof(*response));
   rc_buffer_init(&response->response.buffer);
 
@@ -364,32 +371,50 @@ int rc_api_process_fetch_games_list_server_response(rc_api_fetch_games_list_resp
   if (result != RC_OK)
     return result;
 
-  if (!fields[2].value_start) {
-    /* call rc_json_get_required_object to generate the error message */
-    rc_json_get_required_object(NULL, 0, &response->response, &fields[2], "Response");
+  if (!rc_json_get_required_array(&response->num_entries, &array_field, &response->response, &fields[2], "Response"))
     return RC_MISSING_VALUE;
-  }
 
-  response->num_entries = fields[2].array_size;
-  rc_buffer_reserve(&response->response.buffer, response->num_entries * (32 + sizeof(rc_api_game_list_entry_t)));
+  if (response->num_entries) {
+    /* 8=image_name, 32=title, 64=image_url, 32=one hash */
+    rc_buffer_reserve(&response->response.buffer, response->num_entries * (8 + 32 + 64 + 32 + sizeof(rc_api_game_list_entry_t)));
 
-  response->entries = (rc_api_game_list_entry_t*)rc_buffer_alloc(&response->response.buffer, response->num_entries * sizeof(rc_api_game_list_entry_t));
-  if (!response->entries)
-    return RC_OUT_OF_MEMORY;
+    response->entries = (rc_api_game_list_entry_t*)rc_buffer_alloc(&response->response.buffer, response->num_entries * sizeof(rc_api_game_list_entry_t));
+    if (!response->entries)
+      return RC_OUT_OF_MEMORY;
 
-  memset(&iterator, 0, sizeof(iterator));
-  iterator.json = fields[2].value_start;
-  iterator.end = fields[2].value_end;
+    memset(&iterator, 0, sizeof(iterator));
+    iterator.json = array_field.value_start;
+    iterator.end = array_field.value_end;
 
-  entry = response->entries;
-  while (rc_json_get_next_object_field(&iterator, &field)) {
-    entry->id = strtol(field.name, &end, 10);
+    entry = response->entries;
+    while (rc_json_get_array_entry_object(game_fields, sizeof(game_fields) / sizeof(game_fields[0]), &iterator)) {
+      if (!rc_json_get_required_unum(&entry->id, &response->response, &game_fields[0], "ID"))
+        return RC_MISSING_VALUE;
+      if (!rc_json_get_required_string(&entry->name, &response->response, &game_fields[1], "Title"))
+        return RC_MISSING_VALUE;
+      if (!rc_json_get_required_unum(&entry->num_achievements, &response->response, &game_fields[4], "NumAchievements"))
+        return RC_MISSING_VALUE;
+      if (!rc_json_get_required_unum(&entry->num_leaderboards, &response->response, &game_fields[5], "NumLeaderboards"))
+        return RC_MISSING_VALUE;
+      if (!rc_json_get_required_unum(&entry->points, &response->response, &game_fields[6], "Points"))
+        return RC_MISSING_VALUE;
 
-    field.name = "";
-    if (!rc_json_get_string(&entry->name, &response->response.buffer, &field, ""))
-      return RC_MISSING_VALUE;
+      /* ImageIcon will be '/Images/0123456.png' - only return the '0123456' */
+      rc_json_extract_filename(&game_fields[2]);
+      if (!rc_json_get_required_string(&entry->image_name, &response->response, &game_fields[2], "ImageIcon"))
+        return RC_MISSING_VALUE;
+      if (!rc_json_get_required_string(&entry->image_url, &response->response, &game_fields[3], "ImageUrl"))
+        return RC_MISSING_VALUE;
 
-    ++entry;
+      result = rc_json_get_required_string_array(&entry->supported_hashes, &entry->num_supported_hashes, &response->response, &game_fields[7], "SupportedHashes");
+      if (result != RC_OK)
+        return result;
+      result = rc_json_get_optional_string_array(&entry->unsupported_hashes, &entry->num_unsupported_hashes, &response->response, &game_fields[8], "UnsupportedHashes");
+      if (result != RC_OK)
+        return result;
+
+      ++entry;
+    }
   }
 
   return RC_OK;
@@ -484,7 +509,7 @@ int rc_api_process_fetch_game_titles_server_response(rc_api_fetch_game_titles_re
         return RC_MISSING_VALUE;
 
       rc_json_get_optional_string(&entry->image_url, &response->response, &entry_fields[3], "ImageUrl", "");
-      if (!entry->image_url[0])
+      if (!entry->image_url || !entry->image_url[0])
         entry->image_url = rc_api_build_avatar_url(&response->response.buffer, RC_IMAGE_TYPE_GAME, entry->image_name);
 
       ++entry;

dep/rcheevos/src/rapi/rc_api_runtime.c

@@ -113,7 +113,6 @@ static int rc_api_process_fetch_game_data_achievements(rc_api_response_t* respon
   const char* last_author = "";
   const char* last_author_field = "";
   size_t last_author_len = 0;
-  uint32_t timet;
   size_t len;
 
   rc_json_field_t achievement_fields[] = {
@@ -155,11 +154,11 @@ static int rc_api_process_fetch_game_data_achievements(rc_api_response_t* respon
       return RC_MISSING_VALUE;
 
     rc_json_get_optional_string(&achievement->badge_url, response, &achievement_fields[13], "BadgeURL", "");
-    if (!achievement->badge_url[0])
+    if (!achievement->badge_url || !achievement->badge_url[0])
       achievement->badge_url = rc_api_build_avatar_url(&response->buffer, RC_IMAGE_TYPE_ACHIEVEMENT, achievement->badge_name);
 
     rc_json_get_optional_string(&achievement->badge_locked_url, response, &achievement_fields[14], "BadgeLockedURL", "");
-    if (!achievement->badge_locked_url[0])
+    if (!achievement->badge_locked_url || !achievement->badge_locked_url[0])
       achievement->badge_locked_url = rc_api_build_avatar_url(&response->buffer, RC_IMAGE_TYPE_ACHIEVEMENT_LOCKED, achievement->badge_name);
 
     len = achievement_fields[6].value_end - achievement_fields[6].value_start;
@@ -181,12 +180,10 @@ static int rc_api_process_fetch_game_data_achievements(rc_api_response_t* respon
       }
     }
 
-    if (!rc_json_get_required_unum(&timet, response, &achievement_fields[8], "Created"))
+    if (!rc_json_get_required_timet(&achievement->created, response, &achievement_fields[8], "Created"))
       return RC_MISSING_VALUE;
-    achievement->created = (time_t)timet;
-    if (!rc_json_get_required_unum(&timet, response, &achievement_fields[9], "Modified"))
+    if (!rc_json_get_required_timet(&achievement->updated, response, &achievement_fields[9], "Modified"))
       return RC_MISSING_VALUE;
-    achievement->updated = (time_t)timet;
 
     if (rc_json_field_string_matches(&achievement_fields[10], ""))
       achievement->type = RC_ACHIEVEMENT_TYPE_STANDARD;
@@ -320,7 +317,7 @@ int rc_api_process_fetch_game_data_server_response(rc_api_fetch_game_data_respon
   rc_json_extract_filename(&patchdata_fields[3]);
   rc_json_get_optional_string(&response->image_name, &response->response, &patchdata_fields[3], "ImageIcon", "");
   rc_json_get_optional_string(&response->image_url, &response->response, &patchdata_fields[4], "ImageIconURL", "");
-  if (!response->image_url[0])
+  if (!response->image_url || !response->image_url[0])
     response->image_url = rc_api_build_avatar_url(&response->response.buffer, RC_IMAGE_TYPE_GAME, response->image_name);
 
   /* estimate the amount of space necessary to store the rich presence script, achievements, and leaderboards.

dep/rcheevos/src/rapi/rc_api_user.c

@@ -145,7 +145,6 @@ int rc_api_process_start_session_server_response(rc_api_start_session_response_t
   rc_api_unlock_entry_t* unlock;
   rc_json_field_t array_field;
   rc_json_iterator_t iterator;
-  uint32_t timet;
   int result;
 
   rc_json_field_t fields[] = {
@@ -181,9 +180,8 @@ int rc_api_process_start_session_server_response(rc_api_start_session_response_t
     while (rc_json_get_array_entry_object(unlock_entry_fields, sizeof(unlock_entry_fields) / sizeof(unlock_entry_fields[0]), &iterator)) {
       if (!rc_json_get_required_unum(&unlock->achievement_id, &response->response, &unlock_entry_fields[0], "ID"))
         return RC_MISSING_VALUE;
-      if (!rc_json_get_required_unum(&timet, &response->response, &unlock_entry_fields[1], "When"))
+      if (!rc_json_get_required_timet(&unlock->when, &response->response, &unlock_entry_fields[1], "When"))
         return RC_MISSING_VALUE;
-      unlock->when = (time_t)timet;
 
       ++unlock;
     }
@@ -202,16 +200,14 @@ int rc_api_process_start_session_server_response(rc_api_start_session_response_t
     while (rc_json_get_array_entry_object(unlock_entry_fields, sizeof(unlock_entry_fields) / sizeof(unlock_entry_fields[0]), &iterator)) {
       if (!rc_json_get_required_unum(&unlock->achievement_id, &response->response, &unlock_entry_fields[0], "ID"))
         return RC_MISSING_VALUE;
-      if (!rc_json_get_required_unum(&timet, &response->response, &unlock_entry_fields[1], "When"))
+      if (!rc_json_get_required_timet(&unlock->when, &response->response, &unlock_entry_fields[1], "When"))
         return RC_MISSING_VALUE;
-      unlock->when = (time_t)timet;
 
       ++unlock;
     }
   }
 
-  rc_json_get_optional_unum(&timet, &fields[4], "ServerNow", 0);
-  response->server_now = (time_t)timet;
+  rc_json_get_optional_timet(&response->server_now, &fields[4], "ServerNow", 0);
 
   return RC_OK;
 }
@@ -307,7 +303,6 @@ int rc_api_process_fetch_followed_users_server_response(rc_api_fetch_followed_us
   rc_json_field_t array_field;
   rc_json_iterator_t iterator;
   rc_api_followed_user_t* user;
-  uint32_t timet;
   int result;
   rc_json_field_t fields[] = {
     RC_JSON_NEW_FIELD("Success"),
@@ -355,10 +350,7 @@ int rc_api_process_fetch_followed_users_server_response(rc_api_fetch_followed_us
         return RC_MISSING_VALUE;
 
       rc_json_get_optional_string(&user->recent_activity.description, &response->response, &followed_user_entry_fields[3], "LastSeen", NULL);
-
-      rc_json_get_optional_unum(&timet, &followed_user_entry_fields[4], "LastSeenTime", 0);
-      user->recent_activity.when = (time_t)timet;
-
+      rc_json_get_optional_timet(&user->recent_activity.when, &followed_user_entry_fields[4], "LastSeenTime", 0);
       rc_json_get_optional_unum(&user->recent_activity.context_id, &followed_user_entry_fields[5], "LastGameId", 0);
       rc_json_get_optional_string(&user->recent_activity.context, &response->response, &followed_user_entry_fields[6], "LastGameTitle", NULL);
       rc_json_get_optional_string(&user->recent_activity.context_image_url, &response->response, &followed_user_entry_fields[7], "LastGameIconUrl", NULL);

dep/rcheevos/src/rc_client.c

@@ -14,15 +14,15 @@
 #include <stdarg.h>
 
 #ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <profileapi.h>
+ #define WIN32_LEAN_AND_MEAN
+ #include <windows.h>
 #else
-#include <time.h>
+ #include <time.h>
 #endif
 
 #define RC_CLIENT_UNKNOWN_GAME_ID (uint32_t)-1
 #define RC_CLIENT_RECENT_UNLOCK_DELAY_SECONDS (10 * 60) /* ten minutes */
+#define RC_CLIENT_ACHIEVEMENT_WARNING_ID 101000001
 
 #define RC_MINIMUM_UNPAUSED_FRAMES 20
 #define RC_PAUSE_DECAY_MULTIPLIER 4
@@ -240,7 +240,7 @@ static void rc_client_log_message_va(const rc_client_t* client, const char* form
     char buffer[2048];
 
 #ifdef __STDC_SECURE_LIB__
-    _vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
+    vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
 #elif __STDC_VERSION__ >= 199901L /* vsnprintf requires c99 */
     vsnprintf(buffer, sizeof(buffer), format, args);
 #else /* c89 doesn't have a size-limited vsprintf function - assume the buffer is large enough */
@@ -320,6 +320,22 @@ void rc_client_enable_logging(rc_client_t* client, int level, rc_client_message_
 
 static rc_clock_t rc_client_clock_get_now_millisecs(const rc_client_t* client)
 {
+#if defined(__APPLE__) && defined(__MACH__)
+ #ifdef CLOCK_MONOTONIC
+  /* clock_gettime() was added to Darwin in iOS 10.0 and macOS 10.12.
+   * On earlier deployment targets (like Leopard 10.5), the symbol doesn't exist
+   * in libSystem causing an "undefined reference to clock_gettime" linker error.
+   * To get the code to use the #else block below, forcibly undefine CLOCK_MONOTONIC
+   * when targeting earlier versions. */
+  #include <AvailabilityMacros.h>
+  #if (defined(MAC_OS_X_VERSION_MIN_REQUIRED) && MAC_OS_X_VERSION_MIN_REQUIRED < 101200)
+   #undef CLOCK_MONOTONIC
+  #elif (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 100000)
+   #undef CLOCK_MONOTONIC
+  #endif
+ #endif
+#endif
+
 #if defined(CLOCK_MONOTONIC)
   struct timespec now;
   (void)client;
@@ -934,6 +950,11 @@ static void rc_client_subset_get_user_game_summary(const rc_client_t* client,
   for (; achievement < stop; ++achievement) {
     switch (achievement->public_.category) {
       case RC_CLIENT_ACHIEVEMENT_CATEGORY_CORE:
+        if (achievement->public_.id >= RC_CLIENT_ACHIEVEMENT_WARNING_ID) {
+          /* ignore warning achievements */
+          continue;
+        }
+
         ++summary->num_core_achievements;
         summary->points_core += achievement->public_.points;
 
@@ -2109,10 +2130,10 @@ static void rc_client_copy_achievements(rc_client_load_state_t* load_state,
       else {
         rc_buffer_consume(buffer, (const uint8_t*)preparse.parse.buffer, (uint8_t*)preparse.parse.buffer + preparse.parse.offset);
       }
-
-      rc_destroy_preparse_state(&preparse);
     }
 
+    rc_destroy_preparse_state(&preparse);
+
     achievement->created_time = read->created;
     achievement->updated_time = read->updated;
 
@@ -3926,7 +3947,7 @@ static void rc_client_update_achievement_display_information(rc_client_t* client
           if (!achievement->trigger->measured_as_percent) {
             char* ptr = achievement->public_.measured_progress;
             const int buffer_size = (int)sizeof(achievement->public_.measured_progress);
-            const int chars = rc_format_value(ptr, buffer_size, (int32_t)new_measured_value, RC_FORMAT_UNSIGNED_VALUE);
+            const int chars = rc_format_value(ptr, buffer_size - 1, (int32_t)new_measured_value, RC_FORMAT_UNSIGNED_VALUE);
             ptr[chars] = '/';
             rc_format_value(ptr + chars + 1, buffer_size - chars - 1, (int32_t)achievement->trigger->measured_target, RC_FORMAT_UNSIGNED_VALUE);
           }
@@ -4647,6 +4668,11 @@ static void rc_client_award_achievement(rc_client_t* client, rc_client_achieveme
 
   rc_mutex_unlock(&client->state.mutex);
 
+  if (achievement->public_.id >= RC_CLIENT_ACHIEVEMENT_WARNING_ID) {
+    RC_CLIENT_LOG_INFO_FORMATTED(client, "Unlocked warning achievement %u: %s", achievement->public_.id, achievement->public_.title);
+    return;
+  }
+
   if (client->callbacks.can_submit_achievement_unlock &&
       !client->callbacks.can_submit_achievement_unlock(achievement->public_.id, client)) {
     RC_CLIENT_LOG_INFO_FORMATTED(client, "Achievement %u unlock blocked by client", achievement->public_.id);
@@ -4674,7 +4700,6 @@ static void rc_client_award_achievement(rc_client_t* client, rc_client_achieveme
   callback_data->client = client;
   callback_data->id = achievement->public_.id;
   callback_data->hardcore = client->state.hardcore;
-  callback_data->game_hash = client->game->public_.hash;
   callback_data->unlock_time = client->callbacks.get_time_millisecs(client);
 
   if (client->game) /* may be NULL if this gets called while unloading the game (from another thread - events are raised outside the lock) */
@@ -5851,9 +5876,6 @@ static void rc_client_update_memref_values(rc_client_t* client) {
     } while (modified_memref_list);
   }
 
-  if (client->game->runtime.richpresence && client->game->runtime.richpresence->richpresence)
-    rc_update_values(client->game->runtime.richpresence->richpresence->values, client->state.legacy_peek, client);
-
   if (invalidated_memref)
     rc_client_update_active_achievements(client->game);
 }
@@ -5883,6 +5905,7 @@ static void rc_client_do_frame_process_achievements(rc_client_t* client, rc_clie
     /* if the measured value changed and the achievement hasn't triggered, show a progress indicator */
     if (trigger->measured_value != old_measured_value && old_measured_value != RC_MEASURED_UNKNOWN &&
         trigger->measured_value <= trigger->measured_target &&
+        trigger->measured_target != 0 &&
         rc_trigger_state_active(new_state) && new_state != RC_TRIGGER_STATE_WAITING) {
 
       /* only show a popup for the achievement closest to triggering */

dep/rcheevos/src/rc_client_external.c

@@ -43,6 +43,7 @@ static const char* rc_client_external_build_avatar_url(char buffer[], size_t buf
     return NULL;
 
   snprintf(buffer, buffer_size, "%s", request.url);
+  rc_api_destroy_request(&request);
   return buffer;
 }
 

dep/rcheevos/src/rc_util.c

@@ -121,7 +121,7 @@ char* rc_buffer_strncpy(rc_buffer_t* buffer, const char* src, size_t len)
   uint8_t* dst = rc_buffer_reserve(buffer, len + 1);
   memcpy(dst, src, len);
   dst[len] = '\0';
-  rc_buffer_consume(buffer, dst, dst + len + 2);
+  rc_buffer_consume(buffer, dst, dst + len + 1);
   return (char*)dst;
 }
 
@@ -194,6 +194,7 @@ const char* rc_error_str(int ret)
     case RC_INVALID_VARIABLE_NAME: return "Invalid variable name";
     case RC_UNKNOWN_VARIABLE_NAME: return "Unknown variable name";
     case RC_NOT_FOUND: return "Not found";
+    case RC_INVALID_VALUE: return "Invalid value expression";
     default: return "Unknown error";
   }
 }

dep/rcheevos/src/rc_version.h

@@ -8,8 +8,8 @@
 RC_BEGIN_C_DECLS
 
 #define RCHEEVOS_VERSION_MAJOR 12
-#define RCHEEVOS_VERSION_MINOR 2
-#define RCHEEVOS_VERSION_PATCH 1
+#define RCHEEVOS_VERSION_MINOR 3
+#define RCHEEVOS_VERSION_PATCH 0
 
 #define RCHEEVOS_MAKE_VERSION(major, minor, patch) (major * 1000000 + minor * 1000 + patch)
 #define RCHEEVOS_VERSION RCHEEVOS_MAKE_VERSION(RCHEEVOS_VERSION_MAJOR, RCHEEVOS_VERSION_MINOR, RCHEEVOS_VERSION_PATCH)

dep/rcheevos/src/rcheevos/alloc.c

@@ -213,6 +213,10 @@ static void rc_preparse_sync_operand(rc_operand_t* operand, rc_parse_state_t* pa
 {
   if (rc_operand_is_memref(operand) || rc_operand_is_recall(operand)) {
     const rc_memref_t* src_memref = operand->value.memref;
+    if (!src_memref) {
+      parse->offset = RC_INVALID_MEMORY_OPERAND;
+      return;
+    }
 
     if (src_memref->value.memref_type == RC_MEMREF_TYPE_MODIFIED_MEMREF) {
       const rc_modified_memref_list_t* modified_memref_list = &memrefs->modified_memrefs;

dep/rcheevos/src/rcheevos/consoleinfo.c

@@ -818,12 +818,14 @@ static const rc_memory_region_t _rc_memory_regions_playstation2[] = {
 static const rc_memory_regions_t rc_memory_regions_playstation2 = { _rc_memory_regions_playstation2, 3 };
 
 /* ===== PlayStation Portable ===== */
-/* https://github.com/uofw/upspd/wiki/Memory-map */
+/* https://github.com/uofw/upspd/wiki/Memory-map
+ * the RAM is extended at loadtime if the game has a MEMSIZE flag in its PARAM.SFO */
 static const rc_memory_region_t _rc_memory_regions_psp[] = {
     { 0x00000000U, 0x007FFFFFU, 0x08000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "Kernel RAM" },
     { 0x00800000U, 0x01FFFFFFU, 0x08800000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" },
+    { 0x02000000U, 0x03FFFFFFU, 0x0A000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "Extended RAM" },
 };
-static const rc_memory_regions_t rc_memory_regions_psp = { _rc_memory_regions_psp, 2 };
+static const rc_memory_regions_t rc_memory_regions_psp = { _rc_memory_regions_psp, 3 };
 
 /* ===== Pokemon Mini ===== */
 /* https://www.pokemon-mini.net/documentation/memory-map/ */
@@ -993,6 +995,13 @@ static const rc_memory_region_t _rc_memory_regions_wonderswan[] = {
 };
 static const rc_memory_regions_t rc_memory_regions_wonderswan = { _rc_memory_regions_wonderswan, 2 };
 
+/* ===== Xbox ===== */
+static const rc_memory_region_t _rc_memory_regions_xbox[] = {
+    /* Retail Xbox memory map: https://xboxdevwiki.net/Memory */
+    { 0x00000000U, 0x03FFFFFFU, 0x00000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }
+};
+static const rc_memory_regions_t rc_memory_regions_xbox = { _rc_memory_regions_xbox, 1 };
+
 /* ===== ZX Spectrum ===== */
 /* https://github.com/TASEmulators/BizHawk/blob/3a3b22c/src/BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Machine/ZXSpectrum16K/ZX16.cs
  * https://github.com/TASEmulators/BizHawk/blob/3a3b22c/src/BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Machine/ZXSpectrum48K/ZX48.Memory.cs
@@ -1206,6 +1215,9 @@ const rc_memory_regions_t* rc_console_memory_regions(uint32_t console_id)
     case RC_CONSOLE_WONDERSWAN:
       return &rc_memory_regions_wonderswan;
 
+    case RC_CONSOLE_XBOX:
+      return &rc_memory_regions_xbox;
+
     case RC_CONSOLE_ZX_SPECTRUM:
       return &rc_memory_regions_zx_spectrum;
 

dep/rcheevos/src/rcheevos/richpresence.c

@@ -38,6 +38,11 @@ static void rc_alloc_helper_variable_memref_value(rc_richpresence_display_part_t
   /* ensure new needed memrefs are allocated in the primary buffer */
   rc_preparse_copy_memrefs(parse, &preparse.memrefs);
 
+  if (parse->offset < 0) {
+    rc_destroy_preparse_state(&preparse);
+    return;
+  }
+
   /* parse the value into the scratch buffer so we can look at it */
   rc_reset_parse_state(&preparse.parse, rc_buffer_alloc(&preparse.parse.scratch.buffer, (size_t)size));
   preparse.parse.memrefs = parse->memrefs;
@@ -725,14 +730,15 @@ rc_memrefs_t* rc_richpresence_get_memrefs(rc_richpresence_t* self) {
 void rc_update_richpresence(rc_richpresence_t* richpresence, rc_peek_t peek, void* peek_ud, void* unused_L) {
   (void)unused_L;
 
-  rc_update_richpresence_memrefs(richpresence, peek, peek_ud);
-  rc_update_values(richpresence->values, peek, peek_ud);
   rc_update_richpresence_internal(richpresence, peek, peek_ud);
 }
 
 void rc_update_richpresence_internal(rc_richpresence_t* richpresence, rc_peek_t peek, void* peek_ud) {
   rc_richpresence_display_t* display;
 
+  rc_update_richpresence_memrefs(richpresence, peek, peek_ud);
+  rc_update_values(richpresence->values, peek, peek_ud);
+
   for (display = richpresence->first_display; display; display = display->next) {
     if (display->has_required_hits)
       rc_test_trigger(&display->trigger, peek, peek_ud, NULL);

dep/rcheevos/src/rcheevos/runtime.c

@@ -510,7 +510,7 @@ int rc_runtime_get_richpresence(const rc_runtime_t* self, char* buffer, size_t b
 
 void rc_runtime_do_frame(rc_runtime_t* self, rc_runtime_event_handler_t event_handler, rc_runtime_peek_t peek, void* ud, void* unused_L) {
   rc_runtime_event_t runtime_event;
-  int i;
+  int32_t i;
 
   runtime_event.value = 0;
 
@@ -670,7 +670,7 @@ void rc_runtime_do_frame(rc_runtime_t* self, rc_runtime_event_handler_t event_ha
         break;
 
       case RC_LBOARD_STATE_TRIGGERED:
-        if (lboard_state != RC_RUNTIME_EVENT_LBOARD_TRIGGERED) {
+        if (lboard_state != RC_LBOARD_STATE_TRIGGERED) {
           runtime_event.type = RC_RUNTIME_EVENT_LBOARD_TRIGGERED;
           runtime_event.id = self->lboards[i].id;
           event_handler(&runtime_event);

dep/rcheevos/src/rcheevos/value.c

@@ -120,6 +120,12 @@ static void rc_parse_legacy_value(rc_value_t* self, const char** memaddr, rc_par
 
       /* extract the next clause */
       for (;; ++(*memaddr)) {
+        if (ptr == &buffer[sizeof(buffer)]) {
+          /* ran out of local buffer space for converting the condition */
+          parse->offset = RC_INVALID_VALUE;
+          return;
+        }
+
         switch (**memaddr) {
           case '_': /* add next */
             *ptr = '\0';
@@ -176,7 +182,7 @@ static void rc_parse_legacy_value(rc_value_t* self, const char** memaddr, rc_par
 
       if (*buffer_ptr) {
         /* whatever we copied as a single condition was not fully consumed */
-        parse->offset = RC_INVALID_COMPARISON;
+        parse->offset = RC_INVALID_VALUE;
         return;
       }
 
@@ -429,7 +435,7 @@ rc_value_t* rc_alloc_variable(const char* memaddr, size_t memaddr_len, rc_parse_
 
   /* no match found, create a new entry */
   value = RC_ALLOC_SCRATCH(rc_value_t, parse);
-  memset(value, 0, sizeof(value->value));
+  memset(value, 0, sizeof(*value));
   value->value.size = RC_MEMSIZE_VARIABLE;
   value->next = NULL;