Merge "fastboot: call mke2fs to format ext4 filesystem on windows"

#include <sys/types.h>

#include <sys/types.h>

#ifndef WIN32

#ifndef WIN32

#include <sys/wait.h>

#include <sys/wait.h>

#else

#include <tchar.h>

#include <windows.h>

#endif

#endif

#include <unistd.h>

#include <unistd.h>

#include <vector>

#include <vector>

#include <android-base/errors.h>

#include <android-base/file.h>

#include <android-base/file.h>

#include <android-base/stringprintf.h>

#include <android-base/stringprintf.h>

#include <android-base/unique_fd.h>

#include <android-base/unique_fd.h>

using android::base::unique_fd;

using android::base::unique_fd;

#ifdef WIN32

#ifdef WIN32

static int generate_ext4_image(const char* fileName, long long partSize, const std::string& initial_dir,

static int exec_e2fs_cmd(const char* path, char* const argv[]) {

                                       unsigned eraseBlkSize, unsigned logicalBlkSize)

    std::string cmd;

{

    int i = 0;

    unique_fd fd(open(fileName, O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR));

    while (argv[i] != nullptr) {

    if (fd == -1) {

        cmd += argv[i++];

        fprintf(stderr, "Unable to open output file for EXT4 filesystem: %s\n", strerror(errno));

        cmd += " ";

    }

    cmd = cmd.substr(0, cmd.size() - 1);

    STARTUPINFO si;

    PROCESS_INFORMATION pi;

    DWORD exit_code = 0;

    ZeroMemory(&si, sizeof(si));

    si.cb = sizeof(si);

    ZeroMemory(&pi, sizeof(pi));

    SetEnvironmentVariableA("MKE2FS_CONFIG", "");

    if (!CreateProcessA(nullptr,                         // No module name (use command line)

                        const_cast<char*>(cmd.c_str()),  // Command line

                        nullptr,                         // Process handle not inheritable

                        nullptr,                         // Thread handle not inheritable

                        FALSE,                           // Set handle inheritance to FALSE

                        0,                               // No creation flags

                        nullptr,                         // Use parent's environment block

                        nullptr,                         // Use parent's starting directory

                        &si,                             // Pointer to STARTUPINFO structure

                        &pi)                             // Pointer to PROCESS_INFORMATION structure

    ) {

        fprintf(stderr, "CreateProcess failed: %s\n",

                android::base::SystemErrorCodeToString(GetLastError()).c_str());

        return -1;

        return -1;

    }

    }

    if (initial_dir.empty()) {

        make_ext4fs_sparse_fd_align(fd, partSize, NULL, NULL, eraseBlkSize, logicalBlkSize);

    WaitForSingleObject(pi.hProcess, INFINITE);

    } else {

        make_ext4fs_sparse_fd_directory_align(fd, partSize, NULL, NULL, initial_dir.c_str(),

    GetExitCodeProcess(pi.hProcess, &exit_code);

                                              eraseBlkSize, logicalBlkSize);

    }

    CloseHandle(pi.hProcess);

    return 0;

    CloseHandle(pi.hThread);

    return exit_code != 0;

}

}

#else

#else

static int exec_e2fs_cmd(const char* path, char* const argv[]) {

static int exec_e2fs_cmd(const char* path, char* const argv[]) {

    }

    }

    return ret;

    return ret;

}

}

#endif

static int generate_ext4_image(const char* fileName, long long partSize,

static int generate_ext4_image(const char* fileName, long long partSize,

                               const std::string& initial_dir, unsigned eraseBlkSize,

                               const std::string& initial_dir, unsigned eraseBlkSize,

    return 0;

    return 0;

}

}

#endif

#ifdef USE_F2FS

#ifdef USE_F2FS

static int generate_f2fs_image(const char* fileName, long long partSize, const std::string& initial_dir,

static int generate_f2fs_image(const char* fileName, long long partSize, const std::string& initial_dir,