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

except ImportError:

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_TIMEOUT = 0x00000102

    WAIT_OBJECT_0 = 0x00000000

    class OVERLAPPED(ctypes.Structure):

        _fields_ = [

            ("Offset", wintypes.DWORD), ("OffsetHigh", wintypes.DWORD),

            ("hEvent", wintypes.HANDLE)

        ]

        def __init__(self):

            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

    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

    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

class WatchmanError(Exception):

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

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

            self.buf = [b]

            return line

        while True:

            b = self.readBytes(4096)

                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:

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

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)

        if self.pipe == INVALID_HANDLE_VALUE:

            self.pipe = None

            self._raise_win_err('failed to open pipe %s' % sockpath,

                                GetLastError())