//Get Nickname,PSSID,Language & MAC Address Functions
static int lua_nickname(lua_State *L)
{
if (lua_gettop(L) != 0) return luaL_error(L, "no arguments expected.");
char nickname[256];
sceUtilityGetSystemParamString(PSP_SYSTEMPARAM_ID_STRING_NICKNAME, nickname, 128);
lua_pushstring(L,nickname);
return 1;
}
/**
* Initialize Networking Components for Adhocctl Emulator
* @param adhoc_id Game Product Code
* @param server_ip Server IP
* @return 0 on success or... -1
*/
int _initNetwork(const SceNetAdhocctlAdhocId * adhoc_id, const char * server_ip)
{
// WLAN Switch Check
if(sceWlanGetSwitchState() == 1)
{
// Initialize Access Point Control
if(sceNetApctlInit(0x1800, 0x30) == 0)
{
// Attempt Counter
int attemptmax = 10;
// Attempt Number
int attempt = 0;
// Attempt Connection Setup
for(; attempt < attemptmax; attempt++)
{
// Start Connection
if(sceNetApctlConnect(_hotspot) == 0)
{
// Wait for Connection
int statebefore = 0;
int state = 0; while(state != 4)
{
// Query State
int getstate = sceNetApctlGetState(&state);
// Log State Change
if(statebefore != state) printk("New Connection State: %d\n", state);
// Query Success
if(getstate == 0 && state != 4)
{
// Wait for Retry
sceKernelDelayThread(1000000);
}
// Query Error
else break;
// Save Before State
statebefore = state;
}
// Connected
if(state == 4)
{
// Create Friend Finder Socket
int socket = sceNetInetSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
// Created Socket
if(socket > 0)
{
// Enable Port Re-use
sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &_one, sizeof(_one));
sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEPORT, &_one, sizeof(_one));
// Apply Receive Timeout Settings to Socket
// uint32_t timeout = ADHOCCTL_RECV_TIMEOUT;
// sceNetInetSetsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
// Server IP
uint32_t ip = 0;
// Initialize DNS Resolver
if(sceNetResolverInit() == 0)
{
// Create DNS Resolver
unsigned char rbuf[512]; int rid = 0;
if(sceNetResolverCreate(&rid, rbuf, sizeof(rbuf)) == 0)
{
// Resolve Domain
if(sceNetResolverStartNtoA(rid, server_ip, &ip, 500000, 2) != 0)
{
// Attempt IP Conversion
sceNetInetInetAton(server_ip, &ip);
}
// Delete DNS Resolver
sceNetResolverDelete(rid);
}
// Shutdown DNS Resolver
sceNetResolverTerm();
}
// Prepare Server Address
SceNetInetSockaddrIn addr;
addr.sin_len = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_addr = ip;
addr.sin_port = sceNetHtons(ADHOCCTL_METAPORT);
// Connect to Server
if(sceNetInetConnect(socket, (SceNetInetSockaddr *)&addr, sizeof(addr)) == 0)
{
// Save Meta Socket
_metasocket = socket;
// Save Product Code
_product_code = *adhoc_id;
// Clear Event Handler
memset(_event_handler, 0, sizeof(_event_handler[0]) * ADHOCCTL_MAX_HANDLER);
memset(_event_args, 0, sizeof(_event_args[0]) * ADHOCCTL_MAX_HANDLER);
// Clear Internal Control Status
memset(&_parameter, 0, sizeof(_parameter));
// Read PSP Player Name
sceUtilityGetSystemParamString(PSP_SYSTEMPARAM_ID_STRING_NICKNAME, (char *)_parameter.nickname.data, ADHOCCTL_NICKNAME_LEN);
// Read Adhoc Channel
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_ADHOC_CHANNEL, &_parameter.channel);
// Fake Channel Number 1 on Automatic Channel
if(_parameter.channel == 0) _parameter.channel = 1;
// Read PSP MAC Address
sceWlanGetEtherAddr((void *)&_parameter.bssid.mac_addr.data);
// Prepare Login Packet
SceNetAdhocctlLoginPacketC2S packet;
// Set Packet Opcode
packet.base.opcode = OPCODE_LOGIN;
// Set MAC Address
packet.mac = _parameter.bssid.mac_addr;
// Set Nickname
packet.name = _parameter.nickname;
// Set Game Product ID
memcpy(packet.game.data, adhoc_id->data, ADHOCCTL_ADHOCID_LEN);
// Acquire Network Layer Lock
_acquireNetworkLock();
// Send Login Packet
sceNetInetSend(_metasocket, &packet, sizeof(packet), INET_MSG_DONTWAIT);
// Free Network Layer Lock
_freeNetworkLock();
// Load UPNP Library
_upnp_uid = sceKernelLoadModule("ms0:/kd/pspnet_miniupnc.prx", 0, NULL);
// Start UPNP Library
int status = 0; sceKernelStartModule(_upnp_uid, 0, NULL, &status, NULL);
// Return Success
return 0;
}
// Delete Socket
sceNetInetClose(socket);
}
// Close Hotspot Connection
sceNetApctlDisconnect();
}
}
}
// Terminate Access Point Control
sceNetApctlTerm();
}
}
// Generic Error
return -1;
}
int pspAdhocInit(const char *product_name,
PspMatchingCallback callback)
{
/* Shut down adhoc, if currently enabled */
pspAdhocShutdown();
struct productStruct product;
char mac[20];
int err, state = 0;
strncpy(product.product, product_name, 9);
product.unknown = 0;
if (sceUtilityGetSystemParamString(PSP_SYSTEMPARAM_ID_STRING_NICKNAME,
_matching_data, 128) != 0)
return 0;
if ((err = sceNetInit(0x20000, 0x2A, 0x1000, 0x2A, 0x1000)) == 0)
{
_net_init = 1;
if ((err = sceNetAdhocInit()) == 0)
{
_net_adhoc_init = 1;
if ((err = sceNetAdhocctlInit(0x2000, 0x20, &product)) == 0)
{
_net_adhoc_ctl_init = 1;
if ((err = sceNetAdhocctlConnect((void*)"")) == 0)
{
_net_adhoc_ctl_connect = 1;
do
{
if ((err = sceNetAdhocctlGetState(&state)) != 0) break;
sceKernelDelayThread(1000000/60);
} while (state != 1);
/* Get WLAN MAC */
unsigned char own_mac[8];
sceWlanGetEtherAddr(own_mac);
memcpy(_own_mac, own_mac, sizeof(unsigned char) * 6);
if (err == 0)
{
sceWlanGetEtherAddr((unsigned char*)mac);
if ((_pdp_id = sceNetAdhocPdpCreate((unsigned char*)mac, 0x309, 0x400, 0)) > 0)
{
_net_adhoc_pdp_create = 1;
if ((err = sceNetAdhocMatchingInit(0x20000)) == 0)
{
_net_adhoc_matching_init = 1;
_matching_id = sceNetAdhocMatchingCreate(3,
0xa,
0x22b,
0x800,
0x2dc6c0,
0x5b8d80,
3,
0x7a120,
callback);
if (_matching_id >= 0)
{
_net_adhoc_matching_create = 1;
err = sceNetAdhocMatchingStart(_matching_id,
0x10,
0x2000,
0x10,
0x2000,
strlen(_matching_data) + 1,
_matching_data);
if (err == 0)
{
_net_adhoc_matching_start = 1;
/* Everything checked out */
return 1;
}
sceNetAdhocMatchingDelete(_matching_id);
_net_adhoc_matching_create = 0;
}
sceNetAdhocMatchingTerm();
_net_adhoc_matching_init = 0;
}
sceNetAdhocPdpDelete(_pdp_id, 0);
_net_adhoc_pdp_create = 0;
}
}
sceNetAdhocctlDisconnect();
_net_adhoc_ctl_connect = 0;
}
sceNetAdhocctlTerm();
_net_adhoc_ctl_init = 0;
}
sceNetAdhocTerm();
_net_adhoc_init = 0;
}
sceNetTerm();
_net_init = 0;
}
return 0;
}
void *orpGetValue(char *key, SceSize *key_size)
{
void *value = NULL;
REGHANDLE rh;
struct RegParam reg = {
.regtype = 1,
.namelen = strlen(SYSTEM_REGISTRY),
.unk2 = 1,
.unk3 = 1,
};
strcpy(reg.name, SYSTEM_REGISTRY);
int rc;
if ((rc = sceRegOpenRegistry(®, 1, &rh)) < 0) {
printf("Error opening registry.\n");
return value;
}
REGHANDLE cat;
if ((rc = sceRegOpenCategory(rh, "/CONFIG/PREMO", 1, &cat)) < 0) {
printf("Error opening: /CONFIG/PREMO\n");
goto _orpGetValue_exit1;
}
unsigned int key_type;
if ((rc = sceRegGetKeyInfoByName(cat, key, &key_type, key_size)) < 0)
printf("Key info failed: %s: %d\n", key, rc);
else {
// printf("%s: type: %d, size: %d\n", key, key_type, *key_size);
value = malloc(*key_size);
if ((rc = sceRegGetKeyValueByName(cat, key, value, *key_size)) < 0) {
free(value);
value = NULL;
printf("Key look-up failed: %s\n", key);
goto _orpGetValue_exit2;
}
}
_orpGetValue_exit2:
sceRegCloseCategory(cat);
_orpGetValue_exit1:
sceRegCloseRegistry(rh);
return value;
}
int main()
{
pspDebugScreenInit();
SetupCallbacks();
printf("Open Remote Play Exporter!\n\n");
int rc;
struct orpConfigRecord_t record;
memset(&record, 0, sizeof(struct orpConfigRecord_t));
record.ps3_port = ORP_PORT;
strcpy((char *)record.ps3_hostname, "0.0.0.0");
SceSize key_size;
unsigned char *value;
if ((value = orpGetValue("ps3_name", &key_size)) != NULL) {
printf("%16s: %s\n", "Name", value);
strncpy((char *)record.ps3_nickname,
(const char *)value, ORP_NICKNAME_LEN);
free(value);
} else {
printf("This PSP has not been registered for Remote Play!\n");
printf("\nPress HOME to quit.\n");
sceKernelSleepThread();
return 0;
}
if ((rc =
sceUtilityGetSystemParamString(PSP_SYSTEMPARAM_ID_STRING_NICKNAME,
(char *)record.psp_owner, ORP_NICKNAME_LEN)) == 0) {
printf("%16s: %s\n", "PSP Owner", record.psp_owner);
}
if ((value = orpGetValue("ps3_mac", &key_size)) != NULL) {
printf("%16s: ", "PS3 MAC Address");
int i;
for (i = 0; i < key_size - 1; i++)
printf("%02x:", value[i]);
printf("%02x\n", value[key_size - 1]);
memcpy(record.ps3_mac, value, ORP_MAC_LEN);
free(value);
}
u8 mac[8];
if ((rc = sceWlanGetEtherAddr(mac)) == 0) {
printf("%16s: ", "PSP MAC Address");
int i;
memcpy(record.psp_mac, mac, ORP_MAC_LEN);
for (i = 0; i < ORP_MAC_LEN - 1; i++)
printf("%02x:", record.psp_mac[i]);
printf("%02x\n", record.psp_mac[ORP_MAC_LEN - 1]);
}
PspOpenPSID psid;
memset(&psid, 0, sizeof(psid));
if ((rc = sceOpenPSIDGetOpenPSID(&psid) == 0)) {
printf("%16s: ", "PSP ID");
int i;
for (i = 0; i < sizeof(psid.data) - 1; i++)
printf("%02x", psid.data[i]);
printf("%02x\n", psid.data[sizeof(psid.data) - 1]);
memcpy(record.psp_id, psid.data, ORP_KEY_LEN);
}
if ((value = orpGetValue("ps3_key", &key_size)) != NULL) {
printf("%16s: ", "Private Key");
int i;
for (i = 0; i < key_size; i++)
printf("%02x", value[i]);
printf("\n");
memcpy(record.pkey, value, ORP_KEY_LEN);
free(value);
}
char path[] = { "ms0:/export.orp" };
sceIoRemove(path);
SceUID fd = sceIoOpen(path,
PSP_O_WRONLY | PSP_O_CREAT, 0777);
if (fd < 0)
printf("\nUnable to open: %s\n", path);
else {
struct orpConfigHeader_t header;
memset(&header, 0, sizeof(struct orpConfigHeader_t));
header.magic[0] = 'O'; header.magic[1] = 'R'; header.magic[2] = 'P';
header.version = ORP_CONFIG_VER;
header.flags = ORP_CONFIG_EXPORT;
sceIoWrite(fd, &header, sizeof(struct orpConfigHeader_t));
sceIoWrite(fd, &record, sizeof(struct orpConfigRecord_t));
sceIoClose(fd);
printf("\nConfiguration saved to: %s\n", path);
}
printf("\nPress HOME to quit.\n");
sceKernelSleepThread();
return 0;
}
