Home | History | Annotate | Download | only in socket 
      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 "base/memory/ref_counted.h"
     14 #include "build/build_config.h"
     15 #include "net/base/net_export.h"
     16 #include "net/socket/stream_listen_socket.h"
     17 
     18 #if defined(OS_ANDROID) || defined(OS_LINUX)
     19 // Feature only supported on Linux currently. This lets the Unix Domain Socket
     20 // not be backed by the file system.
     21 #define SOCKET_ABSTRACT_NAMESPACE_SUPPORTED
     22 #endif
     23 
     24 namespace net {
     25 
     26 // Unix Domain Socket Implementation. Supports abstract namespaces on Linux.
     27 class NET_EXPORT UnixDomainSocket : public StreamListenSocket {
     28  public:
     29   // Callback that returns whether the already connected client, identified by
     30   // its process |user_id| and |group_id|, is allowed to keep the connection
     31   // open. Note that the socket is closed immediately in case the callback
     32   // returns false.
     33   typedef base::Callback<bool (uid_t user_id, gid_t group_id)> AuthCallback;
     34 
     35   // Returns an authentication callback that always grants access for
     36   // convenience in case you don't want to use authentication.
     37   static AuthCallback NoAuthentication();
     38 
     39   // Note that the returned UnixDomainSocket instance does not take ownership of
     40   // |del|.
     41   static scoped_refptr<UnixDomainSocket> CreateAndListen(
     42       const std::string& path,
     43       StreamListenSocket::Delegate* del,
     44       const AuthCallback& auth_callback);
     45 
     46 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
     47   // Same as above except that the created socket uses the abstract namespace
     48   // which is a Linux-only feature. If |fallback_path| is not empty,
     49   // make the second attempt with the provided fallback name.
     50   static scoped_refptr<UnixDomainSocket> CreateAndListenWithAbstractNamespace(
     51       const std::string& path,
     52       const std::string& fallback_path,
     53       StreamListenSocket::Delegate* del,
     54       const AuthCallback& auth_callback);
     55 #endif
     56 
     57  private:
     58   UnixDomainSocket(SocketDescriptor s,
     59                    StreamListenSocket::Delegate* del,
     60                    const AuthCallback& auth_callback);
     61   virtual ~UnixDomainSocket();
     62 
     63   static 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_refptr<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_refptr<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_
    127