int main(int argc, char *argv[]) { printf("iRecovery - Recovery Utility\n"); printf("by westbaer\nThanks to pod2g, tom3q, planetbeing, geohot and posixninja.\n\n"); if(argc < 2) { irecv_usage(); return -1; } struct usb_dev_handle* handle = irecv_init(RECV_MODE); if (handle == NULL) { handle = irecv_init(WTF_MODE); if (handle == NULL) { printf("No iPhone/iPod found.\n"); return -1; } else { printf("Found iPhone/iPod in DFU/WTF mode\n"); } } else { printf("Found iPhone/iPod in Recovery mode\n"); } if(!strcmp(argv[1], "-f")) { if(argc == 3) { irecv_upload(handle, argv[2]); } } else if(!strcmp(argv[1], "-c")) { if(argc >= 3) { irecv_command(handle, argc-2, &argv[2]); } } else if(!strcmp(argv[1], "-k")) { if(argc >= 3) { irecv_exploit(handle, argv[2]); } else { irecv_exploit(handle, NULL); } } else if(!strcmp(argv[1], "-s")) { if(argc >= 3) { irecv_console(handle, argv[2]); } else { irecv_console(handle, NULL); } } else if(!strcmp(argv[1], "-r")) { irecv_reset(handle); } else if (!strcmp(argv[1], "-l")) { irecv_list(handle, argv[2]); } else if (!strcmp(argv[1], "-x")) { if(argc == 3) { irecv_upload(handle, argv[2]); irecv_reset(handle); } } irecv_close(handle); return 0; }
void irecv_reset(void) { devPhone = irecv_init(WTF_MODE); if(devPhone == NULL) { devPhone = irecv_init(RECV_MODE); if(devPhone == NULL) { printf("No iPhone/iPod found.\n"); exit(EXIT_FAILURE); } } if(devPhone != NULL) { usb_reset(devPhone); } }
int connect_to_device() { irecv_error_t error; irecv_init(); printf("\nWaiting for device...\n"); error = irecv_open_attempts(&client, 10); if(error != IRECV_E_SUCCESS) { fprintf(stderr, "Failed to connect to iBoot, error %d.\n", error); return -error; } if (client->mode == kDfuMode) { printf("Loaded DFU\n"); model(); } if (client->mode == kRecoveryMode1 || client->mode == kRecoveryMode2 || client->mode == kRecoveryMode3 || client->mode == kRecoveryMode4 ) { model(); } }
BOOL WINAPI DllMain( __in HINSTANCE hinstDLL, __in DWORD fdwReason, __in LPVOID lpvReserved ) { if (fdwReason == DLL_PROCESS_ATTACH) { irecv_init(); } return TRUE; }
void pois0n_init() { irecv_init(); irecv_set_debug_level(libpois0n_debug); debug("Initializing libpois0n\n"); #ifdef __APPLE__ system("killall -9 iTunesHelper"); #endif #ifdef _WIN32 system("TASKKILL /F /IM iTunes.exe > NUL"); system("TASKKILL /F /IM iTunesHelper.exe > NUL"); #endif }
const char* dfu_check_hardware_model(struct idevicerestore_client_t* client) { irecv_client_t dfu = NULL; irecv_error_t dfu_error = IRECV_E_SUCCESS; irecv_device_t device = NULL; irecv_init(); dfu_error = irecv_open_with_ecid(&dfu, client->ecid); if (dfu_error != IRECV_E_SUCCESS) { return NULL; } dfu_error = irecv_devices_get_device_by_client(dfu, &device); if (dfu_error != IRECV_E_SUCCESS) { return NULL; } irecv_close(dfu); return device->hardware_model; }
int recovery_check_mode(struct idevicerestore_client_t* client) { irecv_client_t recovery = NULL; irecv_error_t recovery_error = IRECV_E_SUCCESS; irecv_init(); recovery_error=irecv_open(&recovery, client->ecid); if (recovery_error != IRECV_E_SUCCESS) { return -1; } if ((recovery->mode == kDfuMode) || (recovery->mode == kWTFMode)) { irecv_close(recovery); return -1; } irecv_close(recovery); recovery = NULL; return 0; }
void irecv_sendcmd(char *cmd) { int length; char *sendbuf; irecv_init(RECV_MODE); if(devPhone == 0) { printf("No iPhone/iPod found.\n"); exit(EXIT_FAILURE); } sendbuf = malloc(160); length = (int)(((strlen(cmd)-1)/0x10)+1)*0x10; memset(sendbuf, 0, length); memcpy(sendbuf, cmd, strlen(cmd)); if(!usb_control_msg(devPhone, 0x40, 0, 0, 0, sendbuf, length, 1000)) { printf("[!] %s", usb_strerror()); } free(sendbuf); irecv_close(devPhone); }
int dfu_check_mode(struct idevicerestore_client_t* client, int* mode) { irecv_client_t dfu = NULL; irecv_error_t dfu_error = IRECV_E_SUCCESS; irecv_init(); dfu_error=irecv_open(&dfu, client->ecid); if (dfu_error != IRECV_E_SUCCESS) { return -1; } if ((dfu->mode != kDfuMode) && (dfu->mode != kWTFMode)) { irecv_close(dfu); return -1; } *mode = (dfu->mode == kWTFMode) ? MODE_WTF : MODE_DFU; irecv_close(dfu); return 0; }
int dfu_check_mode(struct idevicerestore_client_t* client, int* mode) { irecv_client_t dfu = NULL; irecv_error_t dfu_error = IRECV_E_SUCCESS; int probe_mode = -1; irecv_init(); dfu_error = irecv_open_with_ecid(&dfu, client->ecid); if (dfu_error != IRECV_E_SUCCESS) { return -1; } irecv_get_mode(dfu, &probe_mode); if ((probe_mode != IRECV_K_DFU_MODE) && (probe_mode != IRECV_K_WTF_MODE)) { irecv_close(dfu); return -1; } *mode = (probe_mode == IRECV_K_WTF_MODE) ? MODE_WTF : MODE_DFU; irecv_close(dfu); return 0; }
int recovery_check_mode(struct idevicerestore_client_t* client) { irecv_client_t recovery = NULL; irecv_error_t recovery_error = IRECV_E_SUCCESS; int mode = 0; irecv_init(); recovery_error=irecv_open_with_ecid(&recovery, client->ecid); if (recovery_error != IRECV_E_SUCCESS) { return -1; } irecv_get_mode(recovery, &mode); if ((mode == IRECV_K_DFU_MODE) || (mode == IRECV_K_WTF_MODE)) { irecv_close(recovery); return -1; } irecv_close(recovery); recovery = NULL; return 0; }
void irecv_sendfile(char *filename) { FILE *file; int packets, len, last, i, a, c, sl; char *fbuf, buf[6]; if(!filename) return; file = fopen(filename, "rb"); if(file == NULL) { printf("File %s not found.\n", filename); exit(EXIT_FAILURE); } fseek(file, 0, 0); fclose(file); irecv_init(WTF_MODE); if(!devPhone) { devPhone = irecv_init(RECV_MODE); if(devPhone) { printf("Found iPhone/iPod in Recovery mode\n"); } } else { printf("Found iPhone/iPod in DFU/WTF mode\n"); } if(!devPhone) { printf("No iPhone/iPod found.\n"); exit(EXIT_FAILURE); } if(usb_set_configuration(devPhone, 1)) { printf("Error setting configuration\n"); } printf("\n"); file = fopen(filename, "rb"); fseek(file, 0, SEEK_END); len = ftell(file); fseek(file, 0, 0); packets = len / 0x800; if(len % 0x800) packets++; last = len % 0x800; printf("Loaded image file (len: 0x%x, packets: %d, last: 0x%x).\n", len, packets, last); fbuf = malloc(packets * 0x800); if(!last) { last = 0x800; } fread(fbuf, 1, len, file); fclose(file); printf("Sending 0x%x bytes\n", len); for(i=0, a=0, c=0; i<packets; i++, a+=0x800, c++) { sl = 0x800; if(i == packets-1) { sl = last; } printf("Sending 0x%x bytes in packet %d... ", sl, c); if(usb_control_msg(devPhone, 0x21, 1, c, 0, &fbuf[a], sl, 1000)) { printf(" OK\n"); } else{ printf(" x\n"); } if(usb_control_msg(devPhone, 0xA1, 3, 0, 0, buf, 6, 1000) != 6){ printf("Error receiving status!\n"); } else { irecv_hexdump(buf, 6); if(buf[4]!=5) { printf("Status error!\n"); } } } printf("Successfully uploaded file!\nExecuting it...\n"); usb_control_msg(devPhone, 0x21, 1, c, 0, fbuf, 0, 1000); for(i=6; i<=8; i++) { if(usb_control_msg(devPhone, 0xA1, 3, 0, 0, buf, 6, 1000) != 6){ printf("Error receiving status!\n"); } else { irecv_hexdump(buf, 6); if(buf[4]!=i) { printf("Status error!\n"); } } } free(fbuf); irecv_close(devPhone); }
void initializer_proc() { irecv_init(); }
/* * Linear functions are copied from the basic coll module. For * some small number of nodes and/or small data sizes they are just as * fast as tuned/tree based segmenting operations and as such may be * selected by the decision functions. These are copied into this module * due to the way we select modules in V1. i.e. in V2 we will handle this * differently and so will not have to duplicate code. * GEF Oct05 after asking Jeff. */ int ompi_coll_tuned_alltoallv_intra_basic_linear(void *sbuf, int *scounts, int *sdisps, struct ompi_datatype_t *sdtype, void *rbuf, int *rcounts, int *rdisps, struct ompi_datatype_t *rdtype, struct ompi_communicator_t *comm, mca_coll_base_module_t *module) { int i, size, rank, err; char *psnd, *prcv; int nreqs; ptrdiff_t sext, rext; MPI_Request *preq; mca_coll_tuned_module_t *tuned_module = (mca_coll_tuned_module_t*) module; mca_coll_tuned_comm_t *data = tuned_module->tuned_data; size = ompi_comm_size(comm); rank = ompi_comm_rank(comm); OPAL_OUTPUT((ompi_coll_tuned_stream, "coll:tuned:alltoallv_intra_basic_linear rank %d", rank)); ompi_ddt_type_extent(sdtype, &sext); ompi_ddt_type_extent(rdtype, &rext); /* Simple optimization - handle send to self first */ psnd = ((char *) sbuf) + (sdisps[rank] * sext); prcv = ((char *) rbuf) + (rdisps[rank] * rext); if (0 != scounts[rank]) { err = ompi_ddt_sndrcv(psnd, scounts[rank], sdtype, prcv, rcounts[rank], rdtype); if (MPI_SUCCESS != err) { return err; } } /* If only one process, we're done. */ if (1 == size) { return MPI_SUCCESS; } /* Now, initiate all send/recv to/from others. */ nreqs = 0; preq = data->mcct_reqs; /* Post all receives first */ for (i = 0; i < size; ++i) { if (i == rank || 0 == rcounts[i]) { continue; } prcv = ((char *) rbuf) + (rdisps[i] * rext); err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtype, i, MCA_COLL_BASE_TAG_ALLTOALLV, comm, preq++)); ++nreqs; if (MPI_SUCCESS != err) { ompi_coll_tuned_free_reqs(data->mcct_reqs, nreqs); return err; } } /* Now post all sends */ for (i = 0; i < size; ++i) { if (i == rank || 0 == scounts[i]) { continue; } psnd = ((char *) sbuf) + (sdisps[i] * sext); err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtype, i, MCA_COLL_BASE_TAG_ALLTOALLV, MCA_PML_BASE_SEND_STANDARD, comm, preq++)); ++nreqs; if (MPI_SUCCESS != err) { ompi_coll_tuned_free_reqs(data->mcct_reqs, nreqs); return err; } } /* Start your engines. This will never return an error. */ MCA_PML_CALL(start(nreqs, data->mcct_reqs)); /* Wait for them all. If there's an error, note that we don't care * what the error was -- just that there *was* an error. The PML * will finish all requests, even if one or more of them fail. * i.e., by the end of this call, all the requests are free-able. * So free them anyway -- even if there was an error, and return the * error after we free everything. */ err = ompi_request_wait_all(nreqs, data->mcct_reqs, MPI_STATUSES_IGNORE); /* Free the requests. */ ompi_coll_tuned_free_reqs(data->mcct_reqs, nreqs); return err; }
int ompi_coll_tuned_alltoall_intra_basic_linear(void *sbuf, int scount, struct ompi_datatype_t *sdtype, void* rbuf, int rcount, struct ompi_datatype_t *rdtype, struct ompi_communicator_t *comm) { int i; int rank; int size; int err; int nreqs; char *psnd; char *prcv; MPI_Aint lb; MPI_Aint sndinc; MPI_Aint rcvinc; ompi_request_t **req; ompi_request_t **sreq; ompi_request_t **rreq; /* Initialize. */ size = ompi_comm_size(comm); rank = ompi_comm_rank(comm); OPAL_OUTPUT((ompi_coll_tuned_stream,"ompi_coll_tuned_alltoall_intra_basic_linear rank %d", rank)); err = ompi_ddt_get_extent(sdtype, &lb, &sndinc); if (OMPI_SUCCESS != err) { return err; } sndinc *= scount; err = ompi_ddt_get_extent(rdtype, &lb, &rcvinc); if (OMPI_SUCCESS != err) { return err; } rcvinc *= rcount; /* simple optimization */ psnd = ((char *) sbuf) + (rank * sndinc); prcv = ((char *) rbuf) + (rank * rcvinc); err = ompi_ddt_sndrcv(psnd, scount, sdtype, prcv, rcount, rdtype); if (MPI_SUCCESS != err) { return err; } /* If only one process, we're done. */ if (1 == size) { return MPI_SUCCESS; } /* Initiate all send/recv to/from others. */ req = rreq = comm->c_coll_basic_data->mcct_reqs; sreq = rreq + size - 1; prcv = (char *) rbuf; psnd = (char *) sbuf; /* Post all receives first -- a simple optimization */ for (nreqs = 0, i = (rank + 1) % size; i != rank; i = (i + 1) % size, ++rreq, ++nreqs) { err = MCA_PML_CALL(irecv_init (prcv + (i * rcvinc), rcount, rdtype, i, MCA_COLL_BASE_TAG_ALLTOALL, comm, rreq)); if (MPI_SUCCESS != err) { ompi_coll_tuned_free_reqs(req, rreq - req); return err; } } /* Now post all sends in reverse order - We would like to minimize the search time through message queue when messages actually arrive in the order in which they were posted. */ for (nreqs = 0, i = (rank + size - 1) % size; i != rank; i = (i + size - 1) % size, ++sreq, ++nreqs) { err = MCA_PML_CALL(isend_init (psnd + (i * sndinc), scount, sdtype, i, MCA_COLL_BASE_TAG_ALLTOALL, MCA_PML_BASE_SEND_STANDARD, comm, sreq)); if (MPI_SUCCESS != err) { ompi_coll_tuned_free_reqs(req, sreq - req); return err; } } nreqs = (size - 1) * 2; /* Start your engines. This will never return an error. */ MCA_PML_CALL(start(nreqs, req)); /* Wait for them all. If there's an error, note that we don't * care what the error was -- just that there *was* an error. The * PML will finish all requests, even if one or more of them fail. * i.e., by the end of this call, all the requests are free-able. * So free them anyway -- even if there was an error, and return * the error after we free everything. */ err = ompi_request_wait_all(nreqs, req, MPI_STATUSES_IGNORE); /* Free the reqs */ ompi_coll_tuned_free_reqs(req, nreqs); /* All done */ return err; }
int main(int argc, char* argv[]) { int i = 0; int opt = 0; int action = 0; unsigned long long ecid = 0; int mode = -1; char* argument = NULL; irecv_error_t error = 0; char* buffer = NULL; uint64_t buffer_length = 0; if (argc == 1) { print_usage(argc, argv); return 0; } while ((opt = getopt(argc, argv, "i:vhrsmnc:f:e:k::")) > 0) { switch (opt) { case 'i': if (optarg) { char* tail = NULL; ecid = strtoull(optarg, &tail, 16); if (tail && (tail[0] != '\0')) { ecid = 0; } if (ecid == 0) { fprintf(stderr, "ERROR: Could not parse ECID from argument '%s'\n", optarg); return -1; } } break; case 'v': verbose += 1; break; case 'h': print_usage(argc, argv); return 0; case 'm': action = kShowMode; break; case 'n': action = kRebootToNormalMode; break; case 'r': action = kResetDevice; break; case 's': action = kStartShell; break; case 'f': action = kSendFile; argument = optarg; break; case 'c': action = kSendCommand; argument = optarg; break; case 'k': action = kSendExploit; argument = optarg; break; case 'e': action = kSendScript; argument = optarg; break; default: fprintf(stderr, "Unknown argument\n"); return -1; } } if (verbose) irecv_set_debug_level(verbose); irecv_init(); irecv_client_t client = NULL; for (i = 0; i <= 5; i++) { debug("Attempting to connect... \n"); if (irecv_open_with_ecid(&client, ecid) != IRECV_E_SUCCESS) sleep(1); else break; if (i == 5) { return -1; } } irecv_device_t device = NULL; irecv_devices_get_device_by_client(client, &device); if (device) debug("Connected to %s, model %s, cpid 0x%04x, bdid 0x%02x\n", device->product_type, device->hardware_model, device->chip_id, device->board_id); switch (action) { case kResetDevice: irecv_reset(client); break; case kSendFile: irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL); error = irecv_send_file(client, argument, 1); debug("%s\n", irecv_strerror(error)); break; case kSendCommand: error = irecv_send_command(client, argument); debug("%s\n", irecv_strerror(error)); break; case kSendExploit: if (argument != NULL) { irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL); error = irecv_send_file(client, argument, 0); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); break; } } error = irecv_trigger_limera1n_exploit(client); debug("%s\n", irecv_strerror(error)); break; case kStartShell: init_shell(client); break; case kSendScript: buffer_read_from_filename(argument, &buffer, &buffer_length); if (buffer) { buffer[buffer_length] = '\0'; error = irecv_execute_script(client, buffer); if(error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); } free(buffer); } else { fprintf(stderr, "Could not read file '%s'\n", argument); } break; case kShowMode: irecv_get_mode(client, &mode); printf("%s Mode\n", mode_to_str(mode)); break; case kRebootToNormalMode: error = irecv_setenv(client, "auto-boot", "true"); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); break; } error = irecv_saveenv(client); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); break; } error = irecv_reboot(client); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); } else { debug("%s\n", irecv_strerror(error)); } break; default: fprintf(stderr, "Unknown action\n"); break; } irecv_close(client); return 0; }
/* * alltoallw_intra * * Function: - MPI_Alltoallw * Accepts: - same as MPI_Alltoallw() * Returns: - MPI_SUCCESS or an MPI error code */ int mca_coll_basic_alltoallw_intra(const void *sbuf, const int *scounts, const int *sdisps, struct ompi_datatype_t * const *sdtypes, void *rbuf, const int *rcounts, const int *rdisps, struct ompi_datatype_t * const *rdtypes, struct ompi_communicator_t *comm, mca_coll_base_module_t *module) { int i; int size; int rank; int err; char *psnd; char *prcv; int nreqs; MPI_Request *preq, *reqs; /* Initialize. */ if (MPI_IN_PLACE == sbuf) { return mca_coll_basic_alltoallw_intra_inplace (rbuf, rcounts, rdisps, rdtypes, comm, module); } size = ompi_comm_size(comm); rank = ompi_comm_rank(comm); /* simple optimization */ psnd = ((char *) sbuf) + sdisps[rank]; prcv = ((char *) rbuf) + rdisps[rank]; err = ompi_datatype_sndrcv(psnd, scounts[rank], sdtypes[rank], prcv, rcounts[rank], rdtypes[rank]); if (MPI_SUCCESS != err) { return err; } /* If only one process, we're done. */ if (1 == size) { return MPI_SUCCESS; } /* Initiate all send/recv to/from others. */ nreqs = 0; reqs = preq = coll_base_comm_get_reqs(module->base_data, 2 * size); /* Post all receives first -- a simple optimization */ for (i = 0; i < size; ++i) { size_t msg_size; ompi_datatype_type_size(rdtypes[i], &msg_size); msg_size *= rcounts[i]; if (i == rank || 0 == msg_size) continue; prcv = ((char *) rbuf) + rdisps[i]; err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtypes[i], i, MCA_COLL_BASE_TAG_ALLTOALLW, comm, preq++)); ++nreqs; if (MPI_SUCCESS != err) { ompi_coll_base_free_reqs(reqs, nreqs); return err; } } /* Now post all sends */ for (i = 0; i < size; ++i) { size_t msg_size; ompi_datatype_type_size(sdtypes[i], &msg_size); msg_size *= scounts[i]; if (i == rank || 0 == msg_size) continue; psnd = ((char *) sbuf) + sdisps[i]; err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtypes[i], i, MCA_COLL_BASE_TAG_ALLTOALLW, MCA_PML_BASE_SEND_STANDARD, comm, preq++)); ++nreqs; if (MPI_SUCCESS != err) { ompi_coll_base_free_reqs(reqs, nreqs); return err; } } /* Start your engines. This will never return an error. */ MCA_PML_CALL(start(nreqs, reqs)); /* Wait for them all. If there's an error, note that we don't care * what the error was -- just that there *was* an error. The PML * will finish all requests, even if one or more of them fail. * i.e., by the end of this call, all the requests are free-able. * So free them anyway -- even if there was an error, and return the * error after we free everything. */ err = ompi_request_wait_all(nreqs, reqs, MPI_STATUSES_IGNORE); /* Free the requests in all cases as they are persistent */ ompi_coll_base_free_reqs(reqs, nreqs); /* All done */ return err; }
/** * Linear functions are copied from the basic coll module. For * some small number of nodes and/or small data sizes they are just as * fast as base/tree based segmenting operations and as such may be * selected by the decision functions. These are copied into this module * due to the way we select modules in V1. i.e. in V2 we will handle this * differently and so will not have to duplicate code. */ int ompi_coll_base_alltoallv_intra_basic_linear(const void *sbuf, const int *scounts, const int *sdisps, struct ompi_datatype_t *sdtype, void *rbuf, const int *rcounts, const int *rdisps, struct ompi_datatype_t *rdtype, struct ompi_communicator_t *comm, mca_coll_base_module_t *module) { int i, size, rank, err, nreqs; char *psnd, *prcv; ptrdiff_t sext, rext; ompi_request_t **preq, **reqs; mca_coll_base_module_t *base_module = (mca_coll_base_module_t*) module; mca_coll_base_comm_t *data = base_module->base_data; if (MPI_IN_PLACE == sbuf) { return mca_coll_base_alltoallv_intra_basic_inplace (rbuf, rcounts, rdisps, rdtype, comm, module); } size = ompi_comm_size(comm); rank = ompi_comm_rank(comm); OPAL_OUTPUT((ompi_coll_base_framework.framework_output, "coll:base:alltoallv_intra_basic_linear rank %d", rank)); ompi_datatype_type_extent(sdtype, &sext); ompi_datatype_type_extent(rdtype, &rext); /* Simple optimization - handle send to self first */ psnd = ((char *) sbuf) + (ptrdiff_t)sdisps[rank] * sext; prcv = ((char *) rbuf) + (ptrdiff_t)rdisps[rank] * rext; if (0 != scounts[rank]) { err = ompi_datatype_sndrcv(psnd, scounts[rank], sdtype, prcv, rcounts[rank], rdtype); if (MPI_SUCCESS != err) { return err; } } /* If only one process, we're done. */ if (1 == size) { return MPI_SUCCESS; } /* Now, initiate all send/recv to/from others. */ nreqs = 0; reqs = preq = coll_base_comm_get_reqs(data, 2 * size); if( NULL == reqs ) { err = OMPI_ERR_OUT_OF_RESOURCE; goto err_hndl; } /* Post all receives first */ for (i = 0; i < size; ++i) { if (i == rank || 0 == rcounts[i]) { continue; } ++nreqs; prcv = ((char *) rbuf) + (ptrdiff_t)rdisps[i] * rext; err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtype, i, MCA_COLL_BASE_TAG_ALLTOALLV, comm, preq++)); if (MPI_SUCCESS != err) { goto err_hndl; } } /* Now post all sends */ for (i = 0; i < size; ++i) { if (i == rank || 0 == scounts[i]) { continue; } ++nreqs; psnd = ((char *) sbuf) + (ptrdiff_t)sdisps[i] * sext; err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtype, i, MCA_COLL_BASE_TAG_ALLTOALLV, MCA_PML_BASE_SEND_STANDARD, comm, preq++)); if (MPI_SUCCESS != err) { goto err_hndl; } } /* Start your engines. This will never return an error. */ MCA_PML_CALL(start(nreqs, reqs)); /* Wait for them all. If there's an error, note that we don't care * what the error was -- just that there *was* an error. The PML * will finish all requests, even if one or more of them fail. * i.e., by the end of this call, all the requests are free-able. * So free them anyway -- even if there was an error, and return the * error after we free everything. */ err = ompi_request_wait_all(nreqs, reqs, MPI_STATUSES_IGNORE); err_hndl: /* Free the requests in all cases as they are persistent */ ompi_coll_base_free_reqs(reqs, nreqs); return err; }
/* * alltoallw_inter * * Function: - MPI_Alltoallw * Accepts: - same as MPI_Alltoallw() * Returns: - MPI_SUCCESS or an MPI error code */ int mca_coll_basic_alltoallw_inter(void *sbuf, int *scounts, int *sdisps, struct ompi_datatype_t **sdtypes, void *rbuf, int *rcounts, int *rdisps, struct ompi_datatype_t **rdtypes, struct ompi_communicator_t *comm, mca_coll_base_module_t *module) { int i; int size; int err; char *psnd; char *prcv; int nreqs; MPI_Request *preq; mca_coll_basic_module_t *basic_module = (mca_coll_basic_module_t*) module; /* Initialize. */ size = ompi_comm_remote_size(comm); /* Initiate all send/recv to/from others. */ nreqs = size * 2; preq = basic_module->mccb_reqs; /* Post all receives first -- a simple optimization */ for (i = 0; i < size; ++i) { prcv = ((char *) rbuf) + rdisps[i]; err = MCA_PML_CALL(irecv_init(prcv, rcounts[i], rdtypes[i], i, MCA_COLL_BASE_TAG_ALLTOALLW, comm, preq++)); if (OMPI_SUCCESS != err) { mca_coll_basic_free_reqs(basic_module->mccb_reqs, nreqs); return err; } } /* Now post all sends */ for (i = 0; i < size; ++i) { psnd = ((char *) sbuf) + sdisps[i]; err = MCA_PML_CALL(isend_init(psnd, scounts[i], sdtypes[i], i, MCA_COLL_BASE_TAG_ALLTOALLW, MCA_PML_BASE_SEND_STANDARD, comm, preq++)); if (OMPI_SUCCESS != err) { mca_coll_basic_free_reqs(basic_module->mccb_reqs, nreqs); return err; } } /* Start your engines. This will never return an error. */ MCA_PML_CALL(start(nreqs, basic_module->mccb_reqs)); /* Wait for them all. If there's an error, note that we don't care * what the error was -- just that there *was* an error. The PML * will finish all requests, even if one or more of them fail. * i.e., by the end of this call, all the requests are free-able. * So free them anyway -- even if there was an error, and return the * error after we free everything. */ err = ompi_request_wait_all(nreqs, basic_module->mccb_reqs, MPI_STATUSES_IGNORE); /* Free the requests. */ mca_coll_basic_free_reqs(basic_module->mccb_reqs, nreqs); /* All done */ return err; }
int ompi_coll_base_alltoall_intra_basic_linear(const void *sbuf, int scount, struct ompi_datatype_t *sdtype, void* rbuf, int rcount, struct ompi_datatype_t *rdtype, struct ompi_communicator_t *comm, mca_coll_base_module_t *module) { int i, rank, size, err, line; int nreqs = 0; char *psnd, *prcv; MPI_Aint lb, sndinc, rcvinc; ompi_request_t **req, **sreq, **rreq; mca_coll_base_module_t *base_module = (mca_coll_base_module_t*) module; mca_coll_base_comm_t *data = base_module->base_data; if (MPI_IN_PLACE == sbuf) { return mca_coll_base_alltoall_intra_basic_inplace (rbuf, rcount, rdtype, comm, module); } /* Initialize. */ size = ompi_comm_size(comm); rank = ompi_comm_rank(comm); OPAL_OUTPUT((ompi_coll_base_framework.framework_output, "ompi_coll_base_alltoall_intra_basic_linear rank %d", rank)); err = ompi_datatype_get_extent(sdtype, &lb, &sndinc); if (OMPI_SUCCESS != err) { return err; } sndinc *= scount; err = ompi_datatype_get_extent(rdtype, &lb, &rcvinc); if (OMPI_SUCCESS != err) { return err; } rcvinc *= rcount; /* simple optimization */ psnd = ((char *) sbuf) + (ptrdiff_t)rank * sndinc; prcv = ((char *) rbuf) + (ptrdiff_t)rank * rcvinc; err = ompi_datatype_sndrcv(psnd, scount, sdtype, prcv, rcount, rdtype); if (MPI_SUCCESS != err) { return err; } /* If only one process, we're done. */ if (1 == size) { return MPI_SUCCESS; } /* Initiate all send/recv to/from others. */ req = rreq = coll_base_comm_get_reqs(data, (size - 1) * 2); if (NULL == req) { err = OMPI_ERR_OUT_OF_RESOURCE; line = __LINE__; goto err_hndl; } prcv = (char *) rbuf; psnd = (char *) sbuf; /* Post all receives first -- a simple optimization */ for (nreqs = 0, i = (rank + 1) % size; i != rank; i = (i + 1) % size, ++rreq) { nreqs++; err = MCA_PML_CALL(irecv_init (prcv + (ptrdiff_t)i * rcvinc, rcount, rdtype, i, MCA_COLL_BASE_TAG_ALLTOALL, comm, rreq)); if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; } } /* Now post all sends in reverse order - We would like to minimize the search time through message queue when messages actually arrive in the order in which they were posted. */ sreq = rreq; for (i = (rank + size - 1) % size; i != rank; i = (i + size - 1) % size, ++sreq) { nreqs++; err = MCA_PML_CALL(isend_init (psnd + (ptrdiff_t)i * sndinc, scount, sdtype, i, MCA_COLL_BASE_TAG_ALLTOALL, MCA_PML_BASE_SEND_STANDARD, comm, sreq)); if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; } } /* Start your engines. This will never return an error. */ MCA_PML_CALL(start(nreqs, req)); /* Wait for them all. If there's an error, note that we don't * care what the error was -- just that there *was* an error. The * PML will finish all requests, even if one or more of them fail. * i.e., by the end of this call, all the requests are free-able. * So free them anyway -- even if there was an error, and return * the error after we free everything. */ err = ompi_request_wait_all(nreqs, req, MPI_STATUSES_IGNORE); if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; } err_hndl: if( MPI_SUCCESS != err ) { OPAL_OUTPUT( (ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d", __FILE__, line, err, rank) ); (void)line; // silence compiler warning } /* Free the reqs in all cases as they are persistent requests */ ompi_coll_base_free_reqs(req, nreqs); /* All done */ return err; }
/* * alltoall_intra * * Function: - MPI_Alltoall * Accepts: - same as MPI_Alltoall() * Returns: - MPI_SUCCESS or an MPI error code */ int mca_coll_basic_alltoall_intra(void *sbuf, int scount, struct ompi_datatype_t *sdtype, void *rbuf, int rcount, struct ompi_datatype_t *rdtype, struct ompi_communicator_t *comm, mca_coll_base_module_t *module) { int i; int rank; int size; int err; int nreqs; char *psnd; char *prcv; MPI_Aint lb; MPI_Aint sndinc; MPI_Aint rcvinc; ompi_request_t **req; ompi_request_t **sreq; ompi_request_t **rreq; mca_coll_basic_module_t *basic_module = (mca_coll_basic_module_t*) module; /* Initialize. */ size = ompi_comm_size(comm); rank = ompi_comm_rank(comm); err = ompi_datatype_get_extent(sdtype, &lb, &sndinc); if (OMPI_SUCCESS != err) { return err; } sndinc *= scount; err = ompi_datatype_get_extent(rdtype, &lb, &rcvinc); if (OMPI_SUCCESS != err) { return err; } rcvinc *= rcount; /* simple optimization */ psnd = ((char *) sbuf) + (rank * sndinc); prcv = ((char *) rbuf) + (rank * rcvinc); err = ompi_datatype_sndrcv(psnd, scount, sdtype, prcv, rcount, rdtype); if (MPI_SUCCESS != err) { return err; } /* If only one process, we're done. */ if (1 == size) { return MPI_SUCCESS; } /* Initiate all send/recv to/from others. */ req = rreq = basic_module->mccb_reqs; sreq = rreq + size - 1; prcv = (char *) rbuf; psnd = (char *) sbuf; /* Post all receives first -- a simple optimization */ for (nreqs = 0, i = (rank + 1) % size; i != rank; i = (i + 1) % size, ++rreq, ++nreqs) { err = MCA_PML_CALL(irecv_init (prcv + (i * rcvinc), rcount, rdtype, i, MCA_COLL_BASE_TAG_ALLTOALL, comm, rreq)); if (MPI_SUCCESS != err) { mca_coll_basic_free_reqs(req, nreqs); return err; } } /* Now post all sends */ for (nreqs = 0, i = (rank + 1) % size; i != rank; i = (i + 1) % size, ++sreq, ++nreqs) { err = MCA_PML_CALL(isend_init (psnd + (i * sndinc), scount, sdtype, i, MCA_COLL_BASE_TAG_ALLTOALL, MCA_PML_BASE_SEND_STANDARD, comm, sreq)); if (MPI_SUCCESS != err) { mca_coll_basic_free_reqs(req, nreqs); return err; } } nreqs = (size - 1) * 2; /* Start your engines. This will never return an error. */ MCA_PML_CALL(start(nreqs, req)); /* Wait for them all. If there's an error, note that we don't * care what the error was -- just that there *was* an error. The * PML will finish all requests, even if one or more of them fail. * i.e., by the end of this call, all the requests are free-able. * So free them anyway -- even if there was an error, and return * the error after we free everything. */ err = ompi_request_wait_all(nreqs, req, MPI_STATUSES_IGNORE); /* Free the reqs */ mca_coll_basic_free_reqs(req, nreqs); /* All done */ return err; }
int main(int argc, char *argv[]) { printf("iRecovery - Recovery Utility\n"); printf("by westbaer\nThanks to pod2g, tom3q, planetbeing, geohot and posixninja.\n\n"); if(argc < 2) { irecv_usage(); return -1; } if(!strcmp(argv[1], "-q")) { enter_recovery(); } struct usb_dev_handle* handle = irecv_init(RECV_MODE); if (handle == NULL) { handle = irecv_init(WTF_MODE); if (handle == NULL) { printf("No iPhone/iPod found.\n"); return -1; } else { printf("Found iPhone/iPod in DFU/WTF mode\n"); } } else { printf("Found iPhone/iPod in Recovery mode\n"); } if (((irecv_command(handle, 1, "setenv auto-boot true")) == -1) || ((irecv_command(handle, 1, "saveenv")) == -1)) printf("Failed to set auto-boot"); if(!strcmp(argv[1], "-f")) { if(argc == 3) { irecv_upload(handle, argv[2]); } } else if(!strcmp(argv[1], "-c")) { if(argc >= 3) { irecv_command(handle, argc-2, &argv[2]); } } else if(!strcmp(argv[1], "-k")) { if(argc >= 3) { irecv_exploit(handle, argv[2]); } else { irecv_exploit(handle, NULL); } } else if(!strcmp(argv[1], "-k")) { if(argc >= 3) { irecv_exploit(handle, argv[2]); } } else if(!strcmp(argv[1], "-x40")) { if(argc >= 3) { irecv_sendrawusb0x40(handle, argv[2]); } } else if(!strcmp(argv[1], "-x21")) { if(argc >= 3) { irecv_sendrawusb0x21(handle, argv[2]); } } else if(!strcmp(argv[1], "-xA1")) { if(argc >= 3) { irecv_sendrawusb0xA1(handle, argv[2]); } } else if(!strcmp(argv[1], "-s")) { if(argc >= 3) { irecv_console(handle, argv[2]); } else { irecv_console(handle, NULL); } } else if(!strcmp(argv[1], "-r")) { irecv_reset(handle); } else if (!strcmp(argv[1], "-l")) { irecv_list(handle, argv[2]); } else if (!strcmp(argv[1], "-x")) { if (argc == 3) { irecv_upload(handle, argv[2]); irecv_reset(handle); } } irecv_close(handle); return 0; }
void irecv_console() { int ret, length, skip_recv, firstresp; char *buf, *sendbuf, *cmd, *response; irecv_init(RECV_MODE); if(devPhone == 0) { printf("No iPhone/iPod found.\n"); exit(EXIT_FAILURE); } if((ret = usb_set_configuration(devPhone, 1)) < 0) { printf("Error %d when setting configuration\n", ret); irecv_close(); exit(EXIT_FAILURE); } if((ret = usb_claim_interface(devPhone, 1)) < 0) { printf("Error %d when claiming interface\n", ret); irecv_close(); exit(EXIT_FAILURE); } if((ret = usb_set_altinterface(devPhone, 1)) < 0) { printf("Error %d when setting altinterface\n", ret); irecv_close(); exit(EXIT_FAILURE); } buf = malloc(0x10001); sendbuf = malloc(160); cmd = malloc(160); skip_recv = 0; firstresp = 0; do { if(!skip_recv) { ret = usb_bulk_read(devPhone, 0x81, buf, 0x10000, 1000); if(ret > 0) { response = buf; while(response < buf + ret) { printf("%s", response); response += strlen(response) + 1; } } } else { skip_recv = 0; } if(firstresp == 1) { printf("] ", response); } cmd = readline(NULL); if(cmd && *cmd) { add_history(cmd); } if(firstresp == 0) { firstresp = 1; } if(cmd[0] == '/') { irecv_parsecmd(cmd); } else { length = (int)(((strlen(cmd)-1)/0x10)+1)*0x10; memset(sendbuf, 0, length); memcpy(sendbuf, cmd, strlen(cmd)); if(!usb_control_msg(devPhone, 0x40, 0, 0, 0, sendbuf, length, 1000)) { printf("[!] %s", usb_strerror()); } } } while(strcmp("/exit", cmd) != 0); usb_release_interface(devPhone, 0); free(buf); free(sendbuf); free(cmd); irecv_close(devPhone); }
int main(int argc, char* argv[]) { int i = 0; int opt = 0; int action = 0; char* argument = NULL; irecv_error_t error = 0; if (argc == 1) print_usage(); while ((opt = getopt(argc, argv, "vhrsc:f:e:k::")) > 0) { switch (opt) { case 'v': verbose += 1; break; case 'h': print_usage(); break; case 'r': action = kResetDevice; break; case 's': action = kStartShell; break; case 'f': action = kSendFile; argument = optarg; break; case 'c': action = kSendCommand; argument = optarg; break; case 'k': action = kSendExploit; argument = optarg; break; case 'e': action = kSendScript; argument = optarg; break; default: fprintf(stderr, "Unknown argument\n"); return -1; } } if (verbose) irecv_set_debug_level(verbose); irecv_init(); irecv_client_t client = NULL; for (i = 0; i <= 5; i++) { debug("Attempting to connect... \n"); if (irecv_open(&client) != IRECV_E_SUCCESS) sleep(1); else break; if (i == 5) { return -1; } } switch (action) { case kResetDevice: irecv_reset(client); break; case kSendFile: irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL); error = irecv_send_file(client, argument, 1); debug("%s\n", irecv_strerror(error)); break; case kSendCommand: error = irecv_send_command(client, argument); debug("%s\n", irecv_strerror(error)); break; case kSendExploit: if (argument != NULL) { irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL); error = irecv_send_file(client, argument, 0); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); break; } } error = irecv_send_exploit(client); debug("%s\n", irecv_strerror(error)); break; case kStartShell: init_shell(client); break; case kSendScript: error = irecv_execute_script(client, argument); if(error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); } break; default: fprintf(stderr, "Unknown action\n"); break; } irecv_close(client); return 0; }
int main(int argc, char* argv[]) { irecv_error_t error; unsigned int cpid; int can_ra1n = 0; printf("Loadibec " LOADIBEC_VERSION COMMIT_STRING ".\n"); if(argc != 2) { printf("Usage: %s <file>\n" "\tLoads a file to an iDevice in recovery mode and jumps to it.\n", argv[0]); return 0; } irecv_init(); printf("Connecting to iDevice...\n"); error = irecv_open_attempts(&g_syringe_client, 10); if(error != IRECV_E_SUCCESS) { fprintf(stderr, "Failed to connect to iBoot, error %d.\n", error); return -error; } if(irecv_get_cpid(g_syringe_client, &cpid) == IRECV_E_SUCCESS) { if(cpid > 8900) can_ra1n = 1; } if(g_syringe_client->mode == kDfuMode && can_ra1n) { int ret; printf("linera1n compatible device detected, injecting limera1n.\n"); irecv_close(&g_syringe_client); irecv_exit(); pois0n_init(); ret = pois0n_is_ready(); if(ret < 0) return ret; ret = pois0n_is_compatible(); if(ret < 0) return ret; pois0n_inject(); irecv_close(&g_syringe_client); g_syringe_client = NULL; printf("limera1ned, reconnecting...\n"); g_syringe_client = irecv_reconnect(g_syringe_client, 10); if(!g_syringe_client) { fprintf(stderr, "Failed to reconnect.\n"); return 4; } } else can_ra1n = 0; printf("Starting transfer of '%s'.\n", argv[1]); irecv_event_subscribe(g_syringe_client, IRECV_PROGRESS, &progress_cb, NULL); error = irecv_send_file(g_syringe_client, argv[1], 0); if(error != IRECV_E_SUCCESS) { fprintf(stderr, "Failed to upload '%s', error %d.\n", argv[1], error); return 2; } error = irecv_send_command(g_syringe_client, "go"); if(error != IRECV_E_SUCCESS) { fprintf(stderr, "Failed to jump to uploaded file, error %d.\n", error); return 3; } irecv_send_command(g_syringe_client, "go jump 0x41000000"); printf("Uploaded Successfully.\n"); irecv_exit(); return 0; }