xjse_result_t xjse_xpnet_init(XPNETCTX** ppxpnctx, const xjse_int_t napa)
{
XPNETCTX* pctx1 = (XPNETCTX*)xjse_malloc(0, sizeof(XPNETCTX));
memset(pctx1, 0, sizeof(XPNETCTX));
memset(&(pctx1->xpnetreqq), 0,
sizeof(XPNETREQQITEM) * XPNETC_NMAXREQQITEMS);
//
pctx1->nap = napa; // default ap
#ifdef XTPF_PSP
sceUtilityLoadNetModule(1);
sceUtilityLoadNetModule(3);
#endif
xjse_result_t xr1 = xjse_xpnet_startthread(pctx1);
if(!XJSE_IS_SUCCESS(xr1))
goto failed;
*ppxpnctx = pctx1;
XJSE_TRACE("(X) xjse_xpnet_init successfully done!");
return XJSE_SUCCESS;
failed:
XJSE_TRACE("(E) xjse_xpnet_init failed!");
XJSE_SAFENNP(pctx1, free);
return XJSE_E_UNKNOWN;
}
int JNetwork::connect(const string& serverIP) {
#ifdef NETWORK_SUPPORT
int err;
char buffer[4096];
if(netthread) return 0;
sceUtilityLoadNetModule(1);
sceUtilityLoadNetModule(3);
if((err = pspSdkInetInit())) {
sprintf(buffer, "JGE Error, could not initialise the network %08X", err);
printf(buffer);
printf("\n");
error = buffer;
return err;
}
if(JNetwork::connect_to_apctl(1)) {
JNetwork::serverIP = serverIP;
/* Create a user thread to do the real work */
netthread = sceKernelCreateThread("net_thread", net_thread, 0x18, 0x10000, PSP_THREAD_ATTR_USER, NULL);
if(netthread < 0)
{
printf("Error, could not create thread\n");
sceKernelSleepThread();
}
sceKernelStartThread(netthread, 0, NULL);
return netthread;
}
#endif
return 0;
}
int AdhocInit(int type)
{
int result;
result = sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
if(result < 0)
{
printf("Adhoc error: sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON): 0x%08X", result);
return result;
}
result = sceUtilityLoadNetModule(PSP_NET_MODULE_ADHOC);
if(result < 0)
{
printf("Adhoc error: sceUtilityLoadNetModule(PSP_NET_MODULE_ADHOC); 0x%08X", result);
return result;
}
result = sceNetInit(128*1024, 42, 4*1024, 42, 4*1024);
if(result < 0)
{
printf("Adhoc error: sceNetInit(); 0x%08X", result);
return result;
}
result = sceNetAdhocInit();
if(result < 0)
printf("Adhoc error: sceNetAdhocInit(): 0x%08X", result);
struct productStruct gameProduct;
gameProduct.unknown = type;
if(type == _ADHOC_TYPE_GAMESHARING)
memcpy(gameProduct.product, "000000001", 9);
else
memcpy(gameProduct.product, "ULUS99999", 9);
result = sceNetAdhocctlInit(32*1024, 0x20, &gameProduct);
if(result < 0)
printf("Adhoc error: sceNetAdhocctlInit(): 0x%08X", result);
// Register pspnet_adhocctl event handler
result = sceNetAdhocctlAddHandler(AdhocctlHandler, NULL);
if(result < 0)
{
printf("Adhoc error: sceNetAdhocctlAddHandler\n");
return 0;
}
return 1;
}
/* Must be called from KERNEL thread */
int pspAdhocLoadDrivers()
{
_net_adhoc_matching_start = 0;
_net_adhoc_matching_create = 0;
_net_adhoc_matching_init = 0;
_net_adhoc_pdp_create = 0;
_net_adhoc_ctl_connect = 0;
_net_adhoc_ctl_init = 0;
_net_adhoc_init = 0;
_net_init = 0;
#if (_PSP_FW_VERSION < 200)
int modID;
modID = pspSdkLoadStartModule("flash0:/kd/ifhandle.prx",
PSP_MEMORY_PARTITION_KERNEL);
if (modID < 0) return modID;
modID = pspSdkLoadStartModule("flash0:/kd/memab.prx",
PSP_MEMORY_PARTITION_KERNEL);
if (modID < 0) return modID;
modID = pspSdkLoadStartModule("flash0:/kd/pspnet_adhoc_auth.prx",
PSP_MEMORY_PARTITION_KERNEL);
if (modID < 0) return modID;
modID = pspSdkLoadStartModule("flash0:/kd/pspnet.prx",
PSP_MEMORY_PARTITION_USER);
if (modID < 0) return modID;
else pspSdkFixupImports(modID);
modID = pspSdkLoadStartModule("flash0:/kd/pspnet_adhoc.prx",
PSP_MEMORY_PARTITION_USER);
if (modID < 0) return modID;
else pspSdkFixupImports(modID);
modID = pspSdkLoadStartModule("flash0:/kd/pspnet_adhocctl.prx",
PSP_MEMORY_PARTITION_USER);
if (modID < 0) return modID;
else pspSdkFixupImports(modID);
modID = pspSdkLoadStartModule("flash0:/kd/pspnet_adhoc_matching.prx",
PSP_MEMORY_PARTITION_USER);
if (modID < 0) return modID;
else pspSdkFixupImports(modID);
sceKernelDcacheWritebackAll();
sceKernelIcacheInvalidateAll();
#else
sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
sceUtilityLoadNetModule(PSP_NET_MODULE_ADHOC);
#endif
return 1;
}
int CSocket::socketSystemInit()
{
// errorOut("debuglog.txt", ":: Initializing socket system...");
#if defined(_WIN32) || defined(_WIN64)
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0)
{
SLOG("Failed to initialize winsocks!\n");
return 1;
}
if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
{
SLOG("Failed to initialize winsocks! Wasn't version 2.2!\n");
WSACleanup();
return 1;
}
#elif defined(PSPSDK)
if (sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON) < 0)
return -1;
if (sceUtilityLoadNetModule(PSP_NET_MODULE_INET) < 0)
return -1;
if (pspSdkInetInit() != 0)
return -2; // false
if (sceNetApctlConnect(1) != 0)
return -3;
while (true)
{
int state = 0;
if (sceNetApctlGetState(&state) != 0)
return -3;
if (state == 4)
break;
sceKernelDelayThread(1000 * 50); // 50ms
}
#endif
CSocket::was_initiated = 1;
return 0;
}
int loadNetCommon()
{
if (isImported(sceUtilityLoadNetModule))
return sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
else if (isImported(sceUtilityLoadModule))
return sceUtilityLoadModule(PSP_MODULE_NET_COMMON);
else
return SCE_KERNEL_ERROR_ERROR;
}
// call from KERNEL thread
int adhocLoadDrivers(SceModuleInfo* modInfoPtr)
{
#ifdef FW3X
sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON); // AHMAN
sceUtilityLoadNetModule(PSP_NET_MODULE_ADHOC); // AHMAN
#else
// libraries load where they want, patch workaround needed
LoadAndStartAndPatch(modInfoPtr, "flash0:/kd/ifhandle.prx"); // kernel
LoadAndStartAndPatch(modInfoPtr, "flash0:/kd/memab.prx");
LoadAndStartAndPatch(modInfoPtr, "flash0:/kd/pspnet_adhoc_auth.prx");
LoadAndStartAndPatch(modInfoPtr, "flash0:/kd/pspnet.prx");
LoadAndStartAndPatch(modInfoPtr, "flash0:/kd/pspnet_adhoc.prx");
LoadAndStartAndPatch(modInfoPtr, "flash0:/kd/pspnet_adhocctl.prx");
LoadAndStartAndPatch(modInfoPtr, "flash0:/kd/pspnet_adhoc_matching.prx");
FlushCaches();
#endif
return 0;
}
int adhocLoadModules(void)
{
#ifdef KERNEL_MODE
return adhoc_modules_loaded;
#else
if (devkit_version >= 0x02000010)
{
int error;
if ((error = sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON)) < 0)
return error;
if ((error = sceUtilityLoadNetModule(PSP_NET_MODULE_ADHOC)) < 0)
return error;
return 0;
}
return -1;
#endif
}
static int load_util(int module)
{
#ifdef UTILITY_AV_AVCODEC_PATH
SceUID ret;
#endif
dbg_printf("Loading 0x%08X\n", module);
if (isImported(sceUtilityLoadModule))
return sceUtilityLoadModule(module);
else if (module <= PSP_MODULE_NET_SSL && isImported(sceUtilityLoadNetModule))
return sceUtilityLoadNetModule(module + PSP_NET_MODULE_COMMON - PSP_MODULE_NET_COMMON);
else if (module == PSP_MODULE_USB_PSPCM && isImported(sceUtilityLoadUsbModule))
return sceUtilityLoadUsbModule(PSP_USB_MODULE_PSPCM);
else if (module <= PSP_MODULE_USB_GPS && isImported(sceUtilityLoadUsbModule))
return sceUtilityLoadUsbModule(module + PSP_USB_MODULE_MIC - PSP_MODULE_USB_MIC);
else if (module <= PSP_MODULE_AV_G729 && isImported(sceUtilityLoadAvModule))
return sceUtilityLoadAvModule(module + PSP_MODULE_AV_AVCODEC - PSP_AV_MODULE_AVCODEC);
else
#ifdef UTILITY_AV_AVCODEC_PATH
if (module == PSP_MODULE_AV_AVCODEC) {
ret = sceKernelLoadModule(UTILITY_AV_AVCODEC_PATH, 0, NULL);
return ret < 0 ? ret : sceKernelStartModule(ret, 0, NULL, NULL, NULL);
} else
#endif
#ifdef UTILITY_AV_SASCORE_PATH
if (module == PSP_MODULE_AV_SASCORE) {
ret = sceKernelLoadModule(UTILITY_AV_SASCORE_PATH, 0, NULL);
return ret < 0 ? ret : sceKernelStartModule(ret, 0, NULL, NULL, NULL);
} else
#endif
#ifdef UTILITY_AV_ATRAC3PLUS_PATH
if (module == PSP_MODULE_AV_ATRAC3PLUS) {
ret = sceKernelLoadModule(UTILITY_AV_ATRAC3PLUS_PATH, 0, NULL);
return ret < 0 ? ret : sceKernelStartModule(ret, 0, NULL, NULL, NULL);
} else
#endif
#ifdef UTILITY_AV_MPEGBASE_PATH
if (module == PSP_MODULE_AV_MPEGBASE) {
ret = sceKernelLoadModule(UTILITY_AV_MPEGBASE_PATH, 0, NULL);
return ret < 0 ? ret : sceKernelStartModule(ret, 0, NULL, NULL, NULL);
} else
#endif
return SCE_KERNEL_ERROR_ERROR;
}
void loadNetModules()
{
sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
sceUtilityLoadNetModule(PSP_NET_MODULE_INET);
sceUtilityLoadNetModule(PSP_NET_MODULE_PARSEURI);
sceUtilityLoadNetModule(PSP_NET_MODULE_PARSEHTTP);
sceUtilityLoadNetModule(PSP_NET_MODULE_HTTP);
sceUtilityLoadNetModule(PSP_NET_MODULE_SSL);
}
//Init Network Prompt
static int lua_NetPromptInit(lua_State *L)
{
int argc = lua_gettop(L);
if (argc > 0)
{
return luaL_error(L, "System.Quit() takes no arguments");
}
static int doOnce = 1;
if (doOnce)
{
sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
sceUtilityLoadNetModule(PSP_NET_MODULE_INET);
netInit();
netDialog();
netTerm();
doOnce = 0;
}
return 0;
}
void JSocket::init(){
#ifdef NETWORK_SUPPORT
sceUtilityLoadNetModule(1);
sceUtilityLoadNetModule(3);
#endif
}
void load_utils()
{
int ret;
int module;
unsigned i;
if (isImported(sceUtilityLoadModule)) {
// Load modules in order
if (!globals->isEmu || sceNetIsImported)
for(i = 0; i < sizeof(netModules) / sizeof(int); i++) {
ret = sceUtilityLoadModule(netModules[i]);
if (ret < 0)
dbg_printf("%s: Loading 0x%08X failed 0x%08X\n",
__func__, netModules[i], ret);
}
for(i = 0; i < sizeof(modules) / sizeof(int); i++) {
ret = sceUtilityLoadModule(modules[i]);
if (ret < 0)
dbg_printf("%s: Loading 0x%08X failed 0x%08X\n",
__func__, modules[i], ret);
}
ret = sceUtilityLoadModule(PSP_MODULE_AV_MP3);
if (ret < 0)
dbg_printf("%s: Loading 0x%08X failed 0x%08X\n",
__func__, PSP_MODULE_AV_MP3, ret);
} else {
if (isImported(sceUtilityLoadNetModule))
for (module = 1; module <= 7; module++) {
ret = sceUtilityLoadNetModule(module);
if (ret < 0)
dbg_printf("%s: Loading net module %d failed 0x%08X\n",
__func__, module, ret);
}
if (isImported(sceUtilityLoadUsbModule))
for (module = 1; module <= 5; module++) {
ret = sceUtilityLoadUsbModule(module);
if (ret < 0)
dbg_printf("%s: Loading USB module %d failed 0x%08X\n",
__func__, module, ret);
}
if (isImported(sceUtilityLoadAvModule))
for (module = 1; module <= 7; module++) {
ret = sceUtilityLoadAvModule(module);
dbg_printf("%s: Loading AV module %d failed 0x%08X\n",
__func__, module, ret);
}
else {
#ifdef UTILITY_AV_AVCODEC_PATH
avcodec_modid = sceKernelLoadModule(UTILITY_AV_AVCODEC_PATH, 0, NULL);
sceKernelStartModule(avcodec_modid, 0, NULL, NULL, NULL);
#endif
#ifdef UTILITY_AV_SASCORE_PATH
sascore_modid = sceKernelLoadModule(UTILITY_AV_SASCORE_PATH, 0, NULL);
sceKernelStartModule(sascore_modid, 0, NULL, NULL, NULL);
#endif
#ifdef UTILITY_AV_ATRAC3PLUS_PATH
atrac3plus_modid = sceKernelLoadModule(UTILITY_AV_ATRAC3PLUS_PATH, 0, NULL);
sceKernelStartModule(atrac3plus_modid, 0, NULL, NULL, NULL);
#endif
#ifdef UTILITY_AV_MPEGBASE_PATH
mpegbase_modid = sceKernelLoadModule(UTILITY_AV_MPEGBASE_PATH, 0, NULL);
sceKernelStartModule(mpegbase_modid, 0, NULL, NULL, NULL);
#endif
}
}
}
// Loads and registers exports from an utility module
SceLibraryEntryTable *load_export_util(UtilModInfo *util_mod, const char *lib)
{
SceLibraryEntryTable *exports;
int *p;
int ret, nid;
if (util_mod == NULL || lib == NULL)
return NULL;
dbg_printf("Loading utility module for library %s\n", lib);
//force load PSP_MODULE_AV_AVCODEC if we request a specific audio module
if (util_mod->id > PSP_MODULE_AV_AVCODEC && util_mod->id <= PSP_MODULE_AV_G729) {
dbg_printf("Force-Loading AVCODEC\n");
if (isImported(sceUtilityLoadModule))
sceUtilityLoadModule(PSP_MODULE_AV_AVCODEC);
else if (isImported(sceUtilityLoadAvModule))
sceUtilityLoadAvModule(PSP_AV_MODULE_AVCODEC);
} else if(util_mod->id == PSP_MODULE_NET_HTTP) {
dbg_printf("Force-Loading HTTP\n");
if (isImported(sceUtilityLoadModule)) {
sceUtilityLoadModule(PSP_MODULE_NET_COMMON);
sceUtilityLoadModule(PSP_MODULE_NET_INET);
sceUtilityLoadModule(PSP_MODULE_NET_PARSEURI);
sceUtilityLoadModule(PSP_MODULE_NET_PARSEHTTP);
} else if (isImported(sceUtilityLoadNetModule)) {
sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
sceUtilityLoadNetModule(PSP_NET_MODULE_INET);
sceUtilityLoadNetModule(PSP_NET_MODULE_PARSEURI);
sceUtilityLoadNetModule(PSP_NET_MODULE_PARSEHTTP);
}
}
ret = load_util(util_mod->id);
if (ret < 0 && ret != 0x80111102)
return NULL;
#ifndef DISABLE_UNLOAD_UTILITY_MODULES
#ifdef UTILITY_UNLOAD_MODULE_FILE
if (!ret)
ret = util_mod->id;
#endif
// PSP_MODULE_AV_AVCODEC -> cast syscall of sceAudiocodec and sceVideocodec
// PSP_MODULE_AV_MP3 -> On 6.20 OFW, libmp3 has a bug when unload it.
if ((util_mod->id != PSP_MODULE_AV_AVCODEC || globals->isEmu)
&& (util_mod->id != PSP_MODULE_AV_MP3
|| globals->module_sdk_version > 0x06020010)) {
#ifdef UTILITY_UNLOAD_MODULE_FILE
add_util_table(ret);
#else
add_util_table(util_mod->id);
#endif
}
#endif
// Get module exports
exports = find_exports(util_mod->name, lib);
if (exports == NULL) {
dbg_printf("->ERROR: could not find module exports for %s\n", util_mod->name);
#ifndef DISABLE_UNLOAD_UTILITY_MODULES
#ifdef UTILITY_UNLOAD_MODULE_FILE
unload_util(ret);
rm_util_table(ret);
#else
unload_util(util_mod->id);
rm_util_table(ret);
#endif
#endif
return NULL;
}
dbg_printf("Number of export functions: %d\n", exports->stubcount);
dbg_printf("Pointer to exports: 0x%08X\n", (int)exports->entrytable);
switch (util_mod->id) {
case PSP_MODULE_NET_INET:
if (util_mod == &net_apctl)
nid = 0xB3EDD0EC; // sceNetApctlTerm
else if (util_mod == &net_resolver)
nid = 0x6138194A; // sceNetResolverTerm
else if (util_mod == &net_inet)
nid = 0xA9ED66B9; // sceNetInetTerm
else
return exports;
break;
case PSP_MODULE_NET_COMMON:
nid = 0x281928A9; // sceNetTerm
break;
default:
return exports;
}
for (p = (int *)exports->entrytable;
(int)p < (int)exports->entrytable + exports->stubcount;
p++)
if (*p == nid) {
net_term_func[net_term_num] = (void *)p[exports->stubcount];
net_term_num++;
break;
}
return exports;
}
