# Copyright 2014-present Facebook, Inc.

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are met:

#

#  * Redistributions of source code must retain the above copyright notice,

#    this list of conditions and the following disclaimer.

#

#  * Redistributions in binary form must reproduce the above copyright notice,

#    this list of conditions and the following disclaimer in the documentation

#    and/or other materials provided with the distribution.

#

#  * Neither the name Facebook nor the names of its contributors may be used to

#    endorse or promote products derived from this software without specific

#    prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import inspect

import math

import os

import socket

import subprocess

import time

from . import capabilities, compat, encoding, load

# Sometimes it's really hard to get Python extensions to compile,

# so fall back to a pure Python implementation.

try:

    from . import bser

    # Demandimport causes modules to be loaded lazily. Force the load now

    # so that we can fall back on pybser if bser doesn't exist

    bser.pdu_info

except ImportError:

    from . import pybser as bser

if os.name == "nt":

    import ctypes

    import ctypes.wintypes

    wintypes = ctypes.wintypes

    GENERIC_READ = 0x80000000

    GENERIC_WRITE = 0x40000000

    FILE_FLAG_OVERLAPPED = 0x40000000

    OPEN_EXISTING = 3

    INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value

    FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000

    FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x00000100

    FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200

    WAIT_FAILED = 0xFFFFFFFF

    WAIT_TIMEOUT = 0x00000102

    WAIT_OBJECT_0 = 0x00000000

    WAIT_IO_COMPLETION = 0x000000C0

    INFINITE = 0xFFFFFFFF

    # Overlapped I/O operation is in progress. (997)

    ERROR_IO_PENDING = 0x000003E5

    # The pointer size follows the architecture

    # We use WPARAM since this type is already conditionally defined

    ULONG_PTR = ctypes.wintypes.WPARAM

    class OVERLAPPED(ctypes.Structure):

        _fields_ = [

            ("Internal", ULONG_PTR),

            ("InternalHigh", ULONG_PTR),

            ("Offset", wintypes.DWORD),

            ("OffsetHigh", wintypes.DWORD),

            ("hEvent", wintypes.HANDLE),

        ]

        def __init__(self):

            self.Internal = 0

            self.InternalHigh = 0

            self.Offset = 0

            self.OffsetHigh = 0

            self.hEvent = 0

    LPDWORD = ctypes.POINTER(wintypes.DWORD)

    _kernel32 = ctypes.windll.kernel32  # pytype: disable=module-attr

    CreateFile = _kernel32.CreateFileA

    CreateFile.argtypes = [

        wintypes.LPSTR,

        wintypes.DWORD,

        wintypes.DWORD,

        wintypes.LPVOID,

        wintypes.DWORD,

        wintypes.DWORD,

        wintypes.HANDLE,

    ]

    CreateFile.restype = wintypes.HANDLE

    CloseHandle = _kernel32.CloseHandle

    CloseHandle.argtypes = [wintypes.HANDLE]

    CloseHandle.restype = wintypes.BOOL

    ReadFile = _kernel32.ReadFile

    ReadFile.argtypes = [

        wintypes.HANDLE,

        wintypes.LPVOID,

        wintypes.DWORD,

        LPDWORD,

        ctypes.POINTER(OVERLAPPED),

    ]

    ReadFile.restype = wintypes.BOOL

    WriteFile = _kernel32.WriteFile

    WriteFile.argtypes = [

        wintypes.HANDLE,

        wintypes.LPVOID,

        wintypes.DWORD,

        LPDWORD,

        ctypes.POINTER(OVERLAPPED),

    ]

    WriteFile.restype = wintypes.BOOL

    GetLastError = _kernel32.GetLastError

    GetLastError.argtypes = []

    GetLastError.restype = wintypes.DWORD

    SetLastError = _kernel32.SetLastError

    SetLastError.argtypes = [wintypes.DWORD]

    SetLastError.restype = None

    FormatMessage = _kernel32.FormatMessageA

    FormatMessage.argtypes = [

        wintypes.DWORD,

        wintypes.LPVOID,

        wintypes.DWORD,

        wintypes.DWORD,

        ctypes.POINTER(wintypes.LPSTR),

        wintypes.DWORD,

        wintypes.LPVOID,

    ]

    FormatMessage.restype = wintypes.DWORD

    LocalFree = _kernel32.LocalFree

    GetOverlappedResult = _kernel32.GetOverlappedResult

    GetOverlappedResult.argtypes = [

        wintypes.HANDLE,

        ctypes.POINTER(OVERLAPPED),

        LPDWORD,

        wintypes.BOOL,

    ]

    GetOverlappedResult.restype = wintypes.BOOL

    GetOverlappedResultEx = getattr(_kernel32, "GetOverlappedResultEx", None)

    if GetOverlappedResultEx is not None:

        GetOverlappedResultEx.argtypes = [

            wintypes.HANDLE,

            ctypes.POINTER(OVERLAPPED),

            LPDWORD,

            wintypes.DWORD,

            wintypes.BOOL,

        ]

        GetOverlappedResultEx.restype = wintypes.BOOL

    WaitForSingleObjectEx = _kernel32.WaitForSingleObjectEx

    WaitForSingleObjectEx.argtypes = [

        wintypes.HANDLE,

        wintypes.DWORD,

        wintypes.BOOL,

    ]

    WaitForSingleObjectEx.restype = wintypes.DWORD

    CreateEvent = _kernel32.CreateEventA

    CreateEvent.argtypes = [

        LPDWORD,

        wintypes.BOOL,

        wintypes.BOOL,

        wintypes.LPSTR,

    ]

    CreateEvent.restype = wintypes.HANDLE

    # Windows Vista is the minimum supported client for CancelIoEx.

    CancelIoEx = _kernel32.CancelIoEx

    CancelIoEx.argtypes = [wintypes.HANDLE, ctypes.POINTER(OVERLAPPED)]

    CancelIoEx.restype = wintypes.BOOL

# 2 bytes marker, 1 byte int size, 8 bytes int64 value

sniff_len = 13

# This is a helper for debugging the client.

_debugging = False

if _debugging:

    def log(fmt, *args):

        print(

            "[%s] %s"

            % (

                time.strftime("%a, %d %b %Y %H:%M:%S", time.gmtime()),

                fmt % args[:],

            )

        )

else:

    def log(fmt, *args):

        pass

def _win32_strerror(err):

    """expand a win32 error code into a human readable message"""

    # FormatMessage will allocate memory and assign it here

    buf = ctypes.c_char_p()

    FormatMessage(

        FORMAT_MESSAGE_FROM_SYSTEM

        | FORMAT_MESSAGE_ALLOCATE_BUFFER

        | FORMAT_MESSAGE_IGNORE_INSERTS,

        None,

        err,

        0,

        buf,

        0,

        None,

    )

    try:

        return buf.value

    finally:

        LocalFree(buf)

class WatchmanError(Exception):

    def __init__(self, msg=None, cmd=None):

        self.msg = msg

        self.cmd = cmd

    def setCommand(self, cmd):

        self.cmd = cmd

    def __str__(self):

        if self.cmd:

            return "%s, while executing %s" % (self.msg, self.cmd)

        return self.msg

class BSERv1Unsupported(WatchmanError):

    pass

class UseAfterFork(WatchmanError):

    pass

class WatchmanEnvironmentError(WatchmanError):

    def __init__(self, msg, errno, errmsg, cmd=None):

        super(WatchmanEnvironmentError, self).__init__(

            "{0}: errno={1} errmsg={2}".format(msg, errno, errmsg), cmd

        )

class SocketConnectError(WatchmanError):

    def __init__(self, sockpath, exc):

        super(SocketConnectError, self).__init__(

            "unable to connect to %s: %s" % (sockpath, exc)

        )

        self.sockpath = sockpath

        self.exc = exc

class SocketTimeout(WatchmanError):

    """A specialized exception raised for socket timeouts during communication to/from watchman.

    This makes it easier to implement non-blocking loops as callers can easily distinguish

    between a routine timeout and an actual error condition.

    Note that catching WatchmanError will also catch this as it is a super-class, so backwards

    compatibility in exception handling is preserved.

    """

class CommandError(WatchmanError):

    """error returned by watchman

    self.msg is the message returned by watchman.

    """

    def __init__(self, msg, cmd=None):

        super(CommandError, self).__init__(

            "watchman command error: %s" % (msg,), cmd

        )

class Transport:

    """communication transport to the watchman server"""

    buf = None

    def close(self):

        """tear it down"""

        raise NotImplementedError()

    def readBytes(self, size):

        """read size bytes"""

        raise NotImplementedError()

    def write(self, buf):

        """write some data"""

        raise NotImplementedError()

    def setTimeout(self, value):

        pass

    def readLine(self):

        """read a line

        Maintains its own buffer, callers of the transport should not mix

        calls to readBytes and readLine.

        """

        if self.buf is None:

            self.buf = []

        # Buffer may already have a line if we've received unilateral

        # response(s) from the server

        if len(self.buf) == 1 and b"\n" in self.buf[0]:

            (line, b) = self.buf[0].split(b"\n", 1)

            self.buf = [b]

            return line

        while True:

            b = self.readBytes(4096)

            if b"\n" in b:

                result = b"".join(self.buf)

                (line, b) = b.split(b"\n", 1)

                self.buf = [b]

                return result + line

            self.buf.append(b)

class Codec:

    """communication encoding for the watchman server"""

    transport = None

    def __init__(self, transport):

        self.transport = transport

    def receive(self):

        raise NotImplementedError()

    def send(self, *args):

        raise NotImplementedError()

    def setTimeout(self, value):

        self.transport.setTimeout(value)

class UnixSocketTransport(Transport):

    """local unix domain socket transport"""

    sock = None

    def __init__(self, sockpath, timeout):

        self.sockpath = sockpath

        self.timeout = timeout

        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

        try:

            sock.settimeout(self.timeout)

            sock.connect(self.sockpath)

            self.sock = sock

        except socket.error as e:

            sock.close()

            raise SocketConnectError(self.sockpath, e)

    def close(self):

        if self.sock:

            self.sock.close()

            self.sock = None

    def setTimeout(self, value):

        self.timeout = value

        self.sock.settimeout(self.timeout)

    def readBytes(self, size):

        try:

            buf = [self.sock.recv(size)]

            if not buf[0]:

                raise WatchmanError("empty watchman response")

            return buf[0]

        except socket.timeout:

            raise SocketTimeout("timed out waiting for response")

    def write(self, data):

        try:

            self.sock.sendall(data)

        except socket.timeout:

            raise SocketTimeout("timed out sending query command")

def _get_overlapped_result_ex_impl(pipe, olap, nbytes, millis, alertable):

    """Windows 7 and earlier does not support GetOverlappedResultEx. The

    alternative is to use GetOverlappedResult and wait for read or write