OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2014 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 #include "net/socket/unix_domain_client_socket_posix.h" | |
6 | |
7 #include <unistd.h> | |
8 | |
9 #include "base/bind.h" | |
10 #include "base/files/file_path.h" | |
11 #include "base/files/scoped_temp_dir.h" | |
12 #include "base/memory/scoped_ptr.h" | |
13 #include "net/base/io_buffer.h" | |
14 #include "net/base/net_errors.h" | |
15 #include "net/base/test_completion_callback.h" | |
16 #include "net/socket/unix_domain_server_socket_posix.h" | |
17 #include "testing/gtest/include/gtest/gtest.h" | |
18 | |
19 namespace net { | |
20 | |
21 namespace { | |
22 | |
23 const char kSocketFilename[] = "unix_domain_socket_for_testing"; | |
24 | |
25 bool UserCanConnectCallback(bool allow_user, uid_t uid, gid_t gid) { | |
26 // Here peers are running in same process. Check if they are expected. | |
mmenke
2014/07/23 18:52:40
nit: Suggest just removing the second sentence, t
byungchul
2014/07/23 22:27:11
Done.
| |
27 EXPECT_EQ(getuid(), uid); | |
28 EXPECT_EQ(getgid(), gid); | |
29 return allow_user; | |
30 } | |
31 | |
32 UnixDomainServerSocket::AuthCallback CreateAuthCallback(bool allow_user) { | |
33 return base::Bind(&UserCanConnectCallback, allow_user); | |
34 } | |
35 | |
36 // Connects socket synchronously. | |
37 int ConnectSynchronously(StreamSocket* socket) { | |
38 TestCompletionCallback connect_callback; | |
39 int rv = socket->Connect(connect_callback.callback()); | |
40 if (rv == ERR_IO_PENDING) | |
41 rv = connect_callback.WaitForResult(); | |
42 return rv; | |
43 } | |
44 | |
45 // Reads data from |socket| until it fills |buf| at least up to |min_data_len|. | |
46 // Returns length of data read, or a net error. | |
47 int ReadSynchronously(StreamSocket* socket, | |
48 IOBuffer* buf, | |
49 int buf_len, | |
50 int min_data_len) { | |
mmenke
2014/07/23 18:52:40
opetional: May want a DCHECK_LE(min_data_len, buf
byungchul
2014/07/23 22:27:11
Done.
| |
51 scoped_refptr<DrainableIOBuffer> read_buf( | |
52 new DrainableIOBuffer(buf, buf_len)); | |
53 TestCompletionCallback read_callback; | |
54 // Iterate reading several times (but not infinite) until it reads buf | |
mmenke
2014/07/23 18:52:41
nit: "reads at least |min_data_len| bytes into |b
byungchul
2014/07/23 22:27:11
Done.
| |
55 // at least up to |min_data_len|. | |
56 for (int retry_count = 10; | |
57 retry_count > 0 && (read_buf->BytesConsumed() < min_data_len || | |
58 // Try at least once when min_data_len == 0. | |
59 min_data_len == 0); | |
60 --retry_count) { | |
61 int rv = socket->Read(read_buf, read_buf->BytesRemaining(), | |
62 read_callback.callback()); | |
63 EXPECT_GE(read_buf->BytesRemaining(), rv); | |
64 if (rv == ERR_IO_PENDING) { | |
65 // If |min_data_len| is 0, returns ERR_IO_PENDING to distinguish the case | |
66 // when some data has been read. | |
67 if (min_data_len == 0) { | |
68 // No data has been read because of for-loop condition. | |
69 DCHECK_EQ(0, read_buf->BytesConsumed()); | |
70 return ERR_IO_PENDING; | |
71 } | |
72 rv = read_callback.WaitForResult(); | |
73 } | |
74 EXPECT_NE(ERR_IO_PENDING, rv); | |
75 if (rv < 0) | |
76 return rv; | |
77 read_buf->DidConsume(rv); | |
78 } | |
79 EXPECT_LE(0, read_buf->BytesRemaining()); | |
80 return read_buf->BytesConsumed(); | |
81 } | |
82 | |
83 // Writes data to |socket| until it completes writing |buf| up to |buf_len|. | |
84 // Returns length of data written, or a net error. | |
85 int WriteSynchronously(StreamSocket* socket, | |
86 IOBuffer* buf, | |
87 int buf_len) { | |
88 scoped_refptr<DrainableIOBuffer> write_buf( | |
89 new DrainableIOBuffer(buf, buf_len)); | |
90 TestCompletionCallback write_callback; | |
91 // Iterate writing several times (but not infinite) until it writes buf fully. | |
92 for (int retry_count = 10; | |
93 retry_count > 0 && write_buf->BytesRemaining() > 0; | |
94 --retry_count) { | |
95 int rv = socket->Write(write_buf, write_buf->BytesRemaining(), | |
96 write_callback.callback()); | |
97 EXPECT_GE(write_buf->BytesRemaining(), rv); | |
98 if (rv == ERR_IO_PENDING) | |
99 rv = write_callback.WaitForResult(); | |
100 EXPECT_NE(ERR_IO_PENDING, rv); | |
101 if (rv < 0) | |
102 return rv; | |
103 write_buf->DidConsume(rv); | |
104 } | |
105 EXPECT_LE(0, write_buf->BytesRemaining()); | |
106 return write_buf->BytesConsumed(); | |
107 } | |
108 | |
109 } // namespace | |
mmenke
2014/07/23 18:52:41
Could just put the entire file in the anonymous na
byungchul
2014/07/23 22:27:11
Done.
| |
110 | |
111 class UnixDomainClientSocketTest : public testing::Test { | |
112 protected: | |
113 UnixDomainClientSocketTest() { | |
114 EXPECT_TRUE(temp_dir_.CreateUniqueTempDir()); | |
115 socket_path_ = temp_dir_.path().Append(kSocketFilename).value(); | |
116 } | |
117 | |
118 base::ScopedTempDir temp_dir_; | |
119 std::string socket_path_; | |
120 }; | |
121 | |
122 TEST_F(UnixDomainClientSocketTest, Connect) { | |
123 const bool kUseAbstractNamespace = false; | |
124 | |
125 UnixDomainServerSocket server_socket(CreateAuthCallback(true), | |
126 kUseAbstractNamespace); | |
127 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
128 | |
129 scoped_ptr<StreamSocket> accepted_socket; | |
130 TestCompletionCallback accept_callback; | |
131 EXPECT_EQ(ERR_IO_PENDING, | |
132 server_socket.Accept(&accepted_socket, accept_callback.callback())); | |
133 EXPECT_FALSE(accepted_socket); | |
134 | |
135 UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace); | |
136 EXPECT_FALSE(client_socket.IsConnected()); | |
137 | |
138 EXPECT_EQ(OK, ConnectSynchronously(&client_socket)); | |
139 EXPECT_TRUE(client_socket.IsConnected()); | |
140 // Server has not yet been notified of the connection. | |
141 EXPECT_FALSE(accepted_socket); | |
142 | |
143 EXPECT_EQ(OK, accept_callback.WaitForResult()); | |
144 EXPECT_TRUE(accepted_socket); | |
145 EXPECT_TRUE(accepted_socket->IsConnected()); | |
146 } | |
147 | |
148 TEST_F(UnixDomainClientSocketTest, ConnectWithAbstractNamespace) { | |
149 const bool kUseAbstractNamespace = true; | |
150 | |
151 UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace); | |
152 EXPECT_FALSE(client_socket.IsConnected()); | |
153 | |
154 #if defined(OS_ANDROID) || defined(OS_LINUX) | |
155 UnixDomainServerSocket server_socket(CreateAuthCallback(true), | |
156 kUseAbstractNamespace); | |
157 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
158 | |
159 scoped_ptr<StreamSocket> accepted_socket; | |
160 TestCompletionCallback accept_callback; | |
161 EXPECT_EQ(ERR_IO_PENDING, | |
162 server_socket.Accept(&accepted_socket, accept_callback.callback())); | |
163 EXPECT_FALSE(accepted_socket); | |
164 | |
165 EXPECT_EQ(OK, ConnectSynchronously(&client_socket)); | |
166 EXPECT_TRUE(client_socket.IsConnected()); | |
167 // Server has not yet beend notified of the connection. | |
168 EXPECT_FALSE(accepted_socket); | |
169 | |
170 EXPECT_EQ(OK, accept_callback.WaitForResult()); | |
171 EXPECT_TRUE(accepted_socket); | |
172 EXPECT_TRUE(accepted_socket->IsConnected()); | |
173 #else | |
174 EXPECT_EQ(ERR_ADDRESS_INVALID, ConnectSynchronously(&client_socket)); | |
175 #endif | |
176 } | |
177 | |
178 TEST_F(UnixDomainClientSocketTest, ConnectToNonExistentSocket) { | |
179 const bool kUseAbstractNamespace = false; | |
180 | |
181 UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace); | |
182 EXPECT_FALSE(client_socket.IsConnected()); | |
183 EXPECT_EQ(ERR_FILE_NOT_FOUND, ConnectSynchronously(&client_socket)); | |
184 } | |
185 | |
186 TEST_F(UnixDomainClientSocketTest, | |
187 ConnectToNonExistentSocketWithAbstractNamespace) { | |
188 const bool kUseAbstractNamespace = true; | |
189 | |
190 UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace); | |
191 EXPECT_FALSE(client_socket.IsConnected()); | |
192 | |
193 TestCompletionCallback connect_callback; | |
194 #if defined(OS_ANDROID) || defined(OS_LINUX) | |
195 EXPECT_EQ(ERR_CONNECTION_REFUSED, ConnectSynchronously(&client_socket)); | |
196 #else | |
197 EXPECT_EQ(ERR_ADDRESS_INVALID, ConnectSynchronously(&client_socket)); | |
198 #endif | |
199 } | |
200 | |
201 TEST_F(UnixDomainClientSocketTest, DisconnectFromClient) { | |
202 UnixDomainServerSocket server_socket(CreateAuthCallback(true), false); | |
203 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
204 scoped_ptr<StreamSocket> accepted_socket; | |
205 TestCompletionCallback accept_callback; | |
206 EXPECT_EQ(ERR_IO_PENDING, | |
207 server_socket.Accept(&accepted_socket, accept_callback.callback())); | |
208 UnixDomainClientSocket client_socket(socket_path_, false); | |
209 EXPECT_EQ(OK, ConnectSynchronously(&client_socket)); | |
210 | |
211 EXPECT_EQ(OK, accept_callback.WaitForResult()); | |
212 EXPECT_TRUE(accepted_socket->IsConnected()); | |
213 EXPECT_TRUE(client_socket.IsConnected()); | |
214 | |
215 // Try to read data. | |
216 const int kReadDataSize = 10; | |
217 scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadDataSize)); | |
218 TestCompletionCallback read_callback; | |
219 EXPECT_EQ(ERR_IO_PENDING, | |
220 accepted_socket->Read(read_buffer, kReadDataSize, | |
221 read_callback.callback())); | |
222 | |
223 // Disconnect from client side. | |
224 client_socket.Disconnect(); | |
225 EXPECT_FALSE(client_socket.IsConnected()); | |
226 EXPECT_FALSE(accepted_socket->IsConnected()); | |
227 | |
228 // Connection closed by peer. | |
229 EXPECT_EQ(0 /* EOF */, read_callback.WaitForResult()); | |
230 // Note that read callback won't be called when the connection is closed | |
231 // locally before the peer closes it. SocketLibevent just clears callbacks. | |
232 } | |
233 | |
234 TEST_F(UnixDomainClientSocketTest, DisconnectFromServer) { | |
235 UnixDomainServerSocket server_socket(CreateAuthCallback(true), false); | |
236 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
237 scoped_ptr<StreamSocket> accepted_socket; | |
238 TestCompletionCallback accept_callback; | |
239 EXPECT_EQ(ERR_IO_PENDING, | |
240 server_socket.Accept(&accepted_socket, accept_callback.callback())); | |
241 UnixDomainClientSocket client_socket(socket_path_, false); | |
242 EXPECT_EQ(OK, ConnectSynchronously(&client_socket)); | |
243 | |
244 EXPECT_EQ(OK, accept_callback.WaitForResult()); | |
245 EXPECT_TRUE(accepted_socket->IsConnected()); | |
246 EXPECT_TRUE(client_socket.IsConnected()); | |
247 | |
248 // Try to read data. | |
249 const int kReadDataSize = 10; | |
250 scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadDataSize)); | |
251 TestCompletionCallback read_callback; | |
252 EXPECT_EQ(ERR_IO_PENDING, | |
253 client_socket.Read(read_buffer, kReadDataSize, | |
254 read_callback.callback())); | |
255 | |
256 // Disconnect from server side. | |
257 accepted_socket->Disconnect(); | |
258 EXPECT_FALSE(accepted_socket->IsConnected()); | |
259 EXPECT_FALSE(client_socket.IsConnected()); | |
260 | |
261 // Connection closed by peer. | |
262 EXPECT_EQ(0 /* EOF */, read_callback.WaitForResult()); | |
263 // Note that read callback won't be called when the connection is closed | |
264 // locally before the peer closes it. SocketLibevent just clears callbacks. | |
265 } | |
266 | |
267 TEST_F(UnixDomainClientSocketTest, ReadAfterWrite) { | |
268 UnixDomainServerSocket server_socket(CreateAuthCallback(true), false); | |
269 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
270 scoped_ptr<StreamSocket> accepted_socket; | |
271 TestCompletionCallback accept_callback; | |
272 EXPECT_EQ(ERR_IO_PENDING, | |
273 server_socket.Accept(&accepted_socket, accept_callback.callback())); | |
274 UnixDomainClientSocket client_socket(socket_path_, false); | |
275 EXPECT_EQ(OK, ConnectSynchronously(&client_socket)); | |
276 | |
277 EXPECT_EQ(OK, accept_callback.WaitForResult()); | |
278 EXPECT_TRUE(accepted_socket->IsConnected()); | |
279 EXPECT_TRUE(client_socket.IsConnected()); | |
280 | |
281 // Send data from client to server. | |
282 const int kWriteDataSize = 10; | |
283 scoped_refptr<IOBuffer> write_buffer( | |
284 new StringIOBuffer(std::string(kWriteDataSize, 'd'))); | |
285 EXPECT_EQ(kWriteDataSize, | |
286 WriteSynchronously(&client_socket, | |
287 write_buffer, | |
288 kWriteDataSize)); | |
289 | |
290 // The buffer is bigger than write data size. | |
291 const int kReadBufferSize = kWriteDataSize * 2; | |
292 scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize)); | |
293 EXPECT_EQ(kWriteDataSize, | |
294 ReadSynchronously(accepted_socket.get(), | |
295 read_buffer, | |
296 kReadBufferSize, | |
297 kWriteDataSize)); | |
298 EXPECT_EQ(std::string(write_buffer->data(), kWriteDataSize), | |
299 std::string(read_buffer->data(), kWriteDataSize)); | |
300 | |
301 // Send data from server and client. | |
302 EXPECT_EQ(kWriteDataSize, | |
303 WriteSynchronously(accepted_socket.get(), | |
304 write_buffer, | |
305 kWriteDataSize)); | |
306 | |
307 // Read multiple times. | |
308 const int kSmallReadBufferSize = kWriteDataSize / 3; | |
309 EXPECT_EQ(kSmallReadBufferSize, | |
310 ReadSynchronously(&client_socket, | |
311 read_buffer, | |
312 kSmallReadBufferSize, | |
313 kSmallReadBufferSize)); | |
314 EXPECT_EQ(std::string(write_buffer->data(), kSmallReadBufferSize), | |
315 std::string(read_buffer->data(), kSmallReadBufferSize)); | |
316 | |
317 EXPECT_EQ(kWriteDataSize - kSmallReadBufferSize, | |
318 ReadSynchronously(&client_socket, | |
319 read_buffer, | |
320 kReadBufferSize, | |
321 kWriteDataSize - kSmallReadBufferSize)); | |
322 EXPECT_EQ(std::string(write_buffer->data() + kSmallReadBufferSize, | |
323 kWriteDataSize - kSmallReadBufferSize), | |
324 std::string(read_buffer->data(), | |
325 kWriteDataSize - kSmallReadBufferSize)); | |
326 | |
327 // No more data. | |
328 EXPECT_EQ(ERR_IO_PENDING, | |
329 ReadSynchronously(&client_socket, | |
330 read_buffer, | |
331 kReadBufferSize, | |
332 0)); | |
333 | |
334 // Disconnect from server side after read-write. | |
335 accepted_socket->Disconnect(); | |
336 EXPECT_FALSE(accepted_socket->IsConnected()); | |
337 EXPECT_FALSE(client_socket.IsConnected()); | |
338 } | |
339 | |
340 TEST_F(UnixDomainClientSocketTest, ReadBeforeWrite) { | |
341 UnixDomainServerSocket server_socket(CreateAuthCallback(true), false); | |
342 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
343 scoped_ptr<StreamSocket> accepted_socket; | |
344 TestCompletionCallback accept_callback; | |
345 EXPECT_EQ(ERR_IO_PENDING, | |
346 server_socket.Accept(&accepted_socket, accept_callback.callback())); | |
347 UnixDomainClientSocket client_socket(socket_path_, false); | |
348 EXPECT_EQ(OK, ConnectSynchronously(&client_socket)); | |
349 | |
350 EXPECT_EQ(OK, accept_callback.WaitForResult()); | |
351 EXPECT_TRUE(accepted_socket->IsConnected()); | |
352 EXPECT_TRUE(client_socket.IsConnected()); | |
353 | |
354 // Wait for data from client. | |
355 const int kWriteDataSize = 10; | |
356 const int kReadBufferSize = kWriteDataSize * 2; | |
357 const int kSmallReadBufferSize = kWriteDataSize / 3; | |
358 // Read smaller than write data size first. | |
359 scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize)); | |
360 TestCompletionCallback read_callback; | |
361 EXPECT_EQ(ERR_IO_PENDING, | |
362 accepted_socket->Read(read_buffer, kSmallReadBufferSize, | |
363 read_callback.callback())); | |
364 | |
365 scoped_refptr<IOBuffer> write_buffer( | |
366 new StringIOBuffer(std::string(kWriteDataSize, 'd'))); | |
367 EXPECT_EQ(kWriteDataSize, | |
368 WriteSynchronously(&client_socket, | |
369 write_buffer, | |
370 kWriteDataSize)); | |
371 | |
372 // First read completed. | |
373 EXPECT_EQ(kSmallReadBufferSize, read_callback.WaitForResult()); | |
mmenke
2014/07/23 18:52:40
Just out of paranoia, suggest allowing any read >
byungchul
2014/07/23 22:27:11
Though I don't know what you want exactly, changed
| |
374 // Read remaining data. | |
375 EXPECT_EQ(kWriteDataSize - kSmallReadBufferSize, | |
376 ReadSynchronously(accepted_socket.get(), | |
377 read_buffer, | |
378 kReadBufferSize, | |
379 kWriteDataSize - kSmallReadBufferSize)); | |
mmenke
2014/07/23 18:52:40
Should check the bytes read from the read two call
byungchul
2014/07/23 22:27:11
Done.
| |
380 // No more data. | |
381 EXPECT_EQ(ERR_IO_PENDING, | |
382 ReadSynchronously(accepted_socket.get(), | |
383 read_buffer, | |
384 kReadBufferSize, | |
385 0)); | |
386 | |
387 // Disconnect from server side after read-write. | |
388 accepted_socket->Disconnect(); | |
389 EXPECT_FALSE(accepted_socket->IsConnected()); | |
390 EXPECT_FALSE(client_socket.IsConnected()); | |
391 } | |
392 | |
393 } // namespace net | |
OLD | NEW |