//===-- ConnectionFileDescriptorPosix.h -------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_Host_posix_ConnectionFileDescriptorPosix_h_
#define liblldb_Host_posix_ConnectionFileDescriptorPosix_h_

// C++ Includes
#include <atomic>
#include <memory>
#include <mutex>

#include "lldb/lldb-forward.h"

// Other libraries and framework includes
// Project includes
#include "lldb/Host/Pipe.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Utility/Connection.h"
#include "lldb/Utility/IOObject.h"

namespace lldb_private {

class Status;
class Socket;
class SocketAddress;

class ConnectionFileDescriptor : public Connection {
public:
  static const char *LISTEN_SCHEME;
  static const char *ACCEPT_SCHEME;
  static const char *UNIX_ACCEPT_SCHEME;
  static const char *CONNECT_SCHEME;
  static const char *TCP_CONNECT_SCHEME;
  static const char *UDP_SCHEME;
  static const char *UNIX_CONNECT_SCHEME;
  static const char *UNIX_ABSTRACT_CONNECT_SCHEME;
  static const char *FD_SCHEME;
  static const char *FILE_SCHEME;

  ConnectionFileDescriptor(bool child_processes_inherit = false);

  ConnectionFileDescriptor(int fd, bool owns_fd);

  ConnectionFileDescriptor(Socket *socket);

  ~ConnectionFileDescriptor() override;

  bool IsConnected() const override;

  lldb::ConnectionStatus Connect(llvm::StringRef s, Status *error_ptr) override;

  lldb::ConnectionStatus Disconnect(Status *error_ptr) override;

  size_t Read(void *dst, size_t dst_len, const Timeout<std::micro> &timeout,
              lldb::ConnectionStatus &status, Status *error_ptr) override;

  size_t Write(const void *src, size_t src_len, lldb::ConnectionStatus &status,
               Status *error_ptr) override;

  std::string GetURI() override;

  lldb::ConnectionStatus BytesAvailable(const Timeout<std::micro> &timeout,
                                        Status *error_ptr);

  bool InterruptRead() override;

  lldb::IOObjectSP GetReadObject() override { return m_read_sp; }

  uint16_t GetListeningPort(uint32_t timeout_sec);

  bool GetChildProcessesInherit() const;
  void SetChildProcessesInherit(bool child_processes_inherit);

protected:
  void OpenCommandPipe();

  void CloseCommandPipe();

  lldb::ConnectionStatus SocketListenAndAccept(llvm::StringRef host_and_port,
                                               Status *error_ptr);

  lldb::ConnectionStatus ConnectTCP(llvm::StringRef host_and_port,
                                    Status *error_ptr);

  lldb::ConnectionStatus ConnectUDP(llvm::StringRef args, Status *error_ptr);

  lldb::ConnectionStatus NamedSocketConnect(llvm::StringRef socket_name,
                                            Status *error_ptr);

  lldb::ConnectionStatus NamedSocketAccept(llvm::StringRef socket_name,
                                           Status *error_ptr);

  lldb::ConnectionStatus UnixAbstractSocketConnect(llvm::StringRef socket_name,
                                                   Status *error_ptr);

  lldb::IOObjectSP m_read_sp;
  lldb::IOObjectSP m_write_sp;

  Predicate<uint16_t>
      m_port_predicate; // Used when binding to port zero to wait for the thread
                        // that creates the socket, binds and listens to resolve
                        // the port number.

  Pipe m_pipe;
  std::recursive_mutex m_mutex;
  std::atomic<bool> m_shutting_down; // This marks that we are shutting down so
                                     // if we get woken up from
  // BytesAvailable to disconnect, we won't try to read again.
  bool m_waiting_for_accept;
  bool m_child_processes_inherit;

  std::string m_uri;

private:
  void InitializeSocket(Socket *socket);

  DISALLOW_COPY_AND_ASSIGN(ConnectionFileDescriptor);
};

} // namespace lldb_private

#endif // liblldb_ConnectionFileDescriptor_h_