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