static PyObject* wlanEtherAddr(PyObject *self, PyObject *args) { char buffer[8]; if (!PyArg_ParseTuple(args, ":wlanEtherAddr")) return NULL; if (sceWlanGetEtherAddr(buffer) < 0) { PyErr_SetString(PyExc_RuntimeError, "Could not get ethernet address"); return NULL; } buffer[7] = 0; return Py_BuildValue("s", buffer); }
void CSystem::GetEthernetAddress() { unsigned char sVal[7]; char themac[18]; memset(sVal, 0, 7); int ret = sceWlanGetEtherAddr(sVal); if (!ret) { sprintf(themac, "%02X:%02X:%02X:%02X:%02X:%02X", sVal[0], sVal[1], sVal[2], sVal[3], sVal[4], sVal[5]); EthernetAddress = L"Ethernet Address: "; EthernetAddress += themac; } else { EthernetAddress = L"None"; } }
u32 sceNetGetLocalEtherAddr(u32 addrAddr) { return sceWlanGetEtherAddr(addrAddr); }
/** * 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; }
/** * Resolve Player Name to Linked List of Peers * @param nickname To-be-resolved Player Nickname * @param buflen IN: Buffer Length in Bytes OUT: Required / Used Buffer Length in Bytes * @param buf OUT: Resolved Peer Information (if NULL then buflen gets filled with required length) * @return 0 on success or... ADHOCCTL_NOT_INITIALIZED, ADHOCCTL_INVALID_ARG */ int proNetAdhocctlGetAddrByName(const SceNetAdhocctlNickname * nickname, int * buflen, SceNetAdhocctlPeerInfo * buf) { // Library initialized if(_init == 1) { // Valid Arguments if(nickname != NULL && buflen != NULL) { // Multithreading Lock _acquirePeerLock(); // Length Calculation Mode if(buf == NULL) *buflen = _getNicknameCount(nickname) * sizeof(SceNetAdhocctlPeerInfo); // Normal Information Mode else { // Clear Memory memset(buf, 0, *buflen); // Discovered Player Count int discovered = 0; // Calculate Requested Elements int requestcount = *buflen / sizeof(SceNetAdhocctlPeerInfo); // Minimum Space available if(requestcount > 0) { // Local Nickname Matches if(strcmp((char *)_parameter.nickname.data, (char *)nickname->data) == 0) { // Get Local IP Address union SceNetApctlInfo info; if(sceNetApctlGetInfo(PSP_NET_APCTL_INFO_IP, &info) == 0) { // Add Local Address buf[discovered].nickname = _parameter.nickname; sceWlanGetEtherAddr((void *)buf[discovered].mac_addr.data); sceNetInetInetAton(info.ip, &buf[discovered].ip_addr); buf[discovered++].last_recv = sceKernelGetSystemTimeWide(); } } // Peer Reference SceNetAdhocctlPeerInfo * peer = _friends; // Iterate Peers for(; peer != NULL && discovered < requestcount; peer = peer->next) { // Match found if(strcmp((char *)peer->nickname.data, (char *)nickname->data) == 0) { // Fake Receive Time peer->last_recv = sceKernelGetSystemTimeWide(); // Copy Peer Info buf[discovered++] = *peer; } } // Link List int i = 0; for(; i < discovered - 1; i++) { // Link Network buf[i].next = &buf[i + 1]; } // Fix Last Element if(discovered > 0) buf[discovered - 1].next = NULL; } // Fix Buffer Size *buflen = discovered * sizeof(SceNetAdhocctlPeerInfo); } // Multithreading Unlock _freePeerLock(); // Return Success return 0; } // Invalid Arguments return ADHOCCTL_INVALID_ARG; } // Library uninitialized return ADHOCCTL_NOT_INITIALIZED; }
int adhocReconnect(char *ssid) { int err = 0; // Disconnect Wifi if(g_NetAdhocctlConnect) { printf2("sceNetAdhocctlDisconnect\n"); err = sceNetAdhocctlDisconnect(); if(err != 0) { pspDebugScreenInit(); printf(" returned %x\n", err); } g_NetAdhocctlConnect = false; } if(g_NetAdhocPdpCreate) { printf2("sceNetAdhocPdpDelete\n"); err = sceNetAdhocPdpDelete(pdpId,0); if(err != 0) { pspDebugScreenInit(); printf("sceNetAdhocPdpDelete returned %x\n", err); } g_NetAdhocPdpCreate = false; } if(g_NetAdhocMatchingStart) { printf2("sceNetAdhocMatchingStop\n"); err = sceNetAdhocMatchingStop(matchingId); if(err != 0) { pspDebugScreenInit(); printf("sceNetAdhocMatchingStop returned %x\n", err); } g_NetAdhocMatchingStart = false; } if(g_NetAdhocMatchingCreate) { printf2("sceNetAdhocMatchingDelete\n"); err = sceNetAdhocMatchingDelete(matchingId); if(err != 0) { pspDebugScreenInit(); printf("sceNetAdhocMatchingDelete returned %x\n", err); } g_NetAdhocMatchingCreate = false; } if(g_NetAdhocMatchingInit) { printf2("sceNetAdhocMatchingTerm\n"); err = sceNetAdhocMatchingTerm(); if(err != 0) { pspDebugScreenInit(); printf("sceNetAdhocMatchingTerm returned %x\n", err); } g_NetAdhocMatchingInit = false; } int stateLast = -1; while (1) { int state; err = sceNetAdhocctlGetState(&state); if (err != 0) { pspDebugScreenInit(); printf("sceNetApctlGetState returns $%x\n", err); sceKernelDelayThread(10*1000000); // 10sec to read before exit return -1; } if (state > stateLast) { sprintf(temp," connection state %d of 1\n", state); printf2(temp); stateLast = state; } if (state == 0) break; // connected // wait a little before polling again sceKernelDelayThread(50*1000); // 50ms } // Now connect to the PSP using a new SSID // Connect err = sceNetAdhocctlConnect(ssid); if (err != 0) { pspDebugScreenInit(); printf("err=%x\n", err); for(;;) sceDisplayWaitVblankStart(); return err; } g_NetAdhocctlConnect = true; stateLast = -1; printf2("Connecting...\n"); while (1) { int state; err = sceNetAdhocctlGetState(&state); if (err != 0) { pspDebugScreenInit(); printf("sceNetApctlGetState returns $%x\n", err); sceKernelDelayThread(10*1000000); // 10sec to read before exit return -1; } if (state > stateLast) { sprintf(temp," connection state %d of 1\n", state); printf2(temp); stateLast = state; } if (state == 1) break; // connected // wait a little before polling again sceKernelDelayThread(50*1000); // 50ms } char macAddr[10]; sceWlanGetEtherAddr(macAddr); printf2("sceNetAdhocPdpCreate\n"); pdpId = sceNetAdhocPdpCreate(macAddr, 0x309, // 0x309 in lumines 0x800, // 0x400 in lumines 0); // 0 in lumines if(pdpId <= 0) { pspDebugScreenInit(); printf("pdpId = %x\n", pdpId); return -1; } g_NetAdhocPdpCreate = true; }
//////////////////////////////////////////////////////////////////////////////////// // This is just a quick and easy procedure to wait for a PSP to join, the following // is what is done in Lumines: // // - Wait for a PSP to join // - Add the PSP to the list of machines available // - Wait for the user to select a PSP // - Call sceMatchingSelectTarget // - The other PSP will receive MATCHING_SELECTED event // - The other PSP displays a message to accept or cancel // - If accepted the other PSP calls sceMatchingSelectTarget // - The first PSP receives MATCHING_ESTABLISHED // // In lumines they then close the connection and start a new adhoc connection // with just those two machines in it. /////////////////////////////////////////////////////////////////////////////////// int adhocSelect(void) { SceCtrlData m_PspPad; int err = 0; char mac[10]; char name[256]; int waitAccept = 0; int currentState = PSP_LISTING; int oldButtons = 0; char tempStr[100]; char str[256]; sceDisplaySetMode( 0, SCREEN_WIDTH, SCREEN_HEIGHT ); sceDisplaySetFrameBuf( (char*)VRAM_ADDR, 512, 1, 1 ); pgFillAllvram(0);pgScreenFrame(2,0); for(;;) { sceCtrlReadBufferPositive(&m_PspPad, 1); //pspDebugScreenSetTextColor(0xFFFF); switch(currentState) { case PSP_LISTING: { //pspDebugScreenInit(); //pspDebugScreenPrintf("Select a server to connect to, or triangle to return\n\n\n"); pgFillAllvram(0);pgScreenFrame(2,0); mh_print(0,0,"Select a server to connect to, or triangle to return",0xFFFF); DisplayPspList(); pgScreenFlipV(); g_Server = 0; if(m_PspPad.Buttons != oldButtons) { if(m_PspPad.Buttons & PSP_CTRL_UP) { UpList(); } if(m_PspPad.Buttons & PSP_CTRL_DOWN) { DownList(); } if(m_PspPad.Buttons & PSP_CTRL_CROSS) { if(GetPspEntry(mac, name) > 0) { currentState = PSP_SELECTING; sceNetAdhocMatchingSelectTarget(matchingId, mac, 0, 0); } } if(m_PspPad.Buttons & PSP_CTRL_TRIANGLE) return -1; } if(matchChanged) { if(g_matchEvent == MATCHING_SELECTED) { memcpy(mac, g_mac, 6); strcpy(name, g_matchOptData); currentState = PSP_SELECTED; } } break; } case PSP_SELECTING: { //pspDebugScreenInit(); pgFillAllvram(0);pgScreenFrame(2,0); sceNetEtherNtostr(mac, tempStr); //printf("Waiting for %s to accept the connection\nTo cancel press O\n", tempStr); sprintf(str,"Waiting for %s to accept the connection\nTo cancel press O\n", tempStr); mh_print(0,0,str,0xFFFF); pgScreenFlipV(); if(m_PspPad.Buttons != oldButtons) { if(m_PspPad.Buttons & PSP_CTRL_CIRCLE) { sceNetAdhocMatchingCancelTarget(matchingId, mac); currentState = PSP_LISTING; } } if(matchChanged) { if(g_matchEvent == MATCHING_SELECTED) { sceNetAdhocMatchingCancelTarget(matchingId, mac); } else if(g_matchEvent == MATCHING_ESTABLISHED) { currentState = PSP_ESTABLISHED; } else if(g_matchEvent == MATCHING_REJECTED) { currentState = PSP_LISTING; } } break; } case PSP_SELECTED: { g_Server = 1; //pspDebugScreenInit(); pgFillAllvram(0);pgScreenFrame(2,0); sceNetEtherNtostr(mac, tempStr); sprintf(str,"%s has requested a connection\nTo accept the connection press X, to cancel press O\n", tempStr); mh_print(0,0,str,0xFFFF); pgScreenFlipV(); if(m_PspPad.Buttons != oldButtons) { if(m_PspPad.Buttons & PSP_CTRL_CIRCLE) { sceNetAdhocMatchingCancelTarget(matchingId, mac); currentState = PSP_LISTING; } if(m_PspPad.Buttons & PSP_CTRL_CROSS) { sceNetAdhocMatchingSelectTarget(matchingId, mac, 0, 0); currentState = PSP_WAIT_EST; } } if(matchChanged) { if(g_matchEvent == MATCHING_CANCELED) { currentState = PSP_LISTING; } } break; } case PSP_WAIT_EST: { if(matchChanged) { if(g_matchEvent == MATCHING_ESTABLISHED) { currentState = PSP_ESTABLISHED; } } break; } } matchChanged = 0; oldButtons = m_PspPad.Buttons; if(currentState == PSP_ESTABLISHED) break; sceDisplayWaitVblankStart(); } char macAddr[10]; char *tempMac; if(g_Server) { sceWlanGetEtherAddr(macAddr); tempMac = macAddr; } else { tempMac = mac; } sceNetEtherNtostr(tempMac, tempStr); char ssid[10]; sprintf(ssid, "%c%c%c%c%c%c", tempStr[9], tempStr[10], tempStr[12], tempStr[13], tempStr[15], tempStr[16]); adhocReconnect(ssid); // We only get here if both PSP's have agreed to connect //pspDebugScreenInit(); //pspDebugScreenPrintf("Connected\n"); pgFillAllvram(0);pgScreenFrame(2,0); mh_print(0,0,"Connected",0xFFFF); pgScreenFlipV(); return 0; }
int adhocInit(char *MatchingData) { char mac[6]; struct productStruct product; ClearPspList(); strcpy(product.product, "ULUS99999"); product.unknown = 0; u32 err; printf2("sceNetInit()\n"); err = sceNetInit(0x20000, 0x20, 0x1000, 0x20, 0x1000); if (err != 0) return err; g_NetInit = true; printf2("sceNetAdhocInit()\n"); err = sceNetAdhocInit(); if (err != 0) return err; g_NetAdhocInit = true; printf2("sceNetAdhocctlInit()\n"); err = sceNetAdhocctlInit(0x2000, 0x20, &product); if (err != 0) return err; g_NetAdhocctlInit = true; // Connect err = sceNetAdhocctlConnect(""); if (err != 0) return err; g_NetAdhocctlConnect = true; int stateLast = -1; printf2("Connecting...\n"); while (1) { int state; err = sceNetAdhocctlGetState(&state); if (err != 0) { pspDebugScreenInit(); printf("sceNetApctlGetState returns $%x\n", err); sceKernelDelayThread(10*1000000); // 10sec to read before exit return -1; } if (state > stateLast) { sprintf(temp," connection state %d of 1\n", state); printf2(temp); stateLast = state; } if (state == 1) break; // connected // wait a little before polling again sceKernelDelayThread(50*1000); // 50ms } printf2("Connected!\n"); sceWlanGetEtherAddr(mac); printf2("sceNetAdhocPdpCreate\n"); pdpId = sceNetAdhocPdpCreate(mac, 0x309, // 0x309 in lumines 0x400, // 0x400 in lumines 0); // 0 in lumines if(pdpId <= 0) { pspDebugScreenInit(); printf("pdpId = %x\n", pdpId); return -1; } g_NetAdhocPdpCreate = true; printf2("sceNetAdhocMatchingInit()\n"); err = sceNetAdhocMatchingInit(0x20000); if(err != 0) { pspDebugScreenInit(); printf("error = %x\n", err); } g_NetAdhocMatchingInit = true; printf2("sceNetAdhocMatchingCreate()\n"); matchingId = sceNetAdhocMatchingCreate( 3, 0xa, 0x22b, 0x800, 0x2dc6c0, 0x5b8d80, 3, 0x7a120, matchingCallback); if(matchingId < 0) { sprintf(temp,"matchingId = %x\n", matchingId); printf2(temp); } g_NetAdhocMatchingCreate = true; /*char tempStr[100]; tempStr[0] = '\0'; if(strlen(MatchingData)) { strncpy(tempStr, strrchr(MatchingData, '/')+1, 100); strrchr(tempStr, '.')[0] = '\0'; }* printf("tempStr=%s\n", tempStr);*/ printf2("sceNetAdhocMatchingStart()\n"); err = sceNetAdhocMatchingStart(matchingId, // 1 in lumines (presuming what is returned from create) 0x10, // 0x10 0x2000, // 0x2000 0x10, // 0x10 0x2000, // 0x2000 strlen(MatchingData)+1, MatchingData); if(err != 0) { pspDebugScreenInit(); printf("error = %x\n", err); } g_NetAdhocMatchingStart = true; // All the init functions have passed return 0; }
void SystemGetMac(unsigned char *mac) { sceWlanGetEtherAddr(mac); }
int adhocSelect(void) { int top = 0; int rows = 11; int currentState = PSP_LISTING; int prev_max = 0; int update = 1; unsigned char mac[6]; char name[64]; char temp[64]; char title[32]; sprintf(title, "AdHoc - %s", game_name); msg_screen_init(WP_LOGO, ICON_SYSTEM, title); while (1) { pad_update(); msg_set_text_color(0xffff); switch (currentState) { case PSP_LISTING: Server = 0; if (update) { msg_screen_init(WP_LOGO, ICON_SYSTEM, title); msg_printf(TEXT(SELECT_A_SERVER_TO_CONNECT_TO)); msg_printf("\n"); DisplayPspList(top, rows); update = 0; } if (pad_pressed(PSP_CTRL_UP)) { if (pos > 0) pos--; update = 1; } else if (pad_pressed(PSP_CTRL_DOWN)) { if (pos < max - 1) pos++; update = 1; } else if (pad_pressed(PSP_CTRL_CIRCLE)) { if (GetPspEntry(mac, name) > 0) { if (strcmp(name, g_matchingData) == 0) { currentState = PSP_SELECTING; sceNetAdhocMatchingSelectTarget(matchingId, mac, 0, NULL); update = 1; } } } else if (pad_pressed(PSP_CTRL_TRIANGLE)) { msg_set_text_color(0xffffffff); adhocDisconnect(); pad_wait_clear(); return -1; } if (matchChanged) { if (g_matchEvent == MATCHING_SELECTED) { memcpy(mac, g_mac, 6); strcpy(name, g_matchOptData); currentState = PSP_SELECTED; } update = 1; } break; case PSP_SELECTING: if (update) { msg_screen_init(WP_LOGO, ICON_SYSTEM, title); sceNetEtherNtostr(mac, temp); msg_printf(TEXT(WAITING_FOR_x_TO_ACCEPT_THE_CONNECTION), temp); msg_printf(TEXT(TO_CANCEL_PRESS_CROSS)); update = 0; } if (pad_pressed(PSP_CTRL_CROSS)) { sceNetAdhocMatchingCancelTarget(matchingId, mac); currentState = PSP_LISTING; update = 1; } if (matchChanged) { switch (g_matchEvent) { case MATCHING_SELECTED: sceNetAdhocMatchingCancelTarget(matchingId, mac); break; case MATCHING_ESTABLISHED: currentState = PSP_ESTABLISHED; break; case MATCHING_REJECTED: currentState = PSP_LISTING; break; } update = 1; } break; case PSP_SELECTED: Server = 1; if (update) { msg_screen_init(WP_LOGO, ICON_SYSTEM, title); sceNetEtherNtostr(mac, temp); msg_printf(TEXT(x_HAS_REQUESTED_A_CONNECTION), temp); msg_printf(TEXT(TO_ACCEPT_THE_CONNECTION_PRESS_CIRCLE_TO_CANCEL_PRESS_CIRCLE)); update = 0; } if (pad_pressed(PSP_CTRL_CROSS)) { sceNetAdhocMatchingCancelTarget(matchingId, mac); currentState = PSP_LISTING; update = 1; } else if (pad_pressed(PSP_CTRL_CIRCLE)) { sceNetAdhocMatchingSelectTarget(matchingId, mac, 0, NULL); currentState = PSP_WAIT_EST; update = 1; } if (matchChanged) { if (g_matchEvent == MATCHING_CANCELED) { currentState = PSP_LISTING; } update = 1; } break; case PSP_WAIT_EST: if (matchChanged) { if (g_matchEvent == MATCHING_ESTABLISHED) { currentState = PSP_ESTABLISHED; } update = 1; } break; } matchChanged = 0; if (currentState == PSP_ESTABLISHED) break; if (top > max - rows) top = max - rows; if (top < 0) top = 0; if (pos >= top + rows) top = pos - rows + 1; if (pos < top) top = pos; if (max != prev_max) { prev_max = max; update = 1; } sceDisplayWaitVblankStart(); } msg_set_text_color(0xffffffff); if (Server) sceWlanGetEtherAddr(mac); sceNetEtherNtostr(mac, temp); g_ssid[0] = temp[ 9]; g_ssid[1] = temp[10]; g_ssid[2] = temp[12]; g_ssid[3] = temp[13]; g_ssid[4] = temp[15]; g_ssid[5] = temp[16]; g_ssid[6] = '\0'; return adhocStartP2P(); }
static int adhocStartP2P(void) { int error = 0, state = 1; unsigned char mac[6]; char message[256]; sprintf(message, TEXT(DISCONNECTING_FROM_x), TEXT(LOBBY)); adhoc_init_progress(6, message); sceNetAdhocMatchingStop(matchingId); update_progress(); sceNetAdhocMatchingDelete(matchingId); update_progress(); sceNetAdhocMatchingTerm(); update_progress(); sceNetAdhocPdpDelete(pdpId, 0); update_progress(); sceNetAdhocctlDisconnect(); update_progress(); do { if ((error = sceNetAdhocctlGetState(&state)) != 0) break; sceKernelDelayThread(1000000/60); } while (state == 1); update_progress(); show_progress(TEXT(DISCONNECTED)); mode = MODE_P2P; sprintf(message, TEXT(CONNECTING_TO_x), Server ? TEXT(CLIENT) : TEXT(SERVER)); adhoc_init_progress(4, message); if ((error = sceNetAdhocctlConnect((int *)g_ssid)) == 0) { update_progress(); do { if ((error = sceNetAdhocctlGetState(&state)) != 0) break; sceKernelDelayThread(1000000/60); } while (state != 1); if (!error) { update_progress(); sceWlanGetEtherAddr(mac); memcpy(g_mymac, mac, 6); update_progress(); if ((pdpId = sceNetAdhocPdpCreate(mac, PDP_PORT, PDP_BUFFER_SIZE, 0)) > 0) { update_progress(); adhoc_initialized = 2; show_progress(TEXT(WAITING_FOR_SYNCHRONIZATION)); if ((error = adhocSync()) == 0) return Server; } else { error = 1; } } sceNetAdhocctlDisconnect(); if (state == 1) { do { if ((error = sceNetAdhocctlGetState(&state)) != 0) break; sceKernelDelayThread(1000000/60); } while (state == 1); } } sceNetAdhocctlTerm(); sceNetAdhocTerm(); sceNetTerm(); adhoc_initialized = 0; switch (error) { case 1: sprintf(message, "%s (PDP ID = %08x)", TEXT(FAILED), pdpId); break; default: sprintf(message, "%s (Error Code = %08x)", TEXT(FAILED), error); break; } show_progress(message); pad_wait_clear(); pad_wait_press(PAD_WAIT_INFINITY); return -1; }
int adhocInit(const char *matchingData) { struct productStruct product; int error = 0, state = 0; unsigned char mac[6]; const char *unknown = ""; char message[256]; video_set_mode(32); mode = MODE_LOBBY; Server = 0; adhoc_initialized = 0; g_unk1 = 0; g_matchEvent = 0; g_matchOptLen = 0; matchChanged = 0; memset(g_mac, 0, sizeof(g_mac)); memset(g_mymac, 0, sizeof(g_mymac)); sprintf((char *)product.product, PRODUCT "00%d%d%d", VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD); product.unknown = 0; ClearPspList(); if (strlen(matchingData) == 0) return -1; strcpy(g_matchingData, matchingData); sprintf(message, TEXT(CONNECTING_TO_x), TEXT(LOBBY)); adhoc_init_progress(10, message); if ((error = sceNetInit(0x20000, 0x20, 0x1000, 0x20, 0x1000)) == 0) { update_progress(); if ((error = sceNetAdhocInit()) == 0) { update_progress(); if ((error = sceNetAdhocctlInit(0x2000, 0x20, &product)) == 0) { update_progress(); if ((error = sceNetAdhocctlConnect(unknown)) == 0) { update_progress(); do { if ((error = sceNetAdhocctlGetState(&state)) != 0) break; sceKernelDelayThread(1000000/60); } while (state != 1); if (!error) { update_progress(); sceWlanGetEtherAddr(mac); update_progress(); if ((pdpId = sceNetAdhocPdpCreate(mac, PDP_PORT, PDP_BUFFER_SIZE, 0)) > 0) { update_progress(); if ((error = sceNetAdhocMatchingInit(0x20000)) == 0) { update_progress(); if ((matchingId = sceNetAdhocMatchingCreate(MATCHING_CREATE_PARAMS)) >= 0) { update_progress(); if ((error = sceNetAdhocMatchingStart(MATCHING_START_PARAMS)) == 0) { update_progress(); show_progress(TEXT(CONNECTED)); sceKernelDelayThread(1000000); adhoc_initialized = 1; return 0; } sceNetAdhocMatchingDelete(matchingId); } error = 2; sceNetAdhocMatchingTerm(); } sceNetAdhocPdpDelete(pdpId, 0); } error = 1; } sceNetAdhocctlDisconnect(); } sceNetAdhocctlTerm(); } sceNetAdhocTerm(); } sceNetTerm(); } switch (error) { case 1: sprintf(message, "%s (PDP ID = %08x)", TEXT(FAILED), pdpId); break; case 2: sprintf(message, "%s (Matching ID = %08x)", TEXT(FAILED), matchingId); break; default: sprintf(message, "%s (Error Code = %08x)", TEXT(FAILED), error); break; } show_progress(message); pad_wait_clear(); pad_wait_press(PAD_WAIT_INFINITY); 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; }