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

# 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

    import ctypes

    import ctypes.wintypes

    wintypes = ctypes.wintypes

    GENERIC_READ = 0x80000000

    GENERIC_WRITE = 0x40000000

    FILE_FLAG_OVERLAPPED = 0x40000000

    OPEN_EXISTING = 3

    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_ = [

        ]

        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.restype = wintypes.HANDLE

    CloseHandle = ctypes.windll.kernel32.CloseHandle

    CloseHandle.argtypes = [wintypes.HANDLE]

    CloseHandle.restype = wintypes.BOOL

    ReadFile = ctypes.windll.kernel32.ReadFile

    ReadFile.restype = wintypes.BOOL

    WriteFile = ctypes.windll.kernel32.WriteFile

    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.restype = wintypes.DWORD

    LocalFree = ctypes.windll.kernel32.LocalFree

    GetOverlappedResult = ctypes.windll.kernel32.GetOverlappedResult

    GetOverlappedResult.restype = wintypes.BOOL

    if GetOverlappedResultEx is not None:

        GetOverlappedResultEx.restype = wintypes.BOOL

    WaitForSingleObjectEx = ctypes.windll.kernel32.WaitForSingleObjectEx

    WaitForSingleObjectEx.restype = wintypes.DWORD

    CreateEvent = ctypes.windll.kernel32.CreateEventA

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

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(

    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 self.msg

class WatchmanEnvironmentError(WatchmanError):

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

        super(WatchmanEnvironmentError, self).__init__(

class SocketConnectError(WatchmanError):

    def __init__(self, sockpath, exc):

        super(SocketConnectError, self).__init__(

        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__(

        )

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:

                (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

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

    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]:

            return buf[0]

        except socket.timeout:

    def write(self, data):

        try:

            self.sock.sendall(data)

        except socket.timeout:

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