OLD | NEW |
(Empty) | |
| 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_LISTEN_SOCKET_POSIX_H_ |
| 6 #define NET_SOCKET_UNIX_DOMAIN_LISTEN_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/macros.h" |
| 14 #include "build/build_config.h" |
| 15 #include "net/base/net_export.h" |
| 16 #include "net/socket/stream_listen_socket.h" |
| 17 #include "net/socket/unix_domain_server_socket_posix.h" |
| 18 |
| 19 #if defined(OS_ANDROID) || defined(OS_LINUX) |
| 20 // Feature only supported on Linux currently. This lets the Unix Domain Socket |
| 21 // not be backed by the file system. |
| 22 #define SOCKET_ABSTRACT_NAMESPACE_SUPPORTED |
| 23 #endif |
| 24 |
| 25 namespace net { |
| 26 namespace deprecated { |
| 27 |
| 28 // Unix Domain Socket Implementation. Supports abstract namespaces on Linux. |
| 29 class NET_EXPORT UnixDomainListenSocket : public StreamListenSocket { |
| 30 public: |
| 31 typedef UnixDomainServerSocket::AuthCallback AuthCallback; |
| 32 |
| 33 virtual ~UnixDomainListenSocket(); |
| 34 |
| 35 // Note that the returned UnixDomainListenSocket instance does not take |
| 36 // ownership of |del|. |
| 37 static scoped_ptr<UnixDomainListenSocket> CreateAndListen( |
| 38 const std::string& path, |
| 39 StreamListenSocket::Delegate* del, |
| 40 const AuthCallback& auth_callback); |
| 41 |
| 42 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED) |
| 43 // Same as above except that the created socket uses the abstract namespace |
| 44 // which is a Linux-only feature. If |fallback_path| is not empty, |
| 45 // make the second attempt with the provided fallback name. |
| 46 static scoped_ptr<UnixDomainListenSocket> |
| 47 CreateAndListenWithAbstractNamespace( |
| 48 const std::string& path, |
| 49 const std::string& fallback_path, |
| 50 StreamListenSocket::Delegate* del, |
| 51 const AuthCallback& auth_callback); |
| 52 #endif |
| 53 |
| 54 private: |
| 55 UnixDomainListenSocket(SocketDescriptor s, |
| 56 StreamListenSocket::Delegate* del, |
| 57 const AuthCallback& auth_callback); |
| 58 |
| 59 static scoped_ptr<UnixDomainListenSocket> CreateAndListenInternal( |
| 60 const std::string& path, |
| 61 const std::string& fallback_path, |
| 62 StreamListenSocket::Delegate* del, |
| 63 const AuthCallback& auth_callback, |
| 64 bool use_abstract_namespace); |
| 65 |
| 66 // StreamListenSocket: |
| 67 virtual void Accept() OVERRIDE; |
| 68 |
| 69 AuthCallback auth_callback_; |
| 70 |
| 71 DISALLOW_COPY_AND_ASSIGN(UnixDomainListenSocket); |
| 72 }; |
| 73 |
| 74 // Factory that can be used to instantiate UnixDomainListenSocket. |
| 75 class NET_EXPORT UnixDomainListenSocketFactory |
| 76 : public StreamListenSocketFactory { |
| 77 public: |
| 78 // Note that this class does not take ownership of the provided delegate. |
| 79 UnixDomainListenSocketFactory( |
| 80 const std::string& path, |
| 81 const UnixDomainListenSocket::AuthCallback& auth_callback); |
| 82 virtual ~UnixDomainListenSocketFactory(); |
| 83 |
| 84 // StreamListenSocketFactory: |
| 85 virtual scoped_ptr<StreamListenSocket> CreateAndListen( |
| 86 StreamListenSocket::Delegate* delegate) const OVERRIDE; |
| 87 |
| 88 protected: |
| 89 const std::string path_; |
| 90 const UnixDomainListenSocket::AuthCallback auth_callback_; |
| 91 |
| 92 private: |
| 93 DISALLOW_COPY_AND_ASSIGN(UnixDomainListenSocketFactory); |
| 94 }; |
| 95 |
| 96 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED) |
| 97 // Use this factory to instantiate UnixDomainListenSocket using the abstract |
| 98 // namespace feature (only supported on Linux). |
| 99 class NET_EXPORT UnixDomainListenSocketWithAbstractNamespaceFactory |
| 100 : public UnixDomainListenSocketFactory { |
| 101 public: |
| 102 UnixDomainListenSocketWithAbstractNamespaceFactory( |
| 103 const std::string& path, |
| 104 const std::string& fallback_path, |
| 105 const UnixDomainListenSocket::AuthCallback& auth_callback); |
| 106 virtual ~UnixDomainListenSocketWithAbstractNamespaceFactory(); |
| 107 |
| 108 // UnixDomainListenSocketFactory: |
| 109 virtual scoped_ptr<StreamListenSocket> CreateAndListen( |
| 110 StreamListenSocket::Delegate* delegate) const OVERRIDE; |
| 111 |
| 112 private: |
| 113 std::string fallback_path_; |
| 114 |
| 115 DISALLOW_COPY_AND_ASSIGN(UnixDomainListenSocketWithAbstractNamespaceFactory); |
| 116 }; |
| 117 #endif |
| 118 |
| 119 } // namespace deprecated |
| 120 } // namespace net |
| 121 |
| 122 #endif // NET_SOCKET_UNIX_DOMAIN_LISTEN_SOCKET_POSIX_H_ |
OLD | NEW |