{

if (!m_InteropSocketPath.empty())

{

LOG_ERROR("Interop server already created");

return -1;

}

//

// Generate a unique name to be used for the interop socket path.

//

m_InteropSocketPath = std::format(WSL_INTEROP_SOCKET_FORMAT, WSL_TEMP_FOLDER, getpid(), WSL_INTEROP_SOCKET);

//

// Ensure the WSL temp folder exists and has the correct mode.

//

if (UtilMkdir(WSL_TEMP_FOLDER, WSL_TEMP_FOLDER_MODE) < 0)

{

return -1;

}

//

// Create a unix socket to handle interop requests.

//

// N.B. This is done before the child process is created to ensure that

// the socket is ready for connections.

//

m_InteropSocket.reset(socket(AF_UNIX, (SOCK_STREAM | SOCK_CLOEXEC), 0));

if (!m_InteropSocket)

{

LOG_ERROR("socket failed {}", errno);

return -1;

}

sockaddr_un InteropSocketAddress{};

InteropSocketAddress.sun_family = AF_UNIX;

strncpy(InteropSocketAddress.sun_path, m_InteropSocketPath.c_str(), (sizeof(InteropSocketAddress.sun_path) - 1));

auto Result = bind(m_InteropSocket.get(), reinterpret_cast<sockaddr*>(&InteropSocketAddress), sizeof(InteropSocketAddress));

if (Result < 0)

{

LOG_ERROR("bind failed {}", errno);

return -1;

}

Result = listen(m_InteropSocket.get(), -1);

if (Result < 0)

{

LOG_ERROR("listen failed {}", errno);

return -1;

}

//

// Ensure that any users can connect to the interop socket.

//

Result = chmod(m_InteropSocketPath.c_str(), 0777);

if (Result < 0)

{

LOG_ERROR("chmod failed {}", errno);

return -1;

}

return 0;

{

wil::unique_fd InteropConnection{accept4(m_InteropSocket.get(), nullptr, nullptr, SOCK_CLOEXEC)};

if (!InteropConnection)

{

LOG_ERROR("accept4 failed {}", errno);

}

timeval Timeout{};

Timeout.tv_sec = INTEROP_TIMEOUT_SEC;

if (setsockopt(InteropConnection.get(), SOL_SOCKET, SO_RCVTIMEO, &Timeout, sizeof(Timeout)) < 0)

{

LOG_ERROR("setsockopt(SO_RCVTIMEO) failed {}", errno);

}

return InteropConnection;

{

if (!m_InteropSocketPath.empty())

{

unlink(m_InteropSocketPath.c_str());

m_InteropSocketPath = {};

}

{

//

// If a timeout was specified, use a pollfd to wait for the accept.

//

int Result = 0;

if (Timeout == -1)

{

pollfd PollDescriptor{SocketFd, POLLIN, 0};

while (true)

{

Result = poll(&PollDescriptor, 1, 60 * 1000);

if (Result < 0)

{

LOG_ERROR("poll({}) failed, {}", SocketFd, errno);

return Result;

}

else if ((Result == 0) || ((PollDescriptor.revents & POLLIN) == 0))

{

LOG_ERROR("Waiting for abnormally long accept({})", SocketFd);

}

else

{

break;

}

}

}

else

{

pollfd PollDescriptor{SocketFd, POLLIN, 0};

Result = poll(&PollDescriptor, 1, Timeout);

if ((Result <= 0) || ((PollDescriptor.revents & POLLIN) == 0))

{

errno = ETIMEDOUT;

Result = -1;

}

}

if (Result != -1)

{

socklen_t SocketAddressSize = sizeof(SocketAddress);

Result = accept4(SocketFd, reinterpret_cast<sockaddr*>(&SocketAddress), &SocketAddressSize, SOCK_CLOEXEC);

}

if (Result < 0)

{

LOG_ERROR("accept4 failed {}", errno);

}

return Result;

{

int Result;

socklen_t SocketAddressSize;

int SocketFd;

SocketFd = socket(AF_VSOCK, Type, 0);

if (SocketFd < 0)

{

Result = -1;

LOG_ERROR("socket failed {}", errno);

goto BindVsockAnyPortExit;

}

memset(SocketAddress, 0, sizeof(*SocketAddress));

SocketAddress->svm_family = AF_VSOCK;

SocketAddress->svm_cid = VMADDR_CID_ANY;

SocketAddress->svm_port = VMADDR_PORT_ANY;

SocketAddressSize = sizeof(*SocketAddress);

Result = bind(SocketFd, (const struct sockaddr*)SocketAddress, SocketAddressSize);

if (Result < 0)

{

LOG_ERROR("bind failed {}", errno);

goto BindVsockAnyPortExit;

}

//

// Query the socket name to get the assigned port.

//

Result = getsockname(SocketFd, (struct sockaddr*)SocketAddress, &SocketAddressSize);

if (Result < 0)

{

LOG_ERROR("getsockname failed {}", errno);

goto BindVsockAnyPortExit;

}

Result = SocketFd;

SocketFd = -1;

BindVsockAnyPortExit:

if (SocketFd != -1)

{

CLOSE(SocketFd);

}

return Result;

{

size_t DestIndex;

size_t PathLength;

size_t SourceIndex;

DestIndex = 0;

SourceIndex = 0;

PathLength = strlen(Path);

//

// Iterate through the path, replacing all separators.

//

for (; SourceIndex < PathLength; SourceIndex++)

{

if (Path[SourceIndex] == PATH_SEP || Path[SourceIndex] == PATH_SEP_NT)

{

//

// Don't add a separator if previous char already is a separator.

// Also handle the special case where 'Path' is a UNC path (\\X or //X)

// where both separators should be kept.

//

if (DestIndex > 1 && Path[DestIndex - 1] == Separator)

{

continue;

}

Path[DestIndex] = Separator;

}

else

{

Path[DestIndex] = Path[SourceIndex];

}

DestIndex++;

}

Path[DestIndex] = '\0';

return DestIndex;

{

Path.resize(UtilCanonicalisePathSeparator(Path.data(), Separator));

{

wil::unique_fd Socket{socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)};

if (!Socket)

{

LOG_ERROR("socket failed {}", errno);

return {};

}

sockaddr_un SocketAddress{};

SocketAddress.sun_family = AF_UNIX;

strncpy(SocketAddress.sun_path, Path, sizeof(SocketAddress.sun_path) - 1);

if (connect(Socket.get(), reinterpret_cast<sockaddr*>(&SocketAddress), sizeof(SocketAddress)) < 0)

{

LOG_ERROR("connect failed {}", errno);

return {};

}

return Socket;

{

int Type = SOCK_STREAM;

WI_SetFlagIf(Type, SOCK_CLOEXEC, CloseOnExec);

wil::unique_fd SocketFd{socket(AF_VSOCK, Type, 0)};

if (!SocketFd)

{

LOG_ERROR("socket failed {}", errno);

return {};

}

//

// Set the socket connect timeout.

//

timeval Timeout{};

Timeout.tv_sec = LX_INIT_HVSOCKET_TIMEOUT_SECONDS;

if (setsockopt(SocketFd.get(), AF_VSOCK, SO_VM_SOCKETS_CONNECT_TIMEOUT, &Timeout, sizeof(Timeout)) < 0)

{

LOG_ERROR("setsockopt SO_VM_SOCKETS_CONNECT_TIMEOUT failed {}", errno);

return {};

}

if (SocketBuffer)

{

int BufferSize = *SocketBuffer;

if (setsockopt(SocketFd.get(), SOL_SOCKET, SO_SNDBUF, &BufferSize, sizeof(BufferSize)) < 0)

{

LOG_ERROR("setsockopt(SO_SNDBUF, {}) failed {}", BufferSize, errno);

return {};

}

if (setsockopt(SocketFd.get(), SOL_SOCKET, SO_RCVBUF, &BufferSize, sizeof(BufferSize)) < 0)

{

LOG_ERROR("setsockopt(SO_RCVBUF, {}) failed {}", BufferSize, errno);

return {};

}

}

sockaddr_vm SocketAddress{};

SocketAddress.svm_family = AF_VSOCK;

SocketAddress.svm_cid = VMADDR_CID_HOST;

SocketAddress.svm_port = Port;

if (connect(SocketFd.get(), (const struct sockaddr*)&SocketAddress, sizeof(SocketAddress)) < 0)

{

LOG_ERROR("connect port {} failed {}", Port, errno);

return {};

}

return SocketFd;

{

pid_t ChildPid;

int Result;

int LocalStatus;

pid_t WaitResult;

Result = -1;

//

// Init needs to not ignore SIGCHLD so it can wait for this child.

//

auto restore = signal(SIGCHLD, SIG_DFL);

ChildPid = fork();

if (ChildPid < 0)

{

LOG_ERROR("Forking child process for {} failed with {}", File, errno);

goto CreateProcessAndWaitEnd;

}

if (ChildPid == 0)

{

//

// Restore default signal dispositions for the child process.

//

if (UtilSetSignalHandlers(g_SavedSignalActions, false) < 0 || UtilRestoreBlockedSignals() < 0)

{

exit(-1);

}

//

// Set environment variables.

//

for (const auto& e : Env)

{

setenv(e.first.c_str(), e.second.c_str(), 1);

}

//

// Invoke the executable.

//

// This explicit cast is okay for now because:

// 1. execv function is guaranteed to not alter the arguments

// 2. In sometime we probably will replace most of these string constants

// with std::string anyway.

execv(File, const_cast<char* const*>(Argv));

LOG_ERROR("{} failed with {}", File, errno);

exit(-1);

}

if (Status == nullptr)

{

Status = &LocalStatus;

}

//

// TODO_LX: Do we need a timeout when waiting for the process?

//

WaitResult = waitpid(ChildPid, Status, 0);

if (WaitResult < 0)

{

LOG_ERROR("Waiting for {} failed with {}", File, errno);

goto CreateProcessAndWaitEnd;

}

if (*Status != 0)

{

LOG_ERROR("{} failed with status {:#x}", File, *Status);

goto CreateProcessAndWaitEnd;

}

Result = 0;

CreateProcessAndWaitEnd:

//

// Restore the disposition of SIGCHLD.

//

signal(SIGCHLD, restore);

return Result;

{

//

// Exec the command and read the output.

//

wil::unique_file Pipe{popen(CommandLine, "re")};

if (!Pipe)

{

LOG_ERROR("popen({}) failed {}", CommandLine, errno);

return -1;

}

std::vector<char> Buffer(1024);

int Result = -1;

while (fgets(Buffer.data(), Buffer.size(), Pipe.get()) != nullptr)

{

if (Output)

{

(*Output) += Buffer.data();

if (Result < 0)

{

goto ErrorExit;

}

}

else

{

fputs(Buffer.data(), stdout);

}

}

if (ferror(Pipe.get()))

{

Result = -1;

LOG_ERROR("fgets failed {}", errno);

goto ErrorExit;

}

Result = 0;

ErrorExit:

if (Pipe)

{

Result = pclose(Pipe.release());

if (Result == -1)

{

LOG_ERROR("pclose failed {}", errno);

}

else

{

Result = UtilProcessChildExitCode(Result, CommandLine, ExpectedStatus, PrintError);

}

}

return Result;

try

{

char** MatchField;

char** ReplacementField;

mountutil::MountEnum MountEnum{MountInfoFile};

if (WinPath != false)

{

MatchField = &MountEnum.Current().Source;

ReplacementField = &MountEnum.Current().MountPoint;

}

else

{

MatchField = &MountEnum.Current().MountPoint;

ReplacementField = &MountEnum.Current().Source;

}

std::string FoundReplacement;

size_t FoundPrefixLength = 0;

while (MountEnum.Next())

{

//

// If a mount point was previously found, and this mount point is a

// prefix of the path (or the previously found mount point, for Windows

// to Linux translation), it means that the path is not actually on

// the previously found mount, so discard that result.

//

// For example:

// - When translating /mnt/c/foo/bar, first /mnt/c is found, but a

// later entry indicates /mnt/c/foo is also a mount point (e.g. using

// tmpfs). This means /mnt/c/foo/bar is not on the /mnt/c mount.

// - When translating C:\foo, first /mnt/c is found. A later entry

// indicates /mnt itself is a mount point, making the earlier /mnt/c

// mount unreachable.

//

// TODO_LX: This doesn't catch the case when translating C:\foo\bar and

// /mnt/c/foo is a mount point. Handling that is more complicated.

//

if (!FoundReplacement.empty())

{

const char* LinuxPath = WinPath ? FoundReplacement.c_str() : Path;

size_t LinuxPrefixLength = UtilIsPathPrefix(LinuxPath, MountEnum.Current().MountPoint, false);

if (LinuxPrefixLength > 0)

{

FoundReplacement.resize(0);

}

}

//

// For Plan 9, parse the actual mount source from the superblock options.

// For virtiofs, parse the mount source from source (for example drvfsC or drvfsaC).

// If the file system isn't Plan 9, virtiofs, or DrvFs, skip this mount.

//

std::string MountSource;

if (strcmp(MountEnum.Current().FileSystemType, PLAN9_FS_TYPE) == 0)

{

MountSource = UtilParsePlan9MountSource(MountEnum.Current().SuperOptions);

if (MountSource.empty())

{

continue;

}

MountEnum.Current().Source = MountSource.data();

}

else if (strcmp(MountEnum.Current().FileSystemType, VIRTIO_FS_TYPE) == 0)

{

MountSource = UtilParseVirtiofsMountSource(MountEnum.Current().Source);

if (MountSource.empty())

{

continue;

}

MountEnum.Current().Source = MountSource.data();

}

else if (strcmp(MountEnum.Current().FileSystemType, DRVFS_FS_TYPE) == 0)

{

//

// The mount source is a Windows path and may use forward slashes;

// flip them to backslashes.

//

UtilCanonicalisePathSeparator(MountEnum.Current().Source, PATH_SEP_NT);

}

else

{

continue;

}

//

// Strip the trailing backslash if present.

//

size_t Length = strlen(MountEnum.Current().Source);

if ((Length > 0) && (MountEnum.Current().Source[Length - 1] == PATH_SEP_NT))

{

MountEnum.Current().Source[Length - 1] = '\0';

}

//

// For bind mounts, use the concatenation of the mount source and root

// of the mount as the mount source string.

//

std::string CombinedMountSource;

if (strcmp(MountEnum.Current().Root, "/") != 0)

{

CombinedMountSource += MountEnum.Current().Source;

CombinedMountSource += MountEnum.Current().Root;

UtilCanonicalisePathSeparator(CombinedMountSource, PATH_SEP_NT);

MountEnum.Current().Source = CombinedMountSource.data();

}

//

// Check if the match field is a prefix of the path.

//

// N.B. For Windows paths, only matches longer than the existing match

// are considered. This is because Windows mounts aren't

// guaranteed to be in order and NTFS directory mounts should be

// preferred over plain drive letter mounts if they match.

//

Length = UtilIsPathPrefix(Path, *MatchField, WinPath);

if ((Length == 0) || ((WinPath != false) && (Length < FoundPrefixLength)))

{

continue;

}

//

// Store the length of the prefix so the caller can strip it from the

// string.

//

FoundPrefixLength = Length;

//

// Store the replacement.

//

FoundReplacement = *ReplacementField;

//

// Continue searching the file even if a mount has been found, since

// newer mounts could shadow this one or be a nested mount.

//

}

if (!FoundReplacement.empty() && PrefixLength != nullptr)

{

*PrefixLength = FoundPrefixLength;

}

return FoundReplacement;

}

catch (...)

{

LOG_CAUGHT_EXCEPTION();

return {};