# 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.

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

# no unicode literals

import inspect

import math

import os

import socket

import subprocess

import time

# 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

from . import (

    capabilities,

    compat,

    encoding,

    load,

)

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 = -1

    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)

    CreateFile = ctypes.windll.kernel32.CreateFileA

    CreateFile.argtypes = [wintypes.LPSTR, wintypes.DWORD, wintypes.DWORD,

                           wintypes.LPVOID, wintypes.DWORD, wintypes.DWORD,

                           wintypes.HANDLE]

    CreateFile.restype = wintypes.HANDLE

    CloseHandle = ctypes.windll.kernel32.CloseHandle

    CloseHandle.argtypes = [wintypes.HANDLE]

    CloseHandle.restype = wintypes.BOOL

    ReadFile = ctypes.windll.kernel32.ReadFile

    ReadFile.argtypes = [wintypes.HANDLE, wintypes.LPVOID, wintypes.DWORD,

                         LPDWORD, ctypes.POINTER(OVERLAPPED)]

    ReadFile.restype = wintypes.BOOL

    WriteFile = ctypes.windll.kernel32.WriteFile

    WriteFile.argtypes = [wintypes.HANDLE, wintypes.LPVOID, wintypes.DWORD,

                          LPDWORD, ctypes.POINTER(OVERLAPPED)]

    WriteFile.restype = wintypes.BOOL

    GetLastError = ctypes.windll.kernel32.GetLastError

    GetLastError.argtypes = []

    GetLastError.restype = wintypes.DWORD

    SetLastError = ctypes.windll.kernel32.SetLastError

    SetLastError.argtypes = [wintypes.DWORD]

    SetLastError.restype = None

    FormatMessage = ctypes.windll.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 = ctypes.windll.kernel32.LocalFree

    GetOverlappedResult = ctypes.windll.kernel32.GetOverlappedResult

    GetOverlappedResult.argtypes = [wintypes.HANDLE,

                                    ctypes.POINTER(OVERLAPPED), LPDWORD,

                                    wintypes.BOOL]

    GetOverlappedResult.restype = wintypes.BOOL

    GetOverlappedResultEx = getattr(ctypes.windll.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 = ctypes.windll.kernel32.WaitForSingleObjectEx

    WaitForSingleObjectEx.argtypes = [wintypes.HANDLE, wintypes.DWORD, wintypes.BOOL]

    WaitForSingleObjectEx.restype = wintypes.DWORD

    CreateEvent = ctypes.windll.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 = ctypes.windll.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 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(object):

    """ 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(object):

    """ 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):

        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

    operation to complete. This is done be using CreateEvent and

    WaitForSingleObjectEx. CreateEvent, WaitForSingleObjectEx

    and GetOverlappedResult are all part of Windows API since WindowsXP.

    This is the exact same implementation that can be found in the watchman

    source code (see get_overlapped_result_ex_impl in stream_win.c). This

    way, maintenance should be simplified.

    """

    log('Preparing to wait for maximum %dms', millis )

    if millis != 0:

        waitReturnCode = WaitForSingleObjectEx(olap.hEvent, millis, alertable)

        if waitReturnCode == WAIT_OBJECT_0:

            # Event is signaled, overlapped IO operation result should be available.

            pass

        elif waitReturnCode == WAIT_IO_COMPLETION:

            # WaitForSingleObjectEx returnes because the system added an I/O completion

            # routine or an asynchronous procedure call (APC) to the thread queue.

            SetLastError(WAIT_IO_COMPLETION)

            pass

        elif waitReturnCode == WAIT_TIMEOUT:

            # We reached the maximum allowed wait time, the IO operation failed

            # to complete in timely fashion.

            SetLastError(WAIT_TIMEOUT)

            return False

        elif waitReturnCode == WAIT_FAILED:

            # something went wrong calling WaitForSingleObjectEx

            err = GetLastError()

            log('WaitForSingleObjectEx failed: %s', _win32_strerror(err))

            return False

        else:

            # unexpected situation deserving investigation.

            err = GetLastError()

            log('Unexpected error: %s', _win32_strerror(err))

            return False

    return GetOverlappedResult(pipe, olap, nbytes, False)

class WindowsNamedPipeTransport(Transport):

    """ connect to a named pipe """

    def __init__(self, sockpath, timeout):

        self.sockpath = sockpath

        self.timeout = int(math.ceil(timeout * 1000))

        self._iobuf = None

        self.pipe = CreateFile(sockpath, GENERIC_READ | GENERIC_WRITE, 0, None,

                               OPEN_EXISTING, FILE_FLAG_OVERLAPPED, None)