test

Author: israpps

BOUND.KELF

@@ -8,8 +8,16 @@
 
 EE_BIN = DONGLE_DUMPER.ELF
 
-EE_OBJS = main.o modelname.o ioprp.o \
-	usbd.o bdm.o bdmfs_fatfs.o usbmass_bd.o genvmc.o fileXio.o iomanX.o
+EE_OBJS = $(addsuffix .o, main downloadfile ioprp usbd bdm bdmfs_fatfs usbmass_bd fileXio iomanX secrsif_mechaemu)
+
+TTY = UDP
+ifeq ($(TTY), PPC)
+EE_OBJS += ppctty.o
+EE_CFLAGS += -DTTY=1
+else ifeq ($(TTY), UDP)
+EE_OBJS += ps2dev9.o udptty_standalone.o
+EE_CFLAGS += -DTTY=2
+endif
 
 EE_CFLAGS += -fdata-sections -ffunction-sections -DNEWLIB_PORT_AWARE
 EE_LDFLAGS += -Wl,--gc-sections
@@ -27,10 +35,7 @@ all: $(EE_BIN)
 clean:
 	rm -rf $(EE_OBJS) $(EE_BIN)
 
-ioprp.img:
-	wget https://github.com/israpps/wLaunchELF_ISR/raw/system-2x6-support/iop/__precompiled/IOPRP_FILEIO.IMG -O $@
-
-%.c: %.img
+ioprp.c: IOPRP_RETAIL.IMG
 	bin2c $< $@ ioprp
 
 vpath %.irx iop/

IOPRP_ARCADE.IMG

@@ -0,0 +1,64 @@
+
+#include <stdbool.h>
+#include <tamtypes.h>
+#include <string.h>
+#include <kernel.h>
+#include <sifrpc.h>
+#include <loadfile.h>
+#include <stdio.h>
+#include "mechaemu_rpc.h"
+
+#define DPRINTF(fmt, x...) printf(fmt, ##x)
+#define CHECK_RPC_INIT() if (!rpc_initialized) {DPRINTF("ERROR: Cannot call %s if RPC server is not initialized\n", __FUNCTION__); return -2;}
+
+
+static SifRpcClientData_t MechaEmuRPC;
+static int rpc_initialized = false;
+
+
+int mechaemu_init(void)
+{
+    int retries = 100;
+    if (rpc_initialized)
+        {return 0;}
+
+    int E;
+	while(retries--)
+	{
+		if((E = SifBindRpc(&MechaEmuRPC, MECHAEMU_RPC_IRX, 0)) < 0)
+        {
+            DPRINTF("Failed to bind RPC server for MECHAEMU (%d)\n", E);
+			return SCE_EBINDMISS;
+        }
+
+		if(MechaEmuRPC.server != NULL)
+			break;
+
+		nopdelay();
+	}
+
+	rpc_initialized = retries;
+
+	return (retries) ? 0 : ESRCH;
+}
+
+#define RPC_BUFPARAM(x) &x, sizeof(x)
+int mechaemu_downloadfile(int port, int slot, void* KELFPointer)
+{
+    CHECK_RPC_INIT();
+
+    struct DownLoadFileParam pkt;
+    memset(&pkt, 0, sizeof(pkt));
+
+    pkt.port = port;
+    pkt.slot = slot;
+    memcpy(pkt.buffer, KELFPointer, sizeof(pkt.buffer)); //put 1kilobyte of the KELF into the RPC
+
+    if (SifCallRpc(&MechaEmuRPC, SECRME_DOWNLOADFILE, 0, RPC_BUFPARAM(pkt), RPC_BUFPARAM(pkt), NULL, NULL) < 0)
+    {
+        DPRINTF("%s: RPC ERROR\n", __FUNCTION__);
+        return -SCE_ECALLMISS;
+    }
+    if (pkt.result) memcpy(KELFPointer, pkt.buffer, sizeof(pkt.buffer)); //copy back the kilobyte from RPC to the original pointer, kbit and kc changed
+    return pkt.result;
+}

IOPRP_RETAIL.IMG

@@ -23,18 +23,18 @@
 #include <sbv_patches.h>
 #include <ps2sdkapi.h>
 #include <string.h>
+#include <stdlib.h>
+#include <malloc.h>
 #include <sys/stat.h>
-#include "genvmc.h"
-const char *ModelNameGet(void);
-int ModelNameInit(void);
-uint16_t getConsoleID();
+#include "mechaemu_rpc.h"
+
 
 typedef struct {
     int id;
     int ret;
 } modinfo_t;
 
-modinfo_t sio2man, mcman, mcserv, usbd, bdm, fatfs, usbmass, genvmc, fileXio, iomanX;
+modinfo_t sio2man, mcman, mcserv, usbd, bdm, fatfs, usbmass, genvmc, fileXio, iomanX, secrsif_mechaemu;
 #define EXTERN_MODULE(_irx) extern unsigned char _irx[]; extern unsigned int size_##_irx
 EXTERN_MODULE(ioprp);
 EXTERN_MODULE(usbd_irx);
@@ -44,106 +44,136 @@ EXTERN_MODULE(usbmass_bd_irx);
 EXTERN_MODULE(genvmc_irx);
 EXTERN_MODULE(fileXio_irx);
 EXTERN_MODULE(iomanX_irx);
+EXTERN_MODULE(secrsif_mechaemu_irx);
+#if TTY == 1
+EXTERN_MODULE(ppctty_irx);
+#elif TTY == 2
+EXTERN_MODULE(ps2dev9_irx);
+EXTERN_MODULE(udptty_standalone_irx);
+#endif
 #define LOADMODULE(_irx, ret) SifExecModuleBuffer(&_irx, size_##_irx, 0, NULL, ret)
 #define LOADMODULEFILE(path, ret) SifLoadStartModule(path, 0, NULL, ret)
 #define MODULE_OK(id, ret) (id >= 0 && ret != 1)
-#define INFORM(x) scr_setfontcolor(MODULE_OK(x.id, x.ret) ? 0x00cc00 : 0x0000cc);scr_printf("\t %s: id:%d ret:%d (%s)\n", #x, x.id, x.ret, MODULE_OK(x.id, x.ret) ? "OK" : "ERR")
+#define INFORM(x) scr_setfontcolor(MODULE_OK(x.id, x.ret) ? 0x00cc00 : 0x0000cc);scr_printf(" %s: id:%d ret:%d - %-8s ", #x, x.id, x.ret, MODULE_OK(x.id, x.ret) ? "OK\r" : "ERR\n"); usleep(500000);
 int loadusb();
 
 char ROMVER[15];
 int loadmodulemc();
-
+#define MCPORT 0 
 int main(int argc, char** argv) {
-    sio_puts("# dongle dumper start\n# BuilDate: "__DATE__ " " __TIME__ "\n");
+    sio_puts("> mechaemu update binder\n> BuilDate: "__DATE__ " " __TIME__ "\n");
     while (!SifIopRebootBuffer(ioprp, size_ioprp)) {}; // we need homebrew FILEIO
-    sio_puts("# Waiting for SifIopSync()");
+    sio_puts("> Waiting for SifIopSync()");
     while (!SifIopSync()) {}; // wait for IOP to reboot
-    sio_puts("# startup services");
+    sio_puts("> startup services");
     SifInitIopHeap(); // Initialize SIF services for loading modules and files.
     SifLoadFileInit();
     fioInit();
-    SifLoadStartModule("rom0:CDVDFSV", 0, NULL, NULL);
+    
     init_scr();
     scr_setCursor(0);
-    sio_puts("# pull romver");
+    sleep(2);
+    sio_puts("> pull romver");
     memset(ROMVER, 0, sizeof(ROMVER));
     GetRomName(ROMVER);
-    scr_printf(".\n\t ===== Namco System 246/256 security dongle dumper =====\n");
-    scr_printf("\tCoded by El_isra. genvmc module borrowed from OPL\n");
-    scr_printf("\thttps://github.com/israpps/system2x6-dongle-dumper\n");
-    scr_printf("\tROMVER:        %s\n", ROMVER);
-    ModelNameInit();
-    scr_printf("\tConsole model: %s\n", ModelNameGet());
-    scr_printf("\tConsole ID:    0x%x\n", getConsoleID());
-    scr_printf("\tMachineType:   %04i\n", MachineType());
+    //scr_printf("\tConsole model: %s\n", ModelNameGet());
+    //scr_printf("\tConsole ID:    0x%x\n", getConsoleID());
+    //scr_printf("\tMachineType:   %04i\n", MachineType());
     sbv_patch_enable_lmb(); // patch modload to support SifExecModuleBuffer
     sbv_patch_disable_prefix_check(); // remove security from MODLOAD
+    
+#if TTY == 1
+LOADMODULE(ppctty_irx, NULL);
+#elif TTY == 2
+LOADMODULE(ps2dev9_irx, NULL);
+LOADMODULE(udptty_standalone_irx, NULL);
+#endif
+    scr_printf(".\n\t ===== MECHAEMU Update binder =====\n");
+    scr_printf("\tCoded by El_isra. genvmc module borrowed from OPL\n");
+    //scr_printf("\thttps://github.com/israpps/system2x6-dongle-dumper\n");
+    scr_printf("\tROMVER:        %s\n", ROMVER);
+    //ModelNameInit();
+
 
-    if (!(ROMVER[4] == 'T' && ROMVER[5] == 'Z')) {
-        scr_setfontcolor(0x0000FF);
-        scr_printf("\tthis PS2 is NOT a namco system 246.\n\taborting...\n");
-        goto tosleep;
-    }
     if (!loadusb()) goto tosleep;
 
+    secrsif_mechaemu.id = LOADMODULE(secrsif_mechaemu_irx, &secrsif_mechaemu.ret);
+    INFORM(secrsif_mechaemu);
+    if (mechaemu_init()) {
+        scr_printf("\tCannot connect to secrsif_mechaemu.irx\n");
+        goto brk;
+    }
     iomanX.id = LOADMODULE(iomanX_irx, &iomanX.ret);
     INFORM(iomanX);
     fileXio.id = LOADMODULE(fileXio_irx, &fileXio.ret);
     INFORM(fileXio);
     if (MODULE_OK(fileXio.id, fileXio.ret)) {
+        scr_printf("\nConnecting to filexio.irx...\r");
         fileXioInit();
     } else {
-        scr_printf("\tFailed to load fileXio. aborting dump...\n");
-        goto tosleep;
+        scr_printf("\n\tFailed to load fileXio. aborting dump...\n");
+        goto brk;
     }
     if (loadmodulemc() == 0) {
-        scr_setfontcolor(0xffffff);
-        int ret;
-        createVMCparam_t p;
-        statusVMCparam_t vmc_stats;
-        memset(&p, 0, sizeof(createVMCparam_t));
-        const char* cardpath = "mass:COH-H10020.bin";
-        strcpy(p.VMC_filename, cardpath);
-        p.VMC_card_slot = 0; // 0=slot 1, 1=slot 2
-        p.VMC_thread_priority = 0xf;
-        scr_printf("\trequesting dump to '%s': ", cardpath);
-        ret = fileXioDevctl("genvmc:", GENVMC_DEVCTL_CREATE_VMC, (void *)&p, sizeof(p), NULL, 0);
-        if (ret == 0) {
-            scr_printf("  OK\n");
-        } else {
-            scr_printf("  Error %d\n", ret);
-            goto tosleep;
+         scr_setfontcolor(0xFFFFFF);
+        scr_printf("\n"); 
+        uint8_t* buf;
+        const char* UNBOUND = "UNBOUND.KELF";
+        const char* BOUND = "BOUND.KELF";
+        int fd = open(UNBOUND, O_RDONLY);
+        
+        if (fd < 0) {
+            scr_printf("\tcant open '%s' (%d %s)...\n", UNBOUND, fd, strerror(fd));
+            goto brk;
+        }
+        int size = lseek(fd, 0, SEEK_END);
+        scr_printf("\tKELF size is %d\n", size); 
+        if (size < 0) {
+            goto brk;
         }
+        lseek(fd, 0, SEEK_SET);
+        if ((buf = memalign(64, size)) != NULL) {
+            if ((read(fd, buf, size)) != size) {
+                close(fd);
+                scr_printf("\tcannot read whole KELF: %d bytes\n", size); 
+                goto brk;
+            } else {
+                scr_printf("\tBinding update to memory card on mc%d:\n", MCPORT);
+                int result = mechaemu_downloadfile(MCPORT, 0, buf);
+                if (result) {
+                    scr_printf("\tBinding complete. writing KELF to '%s'\n", BOUND);
+                    int outfd = open(BOUND, O_WRONLY | O_CREAT | O_TRUNC);
+                    if (outfd >= 0)
+                    {
+                        int written = write(outfd, buf, size);
+                        if (written != size) {
+                            result = -EIO;
+                        }
+                        close(outfd);
+                    } else {
+                    scr_printf("\tmechaemu_downloadfile(%d, 0): error\n", MCPORT);
+                        result = -EIO;
+                    }
 
-        memset(&vmc_stats, 0, sizeof(statusVMCparam_t));
-        scr_printf("\twaiting VMC file creation...\n");
-        scr_setfontcolor(0x009090);
-        int x=0;
-        while (1) {
-            x = 20;
-            ret = fileXioDevctl("genvmc:", GENVMC_DEVCTL_STATUS, NULL, 0, (void *)&vmc_stats, sizeof(vmc_stats));
-            if (vmc_stats.VMC_progress > 20 && vmc_stats.VMC_progress < 50) scr_setfontcolor(0x00aaaa);
-            if (vmc_stats.VMC_progress > 50 && vmc_stats.VMC_progress < 80) scr_setfontcolor(0x00aa00);
-            if (vmc_stats.VMC_progress > 80) scr_setfontcolor(0x00ff00);
-            if (ret == 0) {
-                scr_printf("\tprogress: %d: %-30s\r", vmc_stats.VMC_progress, vmc_stats.VMC_msg);
-                if (vmc_stats.VMC_status == GENVMC_STAT_AVAIL) {
-                    scr_printf("\n");
-                    break;
+                } else {
+                    scr_printf("\tmechaemu_downloadfile(%d, 0): error\n", MCPORT);
+                    goto brk;
                 }
             }
-
-            while(--x);
+        } else {
+            close(fd);
+            scr_printf("\tcannot allocate %d bytes\n", size);
+            goto brk;
         }
-        scr_setfontcolor(0xffffff);
-        scr_printf("\n\tDone%-30s\n", "");
-        scr_printf("\tVMC status = %d\n", vmc_stats.VMC_error);
     }
+    brk:
+    scr_printf("Program execution end. exiting to OSDSYS in 2 minutes\n");
     sleep(120);
     return 0;
 tosleep:
     SleepThread();
 }
+
 int loadusb() {
     usbd.id = LOADMODULE(usbd_irx, &usbd.ret);
     INFORM(usbd);
@@ -193,16 +223,13 @@ int loadmodulemc() {
     }
     //mcserv.id =  LOADMODULEFILE("mass:/MCSERV", &mcserv.ret);
     //if (!MODULE_OK(mcserv.id, mcserv.ret))
-        mcserv.id =  LOADMODULEFILE("rom0:MCSERV", &mcserv.ret);
+    /*    mcserv.id =  LOADMODULEFILE("rom0:MCSERV", &mcserv.ret);
     INFORM(mcserv);
     if (!MODULE_OK(mcserv.id, mcserv.ret)) {
         return -1;
-    }
-    genvmc.id =  LOADMODULE(genvmc_irx, &genvmc.ret); // modified genvmc module that auths card with I_McDetectCard2. this should reset the watchdog before begining dump
-    INFORM(genvmc);
-    if (!MODULE_OK(genvmc.id, genvmc.ret)) {
-        return -1;
-    }
+    }*/
+
+
     return 0;
 }
 

Makefile

@@ -0,0 +1,23 @@
+#ifndef MECHAEMU_RPC
+#define MECHAEMU_RPC
+
+#include <stdint.h>
+#include <errno.h>
+
+struct DownLoadFileParam
+{
+    int32_t port, slot;
+    uint8_t buffer[0x400];
+
+    int32_t result;
+};
+
+#define MECHAEMU_RPC_IRX  (0x10245) // 0x10000 + `M` `E` `C` `H` `A` `E` `M` `U`
+#define SECRME_DOWNLOADFILE (0x358) // 0x100   + `D` `O` `W` `N` `L` `O` `A` `D`
+
+
+
+int mechaemu_init(void);
+int mechaemu_downloadfile(int port, int slot, void* KELFPointer);
+
+#endif