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; addr.sun_family = AF_UNIX;
strcpy(&addr.sun_path[1], "retroarch/cmd"); strcpy(&addr.sun_path[1], "retroarch/cmd");
if (bind(fd, (struct sockaddr*)&addr, addrsz) < 0 || if ( bind(fd, (struct sockaddr*)&addr, addrsz) < 0
listen(fd, MAX_USER_CONNECTIONS) < 0) || listen(fd, MAX_USER_CONNECTIONS) < 0)
{ {
socket_close(fd); socket_close(fd);
return NULL; 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->current_video->set_nonblock_state( video_st->current_video->set_nonblock_state(
video_st->data, false, video_st->data, false,
video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC)
adaptive_vsync, && adaptive_vsync,
runloop_get_video_swap_interval(swap_interval_config)); runloop_get_video_swap_interval(swap_interval_config));
#endif #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]; char fw_path[PATH_MAX_LENGTH];
const char *fw_name = path_basename(path); const char *fw_name = path_basename(path);
size_t sz = strlcpy(fw_path, path, sizeof(fw_path)); size_t _len = strlcpy(fw_path, path, sizeof(fw_path));
sz += strlcpy(fw_path + sz, "/", sizeof(fw_path) - sz); _len += strlcpy(fw_path + _len, "/", sizeof(fw_path) - _len);
/* Assume every framework binary is named for the framework. Not always /* Assume every framework binary is named for the framework. Not always
* a great assumption but correct enough for our uses. */ * 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); lib = dlopen(fw_path, RTLD_LAZY | RTLD_LOCAL);
} }
else else

141
network/cloud_sync/webdav.c
View File

@ -43,7 +43,8 @@ typedef struct
webdav_cb_state_t *cb_st; webdav_cb_state_t *cb_st;
} webdav_mkdir_state_t; } 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 typedef struct
{ {
char url[PATH_MAX_LENGTH]; 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) static bool webdav_create_digest_auth(char *digest)
{ {
size_t _len;
webdav_state_t *webdav_st = webdav_state_get_ptr(); webdav_state_t *webdav_st = webdav_state_get_ptr();
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
char *ptr = digest + STRLEN_CONST("WWW-Authenticate: Digest "); char *ptr = digest + STRLEN_CONST("WWW-Authenticate: Digest ");
char *end = ptr + strlen(ptr); char *end = ptr + strlen(ptr);
size_t sz;
if (string_is_empty(settings->arrays.webdav_username) && if ( string_is_empty(settings->arrays.webdav_username)
string_is_empty(settings->arrays.webdav_password)) && string_is_empty(settings->arrays.webdav_password))
return false; return false;
webdav_cleanup_digest(); webdav_cleanup_digest();
@ -169,12 +170,14 @@ static bool webdav_create_digest_auth(char *digest)
if (string_starts_with(ptr, "realm=\"")) if (string_starts_with(ptr, "realm=\""))
{ {
ptr += STRLEN_CONST("realm=\""); ptr += STRLEN_CONST("realm=\"");
sz = strchr(ptr, '"') + 1 - ptr; _len = strchr(ptr, '"') + 1 - ptr;
webdav_st->realm = malloc(sz); webdav_st->realm = malloc(_len);
strlcpy(webdav_st->realm, ptr, sz); strlcpy(webdav_st->realm, ptr, _len);
ptr += sz; 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=\"")) else if (string_starts_with(ptr, "qop=\""))
{ {
@ -183,8 +186,8 @@ static bool webdav_create_digest_auth(char *digest)
tail = strchr(ptr, '"'); tail = strchr(ptr, '"');
while (ptr < tail) while (ptr < tail)
{ {
if (string_starts_with(ptr, "auth") && if ( string_starts_with(ptr, "auth")
(ptr[4] == ',' || ptr[4] == '"')) && (ptr[4] == ',' || ptr[4] == '"'))
{ {
webdav_st->qop_auth = true; webdav_st->qop_auth = true;
break; break;
@ -203,20 +206,20 @@ static bool webdav_create_digest_auth(char *digest)
else if (string_starts_with(ptr, "nonce=\"")) else if (string_starts_with(ptr, "nonce=\""))
{ {
ptr += STRLEN_CONST("nonce=\""); ptr += STRLEN_CONST("nonce=\"");
sz = strchr(ptr, '"') + 1 - ptr; _len = strchr(ptr, '"') + 1 - ptr;
webdav_st->nonce = malloc(sz); webdav_st->nonce = malloc(_len);
strlcpy(webdav_st->nonce, ptr, sz); strlcpy(webdav_st->nonce, ptr, _len);
ptr += sz; ptr += _len;
} }
else if (string_starts_with(ptr, "algorithm=")) else if (string_starts_with(ptr, "algorithm="))
{ {
ptr += STRLEN_CONST("algorithm="); ptr += STRLEN_CONST("algorithm=");
if (strchr(ptr, ',')) if (strchr(ptr, ','))
{ {
sz = strchr(ptr, ',') + 1 - ptr; _len = strchr(ptr, ',') + 1 - ptr;
webdav_st->algo = malloc(sz); webdav_st->algo = malloc(_len);
strlcpy(webdav_st->algo, ptr, sz); strlcpy(webdav_st->algo, ptr, _len);
ptr += sz; ptr += _len;
} }
else else
{ {
@ -227,10 +230,10 @@ static bool webdav_create_digest_auth(char *digest)
else if (string_starts_with(ptr, "opaque=\"")) else if (string_starts_with(ptr, "opaque=\""))
{ {
ptr += STRLEN_CONST("opaque=\""); ptr += STRLEN_CONST("opaque=\"");
sz = strchr(ptr, '"') + 1 - ptr; _len = strchr(ptr, '"') + 1 - ptr;
webdav_st->opaque = malloc(sz); webdav_st->opaque = malloc(_len);
strlcpy(webdav_st->opaque, ptr, sz); strlcpy(webdav_st->opaque, ptr, _len);
ptr += sz; ptr += _len;
} }
else else
{ {
@ -296,10 +299,10 @@ static char *webdav_create_ha1(void)
static char *webdav_create_ha2(const char *method, const char *path) 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; MD5_CTX md5;
unsigned char digest[16]; unsigned char digest[16];
/* no attempt at supporting auth-int, everything else uses this */
char *hash = malloc(33);
MD5_Init(&md5); MD5_Init(&md5);
MD5_Update(&md5, method, strlen(method)); 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) 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(); webdav_state_t *webdav_st = webdav_state_get_ptr();
char *ha1 = webdav_create_ha1(); char *ha1 = webdav_create_ha1();
char *ha2 = webdav_create_ha2(method, path); char *ha2 = webdav_create_ha2(method, path);
char *hash = malloc(33); char *hash = malloc(33);
MD5_CTX md5;
unsigned char digest[16];
MD5_Init(&md5); MD5_Init(&md5);
MD5_Update(&md5, ha1, 32); 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) static char *webdav_create_digest_auth_header(const char *method, const char *url)
{ {
size_t _len; size_t _len, __len;
char nonceCount[10]; char nonceCount[10];
webdav_state_t *webdav_st = webdav_state_get_ptr(); webdav_state_t *webdav_st = webdav_state_get_ptr();
char *header = NULL; 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'); } while (count < 3 && *path != '\0');
response = webdav_create_digest_response(method, path); 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("Authorization: Digest ");
_len += STRLEN_CONST("username=\"") + strlen(webdav_st->username) + STRLEN_CONST("\", "); _len += STRLEN_CONST("username=\"") + strlen(webdav_st->username) + STRLEN_CONST("\", ");
_len += STRLEN_CONST("realm=\"") + strlen(webdav_st->realm) + 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("nonce=\"") + strlen(webdav_st->nonce) + STRLEN_CONST("\", ");
_len += STRLEN_CONST("uri=\"") + strlen(path) + 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("\", "); _len += STRLEN_CONST("cnonce=\"") + strlen(webdav_st->cnonce) + STRLEN_CONST("\", ");
if (webdav_st->qop_auth) if (webdav_st->qop_auth)
_len += STRLEN_CONST("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(); webdav_state_t *webdav_st = webdav_state_get_ptr();
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
if (string_is_empty(settings->arrays.webdav_username) && if ( string_is_empty(settings->arrays.webdav_username)
string_is_empty(settings->arrays.webdav_password)) && string_is_empty(settings->arrays.webdav_password))
return NULL; return NULL;
if (webdav_st->basic) 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) if (strncmp(url, "https", 5) == 0)
return false; return false;
#endif #endif
/* TODO: LOCK? */ /* TODO/FIXME: LOCK? */
if (!strstr(url, "://")) if (!strstr(url, "://"))
_len += strlcpy(webdav_st->url, "http://", STRLEN_CONST("http://")); _len += strlcpy(webdav_st->url, "http://", STRLEN_CONST("http://"));
strlcpy(webdav_st->url + _len, url, sizeof(webdav_st->url) - _len); strlcpy(webdav_st->url + _len, url, sizeof(webdav_st->url) - _len);
fill_pathname_slash(webdav_st->url, sizeof(webdav_st->url)); 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; webdav_st->basic = true;
auth_header = webdav_get_auth_header(NULL, NULL); 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(); webdav_state_t *webdav_st = webdav_state_get_ptr();
/* TODO: UNLOCK? */ /* TODO/FIXME: UNLOCK? */
if (webdav_st->basic_auth_header) if (webdav_st->basic_auth_header)
free(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; webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_data; http_transfer_data_t *data = (http_transfer_data_t*)task_data;
RFILE *file = NULL; RFILE *file = NULL;
bool success; bool success = (data
&& ((data->status >= 200 && data->status < 300) || data->status == 404));
success = (data &&
((data->status >= 200 && data->status < 300) || data->status == 404));
if (!success && data) if (!success && data)
webdav_log_http_failure(webdav_cb_st->path, 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) 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, file = filestream_open(webdav_cb_st->file,
RETRO_VFS_FILE_ACCESS_READ_WRITE, RETRO_VFS_FILE_ACCESS_READ_WRITE,
RETRO_VFS_FILE_ACCESS_HINT_NONE); 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) 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); 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(); void *t;
webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t*)calloc(1, sizeof(webdav_cb_state_t)); char *auth_header;
char url[PATH_MAX_LENGTH]; char url[PATH_MAX_LENGTH];
char url_encoded[PATH_MAX_LENGTH]; char url_encoded[PATH_MAX_LENGTH];
char *auth_header; webdav_state_t *webdav_st = webdav_state_get_ptr();
void *t; 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)); fill_pathname_join_special(url, webdav_st->url, path, sizeof(url));
net_http_urlencode_full(url_encoded, url, sizeof(url_encoded)); 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); RARCH_DBG("[webdav] GET %s\n", url_encoded);
auth_header = webdav_get_auth_header("GET", 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); free(auth_header);
return (t != NULL); 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; webdav_mkdir_state_t *webdav_mkdir_st = (webdav_mkdir_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_data; http_transfer_data_t *data = (http_transfer_data_t*)task_data;
char *auth_header;
if (!webdav_mkdir_st) if (!webdav_mkdir_st)
return; 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_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)); 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]; char url[PATH_MAX_LENGTH];
fill_pathname_join_special(url, webdav_st->url, dir, sizeof(url)); 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_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; webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_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); 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)); webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t*)calloc(1, sizeof(webdav_cb_state_t));
char dir[DIR_MAX_LENGTH]; 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->cb = cb;
webdav_cb_st->user_data = user_data; 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; 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; webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_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_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; webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t *)user_data;
http_transfer_data_t *data = (http_transfer_data_t*)task_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) 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(); webdav_state_t *webdav_st = webdav_state_get_ptr();
char dest_encoded[PATH_MAX_LENGTH]; char dest_encoded[PATH_MAX_LENGTH];
char dest[PATH_MAX_LENGTH]; char dest[PATH_MAX_LENGTH];
char url_encoded[PATH_MAX_LENGTH]; char url_encoded[PATH_MAX_LENGTH];
char url[PATH_MAX_LENGTH]; char url[PATH_MAX_LENGTH];
size_t len;
struct tm tm_;
time_t cur_time = time(NULL); time_t cur_time = time(NULL);
char *auth_header;
if (!webdav_cb_st) if (!webdav_cb_st)
return; 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)); webdav_cb_state_t *webdav_cb_st = (webdav_cb_state_t*)calloc(1, sizeof(webdav_cb_state_t));
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
webdav_cb_st->cb = cb; webdav_cb_st->cb = cb;
webdav_cb_st->user_data = user_data; webdav_cb_st->user_data = user_data;
strlcpy(webdav_cb_st->path, path, sizeof(webdav_cb_st->path)); 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) 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(); 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)); fill_pathname_join_special(url, webdav_st->url, path, sizeof(url));
net_http_urlencode_full(url_encoded, url, sizeof(url_encoded)); 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; 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; const cloud_sync_driver_t *driver = cloud_sync_state_get_ptr()->driver;
if (driver && driver->cloud_sync_end) 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; 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; const cloud_sync_driver_t *driver = cloud_sync_state_get_ptr()->driver;
if (driver && driver->cloud_sync_read) 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, 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; const cloud_sync_driver_t *driver = cloud_sync_state_get_ptr()->driver;
if (driver && driver->cloud_sync_update) if (driver && driver->cloud_sync_update)
@ -121,7 +123,8 @@ bool cloud_sync_update(const char *path, RFILE *file,
return false; 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; const cloud_sync_driver_t *driver = cloud_sync_state_get_ptr()->driver;
if (driver && driver->cloud_sync_free) 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 url_encoded[PATH_MAX_LENGTH];
static char full_path[PATH_MAX_LENGTH]; static char full_path[PATH_MAX_LENGTH];
static char buf[PATH_MAX_LENGTH]; static char buf[PATH_MAX_LENGTH];
file_transfer_t *transf = NULL; file_transfer_t *transf = NULL;
fill_pathname_application_special(buf, fill_pathname_application_special(buf,
sizeof(buf), sizeof(buf),
@ -145,13 +145,9 @@ static void handle_discord_ready(const DiscordUser* connectedUser)
#endif #endif
} }
static void handle_discord_disconnected(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_error(int errcode, const char* message)
{
}
static void handle_discord_join_cb(retro_task_t *task, void *task_data, static void handle_discord_join_cb(retro_task_t *task, void *task_data,
void *user_data, const char *error) 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) static void handle_discord_join_request(const DiscordUser *request)
{ {
#ifdef HAVE_MENU #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, static bool natt_build_control_url(
struct natt_device *device) rxml_node_t *control_url,
struct natt_device *device)
{ {
if (string_is_empty(control_url->data)) if (string_is_empty(control_url->data))
return false; return false;
@ -268,10 +269,10 @@ static bool build_control_url(rxml_node_t *control_url,
return true; return true;
} }
static bool parse_desc_node(rxml_node_t *node, static bool natt_parse_desc_node(rxml_node_t *node,
struct natt_device *device) struct natt_device *device)
{ {
rxml_node_t *child = node->children; rxml_node_t *child = node ? node->children : NULL;
if (child) if (child)
{ {
@ -297,7 +298,7 @@ static bool parse_desc_node(rxml_node_t *node,
if ( strstr(service_type->data, ":WANIPConnection:") if ( strstr(service_type->data, ":WANIPConnection:")
|| strstr(service_type->data, ":WANPPPConnection:")) || 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, strlcpy(device->service_type, service_type->data,
sizeof(device->service_type)); sizeof(device->service_type));
@ -312,7 +313,7 @@ static bool parse_desc_node(rxml_node_t *node,
/* XML recursion */ /* XML recursion */
do do
{ {
if (parse_desc_node(child, device)) if (natt_parse_desc_node(child, device))
return true; return true;
} while ((child = child->next)); } 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); rxml_node_t *root = rxml_root_node(document);
if (root) if (root)
parse_desc_node(root, device); natt_parse_desc_node(root, device);
rxml_free_document(document); rxml_free_document(document);
} }
@ -386,7 +387,7 @@ bool natt_query_device(struct natt_device *device, bool block)
return true; 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) struct natt_device *device)
{ {
if (string_is_equal_case_insensitive(node->name, "NewExternalIPAddress")) if (string_is_equal_case_insensitive(node->name, "NewExternalIPAddress"))
@ -418,7 +419,7 @@ static bool parse_external_address_node(rxml_node_t *node,
{ {
do do
{ {
if (parse_external_address_node(child, device)) if (natt_parse_external_address_node(child, device))
return true; return true;
} while ((child = child->next)); } 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); rxml_node_t *root = rxml_root_node(document);
if (root) if (root)
parse_external_address_node(root, device); natt_parse_external_address_node(root, device);
rxml_free_document(document); rxml_free_document(document);
} }
@ -467,7 +468,7 @@ done:
device->busy = false; 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) struct natt_request *request)
{ {
if (string_is_equal_case_insensitive(node->name, "u:AddPortMappingResponse")) 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 do
{ {
if (parse_open_port_node(child, request)) if (natt_parse_open_port_node(child, request))
return true; return true;
} while ((child = child->next)); } 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); rxml_node_t *root = rxml_root_node(document);
if (root) if (root)
parse_open_port_node(root, request); natt_parse_open_port_node(root, request);
rxml_free_document(document); 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 #if TARGET_IPHONE_SIMULATOR
vprintf(fmt, ap); vprintf(fmt, ap);
#elif __IPHONE_OS_VERSION_MIN_REQUIRED > __IPHONE_10_0 || __TV_OS_VERSION_MIN_REQUIRED > __TVOS_10_0 #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; int _len = vsnprintf(NULL, 0, fmt, ap) + 1;
char buffer[sz]; /* TODO/FIXME - VLA - C89 backwards compatibility */ char buffer[_len]; /* TODO/FIXME - VLA - C89 backwards compatibility */
vsnprintf(buffer, sz, fmt, ap); vsnprintf(buffer, _len, fmt, ap);
os_log(OS_LOG_DEFAULT, "%s %s", tag_v, buffer); os_log(OS_LOG_DEFAULT, "%s %s", tag_v, buffer);
#else #else
static aslclient asl_client; static aslclient asl_client;
@ -506,10 +506,10 @@ void rarch_log_file_init(
if (last_slash) if (last_slash)
{ {
char tmp_buf[PATH_MAX_LENGTH] = {0}; 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)) if ((__len > 1) && (__len < PATH_MAX_LENGTH))
strlcpy(tmp_buf, override_path, _len * sizeof(char)); strlcpy(tmp_buf, override_path, __len * sizeof(char));
strlcpy(log_directory, tmp_buf, sizeof(log_directory)); strlcpy(log_directory, tmp_buf, sizeof(log_directory));
} }