net-syscalls.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef NET_SYSCALLS_H
#define NET_SYSCALLS_H
 
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/OperationBarrier.h"
#include "pedigree/kernel/process/Readiness.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Tree.h"
 
#include "logging.h"
#include "modules/subsys/posix/UnixFilesystem.h"
#include "network-namespace.h"
#include <sys/socket.h>
#include <sys/types.h>
 
// Must be after sys/types.h to avoid problems with endian.h
#include "modules/system/lwip/include/lwip/api.h"
 
extern Filesystem* g_pUnixSocketBacking;
 
struct sockaddr;
struct pbuf;
struct netbuf;
struct netconn;
 
class Semaphore;
class MqueueNetlinkSocket;
class FileDescriptor;
class DescriptorLease;
class UnixSocket;
class UnixSocketGeneration;
class UnixSocketReference;
class Process;
class Thread;
class Event;
 
bool finishInterruptibleSocketCall(Thread* thread, ssize_t result);
bool finishInterruptibleSocketCall(Thread* thread, bool result) = delete;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
using UnixEndpointMutationLockHook = void (*)();
using UnixEndpointReadinessLeaseHook = void (*)();
void setUnixEndpointMutationLockHookForTest(UnixEndpointMutationLockHook hook);
void setUnixEndpointReadinessLeaseHookForTest(UnixEndpointReadinessLeaseHook hook);
#endif
 
ssize_t posix_send_descriptor(const DescriptorLease& descriptor, const void* buffer,
                              size_t bufferLength, int flags, bool kernelBuffer = false);
ssize_t posix_recv_descriptor(const DescriptorLease& descriptor, void* buffer, size_t bufferLength,
                              int flags);
ssize_t posix_sendmsg_descriptor(
    const DescriptorLease& descriptor, const struct msghdr* message,
    const SharedPointer<SocketRights>& rights = SharedPointer<SocketRights>(),
    bool kernelBuffer = false);
ssize_t posix_recvmsg_descriptor(const DescriptorLease& descriptor, struct msghdr* message,
                                 SharedPointer<SocketRights>* rights = nullptr);
 
class NetworkSyscalls : public ReadinessSource {
 public:
  NetworkSyscalls(int domain, int type, int protocol);
  virtual ~NetworkSyscalls();
 
  virtual MqueueNetlinkSocket* asMqueueNetlink() {
    return nullptr;
  }
  virtual bool create();
  virtual int connect(const struct sockaddr_storage* address, socklen_t addrlen) = 0;
 
  virtual ssize_t sendto_msg(const struct msghdr* msghdr,
                             const SharedPointer<SocketRights>& rights) = 0;
  virtual ssize_t recvfrom_msg(struct msghdr* msghdr, SharedPointer<SocketRights>* rights) = 0;
 
  virtual ssize_t sendto(const void* buffer, size_t bufferlen, int flags,
                         const struct sockaddr_storage* address, socklen_t addrlen);
  virtual ssize_t recvfrom(void* buffer, size_t bufferlen, int flags,
                           struct sockaddr_storage* address, socklen_t* addrlen);
 
  virtual int listen(int backlog) = 0;
  virtual int bind(const struct sockaddr_storage* address, socklen_t addrlen) = 0;
  virtual int accept(struct sockaddr_storage* address, socklen_t* addrlen, int flags,
                     DescriptorLease* accepted = nullptr) = 0;
 
  virtual int shutdown(int how);
 
  virtual int getpeername(struct sockaddr_storage* address, socklen_t* address_len) = 0;
  virtual int getsockname(struct sockaddr_storage* address, socklen_t* address_len) = 0;
 
  virtual int setsockopt(int level, int optname, const void* optvalue, socklen_t optlen) = 0;
  virtual int getsockopt(int level, int optname, void* optvalue, socklen_t* optlen) = 0;
 
  virtual bool canPoll() const;
  virtual bool poll(bool& read, bool& write, bool& error, Semaphore* waiter);
  virtual void unPoll(Semaphore* waiter);
 
  virtual ReadyMask queryReady(bool reading, bool writing);
  ReadinessGenerations readinessGenerations() override;
 
  MUST_USE_RESULT bool addDescriptorOwner();
  void removeDescriptorOwner();
 
  void retainDescriptorLifetime(const SharedPointer<NetworkSyscalls>& lifetime);
 
  virtual void lastDescriptorClosed();
 
  virtual bool monitor(Thread* pThread, Event* pEvent);
  virtual bool unmonitor(Event* pEvent);
 
  void associate(FileDescriptor* fd);
 
  int getDomain() const {
    return m_Domain;
  }
 
  int getType() const {
    return m_Type;
  }
 
  int getProtocol() const {
    return m_Protocol;
  }
 
  const NetworkNamespaceRef& networkNamespace() const {
    return m_NetworkNamespace;
  }
 
  bool isBlocking() const;
 
  virtual void setBlocking(bool blocking);
 
  int takeReceiveError();
  void deferReceiveError(int error);
 
 protected:
  virtual bool usesLocalEndpointLifetime() const {
    return false;
  }
  ReadyMask pendingReceiveReadiness() const;
  ReadinessGenerations withReceiveErrorGeneration(ReadinessGenerations generations) const;
 
  bool beginDescriptorClose();
 
  bool hasLastDescriptorClosed() const;
 
  SharedPointer<NetworkSyscalls> acquireDescriptorLifetime() const;
  SharedPointer<NetworkSyscalls> releaseDescriptorLifetime();
 
  int m_Domain;
  int m_Type;
  int m_Protocol;
  NetworkNamespaceRef m_NetworkNamespace;
 
  Atomic<bool> m_Blocking;
  mutable Mutex m_ReceiveErrorLock;
  int m_ReceiveError = 0;
  uint64_t m_ReceiveErrorGeneration = 0;
 
  OperationBarrier m_ReadinessNotifications;
 
 private:
  mutable Mutex m_LifecycleLock;
  size_t m_DescriptorOwners;
  bool m_DescriptorAdmissionOpen;
  bool m_LastDescriptorClosed;
  SharedPointer<NetworkSyscalls> m_DescriptorLifetime;
};
 
class LwipSocketSyscalls : public NetworkSyscalls {
 public:
  LwipSocketSyscalls(int domain, int type, int protocol);
  virtual ~LwipSocketSyscalls();
 
  virtual bool create();
  virtual int connect(const struct sockaddr_storage* address, socklen_t addrlen);
 
  virtual ssize_t sendto_msg(const struct msghdr* msghdr,
                             const SharedPointer<SocketRights>& rights);
  virtual ssize_t recvfrom_msg(struct msghdr* msghdr, SharedPointer<SocketRights>* rights);
 
  virtual int listen(int backlog);
  virtual int bind(const struct sockaddr_storage* address, socklen_t addrlen);
  virtual int accept(struct sockaddr_storage* address, socklen_t* addrlen, int flags,
                     DescriptorLease* accepted = nullptr);
 
  virtual int shutdown(int how);
 
  virtual int getpeername(struct sockaddr_storage* address, socklen_t* address_len);
  virtual int getsockname(struct sockaddr_storage* address, socklen_t* address_len);
 
  virtual int setsockopt(int level, int optname, const void* optvalue, socklen_t optlen);
  virtual int getsockopt(int level, int optname, void* optvalue, socklen_t* optlen);
 
  virtual bool canPoll() const;
  virtual bool poll(bool& read, bool& write, bool& error, Semaphore* waiter);
  virtual void unPoll(Semaphore* waiter);
  virtual ReadyMask queryReady(bool reading, bool writing);
  ReadinessGenerations readinessGenerations() override;
  virtual void lastDescriptorClosed();
 
  virtual void setBlocking(bool blocking);
 
 private:
  static Tree<struct netconn*, LwipSocketSyscalls*> m_SyscallObjects;
  static Mutex m_SyscallObjectsLock;
 
  static void netconnCallback(struct netconn* conn, enum netconn_evt evt, uint16_t len);
  static void lwipToSyscallError(err_t err);
  void registerSocket();
  ReadyMask readinessLevelLocked() const;
  void recordReadinessRisesLocked(ReadyMask previous);
 
  struct netconn* m_Socket;
  Mutex m_ReceiveLock;
 
  struct LwipMetadata {
    LwipMetadata();
 
    ssize_t recv;
    ssize_t send;
    err_t error;
    bool closed;
    bool peerClosed;
    bool writeClosed;
    bool listening;
    bool partialRead;
    bool receivingQueuedData;
 
    Mutex lock;
    List<Semaphore*> semaphores;
 
    size_t offset;
    struct pbuf* pb;
    struct netbuf* buf;
    ReadinessGenerations generations;
  } m_Metadata;
};
 
class UnixSocketSyscalls : public NetworkSyscalls {
 public:
  UnixSocketSyscalls(int domain, int type, int protocol);
  virtual ~UnixSocketSyscalls();
 
  virtual bool create();
  virtual int connect(const struct sockaddr_storage* address, socklen_t addrlen);
 
  virtual ssize_t sendto_msg(const struct msghdr* msghdr,
                             const SharedPointer<SocketRights>& rights);
  virtual ssize_t recvfrom_msg(struct msghdr* msghdr, SharedPointer<SocketRights>* rights);
 
  virtual int listen(int backlog);
  virtual int bind(const struct sockaddr_storage* address, socklen_t addrlen);
  virtual int accept(struct sockaddr_storage* address, socklen_t* addrlen, int flags,
                     DescriptorLease* accepted = nullptr);
 
  virtual int shutdown(int how);
 
  virtual int getpeername(struct sockaddr_storage* address, socklen_t* address_len);
  virtual int getsockname(struct sockaddr_storage* address, socklen_t* address_len);
 
  virtual int setsockopt(int level, int optname, const void* optvalue, socklen_t optlen);
  virtual int getsockopt(int level, int optname, void* optvalue, socklen_t* optlen);
 
  virtual bool canPoll() const;
  virtual bool poll(bool& read, bool& write, bool& error, Semaphore* waiter);
  virtual void unPoll(Semaphore* waiter);
  virtual ReadyMask queryReady(bool reading, bool writing);
  ReadinessGenerations readinessGenerations() override;
  virtual void lastDescriptorClosed();
 
  virtual bool monitor(Thread* pThread, Event* pEvent);
  virtual bool unmonitor(Event* pEvent);
 
  bool pairWith(UnixSocketSyscalls* other);
 
 protected:
  bool usesLocalEndpointLifetime() const override {
    return true;
  }
  virtual UnixSocketSyscalls* createAcceptedSocket();
 
 private:
  friend class UnixSocketGeneration;
  friend bool runHostedUnixEndpointLifetimeRegression(Process* process);
 
  // Endpoint generations and their ownership must not be duplicated implicitly.
  NOT_COPYABLE_OR_ASSIGNABLE(UnixSocketSyscalls);
 
  static Tree<UnixSocket*, UnixSocketSyscalls*> m_SyscallObjects;
  static Tree<UnixSocket*, UnixSocket*> m_Peers;
  static Tree<UnixSocket*, UnixSocket*> m_PendingListeners;
  static Mutex m_SyscallObjectsLock;
  class EndpointMutationGuard {
   public:
    explicit EndpointMutationGuard(UnixSocketSyscalls& socket);
    ~EndpointMutationGuard();
 
   private:
    UnixSocketSyscalls& m_Socket;
    LockGuard<Mutex> m_Guard;
  };
 
  class EndpointMutationPairGuard {
   public:
    EndpointMutationPairGuard(UnixSocketSyscalls& first, UnixSocketSyscalls& second);
    ~EndpointMutationPairGuard();
 
   private:
    UnixSocketSyscalls& m_First;
    UnixSocketSyscalls& m_Second;
    LockGuard<Mutex> m_FirstGuard;
    LockGuard<Mutex> m_SecondGuard;
  };
 
  class EndpointReadinessGuard {
   public:
    EndpointReadinessGuard();
    explicit EndpointReadinessGuard(UnixSocketSyscalls& socket);
    ~EndpointReadinessGuard();
 
    MUST_USE_RESULT bool acquire(UnixSocketSyscalls& socket);
 
    explicit operator bool() const {
      return m_Acquired;
    }
 
   private:
    UnixSocketSyscalls* m_Socket;
    SharedPointer<NetworkSyscalls> m_Lifetime;
    OperationBarrier::Lease m_Lease;
    bool m_Acquired;
  };
 
  void registerSocket(UnixSocket* socket);
  void registerPeer(UnixSocket* socket, UnixSocket* peer, UnixSocket* listener = nullptr);
  void unregisterPeer(UnixSocket* socket, UnixSocket* peer);
  static void unregisterSocket(UnixSocket* socket, List<UnixSocket*>& peers);
  void notifyPeer(UnixSocket* socket, ReadyMask mask);
  static void notifySocket(UnixSocket* socket, ReadyMask mask);
  String abstractKey(const String& address) const;
  bool publishAbstractSocket(const String& address,
                             const SharedPointer<UnixSocketReference>& reference);
  SharedPointer<UnixSocketReference> acquireSocket(const String& address);
  void removeAbstractSocket(const String& address, UnixSocket* socket);
 
  SharedPointer<UnixSocketGeneration> acquireLocalEndpoint() const;
  void replaceLocalEndpoint(UnixSocket* socket, bool tracked, const String* localPath = nullptr);
  void replaceLocalEndpoint(const SharedPointer<UnixSocketReference>& reference,
                            const String* localPath, bool ownsAbstractName);
  void tryCompleteEndpointClose();
 
  UnixSocket::SocketType getSocketType() const;
 
  mutable Mutex m_EndpointStateLock;
  Mutex m_EndpointMutationLock;
  Atomic<bool> m_EndpointMutationReleaseInProgress;
  Atomic<bool> m_EndpointClosePending;
  Atomic<bool> m_EndpointRetired;
  Atomic<bool> m_EndpointCloseFinalized;
  SharedPointer<UnixSocketGeneration> m_LocalEndpoint;
  SharedPointer<UnixSocketReference> m_RemoteEndpoint;
  SharedPointer<UnixSocketGeneration> m_ClosingLocalEndpoint;
  SharedPointer<UnixSocketReference> m_ClosingRemoteEndpoint;
 
  String m_LocalPath;
  String m_RemotePath;
  bool m_OwnsAbstractName;
};
 
struct netconnMetadata* getNetconnMetadata(struct netconn* conn);
 
int posix_socket(int domain, int type, int protocol);
int posix_socketpair(int domain, int type, int protocol, int sv[2]);
int posix_connect(int sock, const struct sockaddr_storage* address, socklen_t addrlen);
 
ssize_t posix_send(int sock, const void* buff, size_t bufflen, int flags);
ssize_t posix_sendto(int sock, const void* buff, size_t bufflen, int flags,
                     struct sockaddr_storage* address, socklen_t addrlen);
ssize_t posix_recv(int sock, void* buff, size_t bufflen, int flags);
ssize_t posix_recvfrom(int sock, void* buff, size_t bufflen, int flags,
                       struct sockaddr_storage* address, socklen_t* addrlen);
 
int posix_listen(int sock, int backlog);
int posix_bind(int sock, const struct sockaddr_storage* address, socklen_t addrlen);
int posix_accept(int sock, struct sockaddr_storage* address, socklen_t* addrlen);
int posix_accept4(int sock, struct sockaddr_storage* address, socklen_t* addrlen, int flags);
 
int posix_shutdown(int socket, int how);
 
int posix_getpeername(int socket, struct sockaddr_storage* address, socklen_t* address_len);
int posix_getsockname(int socket, struct sockaddr_storage* address, socklen_t* address_len);
 
int posix_setsockopt(int sock, int level, int optname, const void* optvalue, socklen_t optlen);
int posix_getsockopt(int sock, int level, int optname, void* optvalue, socklen_t* optlen);
 
int posix_sethostname(const char* name, size_t len);
 
ssize_t posix_sendmsg(int sockfd, const struct msghdr* msg, int flags);
ssize_t posix_recvmsg(int sockfd, struct msghdr* msg, int flags);
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
bool runHostedUnixEndpointLifetimeRegression(Process* process);
#endif
 
#endif