ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Variable name changes

This commit is contained in:
libretroadmin 2025-07-17 23:41:27 +02:00
parent d822cf58a1
commit ae2465f0db
7 changed files with 116 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
command.c
View File

@ -589,8 +589,8 @@ command_t* command_uds_new(void)
addr.sun_family = AF_UNIX;
strcpy(&addr.sun_path[1], "retroarch/cmd");
if (bind(fd, (struct sockaddr*)&addr, addrsz) < 0 ||
listen(fd, MAX_USER_CONNECTIONS) < 0)
if ( bind(fd, (struct sockaddr*)&addr, addrsz) < 0
|| listen(fd, MAX_USER_CONNECTIONS) < 0)
{
socket_close(fd);
return NULL;
@ -2333,8 +2333,8 @@ void command_event_reinit(const int flags)
&& video_st->current_video->set_nonblock_state)
video_st->current_video->set_nonblock_state(
video_st->data, false,
video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC) &&
adaptive_vsync,
video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC)
&& adaptive_vsync,
runloop_get_video_swap_interval(swap_interval_config));
#endif
}

6
libretro-common/dynamic/dylib.c
View File

@ -135,11 +135,11 @@ dylib_t dylib_load(const char *path)
{
char fw_path[PATH_MAX_LENGTH];
const char *fw_name = path_basename(path);
size_t sz = strlcpy(fw_path, path, sizeof(fw_path));
sz += strlcpy(fw_path + sz, "/", sizeof(fw_path) - sz);
size_t _len = strlcpy(fw_path, path, sizeof(fw_path));
_len += strlcpy(fw_path + _len, "/", sizeof(fw_path) - _len);
/* Assume every framework binary is named for the framework. Not always
* a great assumption but correct enough for our uses. */
strlcpy(fw_path + sz, fw_name, strlen(fw_name) - STRLEN_CONST(fw_suffix) + 1);
strlcpy(fw_path + _len, fw_name, strlen(fw_name) - STRLEN_CONST(fw_suffix) + 1);
lib = dlopen(fw_path, RTLD_LAZY | RTLD_LOCAL);
}
else

141
network/cloud_sync/webdav.c
View File

@ -43,7 +43,8 @@ typedef struct
webdav_cb_state_t *cb_st;
} webdav_mkdir_state_t;
/* TODO: all of this HTTP auth stuff should probably live in libretro-common/net? */
/* TODO: all of this HTTP auth stuff should
* probably live in libretro-common/net? */
typedef struct
{
char url[PATH_MAX_LENGTH];
@ -144,14 +145,14 @@ static char *webdav_create_ha1_hash(char *user, char *realm, char *pass)
static bool webdav_create_digest_auth(char *digest)
{
size_t _len;
webdav_state_t *webdav_st = webdav_state_get_ptr();
settings_t *settings = config_get_ptr();
char *ptr = digest + STRLEN_CONST("WWW-Authenticate: Digest ");
char *end = ptr + strlen(ptr);
size_t sz;
if (string_is_empty(settings->arrays.webdav_username) &&
string_is_empty(settings->arrays.webdav_password))
if ( string_is_empty(settings->arrays.webdav_username)
&& string_is_empty(settings->arrays.webdav_password))
return false;
webdav_cleanup_digest();
@ -169,12 +170,14 @@ static bool webdav_create_digest_auth(char *digest)
if (string_starts_with(ptr, "realm=\""))
{
ptr += STRLEN_CONST("realm=\"");
sz = strchr(ptr, '"') + 1 - ptr;
webdav_st->realm = malloc(sz);
strlcpy(webdav_st->realm, ptr, sz);
ptr += sz;
_len = strchr(ptr, '"') + 1 - ptr;
webdav_st->realm = malloc(_len);
strlcpy(webdav_st->realm, ptr, _len);
ptr += _len;
webdav_st->ha1hash = webdav_create_ha1_hash(webdav_st->username, webdav_st->realm, settings->arrays.webdav_password);
webdav_st->ha1hash = webdav_create_ha1_hash(
webdav_st->username, webdav_st->realm,
settings->arrays.webdav_password);
}
else if (string_starts_with(ptr, "qop=\""))
{
@ -183,8 +186,8 @@ static bool webdav_create_digest_auth(char *digest)
tail = strchr(ptr, '"');
while (ptr < tail)
{
if (string_starts_with(ptr, "auth") &&
(ptr[4] == ',' || ptr[4] == '"'))
if ( string_starts_with(ptr, "auth")
&& (ptr[4] == ',' || ptr[4] == '"'))
{
webdav_st->qop_auth = true;
break;
@ -203,20 +206,20 @@ static bool webdav_create_digest_auth(char *digest)
else if (string_starts_with(ptr, "nonce=\""))
{
ptr += STRLEN_CONST("nonce=\"");
sz = strchr(ptr, '"') + 1 - ptr;
webdav_st->nonce = malloc(sz);
strlcpy(webdav_st->nonce, ptr, sz);
ptr += sz;
_len = strchr(ptr, '"') + 1 - ptr;
webdav_st->nonce = malloc(_len);
strlcpy(webdav_st->nonce, ptr, _len);
ptr += _len;
}
else if (string_starts_with(ptr, "algorithm="))
{
ptr += STRLEN_CONST("algorithm=");
if (strchr(ptr, ','))
{
sz = strchr(ptr, ',') + 1 - ptr;
webdav_st->algo = malloc(sz);
strlcpy(webdav_st->algo, ptr, sz);
ptr += sz;
_len = strchr(ptr, ',') + 1 - ptr;
webdav_st->algo = malloc(_len);
strlcpy(webdav_st->algo, ptr, _len);
ptr += _len;
}
else
{
@ -227,10 +230,10 @@ static bool webdav_create_digest_auth(char *digest)
else if (string_starts_with(ptr, "opaque=\""))
{
ptr += STRLEN_CONST("opaque=\"");
sz = strchr(ptr, '"') + 1 - ptr;
webdav_st->opaque = malloc(sz);
strlcpy(webdav_st->opaque, ptr, sz);
ptr += sz;
_len = strchr(ptr, '"') + 1 - ptr;
webdav_st->opaque = malloc(_len);
strlcpy(webdav_st->opaque, ptr, _len);
ptr += _len;
}
else
{
@ -296,10 +299,10 @@ static char *webdav_create_ha1(void)
static char *webdav_create_ha2(const char *method, const char *path)
{
/* no attempt at supporting auth-int, everything else uses this */
char *hash = malloc(33);
MD5_CTX md5;
unsigned char digest[16];
/* no attempt at supporting auth-int, everything else uses this */
char *hash = malloc(33);
MD5_Init(&md5);
MD5_Update(&md5, method, strlen(method));
@ -317,12 +320,12 @@ static char *webdav_create_ha2(const char *method, const char *path)
static char *webdav_create_digest_response(const char *method, const char *path)
{
MD5_CTX md5;
unsigned char digest[16];
webdav_state_t *webdav_st = webdav_state_get_ptr();
char *ha1 = webdav_create_ha1();
char *ha2 = webdav_create_ha2(method, path);
char *hash = malloc(33);
MD5_CTX md5;
unsigned char digest[16];
MD5_Init(&md5);
MD5_Update(&md5, ha1, 32);
@ -356,7 +359,7 @@ static char *webdav_create_digest_response(const char *method, const char *path)
static char *webdav_create_digest_auth_header(const char *method, const char *url)
{
size_t _len;
size_t _len, __len;
char nonceCount[10];
webdav_state_t *webdav_st = webdav_state_get_ptr();
char *header = NULL;
@ -373,14 +376,15 @@ static char *webdav_create_digest_auth_header(const char *method, const char *ur
} while (count < 3 && *path != '\0');
response = webdav_create_digest_response(method, path);
snprintf(nonceCount, sizeof(nonceCount), "%08x", webdav_st->nc++);
__len = snprintf(nonceCount, sizeof(nonceCount),
"%08x", webdav_st->nc++);
_len = STRLEN_CONST("Authorization: Digest ");
_len += STRLEN_CONST("username=\"") + strlen(webdav_st->username) + STRLEN_CONST("\", ");
_len += STRLEN_CONST("realm=\"") + strlen(webdav_st->realm) + STRLEN_CONST("\", ");
_len += STRLEN_CONST("nonce=\"") + strlen(webdav_st->nonce) + STRLEN_CONST("\", ");
_len += STRLEN_CONST("uri=\"") + strlen(path) + STRLEN_CONST("\", ");
_len += STRLEN_CONST("nc=\"") + strlen(nonceCount) + STRLEN_CONST("\", ");
_len += STRLEN_CONST("nc=\"") + __len + STRLEN_CONST("\", ");
_len += STRLEN_CONST("cnonce=\"") + strlen(webdav_st->cnonce) + STRLEN_CONST("\", ");
if (webdav_st->qop_auth)
_len += STRLEN_CONST("qop=\"auth\", ");
@ -423,8 +427,8 @@ static char *webdav_get_auth_header(const char *method, const char *url)
webdav_state_t *webdav_st = webdav_state_get_ptr();
settings_t *settings = config_get_ptr();
if (string_is_empty(settings->arrays.webdav_username) &&
string_is_empty(settings->arrays.webdav_password))
if ( string_is_empty(settings->arrays.webdav_username)
&& string_is_empty(settings->arrays.webdav_password))
return NULL;
if (webdav_st->basic)
@ -515,14 +519,13 @@ static bool webdav_sync_begin(cloud_sync_complete_handler_t cb, void *user_data)
if (strncmp(url, "https", 5) == 0)
return false;
#endif
/* TODO: LOCK? */
/* TODO/FIXME: LOCK? */
if (!strstr(url, "://"))
_len += strlcpy(webdav_st->url, "http://", STRLEN_CONST("http://"));
strlcpy(webdav_st->url + _len, url, sizeof(webdav_st->url) - _len);
fill_pathname_slash(webdav_st->url, sizeof(webdav_st->url));
/* url/username/password may have changed, redo auth check */
/* URL/username/password may have changed, redo auth check */
webdav_st->basic = true;
auth_header = webdav_get_auth_header(NULL, NULL);
@ -546,7 +549,7 @@ static bool webdav_sync_end(cloud_sync_complete_handler_t cb, void *user_data)
{
webdav_state_t *webdav_st = webdav_state_get_ptr();
/* TODO: UNLOCK? */
/* TODO/FIXME: UNLOCK? */
if (webdav_st->basic_auth_header)
free(webdav_st->basic_auth_header);
@ -563,10 +566,8 @@ static void webdav_read_cb(retro_task_t *task, void *task_data, void *user_data,
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_data;
RFILE *file = NULL;
bool success;
success = (data &&
((data->status >= 200 && data->status < 300) || data->status == 404));
bool success = (data
&& ((data->status >= 200 && data->status < 300) || data->status == 404));
if (!success && data)
webdav_log_http_failure(webdav_cb_st->path, data);
@ -590,7 +591,8 @@ static void webdav_read_cb(retro_task_t *task, void *task_data, void *user_data,
if (success && data->data && webdav_cb_st)
{
/* TODO: it would be better if writing to the file happened during the network reads */
/* TODO/FIXME: it would be better if writing
* to the file happened during the network reads */
file = filestream_open(webdav_cb_st->file,
RETRO_VFS_FILE_ACCESS_READ_WRITE,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
@ -603,19 +605,21 @@ static void webdav_read_cb(retro_task_t *task, void *task_data, void *user_data,
if (webdav_cb_st)
{
webdav_cb_st->cb(webdav_cb_st->user_data, webdav_cb_st->path, success, file);
webdav_cb_st->cb(webdav_cb_st->user_data,
webdav_cb_st->path, success, file);
free(webdav_cb_st);
}
}
static bool webdav_read(const char *path, const char *file, cloud_sync_complete_handler_t cb, void *user_data)
static bool webdav_read(const char *path, const char *file,
cloud_sync_complete_handler_t cb, void *user_data)
{
webdav_state_t *webdav_st = webdav_state_get_ptr();
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t*)calloc(1, sizeof(webdav_cb_state_t));
void *t;
char *auth_header;
char url[PATH_MAX_LENGTH];
char url_encoded[PATH_MAX_LENGTH];
char *auth_header;
void *t;
webdav_state_t *webdav_st = webdav_state_get_ptr();
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t*)calloc(1, sizeof(webdav_cb_state_t));
fill_pathname_join_special(url, webdav_st->url, path, sizeof(url));
net_http_urlencode_full(url_encoded, url, sizeof(url_encoded));
@ -627,16 +631,18 @@ static bool webdav_read(const char *path, const char *file, cloud_sync_complete_
RARCH_DBG("[webdav] GET %s\n", url_encoded);
auth_header = webdav_get_auth_header("GET", url_encoded);
t = task_push_http_transfer_with_headers(url_encoded, true, NULL, auth_header, webdav_read_cb, webdav_cb_st);
t = task_push_http_transfer_with_headers(url_encoded, true, NULL,
auth_header, webdav_read_cb, webdav_cb_st);
free(auth_header);
return (t != NULL);
}
static void webdav_mkdir_cb(retro_task_t *task, void *task_data, void *user_data, const char *err)
static void webdav_mkdir_cb(retro_task_t *task, void *task_data,
void *user_data, const char *err)
{
char *auth_header;
webdav_mkdir_state_t *webdav_mkdir_st = (webdav_mkdir_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_data;
char *auth_header;
if (!webdav_mkdir_st)
return;
@ -681,11 +687,12 @@ static void webdav_mkdir_cb(retro_task_t *task, void *task_data, void *user_data
}
}
static void webdav_ensure_dir(const char *dir, webdav_mkdir_cb_t cb, webdav_cb_state_t *webdav_cb_st)
static void webdav_ensure_dir(const char *dir, webdav_mkdir_cb_t cb,
webdav_cb_state_t *webdav_cb_st)
{
http_transfer_data_t data;
webdav_state_t *webdav_st = webdav_state_get_ptr();
webdav_mkdir_state_t *webdav_mkdir_st = (webdav_mkdir_state_t *)malloc(sizeof(webdav_mkdir_state_t));
http_transfer_data_t data;
char url[PATH_MAX_LENGTH];
fill_pathname_join_special(url, webdav_st->url, dir, sizeof(url));
@ -701,7 +708,9 @@ static void webdav_ensure_dir(const char *dir, webdav_mkdir_cb_t cb, webdav_cb_s
}
static void webdav_do_update(bool success, webdav_cb_state_t *webdav_cb_st);
static void webdav_update_cb(retro_task_t *task, void *task_data, void *user_data, const char *err)
static void webdav_update_cb(retro_task_t *task, void *task_data,
void *user_data, const char *err)
{
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_data;
@ -763,12 +772,13 @@ static void webdav_do_update(bool success, webdav_cb_state_t *webdav_cb_st)
free(buf);
}
static bool webdav_update(const char *path, RFILE *rfile, cloud_sync_complete_handler_t cb, void *user_data)
static bool webdav_update(const char *path, RFILE *rfile,
cloud_sync_complete_handler_t cb, void *user_data)
{
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t*)calloc(1, sizeof(webdav_cb_state_t));
char dir[DIR_MAX_LENGTH];
/* TODO: if !settings->bools.cloud_sync_destructive, should move to deleted/ first */
/* TODO/FIXME: if !settings->bools.cloud_sync_destructive, should move to deleted/ first */
webdav_cb_st->cb = cb;
webdav_cb_st->user_data = user_data;
@ -786,7 +796,8 @@ static bool webdav_update(const char *path, RFILE *rfile, cloud_sync_complete_ha
return true;
}
static void webdav_delete_cb(retro_task_t *task, void *task_data, void *user_data, const char *err)
static void webdav_delete_cb(retro_task_t *task, void *task_data,
void *user_data, const char *err)
{
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_data;
@ -824,7 +835,9 @@ static void webdav_delete_cb(retro_task_t *task, void *task_data, void *user_dat
}
static void webdav_do_backup(bool success, webdav_cb_state_t *webdav_cb_st);
static void webdav_backup_cb(retro_task_t *task, void *task_data, void *user_data, const char *err)
static void webdav_backup_cb(retro_task_t *task, void *task_data,
void *user_data, const char *err)
{
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_data;
@ -852,15 +865,15 @@ static void webdav_backup_cb(retro_task_t *task, void *task_data, void *user_dat
static void webdav_do_backup(bool success, webdav_cb_state_t *webdav_cb_st)
{
char *auth_header;
size_t len;
struct tm tm_;
webdav_state_t *webdav_st = webdav_state_get_ptr();
char dest_encoded[PATH_MAX_LENGTH];
char dest[PATH_MAX_LENGTH];
char url_encoded[PATH_MAX_LENGTH];
char url[PATH_MAX_LENGTH];
size_t len;
struct tm tm_;
time_t cur_time = time(NULL);
char *auth_header;
if (!webdav_cb_st)
return;
@ -893,7 +906,7 @@ static bool webdav_delete(const char *path, cloud_sync_complete_handler_t cb, vo
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t*)calloc(1, sizeof(webdav_cb_state_t));
settings_t *settings = config_get_ptr();
webdav_cb_st->cb = cb;
webdav_cb_st->cb = cb;
webdav_cb_st->user_data = user_data;
strlcpy(webdav_cb_st->path, path, sizeof(webdav_cb_st->path));
@ -904,10 +917,10 @@ static bool webdav_delete(const char *path, cloud_sync_complete_handler_t cb, vo
*/
if (settings->bools.cloud_sync_destructive)
{
char *auth_header;
char url[PATH_MAX_LENGTH];
char url_encoded[PATH_MAX_LENGTH];
webdav_state_t *webdav_st = webdav_state_get_ptr();
char url_encoded[PATH_MAX_LENGTH];
char url[PATH_MAX_LENGTH];
char *auth_header;
fill_pathname_join_special(url, webdav_st->url, path, sizeof(url));
net_http_urlencode_full(url_encoded, url, sizeof(url_encoded));

11
network/cloud_sync_driver.c
View File

@ -96,7 +96,8 @@ bool cloud_sync_begin(cloud_sync_complete_handler_t cb, void *user_data)
return false;
}
bool cloud_sync_end(cloud_sync_complete_handler_t cb, void *user_data)
bool cloud_sync_end(cloud_sync_complete_handler_t cb,
void *user_data)
{
const cloud_sync_driver_t *driver = cloud_sync_state_get_ptr()->driver;
if (driver && driver->cloud_sync_end)
@ -104,7 +105,8 @@ bool cloud_sync_end(cloud_sync_complete_handler_t cb, void *user_data)
return false;
}
bool cloud_sync_read(const char *path, const char *file, cloud_sync_complete_handler_t cb, void *user_data)
bool cloud_sync_read(const char *path, const char *file,
cloud_sync_complete_handler_t cb, void *user_data)
{
const cloud_sync_driver_t *driver = cloud_sync_state_get_ptr()->driver;
if (driver && driver->cloud_sync_read)
@ -113,7 +115,7 @@ bool cloud_sync_read(const char *path, const char *file, cloud_sync_complete_han
}
bool cloud_sync_update(const char *path, RFILE *file,
cloud_sync_complete_handler_t cb, void *user_data)
cloud_sync_complete_handler_t cb, void *user_data)
{
const cloud_sync_driver_t *driver = cloud_sync_state_get_ptr()->driver;
if (driver && driver->cloud_sync_update)
@ -121,7 +123,8 @@ bool cloud_sync_update(const char *path, RFILE *file,
return false;
}
bool cloud_sync_free(const char *path, cloud_sync_complete_handler_t cb, void *user_data)
bool cloud_sync_free(const char *path,
cloud_sync_complete_handler_t cb, void *user_data)
{
const cloud_sync_driver_t *driver = cloud_sync_state_get_ptr()->driver;
if (driver && driver->cloud_sync_free)

16
network/discord.c
View File

@ -102,7 +102,7 @@ static bool discord_download_avatar(
static char url_encoded[PATH_MAX_LENGTH];
static char full_path[PATH_MAX_LENGTH];
static char buf[PATH_MAX_LENGTH];
file_transfer_t *transf = NULL;
file_transfer_t *transf = NULL;
fill_pathname_application_special(buf,
sizeof(buf),
@ -145,13 +145,9 @@ static void handle_discord_ready(const DiscordUser* connectedUser)
#endif
}
static void handle_discord_disconnected(int errcode, const char* message)
{
}
static void handle_discord_error(int errcode, const char* message)
{
}
static void handle_discord_disconnected(int errcode, const char *msg) { }
static void handle_discord_error(int errcode, const char *msg) { }
static void handle_discord_spectate(const char *secret) { }
static void handle_discord_join_cb(retro_task_t *task, void *task_data,
void *user_data, const char *error)
@ -222,10 +218,6 @@ static void handle_discord_join(const char *secret)
}
}
static void handle_discord_spectate(const char *secret)
{
}
static void handle_discord_join_request(const DiscordUser *request)
{
#ifdef HAVE_MENU

29
network/natt.c
View File

@ -223,8 +223,9 @@ void natt_device_end(struct natt_discovery *discovery)
}
}
static bool build_control_url(rxml_node_t *control_url,
struct natt_device *device)
static bool natt_build_control_url(
rxml_node_t *control_url,
struct natt_device *device)
{
if (string_is_empty(control_url->data))
return false;
@ -268,10 +269,10 @@ static bool build_control_url(rxml_node_t *control_url,
return true;
}
static bool parse_desc_node(rxml_node_t *node,
struct natt_device *device)
static bool natt_parse_desc_node(rxml_node_t *node,
struct natt_device *device)
{
rxml_node_t *child = node->children;
rxml_node_t *child = node ? node->children : NULL;
if (child)
{
@ -297,7 +298,7 @@ static bool parse_desc_node(rxml_node_t *node,
if ( strstr(service_type->data, ":WANIPConnection:")
|| strstr(service_type->data, ":WANPPPConnection:"))
{
if (build_control_url(control_url, device))
if (natt_build_control_url(control_url, device))
{
strlcpy(device->service_type, service_type->data,
sizeof(device->service_type));
@ -312,7 +313,7 @@ static bool parse_desc_node(rxml_node_t *node,
/* XML recursion */
do
{
if (parse_desc_node(child, device))
if (natt_parse_desc_node(child, device))
return true;
} while ((child = child->next));
}
@ -350,7 +351,7 @@ static void natt_query_device_cb(retro_task_t *task, void *task_data,
{
rxml_node_t *root = rxml_root_node(document);
if (root)
parse_desc_node(root, device);
natt_parse_desc_node(root, device);
rxml_free_document(document);
}
@ -386,7 +387,7 @@ bool natt_query_device(struct natt_device *device, bool block)
return true;
}
static bool parse_external_address_node(rxml_node_t *node,
static bool natt_parse_external_address_node(rxml_node_t *node,
struct natt_device *device)
{
if (string_is_equal_case_insensitive(node->name, "NewExternalIPAddress"))
@ -418,7 +419,7 @@ static bool parse_external_address_node(rxml_node_t *node,
{
do
{
if (parse_external_address_node(child, device))
if (natt_parse_external_address_node(child, device))
return true;
} while ((child = child->next));
}
@ -456,7 +457,7 @@ static void natt_external_address_cb(retro_task_t *task, void *task_data,
{
rxml_node_t *root = rxml_root_node(document);
if (root)
parse_external_address_node(root, device);
natt_parse_external_address_node(root, device);
rxml_free_document(document);
}
@ -467,7 +468,7 @@ done:
device->busy = false;
}
static bool parse_open_port_node(rxml_node_t *node,
static bool natt_parse_open_port_node(rxml_node_t *node,
struct natt_request *request)
{
if (string_is_equal_case_insensitive(node->name, "u:AddPortMappingResponse"))
@ -501,7 +502,7 @@ static bool parse_open_port_node(rxml_node_t *node,
{
do
{
if (parse_open_port_node(child, request))
if (natt_parse_open_port_node(child, request))
return true;
} while ((child = child->next));
}
@ -540,7 +541,7 @@ static void natt_open_port_cb(retro_task_t *task, void *task_data,
{
rxml_node_t *root = rxml_root_node(document);
if (root)
parse_open_port_node(root, request);
natt_parse_open_port_node(root, request);
rxml_free_document(document);
}

12
verbosity.c
View File

@ -291,9 +291,9 @@ void RARCH_LOG_V(const char *tag, const char *fmt, va_list ap)
#if TARGET_IPHONE_SIMULATOR
vprintf(fmt, ap);
#elif __IPHONE_OS_VERSION_MIN_REQUIRED > __IPHONE_10_0 || __TV_OS_VERSION_MIN_REQUIRED > __TVOS_10_0
int sz = vsnprintf(NULL, 0, fmt, ap) + 1;
char buffer[sz]; /* TODO/FIXME - VLA - C89 backwards compatibility */
vsnprintf(buffer, sz, fmt, ap);
int _len = vsnprintf(NULL, 0, fmt, ap) + 1;
char buffer[_len]; /* TODO/FIXME - VLA - C89 backwards compatibility */
vsnprintf(buffer, _len, fmt, ap);
os_log(OS_LOG_DEFAULT, "%s %s", tag_v, buffer);
#else
static aslclient asl_client;
@ -506,10 +506,10 @@ void rarch_log_file_init(
if (last_slash)
{
char tmp_buf[PATH_MAX_LENGTH] = {0};
size_t _len = last_slash + 1 - override_path;
size_t __len = last_slash + 1 - override_path;
if ((_len > 1) && (_len < PATH_MAX_LENGTH))
strlcpy(tmp_buf, override_path, _len * sizeof(char));
if ((__len > 1) && (__len < PATH_MAX_LENGTH))
strlcpy(tmp_buf, override_path, __len * sizeof(char));
strlcpy(log_directory, tmp_buf, sizeof(log_directory));
}