Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(464)

Side by Side Diff: net/socket/unix_domain_listen_socket_posix.h

Issue 296053012: Replace StreamListenSocket with StreamSocket in HttpServer. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Don't export HttpServer which is built in a static lib Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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_
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698