Cool_Tools/bemanitools
1
0
Fork 0
mirror of https://github.com/djhackersdev/bemanitools.git synced 2025-02-17 11:18:31 +01:00
Code Releases Activity

Split USB memory path configurations

Browse Source
This commit is contained in:
QCDLZCLW3K 2022-05-23 08:20:18 +09:00
parent 0294eed22b
commit 2223947dd8
9 changed files with 194 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
dist/ddr/ddr-11-us.conf vendored
View File

@ -22,8 +22,11 @@ ddrhook1.use_15khz=false
# Enable USB memory data emulation
ddrhook1.usbmem_enabled=false
# Specify path for USB memory data
ddrhook1.usbmem_path=usbmem
# Specify path for USB memory data for P1
ddrhook1.usbmem_path_p1=usbmem_p1
# Specify path for USB memory data for P2
ddrhook1.usbmem_path_p2=usbmem_p2
# Run the game windowed
gfx.windowed=false

7
dist/ddr/ddr-11.conf vendored
View File

@ -22,8 +22,11 @@ ddrhook1.use_15khz=false
# Enable USB memory data emulation
ddrhook1.usbmem_enabled=false
# Specify path for USB memory data
ddrhook1.usbmem_path=usbmem
# Specify path for P1 USB memory data
ddrhook1.usbmem_path_p1=usbmem_p1
# Specify path for P2 USB memory data
ddrhook1.usbmem_path_p2=usbmem_p2
# Run the game windowed
gfx.windowed=false

246
src/main/ddrhook-util/usbmem.c
View File

@ -48,6 +48,7 @@ struct USBMEM_STATE {
bool errored;
USBMEM_FILE_TYPE file_type;
char basepath[MAX_PATH];
char path[MAX_PATH];
char filename[MAX_PATH];
@ -57,8 +58,6 @@ struct USBMEM_STATE {
int buffer_frame;
};
static char usb_data_path[MAX_PATH];
static int target_device_id;
static struct USBMEM_STATE usbmem_state[USBMEM_DEVICE_COUNT];
@ -75,11 +74,12 @@ static void usbmem_reset_file_state(int port)
usbmem_state[port].file_type = USBMEM_FILE_TYPE_NONE;
}
void usbmem_init(const char *path, const bool enabled)
void usbmem_init(const char *path_p1, const char *path_p2, const bool enabled)
{
log_assert(usbmem_fd == NULL);
HRESULT hr;
char usb_data_path[USBMEM_DEVICE_COUNT][MAX_PATH];
hr = iohook_open_nul_fd(&usbmem_fd);
@ -89,22 +89,23 @@ void usbmem_init(const char *path, const bool enabled)
usbmem_enabled = enabled;
GetFullPathNameA(path, sizeof(usb_data_path), usb_data_path, NULL);
log_misc("USB memory data path: %s", usb_data_path);
GetFullPathNameA(path_p1, sizeof(usb_data_path[0]), usb_data_path[0], NULL);
log_misc("USB memory data path (P1): %s", usb_data_path[0]);
if (!path_exists(usb_data_path)) {
GetFullPathNameA(path_p2, sizeof(usb_data_path[1]), usb_data_path[1], NULL);
log_misc("USB memory data path (P2): %s", usb_data_path[1]);
if (enabled && !path_exists(usb_data_path[0]) && !path_exists(usb_data_path[1])) {
log_warning("USB memory data path does not exist, disabling");
usbmem_enabled = false;
}
target_device_id = -1;
for (int i = 0; i < USBMEM_DEVICE_COUNT; i++) {
char subpath[MAX_PATH];
snprintf(subpath, sizeof(subpath), "%s\\p%d", usb_data_path, i + 1);
usbmem_state[i].connected = false;
usbmem_state[i].opened = false;
usbmem_state[i].errored = false;
strcpy(usbmem_state[i].basepath, usb_data_path[i]);
memset(usbmem_state[i].path, 0, sizeof(usbmem_state[i].path));
memset(usbmem_state[i].filename, 0, sizeof(usbmem_state[i].filename));
usbmem_reset_file_state(i);
@ -183,7 +184,7 @@ static HRESULT usbmem_write(struct irp *irp)
if (!usbmem_pending && target_device_id >= 0 && target_device_id < USBMEM_DEVICE_COUNT && usbmem_state[target_device_id].file_type == USBMEM_FILE_TYPE_READ) {
memset(usbmem_response, 0, sizeof(usbmem_response));
log_misc("Read progress %08x/%08x bytes", usbmem_state[target_device_id].buffer_index, usbmem_state[target_device_id].buffer_len);
// log_misc("Read progress %08x/%08x bytes", usbmem_state[target_device_id].buffer_index, usbmem_state[target_device_id].buffer_len);
if (usbmem_state[target_device_id].buffer_index < usbmem_state[target_device_id].buffer_len) {
usbmem_response_length = sizeof(usbmem_response);
@ -223,11 +224,7 @@ static HRESULT usbmem_write(struct irp *irp)
target_device_val = *(target_device_id_ptr - 1);
}
// Counterintuitively, b is P1 and a is P2
if (target_device_val == 'a' || target_device_val == 'b') {
target_device_id = target_device_val - 'a';
}
// TODO: Rewrite this code to more cleanly handle hotplugging USB drives
if (str_eq(request, "sver")) {
str_cpy(
usbmem_response,
@ -235,129 +232,134 @@ static HRESULT usbmem_write(struct irp *irp)
"done GQHDXJAA DJHACKRS");
} else if (str_eq(request, "init") || str_eq(request, "start")) {
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
} else if (target_device_id < 0 || target_device_id >= USBMEM_DEVICE_COUNT) {
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
} else if ((target_device_val == 'a' || target_device_val == 'b') && usbmem_state[target_device_id].errored) {
// If the device went through the entire process once and the file didn't exist
// then just force it to be disabled because otherwise it'll get stuck in a loop.
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
} else if (!usbmem_enabled) {
// Ignore all other USB device specific commands and pretend a device isn't plugged in.
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
} else if (str_eq(request, "on_a") || str_eq(request, "on_b")) {
usbmem_state[target_device_id].connected = true;
usbmem_reset_file_state(target_device_id);
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
} else if (str_eq(request, "offa") || str_eq(request, "offb")) {
usbmem_state[target_device_id].connected = false;
usbmem_reset_file_state(target_device_id);
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
} else if (str_eq(request, "opna") || str_eq(request, "opnb")) {
char temp[MAX_PATH];
snprintf(temp, sizeof(temp), "%s\\p%d", usb_data_path, 2 - (request[3] - 'a'));
} else if (target_device_val == 'a' || target_device_val == 'b') {
// Counterintuitively, b is P1 and a is P2
target_device_id = target_device_val == 'b' ? 0 : 1;
usbmem_state[target_device_id].opened = false;
if (!usbmem_enabled) {
// Ignore all other USB device specific commands and pretend a device isn't plugged in
// when USB memory emulation is disabled.
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
} else if (usbmem_state[target_device_id].errored) {
// If the device went through the entire process once and the file didn't exist
// then just force it to be disabled until the game is restarted because otherwise
// it'll get stuck in a loop.
// TODO: This could be better emulated by using a keybind to simulate inserting and
// ejecting the USB drive to additionally clear the error flag.
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
} else if (str_eq(request, "on_a") || str_eq(request, "on_b")) {
usbmem_state[target_device_id].connected = path_exists(usbmem_state[target_device_id].basepath);
usbmem_state[target_device_id].errored = false;
if (usbmem_state[target_device_id].connected != true || !path_exists(temp)) {
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
} else {
usbmem_state[target_device_id].opened = true;
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
}
} else if (str_eq(request, "clsa") || str_eq(request, "clsb")) {
if (usbmem_state[target_device_id].connected != true) {
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
} else if (usbmem_state[target_device_id].opened != true) {
str_cpy(usbmem_response, sizeof(usbmem_response), "already");
} else {
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
}
usbmem_reset_file_state(target_device_id);
usbmem_state[target_device_id].opened = false;
usbmem_reset_file_state(target_device_id);
} else if (strncmp(request, "cda ", 4) == 0 || strncmp(request, "cdb ", 4) == 0) {
char *path = request + 4;
int path_target_device_id = -1;
if (path[0] == 'a' || path[0] == 'b') {
path_target_device_id = path[0] - 'a';
}
if (usbmem_state[target_device_id].connected != true || usbmem_state[target_device_id].opened != true) {
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
} else if (path_target_device_id == -1 || path_target_device_id != target_device_id) {
// Don't allow access to another drive
str_cpy(usbmem_response, sizeof(usbmem_response), "illegal");
} else if (path[1] == ':') {
// Absolute path
char temp[MAX_PATH];
snprintf(temp, sizeof(temp), "%s\\p%d\\%s", usb_data_path, 2 - target_device_id, path + 3);
if (!path_exists(temp)) {
log_warning("Couldn't find path %s\n", temp);
if (usbmem_state[target_device_id].connected)
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
} else {
log_misc("Changing path to %s\n", temp);
str_cpy(usbmem_state[target_device_id].path, sizeof(usbmem_state[target_device_id].path), temp);
else
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
} else if (str_eq(request, "offa") || str_eq(request, "offb")) {
if (usbmem_state[target_device_id].connected)
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
}
} else {
str_cpy(usbmem_response, sizeof(usbmem_response), "illegal");
}
} else if (strncmp(request, "rda ", 4) == 0 || strncmp(request, "rdb ", 4) == 0) {
usbmem_reset_file_state(target_device_id);
else
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
if (usbmem_state[target_device_id].connected != true || usbmem_state[target_device_id].opened != true) {
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
} else {
char temp[MAX_PATH] = {0};
char *filename = request + 4;
usbmem_state[target_device_id].connected = false;
usbmem_reset_file_state(target_device_id);
} else if (str_eq(request, "opna") || str_eq(request, "opnb")) {
bool basepath_exists = path_exists(usbmem_state[target_device_id].basepath);
snprintf(temp, sizeof(temp), "%s\\%s", usbmem_state[target_device_id].path, filename);
if (usbmem_state[target_device_id].buffer) {
free(usbmem_state[target_device_id].buffer);
usbmem_state[target_device_id].buffer = NULL;
}
usbmem_state[target_device_id].file_type = USBMEM_FILE_TYPE_NONE;
usbmem_state[target_device_id].buffer_len = 0;
usbmem_state[target_device_id].buffer_index = 0;
usbmem_state[target_device_id].buffer_frame = 0;
memset(usbmem_state[target_device_id].filename, 0, sizeof(usbmem_state[target_device_id].filename));
if (!path_exists(temp)) {
log_warning("Couldn't find file %s\n", temp);
str_cpy(usbmem_response, sizeof(usbmem_response), "not exist");
usbmem_state[target_device_id].connected = false;
if (!usbmem_state[target_device_id].connected || !basepath_exists) {
usbmem_state[target_device_id].opened = false;
usbmem_state[target_device_id].errored = true;
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
} else {
bool loaded = file_load(temp, (void**)&usbmem_state[target_device_id].buffer,
&usbmem_state[target_device_id].buffer_len, false);
usbmem_state[target_device_id].opened = true;
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
}
} else if (str_eq(request, "clsa") || str_eq(request, "clsb")) {
if (usbmem_state[target_device_id].opened)
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
else
str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
if (loaded) {
log_misc("Reading file %s\n", temp);
usbmem_state[target_device_id].file_type = USBMEM_FILE_TYPE_READ;
usbmem_state[target_device_id].opened = false;
usbmem_reset_file_state(target_device_id);
} else if (strncmp(request, "cda ", 4) == 0 || strncmp(request, "cdb ", 4) == 0) {
char *path = request + 4;
str_cpy(usbmem_state[target_device_id].filename, sizeof(usbmem_state[target_device_id].filename), filename);
str_cpy(usbmem_response, sizeof(usbmem_response), "start");
if (!usbmem_state[target_device_id].connected || !usbmem_state[target_device_id].opened) {
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
} else if (path[1] == ':') {
// Absolute path
char temp[MAX_PATH];
snprintf(temp, sizeof(temp), "%s\\%s", usbmem_state[target_device_id].basepath, path + 3);
if (!path_exists(temp)) {
log_warning("Couldn't find path %s", temp);
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
} else {
log_warning("Couldn't read file %s\n", temp);
log_misc("Changing path to %s", temp);
str_cpy(usbmem_state[target_device_id].path, sizeof(usbmem_state[target_device_id].path), temp);
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
}
} else {
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
}
} else if (strncmp(request, "rda ", 4) == 0 || strncmp(request, "rdb ", 4) == 0) {
usbmem_reset_file_state(target_device_id);
if (!usbmem_state[target_device_id].connected || !usbmem_state[target_device_id].opened) {
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
} else {
char temp[MAX_PATH] = {0};
char *filename = request + 4;
snprintf(temp, sizeof(temp), "%s\\%s", usbmem_state[target_device_id].path, filename);
if (usbmem_state[target_device_id].buffer) {
free(usbmem_state[target_device_id].buffer);
usbmem_state[target_device_id].buffer = NULL;
}
usbmem_state[target_device_id].file_type = USBMEM_FILE_TYPE_NONE;
usbmem_state[target_device_id].buffer_len = 0;
usbmem_state[target_device_id].buffer_index = 0;
usbmem_state[target_device_id].buffer_frame = 0;
memset(usbmem_state[target_device_id].filename, 0, sizeof(usbmem_state[target_device_id].filename));
if (!path_exists(temp)) {
log_warning("Couldn't find file %s", temp);
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
usbmem_state[target_device_id].errored = true;
} else {
bool loaded = file_load(temp, (void**)&usbmem_state[target_device_id].buffer,
&usbmem_state[target_device_id].buffer_len, false);
if (loaded) {
log_misc("Reading file %s", temp);
usbmem_state[target_device_id].file_type = USBMEM_FILE_TYPE_READ;
str_cpy(usbmem_state[target_device_id].filename, sizeof(usbmem_state[target_device_id].filename), filename);
str_cpy(usbmem_response, sizeof(usbmem_response), "start");
} else {
log_warning("Couldn't read file %s", temp);
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
usbmem_state[target_device_id].errored = true;
}
}
}
} else if (strncmp(request, "wra ", 4) == 0 || strncmp(request, "wrb ", 4) == 0) {
// Open file for writing
usbmem_reset_file_state(target_device_id);
str_cpy(usbmem_response, sizeof(usbmem_response), "not supported");
} else if (strncmp(request, "wha ", 4) == 0 || strncmp(request, "whb ", 4) == 0) {
// Something relating to writing?
str_cpy(usbmem_response, sizeof(usbmem_response), "not supported");
} else if (strncmp(request, "lma ", 4) == 0 || strncmp(request, "lmb ", 4) == 0) {
// What is "lm"?
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
} else {
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
}
} else if (strncmp(request, "wra ", 4) == 0 || strncmp(request, "wrb ", 4) == 0) {
// Open file for writing
usbmem_reset_file_state(target_device_id);
str_cpy(usbmem_response, sizeof(usbmem_response), "not supported");
} else if (strncmp(request, "wha ", 4) == 0 || strncmp(request, "whb ", 4) == 0) {
// Something relating to writing?
str_cpy(usbmem_response, sizeof(usbmem_response), "not supported");
} else if (strncmp(request, "lma ", 4) == 0 || strncmp(request, "lmb ", 4) == 0) {
// What is "lm"?
str_cpy(usbmem_response, sizeof(usbmem_response), "done");
} else {
str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
}

2
src/main/ddrhook-util/usbmem.h
View File

@ -1,7 +1,7 @@
#ifndef DDRHOOK_UTIL_USBMEM_H
#define DDRHOOK_UTIL_USBMEM_H
void usbmem_init(const char *path, const bool enabled);
void usbmem_init(const char *path_p1, const char *path_p2, const bool enabled);
void usbmem_fini(void);
HRESULT usbmem_dispatch_irp(struct irp *irp);

41
src/main/ddrhook1/config-ddrhook1.c
View File

@ -9,14 +9,16 @@
#define DDRHOOK1_CONFIG_DDRHOOK1_USE_COM4_EMU_KEY "ddrhook1.use_com4_emu"
#define DDRHOOK1_CONFIG_DDRHOOK1_STANDARD_DEF_KEY "ddrhook1.standard_def"
#define DDRHOOK1_CONFIG_DDRHOOK1_USE_15KHZ_KEY "ddrhook1.use_15khz"
#define DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH "ddrhook1.usbmem_path"
#define DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_ENABLED "ddrhook1.usbmem_enabled"
#define DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P1 "ddrhook1.usbmem_path_p1"
#define DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P2 "ddrhook1.usbmem_path_p2"
#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USE_COM4_EMU_VALUE true
#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_STANDARD_DEF_VALUE false
#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USE_15KHZ_VALUE false
#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_ENABLED false
#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH "usbmem"
#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P1 "usbmem_p1"
#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P2 "usbmem_p2"
void ddrhook1_config_ddrhook1_init(struct cconfig *config)
{
@ -42,9 +44,14 @@ void ddrhook1_config_ddrhook1_init(struct cconfig *config)
"Enable USB memory data emulation");
cconfig_util_set_str(
config,
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH,
"Specify path for USB memory data");
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P1,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P1,
"Specify path for P1 USB memory data");
cconfig_util_set_str(
config,
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P2,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P2,
"Specify path for P2 USB memory data");
}
void ddrhook1_config_ddrhook1_get(
@ -96,14 +103,26 @@ void ddrhook1_config_ddrhook1_get(
}
if (!cconfig_util_get_str(
config,
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH,
config_ddrhook1->usbmem_path,
sizeof(config_ddrhook1->usbmem_path) - 1,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH)) {
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P1,
config_ddrhook1->usbmem_path_p1,
sizeof(config_ddrhook1->usbmem_path_p1) - 1,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P1)) {
log_warning(
"Invalid value for key '%s' specified, fallback "
"to default '%s'",
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH);
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P1,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P1);
}
if (!cconfig_util_get_str(
config,
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P2,
config_ddrhook1->usbmem_path_p2,
sizeof(config_ddrhook1->usbmem_path_p2) - 1,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P2)) {
log_warning(
"Invalid value for key '%s' specified, fallback "
"to default '%s'",
DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P2,
DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P2);
}
}

3
src/main/ddrhook1/config-ddrhook1.h
View File

@ -13,7 +13,8 @@ struct ddrhook1_config_ddrhook1 {
bool standard_def;
bool use_15khz;
bool usbmem_enabled;
char usbmem_path[MAX_PATH];
char usbmem_path_p1[MAX_PATH];
char usbmem_path_p2[MAX_PATH];
};
/**

3
src/main/ddrhook1/dllmain.c
View File

@ -129,7 +129,8 @@ static DWORD STDCALL my_main()
&security_rp_sign_key_black_ddrx,
&security_rp_sign_key_white_eamuse);
extio_init();
usbmem_init(config_ddrhook1.usbmem_path, config_ddrhook1.usbmem_enabled);
usbmem_init(config_ddrhook1.usbmem_path_p1, config_ddrhook1.usbmem_path_p2,
config_ddrhook1.usbmem_enabled);
spike_init();
com4_init();

18
src/main/ddrhook1/filesystem.c
View File

@ -136,26 +136,26 @@ static char *ddrhook1_filesystem_get_path(LPCTSTR path)
} else if (strnicmp(path, "E:/conf", 7) == 0
|| strnicmp(path, "E:\\conf", 7) == 0) {
char *launcher_folder;
char *conf_path;
char *sub_path;
ddrhook1_get_launcher_path_parts(NULL, &launcher_folder);
conf_path = strstr(path, "conf");
sub_path = strstr(path, "conf");
if (conf_path && launcher_folder) {
if (sub_path && launcher_folder) {
new_path = (char*)xmalloc(MAX_PATH);
sprintf(new_path, "%s\\%s", launcher_folder, conf_path);
sprintf(new_path, "%s\\%s", launcher_folder, sub_path);
}
} else if (stricmp(path, "F:/update") == 0
|| stricmp(path, "F:\\update") == 0) {
char *launcher_folder;
char *conf_path;
char *sub_path;
ddrhook1_get_launcher_path_parts(NULL, &launcher_folder);
conf_path = strstr(path, "update");
sub_path = strstr(path, "update");
if (conf_path && launcher_folder) {
if (sub_path && launcher_folder) {
new_path = (char*)xmalloc(MAX_PATH);
sprintf(new_path, "%s\\%s", launcher_folder, conf_path);
sprintf(new_path, "%s\\%s", launcher_folder, sub_path);
}
}
@ -187,7 +187,7 @@ static HANDLE STDCALL my_FindFirstFileA(
new_path,
lpFindFileData);
log_misc("FindFirstFileA remapped path: %s -> %s\n", lpFileName, new_path);
log_misc("FindFirstFileA remapped path: %s -> %s", lpFileName, new_path);
free(new_path);
return r;

21
src/main/ddrhook2/dllmain.c
View File

@ -40,7 +40,8 @@ static bool my_dll_entry_init(char *sidcode, struct property_node *param)
bool com4;
bool ok;
int i;
char usbmem_data_path[MAX_PATH] = "";
char usbmem_data_path_p1[MAX_PATH] = "";
char usbmem_data_path_p2[MAX_PATH] = "";
bool usbmem_enabled = false;
log_info("--- Begin ddrhook dll_entry_init ---");
@ -71,10 +72,20 @@ static bool my_dll_entry_init(char *sidcode, struct property_node *param)
break;
case 'm':
/* Specify a USB memory path */
case 'a':
/* Specify a USB memory path for P1 */
if (i + 1 < argc) {
strcpy(usbmem_data_path, argv[i+1]);
strcpy(usbmem_data_path_p1, argv[i+1]);
usbmem_enabled = true;
i++; // Move forward one to skip the path parameter
}
break;
case 'b':
/* Specify a USB memory path for P2 */
if (i + 1 < argc) {
strcpy(usbmem_data_path_p2, argv[i+1]);
usbmem_enabled = true;
i++; // Move forward one to skip the path parameter
}
@ -102,7 +113,7 @@ static bool my_dll_entry_init(char *sidcode, struct property_node *param)
ddrhook2_master_insert_hooks(NULL);
p3io_ddr_init();
extio_init();
usbmem_init(usbmem_data_path, usbmem_enabled);
usbmem_init(usbmem_data_path_p1, usbmem_data_path_p2, usbmem_enabled);
spike_init();
com4_init();