Emulation/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-05-20 13:27:22 -04:00
Code Issues Packages Projects Releases Wiki Activity

Reduce strlcat calls where possible

Browse source
This commit is contained in:
libretroadmin 2023-06-19 06:00:10 +02:00
parent a7ac52fe91
commit e8242253a7
19 changed files with 261 additions and 188 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
cheevos/cheevos.c
View file

@ -683,16 +683,16 @@ int rcheevos_get_richpresence(char *s, size_t len)
if (ret <= 0 && rcheevos_locals.game.title) if (ret <= 0 && rcheevos_locals.game.title)
{ {
/* TODO/FIXME - localize */ /* TODO/FIXME - localize */
strlcpy(s, "Playing ", len); size_t _len = strlcpy(s, "Playing ", len);
strlcat(s, rcheevos_locals.game.title, len); strlcpy(s + _len, rcheevos_locals.game.title, len - _len);
} }
return ret; return ret;
} }
if (rcheevos_locals.game.title) if (rcheevos_locals.game.title)
{ {
/* TODO/FIXME - localize */ /* TODO/FIXME - localize */
strlcpy(s, "Spectating ", len); size_t _len = strlcpy(s, "Spectating ", len);
return (int)strlcat(s, rcheevos_locals.game.title, len); return (int)strlcpy(s + _len, rcheevos_locals.game.title, len - _len);
} }
return 0; return 0;
} }

4
frontend/drivers/platform_ctr.c
View file

@ -82,8 +82,8 @@ static void get_first_valid_core(char* path_return, size_t len)
if (strlen(ent->d_name) > strlen(extension) if (strlen(ent->d_name) > strlen(extension)
&& !strcmp(ent->d_name + strlen(ent->d_name) - strlen(extension), extension)) && !strcmp(ent->d_name + strlen(ent->d_name) - strlen(extension), extension))
{ {
strlcpy(path_return, "sdmc:/retroarch/cores/", len); size_t _len = strlcpy(path_return, "sdmc:/retroarch/cores/", len);
strlcat(path_return, ent->d_name, len); strlcpy(path_return + _len, ent->d_name, len - _len);
break; break;
} }
} }

16
frontend/drivers/platform_gx.c
View file

@ -141,10 +141,11 @@ static void gx_devthread(void *a)
{ {
if (!gx_devices[i].interface->isInserted()) if (!gx_devices[i].interface->isInserted())
{ {
size_t _len;
char n[8]; char n[8];
gx_devices[i].mounted = false; gx_devices[i].mounted = false;
strlcpy(n, gx_devices[i].name, sizeof(n)); _len = strlcpy(n, gx_devices[i].name, sizeof(n));
strlcat(n, ":", sizeof(n)); strlcpy(n + _len, ":", sizeof(n) - _len);
fatUnmount(n); fatUnmount(n);
} }
} }
@ -215,13 +216,14 @@ static void frontend_gx_get_env(int *argc, char *argv[],
/* When using external loaders (Wiiflow, etc), /* When using external loaders (Wiiflow, etc),
getcwd doesn't return the path correctly and as a result, getcwd doesn't return the path correctly and as a result,
the cfg file is not found. */ the cfg file is not found. */
if ( string_starts_with_size(argv[0], "usb1", STRLEN_CONST("usb1")) || if ( string_starts_with_size(argv[0], "usb1", STRLEN_CONST("usb1"))
string_starts_with_size(argv[0], "usb2", STRLEN_CONST("usb2"))) || string_starts_with_size(argv[0], "usb2", STRLEN_CONST("usb2")))
{ {
strlcpy(g_defaults.dirs[DEFAULT_DIR_CORE], "usb", size_t _len = strlcpy(g_defaults.dirs[DEFAULT_DIR_CORE], "usb",
sizeof(g_defaults.dirs[DEFAULT_DIR_CORE])); sizeof(g_defaults.dirs[DEFAULT_DIR_CORE]));
strlcat(g_defaults.dirs[DEFAULT_DIR_CORE], argv[0] + 4, strlcpy(g_defaults.dirs[DEFAULT_DIR_CORE] + _len,
sizeof(g_defaults.dirs[DEFAULT_DIR_CORE])); argv[0] + 4,
sizeof(g_defaults.dirs[DEFAULT_DIR_CORE]) - _len);
} }
/* Needed on Wii; loaders follow a dumb standard where the path and /* Needed on Wii; loaders follow a dumb standard where the path and

14
frontend/drivers/platform_ps2.c
View file

@ -63,9 +63,8 @@ static enum HDD_INIT_STATUS hddStatus = HDD_INIT_STATUS_UNKNOWN;
static void create_path_names(void) static void create_path_names(void)
{ {
char user_path[FILENAME_MAX]; char user_path[FILENAME_MAX];
size_t _len = strlcpy(user_path, cwd, sizeof(user_path));
strlcpy(user_path, cwd, sizeof(user_path)); strlcpy(user_path + _len, "retroarch", sizeof(user_path) - _len);
strlcat(user_path, "retroarch", sizeof(user_path));
fill_pathname_basedir(g_defaults.dirs[DEFAULT_DIR_PORT], cwd, sizeof(g_defaults.dirs[DEFAULT_DIR_PORT])); fill_pathname_basedir(g_defaults.dirs[DEFAULT_DIR_PORT], cwd, sizeof(g_defaults.dirs[DEFAULT_DIR_PORT]));
/* Content in the same folder */ /* Content in the same folder */
@ -216,16 +215,17 @@ static void mount_partition(void)
return; return;
} }
/* If we're booting from HDD, we must update the cwd variable
* and add : to the mount point */
if (bootDeviceID == BOOT_DEVICE_HDD || bootDeviceID == BOOT_DEVICE_HDD0) if (bootDeviceID == BOOT_DEVICE_HDD || bootDeviceID == BOOT_DEVICE_HDD0)
{ {
/* If we're booting from HDD, we must update the cwd variable and add : to the mount point */ size_t _len = strlcpy(cwd, new_cwd, sizeof(cwd));
strlcpy(cwd, new_cwd, sizeof(cwd)); strlcpy(mountPoint + _len, ":", sizeof(mountPoint) - _len);
strlcat(mountPoint, ":", sizeof(mountPoint));
} }
else else
{ {
/* We MUST put mountPoint as empty to avoid wrong results /* We MUST put mountPoint as empty to avoid wrong results
with LoadELFFromFileWithPartition */ with LoadELFFromFileWithPartition */
strlcpy(mountPoint, "", sizeof(mountPoint)); strlcpy(mountPoint, "", sizeof(mountPoint));
} }
} }

6
frontend/drivers/platform_switch.c
View file

@ -171,8 +171,10 @@ static void get_first_valid_core(char *path_return, size_t len)
break; break;
if (strlen(ent->d_name) > strlen(extension) && !strcmp(ent->d_name + strlen(ent->d_name) - strlen(extension), extension)) if (strlen(ent->d_name) > strlen(extension) && !strcmp(ent->d_name + strlen(ent->d_name) - strlen(extension), extension))
{ {
strlcpy(path_return, SD_PREFIX "/retroarch/cores", len); size_t _len = strlcpy(path_return, SD_PREFIX "/retroarch/cores", len);
strlcat(path_return, "/", len); strlcpy(path_return + _len,
"/",
len - _len);
strlcat(path_return, ent->d_name, len); strlcat(path_return, ent->d_name, len);
break; break;
} }

26
frontend/drivers/platform_unix.c
View file

@ -1741,13 +1741,13 @@ static void frontend_unix_get_env(int *argc,
if (xdg) if (xdg)
{ {
strlcpy(base_path, xdg, sizeof(base_path)); size_t _len = strlcpy(base_path, xdg, sizeof(base_path));
strlcat(base_path, "/retroarch", sizeof(base_path)); strlcpy(base_path + _len, "/retroarch", sizeof(base_path) - _len);
} }
else if (home) else if (home)
{ {
strlcpy(base_path, home, sizeof(base_path)); size_t _len = strlcpy(base_path, home, sizeof(base_path));
strlcat(base_path, "/.config/retroarch", sizeof(base_path)); strlcpy(base_path + _len, "/.config/retroarch", sizeof(base_path) - _len);
} }
else else
strlcpy(base_path, "retroarch", sizeof(base_path)); strlcpy(base_path, "retroarch", sizeof(base_path));
@ -2255,21 +2255,23 @@ static int frontend_unix_parse_drive_list(void *data, bool load_content)
if (xdg) if (xdg)
{ {
strlcpy(base_path, xdg, sizeof(base_path)); size_t _len = strlcpy(base_path, xdg, sizeof(base_path));
strlcat(base_path, "/retroarch", sizeof(base_path)); strlcpy(base_path + _len, "/retroarch", sizeof(base_path) - _len);
} }
else if (home) else if (home)
{ {
strlcpy(base_path, home, sizeof(base_path)); size_t _len = strlcpy(base_path, home, sizeof(base_path));
strlcat(base_path, "/.config/retroarch", sizeof(base_path)); strlcpy(base_path + _len, "/.config/retroarch", sizeof(base_path) - _len);
} }
#endif #endif
strlcpy(udisks_media_path, "/run/media", sizeof(udisks_media_path));
if (user)
{ {
strlcat(udisks_media_path, "/", sizeof(udisks_media_path)); size_t _len = strlcpy(udisks_media_path, "/run/media", sizeof(udisks_media_path));
strlcat(udisks_media_path, user, sizeof(udisks_media_path)); if (user)
{
strlcpy(udisks_media_path + _len, "/", sizeof(udisks_media_path) - _len);
strlcat(udisks_media_path, user, sizeof(udisks_media_path));
}
} }
if (!string_is_empty(base_path)) if (!string_is_empty(base_path))

7
gfx/drivers/ctr_gfx.c
View file

@ -1283,6 +1283,7 @@ static void ctr_render_bottom_screen(void *data)
{ {
case CTR_BOTTOM_MENU_NOT_AVAILABLE: case CTR_BOTTOM_MENU_NOT_AVAILABLE:
{ {
size_t _len;
char str_path[PATH_MAX_LENGTH]; char str_path[PATH_MAX_LENGTH];
const char *dir_assets = settings->paths.directory_bottom_assets; const char *dir_assets = settings->paths.directory_bottom_assets;
@ -1295,8 +1296,10 @@ static void ctr_render_bottom_screen(void *data)
msg_hash_to_str(MSG_3DS_BOTTOM_MENU_ASSET_NOT_FOUND), msg_hash_to_str(MSG_3DS_BOTTOM_MENU_ASSET_NOT_FOUND),
&params); &params);
strlcpy(str_path, dir_assets, sizeof(str_path)); _len = strlcpy(str_path, dir_assets, sizeof(str_path));
strlcat(str_path, "\n/bottom_menu.png", sizeof(str_path)); strlcpy(str_path + _len,
"\n/bottom_menu.png",
sizeof(str_path) - _len);
params.scale = 1.10f; params.scale = 1.10f;
params.y -= 0.10f; params.y -= 0.10f;

21
menu/drivers/materialui.c
View file

@ -7176,7 +7176,10 @@ static void materialui_frame(void *data, video_frame_info_t *video_info)
_len = strlcpy(msg, label, sizeof(msg)); _len = strlcpy(msg, label, sizeof(msg));
msg[_len ] = '\n'; msg[_len ] = '\n';
msg[_len+1] = '\0'; msg[_len+1] = '\0';
strlcat(msg, str, sizeof(msg)); _len += 1;
strlcpy(msg + _len,
str,
sizeof(msg) - _len);
materialui_render_messagebox(mui, materialui_render_messagebox(mui,
p_disp, p_disp,
userdata, video_width, video_height, userdata, video_width, video_height,
@ -7519,9 +7522,10 @@ static void materialui_status_bar_init(
sizeof(mui->status_bar.runtime_fallback_str)); sizeof(mui->status_bar.runtime_fallback_str));
mui->status_bar.runtime_fallback_str[_len ] = ' '; mui->status_bar.runtime_fallback_str[_len ] = ' ';
mui->status_bar.runtime_fallback_str[_len+1] = '\0'; mui->status_bar.runtime_fallback_str[_len+1] = '\0';
strlcat(mui->status_bar.runtime_fallback_str, _len += 1;
strlcpy(mui->status_bar.runtime_fallback_str + _len,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISABLED), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISABLED),
sizeof(mui->status_bar.runtime_fallback_str)); sizeof(mui->status_bar.runtime_fallback_str) - _len);
_len = strlcpy(mui->status_bar.last_played_fallback_str, _len = strlcpy(mui->status_bar.last_played_fallback_str,
msg_hash_to_str( msg_hash_to_str(
@ -7529,9 +7533,10 @@ static void materialui_status_bar_init(
sizeof(mui->status_bar.last_played_fallback_str)); sizeof(mui->status_bar.last_played_fallback_str));
mui->status_bar.last_played_fallback_str[_len ] = ' '; mui->status_bar.last_played_fallback_str[_len ] = ' ';
mui->status_bar.last_played_fallback_str[_len+1] = '\0'; mui->status_bar.last_played_fallback_str[_len+1] = '\0';
strlcat(mui->status_bar.last_played_fallback_str, _len += 1;
strlcpy(mui->status_bar.last_played_fallback_str + _len,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISABLED), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISABLED),
sizeof(mui->status_bar.last_played_fallback_str) sizeof(mui->status_bar.last_played_fallback_str) - _len
); );
} }
} }
@ -10966,8 +10971,10 @@ static void materialui_list_insert(
{ {
char val[255]; char val[255];
unsigned user_value = i + 1; unsigned user_value = i + 1;
snprintf(val, sizeof(val), "%d", user_value); size_t _len = snprintf(val, sizeof(val), "%d", user_value);
strlcat(val, "_input_binds_list", sizeof(val)); strlcpy(val + _len,
"_input_binds_list",
sizeof(val) - _len);
if (string_is_equal(label, val)) if (string_is_equal(label, val))
{ {

11
menu/drivers/rgui.c
View file

@ -4665,7 +4665,10 @@ static void rgui_render_osk(
size_t _len = strlcpy(msg, input_label, sizeof(msg)); size_t _len = strlcpy(msg, input_label, sizeof(msg));
msg[_len ] = '\n'; msg[_len ] = '\n';
msg[_len+1] = '\0'; msg[_len+1] = '\0';
strlcat(msg, input_str, sizeof(msg)); _len += 1;
strlcpy(msg + _len,
input_str,
sizeof(msg) - _len);
rgui_render_messagebox(rgui, msg, fb_width, fb_height); rgui_render_messagebox(rgui, msg, fb_width, fb_height);
return; return;
} }
@ -6879,11 +6882,9 @@ static void rgui_update_savestate_thumbnail_path(void *data, unsigned i)
strlcat(path, FILE_PATH_PNG_EXTENSION, sizeof(path)); strlcat(path, FILE_PATH_PNG_EXTENSION, sizeof(path));
if (path_is_valid(path)) if (path_is_valid(path))
{ strlcpy(rgui->savestate_thumbnail_file_path,
strlcpy( path,
rgui->savestate_thumbnail_file_path, path,
sizeof(rgui->savestate_thumbnail_file_path)); sizeof(rgui->savestate_thumbnail_file_path));
}
} }
} }
} }

5
menu/drivers/xmb.c
View file

@ -6362,7 +6362,10 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
size_t _len = strlcpy(msg, label, sizeof(msg)); size_t _len = strlcpy(msg, label, sizeof(msg));
msg[_len ] = '\n'; msg[_len ] = '\n';
msg[_len+1] = '\0'; msg[_len+1] = '\0';
strlcat(msg, str, sizeof(msg)); _len += 1;
strlcpy(msg + _len,
str,
sizeof(msg) - _len);
render_background = true; render_background = true;
} }

14
network/discord.c
View file

@ -207,13 +207,16 @@ static void handle_discord_join(const char *secret)
if ((room_id = (int)strtol(secret, NULL, 10))) if ((room_id = (int)strtol(secret, NULL, 10)))
{ {
size_t _len;
discord_state_t *discord_st = &discord_state_st; discord_state_t *discord_st = &discord_state_st;
snprintf(discord_st->peer_party_id, snprintf(discord_st->peer_party_id,
sizeof(discord_st->peer_party_id), sizeof(discord_st->peer_party_id),
"%d", room_id); "%d", room_id);
strlcpy(url, FILE_PATH_LOBBY_LIBRETRO_URL, sizeof(url)); _len = strlcpy(url, FILE_PATH_LOBBY_LIBRETRO_URL, sizeof(url));
strlcat(url, discord_st->peer_party_id, sizeof(url)); strlcpy(url + _len,
discord_st->peer_party_id,
sizeof(url) - _len);
task_push_http_transfer(url, true, NULL, handle_discord_join_cb, NULL); task_push_http_transfer(url, true, NULL, handle_discord_join_cb, NULL);
} }
@ -475,9 +478,12 @@ void discord_init(const char *discord_app_id, char *args)
strlcpy(command, args, sizeof(command)); strlcpy(command, args, sizeof(command));
else else
{ {
size_t _len;
path_basedir(full_path); path_basedir(full_path);
strlcpy(command, full_path, sizeof(command)); _len = strlcpy(command, full_path, sizeof(command));
strlcat(command, args, sizeof(command)); strlcpy(command + _len,
args,
sizeof(command) - _len);
} }
#else #else
command[0] = 's'; command[0] = 's';

9
network/netplay/netplay_frontend.c
View file

@ -761,6 +761,7 @@ static bool netplay_handshake_init_send(netplay_t *netplay,
#ifdef HAVE_MENU #ifdef HAVE_MENU
static void handshake_password(void *userdata, const char *line) static void handshake_password(void *userdata, const char *line)
{ {
size_t _len;
struct password_buf_s password_buf; struct password_buf_s password_buf;
char password[8+NETPLAY_PASS_LEN]; /* 8 for salt, 128 for password */ char password[8+NETPLAY_PASS_LEN]; /* 8 for salt, 128 for password */
char hash[NETPLAY_PASS_HASH_LEN+1]; /* + NULL terminator */ char hash[NETPLAY_PASS_HASH_LEN+1]; /* + NULL terminator */
@ -772,10 +773,12 @@ static void handshake_password(void *userdata, const char *line)
return; return;
connection = &netplay->connections[0]; connection = &netplay->connections[0];
_len = snprintf(password, sizeof(password),
snprintf(password, sizeof(password), "%08lX", (unsigned long)connection->salt); "%08lX", (unsigned long)connection->salt);
if (!string_is_empty(line)) if (!string_is_empty(line))
strlcat(password, line, sizeof(password)); strlcpy(password + _len,
line,
sizeof(password) - _len);
password_buf.cmd[0] = htonl(NETPLAY_CMD_PASSWORD); password_buf.cmd[0] = htonl(NETPLAY_CMD_PASSWORD);
password_buf.cmd[1] = htonl(sizeof(password_buf.password)); password_buf.cmd[1] = htonl(sizeof(password_buf.password));

9
play_feature_delivery/play_feature_delivery.c
View file

@ -360,12 +360,11 @@ struct string_list *play_feature_delivery_available_cores(void)
if (!string_is_empty(core_name)) if (!string_is_empty(core_name))
{ {
char core_file[256]; char core_file[256];
core_file[0] = '\0';
/* Generate core file name */ /* Generate core file name */
strlcpy(core_file, core_name, sizeof(core_file)); size_t _len = strlcpy(core_file, core_name, sizeof(core_file));
strlcat(core_file, "_libretro_android.so", sizeof(core_file)); strlcpy(core_file + _len,
"_libretro_android.so",
sizeof(core_file) - _len);
/* Add entry to list */ /* Add entry to list */
if (!string_is_empty(core_file)) if (!string_is_empty(core_file))
string_list_append(core_list, core_file, attr); string_list_append(core_list, core_file, attr);

18
record/record_driver.c
View file

@ -469,23 +469,23 @@ void recording_driver_update_streaming_url(void)
case STREAMING_MODE_TWITCH: case STREAMING_MODE_TWITCH:
if (!string_is_empty(settings->arrays.twitch_stream_key)) if (!string_is_empty(settings->arrays.twitch_stream_key))
{ {
strlcpy(settings->paths.path_stream_url, size_t _len = strlcpy(settings->paths.path_stream_url,
twitch_url, twitch_url,
sizeof(settings->paths.path_stream_url)); sizeof(settings->paths.path_stream_url));
strlcat(settings->paths.path_stream_url, strlcpy(settings->paths.path_stream_url + _len,
settings->arrays.twitch_stream_key, settings->arrays.twitch_stream_key,
sizeof(settings->paths.path_stream_url)); sizeof(settings->paths.path_stream_url) - _len);
} }
break; break;
case STREAMING_MODE_YOUTUBE: case STREAMING_MODE_YOUTUBE:
if (!string_is_empty(settings->arrays.youtube_stream_key)) if (!string_is_empty(settings->arrays.youtube_stream_key))
{ {
strlcpy(settings->paths.path_stream_url, size_t _len = strlcpy(settings->paths.path_stream_url,
youtube_url, youtube_url,
sizeof(settings->paths.path_stream_url)); sizeof(settings->paths.path_stream_url));
strlcat(settings->paths.path_stream_url, strlcpy(settings->paths.path_stream_url + _len,
settings->arrays.youtube_stream_key, settings->arrays.youtube_stream_key,
sizeof(settings->paths.path_stream_url)); sizeof(settings->paths.path_stream_url) - _len);
} }
break; break;
case STREAMING_MODE_LOCAL: case STREAMING_MODE_LOCAL:
@ -500,12 +500,12 @@ void recording_driver_update_streaming_url(void)
case STREAMING_MODE_FACEBOOK: case STREAMING_MODE_FACEBOOK:
if (!string_is_empty(settings->arrays.facebook_stream_key)) if (!string_is_empty(settings->arrays.facebook_stream_key))
{ {
strlcpy(settings->paths.path_stream_url, size_t _len = strlcpy(settings->paths.path_stream_url,
facebook_url, facebook_url,
sizeof(settings->paths.path_stream_url)); sizeof(settings->paths.path_stream_url));
strlcat(settings->paths.path_stream_url, strlcpy(settings->paths.path_stream_url + _len,
settings->arrays.facebook_stream_key, settings->arrays.facebook_stream_key,
sizeof(settings->paths.path_stream_url)); sizeof(settings->paths.path_stream_url) - _len);
} }
break; break;
} }

6
tasks/task_autodetect_blissbox.c
View file

@ -519,8 +519,10 @@ void input_autoconfigure_blissbox_override_handler(
/* override name given to autoconfig so it knows what kind of pad this is */ /* override name given to autoconfig so it knows what kind of pad this is */
if (len > 0) if (len > 0)
{ {
strlcpy(device_name, "Bliss-Box 4-Play ", len); size_t _len = strlcpy(device_name, "Bliss-Box 4-Play ", len);
strlcat(device_name, pad->name, len); strlcpy(device_name + _len,
pad->name,
len - _len);
} }
blissbox_pads[index] = pad; blissbox_pads[index] = pad;

101
tasks/task_core_backup.c
View file

@ -274,6 +274,7 @@ static void task_core_backup_handler(retro_task_t *task)
break; break;
case CORE_BACKUP_PRE_ITERATE: case CORE_BACKUP_PRE_ITERATE:
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
char backup_path[PATH_MAX_LENGTH]; char backup_path[PATH_MAX_LENGTH];
@ -314,9 +315,11 @@ static void task_core_backup_handler(retro_task_t *task)
/* Update task title */ /* Update task title */
task_free_title(task); task_free_title(task);
strlcpy(task_title, msg_hash_to_str(MSG_BACKING_UP_CORE), _len = strlcpy(task_title, msg_hash_to_str(MSG_BACKING_UP_CORE),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, backup_handle->core_name, sizeof(task_title)); strlcpy(task_title + _len,
backup_handle->core_name,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
/* Go to iteration phase */ /* Go to iteration phase */
@ -412,6 +415,7 @@ static void task_core_backup_handler(retro_task_t *task)
* history size limit */ * history size limit */
if (num_backups > backup_handle->auto_backup_history_size) if (num_backups > backup_handle->auto_backup_history_size)
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
/* Get number of old backups to remove */ /* Get number of old backups to remove */
@ -420,9 +424,12 @@ static void task_core_backup_handler(retro_task_t *task)
/* Update task title */ /* Update task title */
task_free_title(task); task_free_title(task);
strlcpy(task_title, msg_hash_to_str(MSG_PRUNING_CORE_BACKUP_HISTORY), _len = strlcpy(task_title,
msg_hash_to_str(MSG_PRUNING_CORE_BACKUP_HISTORY),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, backup_handle->core_name, sizeof(task_title)); strlcpy(task_title + _len,
backup_handle->core_name,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
/* Go to history clean-up phase */ /* Go to history clean-up phase */
@ -479,6 +486,7 @@ static void task_core_backup_handler(retro_task_t *task)
break; break;
case CORE_BACKUP_END: case CORE_BACKUP_END:
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
/* Set final task title */ /* Set final task title */
task_free_title(task); task_free_title(task);
@ -486,19 +494,21 @@ static void task_core_backup_handler(retro_task_t *task)
if (backup_handle->success) if (backup_handle->success)
{ {
if (backup_handle->crc_match) if (backup_handle->crc_match)
strlcpy(task_title, _len = strlcpy(task_title,
msg_hash_to_str(MSG_CORE_BACKUP_ALREADY_EXISTS), msg_hash_to_str(MSG_CORE_BACKUP_ALREADY_EXISTS),
sizeof(task_title)); sizeof(task_title));
else else
strlcpy(task_title, _len = strlcpy(task_title,
msg_hash_to_str(MSG_CORE_BACKUP_COMPLETE), msg_hash_to_str(MSG_CORE_BACKUP_COMPLETE),
sizeof(task_title)); sizeof(task_title));
} }
else else
strlcpy(task_title, msg_hash_to_str(MSG_CORE_BACKUP_FAILED), _len = strlcpy(task_title, msg_hash_to_str(MSG_CORE_BACKUP_FAILED),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, backup_handle->core_name, sizeof(task_title)); strlcpy(task_title + _len,
backup_handle->core_name,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
} }
/* fall-through */ /* fall-through */
@ -530,6 +540,7 @@ void *task_push_core_backup(
size_t auto_backup_history_size, size_t auto_backup_history_size,
const char *dir_core_assets, bool mute) const char *dir_core_assets, bool mute)
{ {
size_t _len;
task_finder_data_t find_data; task_finder_data_t find_data;
const char *core_name = NULL; const char *core_name = NULL;
retro_task_t *task = NULL; retro_task_t *task = NULL;
@ -537,8 +548,8 @@ void *task_push_core_backup(
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
/* Sanity check */ /* Sanity check */
if (string_is_empty(core_path) || if ( string_is_empty(core_path)
!path_is_valid(core_path)) || !path_is_valid(core_path))
goto error; goto error;
/* Concurrent backup/restore tasks for the same core /* Concurrent backup/restore tasks for the same core
@ -601,9 +612,11 @@ void *task_push_core_backup(
goto error; goto error;
/* Get initial task title */ /* Get initial task title */
strlcpy(task_title, msg_hash_to_str(MSG_CORE_BACKUP_SCANNING_CORE), _len = strlcpy(task_title, msg_hash_to_str(MSG_CORE_BACKUP_SCANNING_CORE),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, backup_handle->core_name, sizeof(task_title)); strlcpy(task_title + _len,
backup_handle->core_name,
sizeof(task_title) - _len);
/* Configure task */ /* Configure task */
task->handler = task_core_backup_handler; task->handler = task_core_backup_handler;
@ -737,6 +750,7 @@ static void task_core_restore_handler(retro_task_t *task)
break; break;
case CORE_RESTORE_PRE_ITERATE: case CORE_RESTORE_PRE_ITERATE:
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
/* Open backup file */ /* Open backup file */
@ -803,11 +817,14 @@ static void task_core_restore_handler(retro_task_t *task)
/* Update task title */ /* Update task title */
task_free_title(task); task_free_title(task);
strlcpy(task_title, (backup_handle->backup_type == CORE_BACKUP_TYPE_ARCHIVE) ? _len = strlcpy(task_title,
msg_hash_to_str(MSG_RESTORING_CORE) : (backup_handle->backup_type == CORE_BACKUP_TYPE_ARCHIVE)
msg_hash_to_str(MSG_INSTALLING_CORE), ? msg_hash_to_str(MSG_RESTORING_CORE)
: msg_hash_to_str(MSG_INSTALLING_CORE),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, backup_handle->core_name, sizeof(task_title)); strlcpy(task_title + _len,
backup_handle->core_name,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
/* Go to iteration phase */ /* Go to iteration phase */
@ -870,6 +887,7 @@ static void task_core_restore_handler(retro_task_t *task)
break; break;
case CORE_RESTORE_END: case CORE_RESTORE_END:
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
/* Set final task title */ /* Set final task title */
@ -878,23 +896,28 @@ static void task_core_restore_handler(retro_task_t *task)
if (backup_handle->success) if (backup_handle->success)
{ {
if (backup_handle->crc_match) if (backup_handle->crc_match)
strlcpy(task_title, (backup_handle->backup_type == CORE_BACKUP_TYPE_ARCHIVE) ? _len = strlcpy(task_title,
msg_hash_to_str(MSG_CORE_RESTORATION_ALREADY_INSTALLED) : (backup_handle->backup_type == CORE_BACKUP_TYPE_ARCHIVE)
msg_hash_to_str(MSG_CORE_INSTALLATION_ALREADY_INSTALLED), ? msg_hash_to_str(MSG_CORE_RESTORATION_ALREADY_INSTALLED)
: msg_hash_to_str(MSG_CORE_INSTALLATION_ALREADY_INSTALLED),
sizeof(task_title)); sizeof(task_title));
else else
strlcpy(task_title, (backup_handle->backup_type == CORE_BACKUP_TYPE_ARCHIVE) ? _len = strlcpy(task_title,
msg_hash_to_str(MSG_CORE_RESTORATION_COMPLETE) : (backup_handle->backup_type == CORE_BACKUP_TYPE_ARCHIVE)
msg_hash_to_str(MSG_CORE_INSTALLATION_COMPLETE), ? msg_hash_to_str(MSG_CORE_RESTORATION_COMPLETE)
: msg_hash_to_str(MSG_CORE_INSTALLATION_COMPLETE),
sizeof(task_title)); sizeof(task_title));
} }
else else
strlcpy(task_title, (backup_handle->backup_type == CORE_BACKUP_TYPE_ARCHIVE) ? _len = strlcpy(task_title,
msg_hash_to_str(MSG_CORE_RESTORATION_FAILED) : (backup_handle->backup_type == CORE_BACKUP_TYPE_ARCHIVE)
msg_hash_to_str(MSG_CORE_INSTALLATION_FAILED), ? msg_hash_to_str(MSG_CORE_RESTORATION_FAILED)
: msg_hash_to_str(MSG_CORE_INSTALLATION_FAILED),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, backup_handle->core_name, sizeof(task_title)); strlcpy(task_title + _len,
backup_handle->core_name,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
} }
/* fall-through */ /* fall-through */
@ -916,6 +939,7 @@ task_finished:
bool task_push_core_restore(const char *backup_path, const char *dir_libretro, bool task_push_core_restore(const char *backup_path, const char *dir_libretro,
bool *core_loaded) bool *core_loaded)
{ {
size_t _len;
task_finder_data_t find_data; task_finder_data_t find_data;
enum core_backup_type backup_type; enum core_backup_type backup_type;
core_info_t *core_info = NULL; core_info_t *core_info = NULL;
@ -952,9 +976,13 @@ bool task_push_core_restore(const char *backup_path, const char *dir_libretro,
{ {
const char *backup_filename = path_basename(backup_path); const char *backup_filename = path_basename(backup_path);
char msg[PATH_MAX_LENGTH]; char msg[PATH_MAX_LENGTH];
strlcpy(msg, msg_hash_to_str(MSG_CORE_RESTORATION_INVALID_CONTENT), sizeof(msg)); _len = strlcpy(msg,
msg_hash_to_str(MSG_CORE_RESTORATION_INVALID_CONTENT),
sizeof(msg));
if (backup_filename) if (backup_filename)
strlcat(msg, backup_filename, sizeof(msg)); strlcpy(msg + _len,
backup_filename,
sizeof(msg) - _len);
RARCH_ERR("[core restore] Invalid core file selected: %s\n", backup_path); RARCH_ERR("[core restore] Invalid core file selected: %s\n", backup_path);
runloop_msg_queue_push(msg, 1, 100, true, runloop_msg_queue_push(msg, 1, 100, true,
@ -980,12 +1008,14 @@ bool task_push_core_restore(const char *backup_path, const char *dir_libretro,
if (core_info_get_core_lock(core_path, true)) if (core_info_get_core_lock(core_path, true))
{ {
char msg[PATH_MAX_LENGTH]; char msg[PATH_MAX_LENGTH];
strlcpy(msg, _len = strlcpy(msg,
(backup_type == CORE_BACKUP_TYPE_ARCHIVE) (backup_type == CORE_BACKUP_TYPE_ARCHIVE)
? msg_hash_to_str(MSG_CORE_RESTORATION_DISABLED) ? msg_hash_to_str(MSG_CORE_RESTORATION_DISABLED)
: msg_hash_to_str(MSG_CORE_INSTALLATION_DISABLED), : msg_hash_to_str(MSG_CORE_INSTALLATION_DISABLED),
sizeof(msg)); sizeof(msg));
strlcat(msg, core_name, sizeof(msg)); strlcpy(msg + _len,
core_name,
sizeof(msg) - _len);
RARCH_ERR("[core restore] Restoration disabled - core is locked: %s\n", core_path); RARCH_ERR("[core restore] Restoration disabled - core is locked: %s\n", core_path);
runloop_msg_queue_push(msg, 1, 100, true, runloop_msg_queue_push(msg, 1, 100, true,
@ -1031,9 +1061,12 @@ bool task_push_core_restore(const char *backup_path, const char *dir_libretro,
goto error; goto error;
/* Get initial task title */ /* Get initial task title */
strlcpy(task_title, msg_hash_to_str(MSG_CORE_BACKUP_SCANNING_CORE), _len = strlcpy(task_title,
msg_hash_to_str(MSG_CORE_BACKUP_SCANNING_CORE),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, backup_handle->core_name, sizeof(task_title)); strlcpy(task_title + _len,
backup_handle->core_name,
sizeof(task_title) - _len);
/* Configure task */ /* Configure task */
task->handler = task_core_restore_handler; task->handler = task_core_restore_handler;

37
tasks/task_manual_content_scan.c
View file

@ -296,6 +296,7 @@ static void task_manual_content_scan_handler(retro_task_t *task)
if (entry) if (entry)
{ {
size_t _len;
const char *entry_file = NULL; const char *entry_file = NULL;
const char *entry_file_ext = NULL; const char *entry_file_ext = NULL;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
@ -303,13 +304,15 @@ static void task_manual_content_scan_handler(retro_task_t *task)
/* Update progress display */ /* Update progress display */
task_free_title(task); task_free_title(task);
strlcpy(task_title, _len = strlcpy(task_title,
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_PLAYLIST_CLEANUP), msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_PLAYLIST_CLEANUP),
sizeof(task_title)); sizeof(task_title));
if (!string_is_empty(entry->path) && if (!string_is_empty(entry->path) &&
(entry_file = path_basename(entry->path))) (entry_file = path_basename(entry->path)))
strlcat(task_title, entry_file, sizeof(task_title)); strlcpy(task_title + _len,
entry_file,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
task_set_progress(task, (manual_scan->playlist_index * 100) / task_set_progress(task, (manual_scan->playlist_index * 100) /
@ -359,18 +362,21 @@ static void task_manual_content_scan_handler(retro_task_t *task)
if (!string_is_empty(content_path)) if (!string_is_empty(content_path))
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
const char *content_file = path_basename(content_path); const char *content_file = path_basename(content_path);
/* Update progress display */ /* Update progress display */
task_free_title(task); task_free_title(task);
strlcpy(task_title, _len = strlcpy(task_title,
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_IN_PROGRESS), msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_IN_PROGRESS),
sizeof(task_title)); sizeof(task_title));
if (!string_is_empty(content_file)) if (!string_is_empty(content_file))
strlcat(task_title, content_file, sizeof(task_title)); strlcpy(task_title + _len,
content_file,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
task_set_progress(task, task_set_progress(task,
@ -417,6 +423,7 @@ static void task_manual_content_scan_handler(retro_task_t *task)
if (!string_is_empty(m3u_path)) if (!string_is_empty(m3u_path))
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
const char *m3u_name = path_basename_nocompression(m3u_path); const char *m3u_name = path_basename_nocompression(m3u_path);
m3u_file_t *m3u_file = NULL; m3u_file_t *m3u_file = NULL;
@ -424,12 +431,14 @@ static void task_manual_content_scan_handler(retro_task_t *task)
/* Update progress display */ /* Update progress display */
task_free_title(task); task_free_title(task);
strlcpy(task_title, _len = strlcpy(task_title,
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_M3U_CLEANUP), msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_M3U_CLEANUP),
sizeof(task_title)); sizeof(task_title));
if (!string_is_empty(m3u_name)) if (!string_is_empty(m3u_name))
strlcat(task_title, m3u_name, sizeof(task_title)); strlcpy(task_title + _len,
m3u_name,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
task_set_progress(task, (manual_scan->m3u_index * 100) / task_set_progress(task, (manual_scan->m3u_index * 100) /
@ -464,6 +473,7 @@ static void task_manual_content_scan_handler(retro_task_t *task)
break; break;
case MANUAL_SCAN_END: case MANUAL_SCAN_END:
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
/* Ensure playlist is alphabetically sorted /* Ensure playlist is alphabetically sorted
@ -477,11 +487,12 @@ static void task_manual_content_scan_handler(retro_task_t *task)
/* Update progress display */ /* Update progress display */
task_free_title(task); task_free_title(task);
strlcpy( _len = strlcpy(
task_title, msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_END), task_title, msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_END),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, manual_scan->task_config->system_name, strlcpy(task_title + _len,
sizeof(task_title)); manual_scan->task_config->system_name,
sizeof(task_title) - _len);
task_set_title(task, strdup(task_title)); task_set_title(task, strdup(task_title));
} }
@ -517,6 +528,7 @@ bool task_push_manual_content_scan(
const playlist_config_t *playlist_config, const playlist_config_t *playlist_config,
const char *playlist_directory) const char *playlist_directory)
{ {
size_t _len;
task_finder_data_t find_data; task_finder_data_t find_data;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
retro_task_t *task = NULL; retro_task_t *task = NULL;
@ -585,11 +597,12 @@ bool task_push_manual_content_scan(
goto error; goto error;
/* > Get task title */ /* > Get task title */
strlcpy( _len = strlcpy(
task_title, msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_START), task_title, msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_START),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, manual_scan->task_config->system_name, strlcpy(task_title + _len,
sizeof(task_title)); manual_scan->task_config->system_name,
sizeof(task_title) - _len);
/* > Configure task */ /* > Configure task */
task->handler = task_manual_content_scan_handler; task->handler = task_manual_content_scan_handler;

123
tasks/task_overlay.c
View file

@ -648,9 +648,9 @@ static void task_overlay_deferred_load(retro_task_t *task)
for (i = 0; i < loader->pos_increment; i++, loader->pos++) for (i = 0; i < loader->pos_increment; i++, loader->pos++)
{ {
size_t _len;
char conf_key_base[10]; char conf_key_base[10];
char conf_key[32]; char conf_key[32];
char overlay_full_screen_key[32];
char tmp_str[PATH_MAX_LENGTH]; char tmp_str[PATH_MAX_LENGTH];
float tmp_float = 0.0; float tmp_float = 0.0;
bool tmp_bool = false; bool tmp_bool = false;
@ -671,12 +671,24 @@ static void task_overlay_deferred_load(retro_task_t *task)
overlay = &loader->overlays[loader->pos]; overlay = &loader->overlays[loader->pos];
snprintf(conf_key_base, sizeof(conf_key_base), "overlay%u", loader->pos); snprintf(conf_key_base, sizeof(conf_key_base), "overlay%u", loader->pos);
_len = strlcpy(conf_key, conf_key_base, sizeof(conf_key));
strlcpy(overlay->config.descs.key, conf_key_base, strlcpy(conf_key + _len, "_rect", sizeof(conf_key) - _len);
sizeof(overlay->config.descs.key)); strlcpy(overlay->config.rect.key, conf_key,
strlcat(overlay->config.descs.key, "_descs", sizeof(overlay->config.rect.key));
strlcpy(conf_key + _len, "_name", sizeof(conf_key) - _len);
strlcpy(overlay->config.names.key, conf_key,
sizeof(overlay->config.names.key));
strlcpy(conf_key + _len, "_descs", sizeof(conf_key) - _len);
strlcpy(overlay->config.descs.key, conf_key,
sizeof(overlay->config.descs.key)); sizeof(overlay->config.descs.key));
strlcpy(conf_key + _len, "_overlay", sizeof(conf_key) - _len);
strlcpy(overlay->config.paths.key, conf_key,
sizeof(overlay->config.paths.key));
if (!config_get_uint(conf, overlay->config.descs.key, if (!config_get_uint(conf, overlay->config.descs.key,
&overlay->config.descs.size)) &overlay->config.descs.size))
{ {
@ -697,35 +709,31 @@ static void task_overlay_deferred_load(retro_task_t *task)
overlay->descs = overlay_desc; overlay->descs = overlay_desc;
overlay->size = overlay->config.descs.size; overlay->size = overlay->config.descs.size;
strlcpy(overlay_full_screen_key, conf_key_base, strlcpy(conf_key + _len, "_alpha_mod", sizeof(conf_key) - _len);
sizeof(overlay_full_screen_key)); if (config_get_float(conf, conf_key, &tmp_float))
strlcat(overlay_full_screen_key, "_full_screen", overlay->config.alpha_mod = tmp_float;
sizeof(overlay_full_screen_key)); else
overlay->flags &= ~OVERLAY_FULL_SCREEN; overlay->config.alpha_mod = 1.0f;
if (config_get_bool(conf, overlay_full_screen_key, &tmp_bool)
&& tmp_bool)
overlay->flags |= OVERLAY_FULL_SCREEN;
overlay->config.normalized = false; strlcpy(conf_key + _len, "_range_mod", sizeof(conf_key) - _len);
overlay->config.alpha_mod = 1.0f; if (config_get_float(conf, conf_key, &tmp_float))
overlay->config.range_mod = 1.0f; overlay->config.range_mod = tmp_float;
else
overlay->config.range_mod = 1.0f;
strlcpy(conf_key, conf_key_base, sizeof(conf_key)); strlcpy(conf_key + _len, "_normalized", sizeof(conf_key) - _len);
strlcat(conf_key, "_normalized", sizeof(conf_key));
if (config_get_bool(conf, conf_key, &tmp_bool) if (config_get_bool(conf, conf_key, &tmp_bool)
&& tmp_bool) && tmp_bool)
overlay->config.normalized = tmp_bool; overlay->config.normalized = tmp_bool;
else
overlay->config.normalized = false;
strlcpy(conf_key, conf_key_base, sizeof(conf_key)); strlcpy(conf_key + _len, "_full_screen", sizeof(conf_key) - _len);
strlcat(conf_key, "_alpha_mod", sizeof(conf_key)); if (config_get_bool(conf, conf_key, &tmp_bool)
if (config_get_float(conf, conf_key, &tmp_float)) && tmp_bool)
overlay->config.alpha_mod = tmp_float; overlay->flags |= OVERLAY_FULL_SCREEN;
else
strlcpy(conf_key, conf_key_base, sizeof(conf_key)); overlay->flags &= ~OVERLAY_FULL_SCREEN;
strlcat(conf_key, "_range_mod", sizeof(conf_key));
if (config_get_float(conf, conf_key, &tmp_float))
overlay->config.range_mod = tmp_float;
/* Precache load image array for simplicity. */ /* Precache load image array for simplicity. */
texture_img = (struct texture_image*) texture_img = (struct texture_image*)
@ -739,11 +747,6 @@ static void task_overlay_deferred_load(retro_task_t *task)
overlay->load_images = texture_img; overlay->load_images = texture_img;
strlcpy(overlay->config.paths.key, conf_key_base,
sizeof(overlay->config.paths.key));
strlcat(overlay->config.paths.key, "_overlay",
sizeof(overlay->config.paths.key));
if (config_get_path(conf, overlay->config.paths.key, if (config_get_path(conf, overlay->config.paths.key,
tmp_str, sizeof(tmp_str))) tmp_str, sizeof(tmp_str)))
strlcpy(overlay->config.paths.path, strlcpy(overlay->config.paths.path,
@ -775,19 +778,15 @@ static void task_overlay_deferred_load(retro_task_t *task)
overlay->image = image_tex; overlay->image = image_tex;
} }
strlcpy(overlay->config.names.key, conf_key_base,
sizeof(overlay->config.names.key));
strlcat(overlay->config.names.key, "_name",
sizeof(overlay->config.names.key));
config_get_array(conf, overlay->config.names.key, config_get_array(conf, overlay->config.names.key,
overlay->name, sizeof(overlay->name)); overlay->name, sizeof(overlay->name));
/* Attempt to determine native aspect ratio */ /* Attempt to determine native aspect ratio */
strlcpy(conf_key, conf_key_base, sizeof(conf_key)); strlcpy(conf_key + _len, "_aspect_ratio", sizeof(conf_key) - _len);
strlcat(conf_key, "_aspect_ratio", sizeof(conf_key));
overlay->aspect_ratio = 0.0f;
if (config_get_float(conf, conf_key, &tmp_float)) if (config_get_float(conf, conf_key, &tmp_float))
overlay->aspect_ratio = tmp_float; overlay->aspect_ratio = tmp_float;
else
overlay->aspect_ratio = 0.0f;
if (overlay->aspect_ratio <= 0.0f) if (overlay->aspect_ratio <= 0.0f)
{ {
@ -806,11 +805,6 @@ static void task_overlay_deferred_load(retro_task_t *task)
overlay->x = overlay->y = 0.0f; overlay->x = overlay->y = 0.0f;
overlay->w = overlay->h = 1.0f; overlay->w = overlay->h = 1.0f;
strlcpy(overlay->config.rect.key, conf_key_base,
sizeof(overlay->config.rect.key));
strlcat(overlay->config.rect.key, "_rect",
sizeof(overlay->config.rect.key));
if (config_get_array(conf, overlay->config.rect.key, if (config_get_array(conf, overlay->config.rect.key,
overlay->config.rect.array, sizeof(overlay->config.rect.array))) overlay->config.rect.array, sizeof(overlay->config.rect.array)))
{ {
@ -841,26 +835,9 @@ static void task_overlay_deferred_load(retro_task_t *task)
overlay->center_x = overlay->x + 0.5f * overlay->w; overlay->center_x = overlay->x + 0.5f * overlay->w;
overlay->center_y = overlay->y + 0.5f * overlay->h; overlay->center_y = overlay->y + 0.5f * overlay->h;
/* Check whether x/y separation are force disabled
* for this overlay */
strlcpy(conf_key, conf_key_base, sizeof(conf_key));
strlcat(conf_key, "_block_x_separation", sizeof(conf_key));
overlay->flags &= ~OVERLAY_BLOCK_X_SEPARATION;
if (config_get_bool(conf, conf_key, &tmp_bool)
&& tmp_bool)
overlay->flags |= OVERLAY_BLOCK_X_SEPARATION;
strlcpy(conf_key, conf_key_base, sizeof(conf_key));
strlcat(conf_key, "_block_y_separation", sizeof(conf_key));
overlay->flags &= ~OVERLAY_BLOCK_Y_SEPARATION;
if (config_get_bool(conf, conf_key, &tmp_bool)
&& tmp_bool)
overlay->flags |= OVERLAY_BLOCK_Y_SEPARATION;
/* Check whether x/y separation are enabled /* Check whether x/y separation are enabled
* for this overlay in auto-scale mode */ * for this overlay in auto-scale mode */
strlcpy(conf_key, conf_key_base, sizeof(conf_key)); strlcpy(conf_key + _len, "_auto_x_separation", sizeof(conf_key) - _len);
strlcat(conf_key, "_auto_x_separation", sizeof(conf_key));
overlay->flags |= OVERLAY_AUTO_X_SEPARATION; overlay->flags |= OVERLAY_AUTO_X_SEPARATION;
if (config_get_bool(conf, conf_key, &tmp_bool)) if (config_get_bool(conf, conf_key, &tmp_bool))
{ {
@ -874,12 +851,28 @@ static void task_overlay_deferred_load(retro_task_t *task)
overlay->flags &= ~OVERLAY_AUTO_X_SEPARATION; overlay->flags &= ~OVERLAY_AUTO_X_SEPARATION;
} }
strlcpy(conf_key, conf_key_base, sizeof(conf_key)); strlcpy(conf_key + _len, "_auto_y_separation", sizeof(conf_key) - _len);
strlcat(conf_key, "_auto_y_separation", sizeof(conf_key));
overlay->flags &= ~OVERLAY_AUTO_Y_SEPARATION;
if (config_get_bool(conf, conf_key, &tmp_bool) if (config_get_bool(conf, conf_key, &tmp_bool)
&& tmp_bool) && tmp_bool)
overlay->flags |= OVERLAY_AUTO_Y_SEPARATION; overlay->flags |= OVERLAY_AUTO_Y_SEPARATION;
else
overlay->flags &= ~OVERLAY_AUTO_Y_SEPARATION;
/* Check whether x/y separation are force disabled
* for this overlay */
strlcpy(conf_key + _len, "_block_x_separation", sizeof(conf_key) - _len);
if (config_get_bool(conf, conf_key, &tmp_bool)
&& tmp_bool)
overlay->flags |= OVERLAY_BLOCK_X_SEPARATION;
else
overlay->flags &= ~OVERLAY_BLOCK_X_SEPARATION;
strlcpy(conf_key + _len, "_block_y_separation", sizeof(conf_key) - _len);
if (config_get_bool(conf, conf_key, &tmp_bool)
&& tmp_bool)
overlay->flags |= OVERLAY_BLOCK_Y_SEPARATION;
else
overlay->flags &= ~OVERLAY_BLOCK_Y_SEPARATION;
} }
return; return;

14
tasks/task_steam.c
View file

@ -76,10 +76,11 @@ task_finished:
if (MIST_IS_SUCCESS(result)) if (MIST_IS_SUCCESS(result))
{ {
char msg[PATH_MAX_LENGTH]; char msg[PATH_MAX_LENGTH];
strlcpy(msg, msg_hash_to_str(MSG_CORE_INSTALLED), size_t _len = strlcpy(msg, msg_hash_to_str(MSG_CORE_INSTALLED),
sizeof(msg));
strlcat(msg, state->name,
sizeof(msg)); sizeof(msg));
strlcpy(msg + _len,
state->name,
sizeof(msg) - _len);
runloop_msg_queue_push(msg, 1, 180, true, NULL, runloop_msg_queue_push(msg, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR); MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
@ -97,6 +98,7 @@ void task_push_steam_core_dlc_install(
AppId app_id, AppId app_id,
const char *name) const char *name)
{ {
size_t _len;
char task_title[PATH_MAX_LENGTH]; char task_title[PATH_MAX_LENGTH];
retro_task_t *task = task_init(); retro_task_t *task = task_init();
@ -107,9 +109,11 @@ void task_push_steam_core_dlc_install(
state->name = strdup(name); state->name = strdup(name);
state->has_downloaded = false; state->has_downloaded = false;
strlcpy(task_title, msg_hash_to_str(MSG_CORE_STEAM_INSTALLING), _len = strlcpy(task_title, msg_hash_to_str(MSG_CORE_STEAM_INSTALLING),
sizeof(task_title)); sizeof(task_title));
strlcat(task_title, name, sizeof(task_title)); strlcpy(task_title + _len,
name,
sizeof(task_title) - _len);
task->handler = task_steam_core_dlc_install_handler; task->handler = task_steam_core_dlc_install_handler;
task->state = state; task->state = state;