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_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_ | |
OLD | NEW |