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; }
/** * Create Matching Context * @param mode Operating Mode (HOST, CLIENT, P2P) * @param maxnum Member Limit * @param port PDP Port * @param rxbuflen Receive Buffer Size * @param hello_int Hello Interval (Microseconds) * @param keepalive_int Keep-Alive Interval (Microseconds) * @param init_count Resend & Keep-Alive Counter Initial Value * @param rexmt_int Message Resend Interval (Microseconds) * @return ID > 0 on success or... ADHOC_MATCHING_NOT_INITIALIZED, ADHOC_MATCHING_INVALID_MAXNUM, ADHOC_MATCHING_RXBUF_TOO_SHORT, ADHOC_MATCHING_INVALID_ARG, ADHOC_MATCHING_NO_SPACE, ADHOC_MATCHING_ID_NOT_AVAIL, ADHOC_MATCHING_PORT_IN_USE */ int proNetAdhocMatchingCreate(int mode, int maxnum, uint16_t port, int rxbuflen, uint32_t hello_int, uint32_t keepalive_int, int init_count, uint32_t rexmt_int, SceNetAdhocMatchingHandler handler) { // Library initialized if(_init == 1) { // Valid Member Limit if(maxnum > 1 && maxnum <= 16) { // Valid Receive Buffer size if(rxbuflen >= 1024) // Maybe 2048? { // Valid Arguments if(mode >= 1 && mode <= 3) { // Iterate Matching Contexts SceNetAdhocMatchingContext * item = _contexts; for(; item != NULL; item = item->next) { // Port Match found if(item->port == port) return ADHOC_MATCHING_PORT_IN_USE; } // Allocate Context Memory SceNetAdhocMatchingContext * context = (SceNetAdhocMatchingContext *)_malloc(sizeof(SceNetAdhocMatchingContext)); // Allocated Memory if(context != NULL) { // Create PDP Socket SceNetEtherAddr localmac; sceNetGetLocalEtherAddr(&localmac); int socket = sceNetAdhocPdpCreate(&localmac, port, rxbuflen, 0); // Created PDP Socket if(socket > 0) { // Clear Memory memset(context, 0, sizeof(SceNetAdhocMatchingContext)); // Allocate Receive Buffer context->rxbuf = (uint8_t *)_malloc(rxbuflen); // Allocated Memory if(context->rxbuf != NULL) { // Clear Memory memset(context->rxbuf, 0, rxbuflen); // Fill in Context Data context->id = _findFreeMatchingID(); context->mode = mode; context->maxpeers = maxnum; context->port = port; context->socket = socket; context->rxbuflen = rxbuflen; context->hello_int = hello_int; context->keepalive_int = 500000; //context->keepalive_int = keepalive_int; context->resendcounter = init_count; context->keepalivecounter = 100; //context->keepalivecounter = init_count; context->resend_int = rexmt_int; context->handler = handler; // Fill in Selfpeer context->mac = localmac; // Link Context context->next = _contexts; _contexts = context; // Return Matching ID return context->id; } // Close PDP Socket sceNetAdhocPdpDelete(socket, 0); } // Free Memory _free(context); // Port in use if(socket < 1) return ADHOC_MATCHING_PORT_IN_USE; } // Out of Memory return ADHOC_MATCHING_NO_SPACE; } // Invalid Arguments return ADHOC_MATCHING_INVALID_ARG; } // Invalid Receive Buffer Size return ADHOC_MATCHING_RXBUF_TOO_SHORT; } // Invalid Member Limit return ADHOC_MATCHING_INVALID_MAXNUM; } // Uninitialized Library return ADHOC_MATCHING_NOT_INITIALIZED; }
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; }
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; }
int pspAdhocConnect(const PspMAC mac) { int err, state = 0; char temp[64]; char ssid[10]; sceNetEtherNtostr((unsigned char*)mac, temp); ssid[0] = temp[9]; ssid[1] = temp[10]; ssid[2] = temp[12]; ssid[3] = temp[13]; ssid[4] = temp[15]; ssid[5] = temp[16]; ssid[6] = '\0'; if (_net_adhoc_ctl_connect) { if (_net_adhoc_pdp_create) { if (_net_adhoc_matching_init) { if (_net_adhoc_matching_create) { if (_net_adhoc_matching_start) { sceNetAdhocMatchingStop(_matching_id); _net_adhoc_matching_start = 0; } 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; } do { if ((err = sceNetAdhocctlGetState(&state)) != 0) break; sceKernelDelayThread(1000000/60); } while (state == 1); if ((err = sceNetAdhocctlConnect((void*)ssid)) == 0) { do { if ((err = sceNetAdhocctlGetState(&state)) != 0) break; sceKernelDelayThread(1000000/60); } while (state != 1); if (!err) { if ((_pdp_id = sceNetAdhocPdpCreate(_own_mac, 0x309, 0x800, 0)) > 0) { if (pspAdhocIsMACEqual(mac, _own_mac)) sceKernelDelayThread(1000000); return 1; } } if (_net_adhoc_ctl_connect) { sceNetAdhocctlDisconnect(); _net_adhoc_ctl_connect = 0; } if (state == 1) { do { if ((err = sceNetAdhocctlGetState(&state)) != 0) break; sceKernelDelayThread(1000000/60); } while (state == 1); } } if (_net_init) { if (_net_adhoc_init) { if (_net_adhoc_ctl_init) { sceNetAdhocctlTerm(); _net_adhoc_ctl_init = 0; } sceNetAdhocTerm(); _net_adhoc_init = 0; } sceNetTerm(); _net_init = 0; } return 0; }