net/socket/unix_domain_socket_posix.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_SOCKET_UNIX_DOMAIN_SOCKET_POSIX_H_
   6 #define NET_SOCKET_UNIX_DOMAIN_SOCKET_POSIX_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback_forward.h"
  12 #include "base/compiler_specific.h"
  13 #include "build/build_config.h"
  14 #include "net/base/net_export.h"
  15 #include "net/socket/stream_listen_socket.h"
  16
  17 #if defined(OS_ANDROID) || defined(OS_LINUX)
  18 // Feature only supported on Linux currently. This lets the Unix Domain Socket
  19 // not be backed by the file system.
  20 #define SOCKET_ABSTRACT_NAMESPACE_SUPPORTED
  21 #endif
  22
  23 namespace net {
  24
  25 // Unix Domain Socket Implementation. Supports abstract namespaces on Linux.
  26 class NET_EXPORT UnixDomainSocket : public StreamListenSocket {
  27  public:
  28   virtual ~UnixDomainSocket();
  29
  30   // Callback that returns whether the already connected client, identified by
  31   // its process |user_id| and |group_id|, is allowed to keep the connection
  32   // open. Note that the socket is closed immediately in case the callback
  33   // returns false.
  34   typedef base::Callback<bool (uid_t user_id, gid_t group_id)> AuthCallback;
  35
  36   // Returns an authentication callback that always grants access for
  37   // convenience in case you don't want to use authentication.
  38   static AuthCallback NoAuthentication();
  39
  40   // Note that the returned UnixDomainSocket instance does not take ownership of
  41   // |del|.
  42   static scoped_ptr<UnixDomainSocket> CreateAndListen(
  43       const std::string& path,
  44       StreamListenSocket::Delegate* del,
  45       const AuthCallback& auth_callback);
  46
  47 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
  48   // Same as above except that the created socket uses the abstract namespace
  49   // which is a Linux-only feature. If |fallback_path| is not empty,
  50   // make the second attempt with the provided fallback name.
  51   static scoped_ptr<UnixDomainSocket> CreateAndListenWithAbstractNamespace(
  52       const std::string& path,
  53       const std::string& fallback_path,
  54       StreamListenSocket::Delegate* del,
  55       const AuthCallback& auth_callback);
  56 #endif
  57
  58  private:
  59   UnixDomainSocket(SocketDescriptor s,
  60                    StreamListenSocket::Delegate* del,
  61                    const AuthCallback& auth_callback);
  62
  63   static scoped_ptr<UnixDomainSocket> CreateAndListenInternal(
  64       const std::string& path,
  65       const std::string& fallback_path,
  66       StreamListenSocket::Delegate* del,
  67       const AuthCallback& auth_callback,
  68       bool use_abstract_namespace);
  69
  70   static SocketDescriptor CreateAndBind(const std::string& path,
  71                                         bool use_abstract_namespace);
  72
  73   // StreamListenSocket:
  74   virtual void Accept() OVERRIDE;
  75
  76   AuthCallback auth_callback_;
  77
  78   DISALLOW_COPY_AND_ASSIGN(UnixDomainSocket);
  79 };
  80
  81 // Factory that can be used to instantiate UnixDomainSocket.
  82 class NET_EXPORT UnixDomainSocketFactory : public StreamListenSocketFactory {
  83  public:
  84   // Note that this class does not take ownership of the provided delegate.
  85   UnixDomainSocketFactory(const std::string& path,
  86                           const UnixDomainSocket::AuthCallback& auth_callback);
  87   virtual ~UnixDomainSocketFactory();
  88
  89   // StreamListenSocketFactory:
  90   virtual scoped_ptr<StreamListenSocket> CreateAndListen(
  91       StreamListenSocket::Delegate* delegate) const OVERRIDE;
  92
  93  protected:
  94   const std::string path_;
  95   const UnixDomainSocket::AuthCallback auth_callback_;
  96
  97  private:
  98   DISALLOW_COPY_AND_ASSIGN(UnixDomainSocketFactory);
  99 };
 100
 101 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
 102 // Use this factory to instantiate UnixDomainSocket using the abstract
 103 // namespace feature (only supported on Linux).
 104 class NET_EXPORT UnixDomainSocketWithAbstractNamespaceFactory
 105     : public UnixDomainSocketFactory {
 106  public:
 107   UnixDomainSocketWithAbstractNamespaceFactory(
 108       const std::string& path,
 109       const std::string& fallback_path,
 110       const UnixDomainSocket::AuthCallback& auth_callback);
 111   virtual ~UnixDomainSocketWithAbstractNamespaceFactory();
 112
 113   // UnixDomainSocketFactory:
 114   virtual scoped_ptr<StreamListenSocket> CreateAndListen(
 115       StreamListenSocket::Delegate* delegate) const OVERRIDE;
 116
 117  private:
 118   std::string fallback_path_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(UnixDomainSocketWithAbstractNamespaceFactory);
 121 };
 122 #endif
 123
 124 }  // namespace net
 125
 126 #endif  // NET_SOCKET_UNIX_DOMAIN_SOCKET_POSIX_H_