void getJavaProperties(WCHAR * location, LauncherProperties * props, JavaProperties ** javaProps) {
WCHAR *testJavaClass = props->testJVMClass;
WCHAR *javaExecutable = getJavaResource(location, JAVA_EXE_SUFFIX);
WCHAR *libDirectory = getJavaResource(location, JAVA_LIB_SUFFIX);
if(fileExists(javaExecutable) && testJavaClass!=NULL && isDirectory(libDirectory)) {
WCHAR * command = NULL;
HANDLE hRead;
HANDLE hWrite;
writeMessageA(props, OUTPUT_LEVEL_DEBUG, 0, "... java hierarchy there", 1);
// <location>\bin\java.exe exists
appendCommandLineArgument(&command, javaExecutable);
appendCommandLineArgument(&command, L"-classpath");
appendCommandLineArgument(&command, props->testJVMFile->resolved);
appendCommandLineArgument(&command, testJavaClass);
CreatePipe(&hRead, &hWrite, NULL, 0);
// Start the child process.
executeCommand(props, command, NULL, JAVA_VERIFICATION_PROCESS_TIMEOUT, hWrite, INVALID_HANDLE_VALUE, JAVA_VERIFICATION_PROCESS_PRIORITY);
if(props->status!= ERROR_ON_EXECUTE_PROCESS && props->status!= ERROR_PROCESS_TIMEOUT) {
char * output = readHandle(hRead);
writeMessageA(props, OUTPUT_LEVEL_DEBUG, 0, " output :\n", 0);
writeMessageA(props, OUTPUT_LEVEL_DEBUG, 0, output, 1);
props->status = getJavaPropertiesFromOutput(props, output, javaProps);
if(props->status == ERROR_OK) {
(*javaProps)->javaHome = appendStringW(NULL, location);
(*javaProps)->javaExe = appendStringW(NULL, javaExecutable);
}
FREE(output);
} else if(props->status == ERROR_PROCESS_TIMEOUT) {
// java verification process finished by time out
props->status = ERROR_INPUTOUPUT;
}
FREE(command);
CloseHandle(hWrite);
CloseHandle(hRead);
} else {
writeMessageA(props, OUTPUT_LEVEL_DEBUG, 0, "... not a java hierarchy", 1);
props->status = ERROR_INPUTOUPUT;
}
FREE(libDirectory);
FREE(javaExecutable);
}
int MtpFfsCompatHandle::receiveFile(mtp_file_range mfr, bool zero_packet) {
// When receiving files, the incoming length is given in 32 bits.
// A >4G file is given as 0xFFFFFFFF
uint32_t file_length = mfr.length;
uint64_t offset = mfr.offset;
int packet_size = getPacketSize(mBulkOut);
unsigned char *data = mIobuf[0].bufs.data();
unsigned char *data2 = mIobuf[1].bufs.data();
struct aiocb aio;
aio.aio_fildes = mfr.fd;
aio.aio_buf = nullptr;
struct aiocb *aiol[] = {&aio};
int ret = -1;
size_t length;
bool read = false;
bool write = false;
posix_fadvise(mfr.fd, 0, 0, POSIX_FADV_SEQUENTIAL | POSIX_FADV_NOREUSE);
// Break down the file into pieces that fit in buffers
while (file_length > 0 || write) {
if (file_length > 0) {
length = std::min(static_cast<uint32_t>(MAX_FILE_CHUNK_SIZE), file_length);
// Read data from USB, handle errors after waiting for write thread.
ret = readHandle(mBulkOut, data, length);
if (file_length != MAX_MTP_FILE_SIZE && ret < static_cast<int>(length)) {
ret = -1;
errno = EIO;
}
read = true;
}
if (write) {
// get the return status of the last write request
aio_suspend(aiol, 1, nullptr);
int written = aio_return(&aio);
if (written == -1) {
errno = aio_error(&aio);
return -1;
}
if (static_cast<size_t>(written) < aio.aio_nbytes) {
errno = EIO;
return -1;
}
write = false;
}
// If there was an error reading above
if (ret == -1) {
return -1;
}
if (read) {
if (file_length == MAX_MTP_FILE_SIZE) {
// For larger files, receive until a short packet is received.
if (static_cast<size_t>(ret) < length) {
file_length = 0;
}
} else {
file_length -= ret;
}
// Enqueue a new write request
aio_prepare(&aio, data, length, offset);
aio_write(&aio);
offset += ret;
std::swap(data, data2);
write = true;
read = false;
}
}
// Receive an empty packet if size is a multiple of the endpoint size.
if (ret % packet_size == 0 || zero_packet) {
if (TEMP_FAILURE_RETRY(::read(mBulkOut, data, packet_size)) != 0) {
return -1;
}
}
return 0;
}
int MtpFfsCompatHandle::read(void* data, size_t len) {
return readHandle(mBulkOut, data, len);
}
