OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2010 The WebRTC Project Authors. All rights reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #include "webrtc/base/socketstream.h" | |
12 | |
13 #include "webrtc/base/checks.h" | |
14 | |
15 namespace rtc { | |
16 | |
17 SocketStream::SocketStream(AsyncSocket* socket) : socket_(nullptr) { | |
18 Attach(socket); | |
19 } | |
20 | |
21 SocketStream::~SocketStream() { | |
22 delete socket_; | |
23 } | |
24 | |
25 void SocketStream::Attach(AsyncSocket* socket) { | |
26 if (socket_) | |
27 delete socket_; | |
28 socket_ = socket; | |
29 if (socket_) { | |
30 socket_->SignalConnectEvent.connect(this, &SocketStream::OnConnectEvent); | |
31 socket_->SignalReadEvent.connect(this, &SocketStream::OnReadEvent); | |
32 socket_->SignalWriteEvent.connect(this, &SocketStream::OnWriteEvent); | |
33 socket_->SignalCloseEvent.connect(this, &SocketStream::OnCloseEvent); | |
34 } | |
35 } | |
36 | |
37 AsyncSocket* SocketStream::Detach() { | |
38 AsyncSocket* socket = socket_; | |
39 if (socket_) { | |
40 socket_->SignalConnectEvent.disconnect(this); | |
41 socket_->SignalReadEvent.disconnect(this); | |
42 socket_->SignalWriteEvent.disconnect(this); | |
43 socket_->SignalCloseEvent.disconnect(this); | |
44 socket_ = nullptr; | |
45 } | |
46 return socket; | |
47 } | |
48 | |
49 StreamState SocketStream::GetState() const { | |
50 RTC_DCHECK(socket_ != nullptr); | |
51 switch (socket_->GetState()) { | |
52 case Socket::CS_CONNECTED: | |
53 return SS_OPEN; | |
54 case Socket::CS_CONNECTING: | |
55 return SS_OPENING; | |
56 case Socket::CS_CLOSED: | |
57 default: | |
58 return SS_CLOSED; | |
59 } | |
60 } | |
61 | |
62 StreamResult SocketStream::Read(void* buffer, size_t buffer_len, | |
63 size_t* read, int* error) { | |
64 RTC_DCHECK(socket_ != nullptr); | |
65 int result = socket_->Recv(buffer, buffer_len, nullptr); | |
66 if (result < 0) { | |
67 if (socket_->IsBlocking()) | |
68 return SR_BLOCK; | |
69 if (error) | |
70 *error = socket_->GetError(); | |
71 return SR_ERROR; | |
72 } | |
73 if ((result > 0) || (buffer_len == 0)) { | |
74 if (read) | |
75 *read = result; | |
76 return SR_SUCCESS; | |
77 } | |
78 return SR_EOS; | |
79 } | |
80 | |
81 StreamResult SocketStream::Write(const void* data, size_t data_len, | |
82 size_t* written, int* error) { | |
83 RTC_DCHECK(socket_ != nullptr); | |
84 int result = socket_->Send(data, data_len); | |
85 if (result < 0) { | |
86 if (socket_->IsBlocking()) | |
87 return SR_BLOCK; | |
88 if (error) | |
89 *error = socket_->GetError(); | |
90 return SR_ERROR; | |
91 } | |
92 if (written) | |
93 *written = result; | |
94 return SR_SUCCESS; | |
95 } | |
96 | |
97 void SocketStream::Close() { | |
98 RTC_DCHECK(socket_ != nullptr); | |
99 socket_->Close(); | |
100 } | |
101 | |
102 void SocketStream::OnConnectEvent(AsyncSocket* socket) { | |
103 RTC_DCHECK(socket == socket_); | |
104 SignalEvent(this, SE_OPEN | SE_READ | SE_WRITE, 0); | |
105 } | |
106 | |
107 void SocketStream::OnReadEvent(AsyncSocket* socket) { | |
108 RTC_DCHECK(socket == socket_); | |
109 SignalEvent(this, SE_READ, 0); | |
110 } | |
111 | |
112 void SocketStream::OnWriteEvent(AsyncSocket* socket) { | |
113 RTC_DCHECK(socket == socket_); | |
114 SignalEvent(this, SE_WRITE, 0); | |
115 } | |
116 | |
117 void SocketStream::OnCloseEvent(AsyncSocket* socket, int err) { | |
118 RTC_DCHECK(socket == socket_); | |
119 SignalEvent(this, SE_CLOSE, err); | |
120 } | |
121 | |
122 | |
123 } // namespace rtc | |
OLD | NEW |