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 "rtc_base/socket_stream.h"
12
13 #include "rtc_base/checks.h"
14 #include "rtc_base/socket.h"
15
16 namespace rtc {
17
SocketStream(AsyncSocket * socket)18 SocketStream::SocketStream(AsyncSocket* socket) : socket_(nullptr) {
19 Attach(socket);
20 }
21
~SocketStream()22 SocketStream::~SocketStream() {
23 delete socket_;
24 }
25
Attach(AsyncSocket * socket)26 void SocketStream::Attach(AsyncSocket* socket) {
27 if (socket_)
28 delete socket_;
29 socket_ = socket;
30 if (socket_) {
31 socket_->SignalConnectEvent.connect(this, &SocketStream::OnConnectEvent);
32 socket_->SignalReadEvent.connect(this, &SocketStream::OnReadEvent);
33 socket_->SignalWriteEvent.connect(this, &SocketStream::OnWriteEvent);
34 socket_->SignalCloseEvent.connect(this, &SocketStream::OnCloseEvent);
35 }
36 }
37
Detach()38 AsyncSocket* SocketStream::Detach() {
39 AsyncSocket* socket = socket_;
40 if (socket_) {
41 socket_->SignalConnectEvent.disconnect(this);
42 socket_->SignalReadEvent.disconnect(this);
43 socket_->SignalWriteEvent.disconnect(this);
44 socket_->SignalCloseEvent.disconnect(this);
45 socket_ = nullptr;
46 }
47 return socket;
48 }
49
GetState() const50 StreamState SocketStream::GetState() const {
51 RTC_DCHECK(socket_ != nullptr);
52 switch (socket_->GetState()) {
53 case Socket::CS_CONNECTED:
54 return SS_OPEN;
55 case Socket::CS_CONNECTING:
56 return SS_OPENING;
57 case Socket::CS_CLOSED:
58 default:
59 return SS_CLOSED;
60 }
61 }
62
Read(void * buffer,size_t buffer_len,size_t * read,int * error)63 StreamResult SocketStream::Read(void* buffer,
64 size_t buffer_len,
65 size_t* read,
66 int* error) {
67 RTC_DCHECK(socket_ != nullptr);
68 int result = socket_->Recv(buffer, buffer_len, nullptr);
69 if (result < 0) {
70 if (socket_->IsBlocking())
71 return SR_BLOCK;
72 if (error)
73 *error = socket_->GetError();
74 return SR_ERROR;
75 }
76 if ((result > 0) || (buffer_len == 0)) {
77 if (read)
78 *read = result;
79 return SR_SUCCESS;
80 }
81 return SR_EOS;
82 }
83
Write(const void * data,size_t data_len,size_t * written,int * error)84 StreamResult SocketStream::Write(const void* data,
85 size_t data_len,
86 size_t* written,
87 int* error) {
88 RTC_DCHECK(socket_ != nullptr);
89 int result = socket_->Send(data, data_len);
90 if (result < 0) {
91 if (socket_->IsBlocking())
92 return SR_BLOCK;
93 if (error)
94 *error = socket_->GetError();
95 return SR_ERROR;
96 }
97 if (written)
98 *written = result;
99 return SR_SUCCESS;
100 }
101
Close()102 void SocketStream::Close() {
103 RTC_DCHECK(socket_ != nullptr);
104 socket_->Close();
105 }
106
OnConnectEvent(AsyncSocket * socket)107 void SocketStream::OnConnectEvent(AsyncSocket* socket) {
108 RTC_DCHECK(socket == socket_);
109 SignalEvent(this, SE_OPEN | SE_READ | SE_WRITE, 0);
110 }
111
OnReadEvent(AsyncSocket * socket)112 void SocketStream::OnReadEvent(AsyncSocket* socket) {
113 RTC_DCHECK(socket == socket_);
114 SignalEvent(this, SE_READ, 0);
115 }
116
OnWriteEvent(AsyncSocket * socket)117 void SocketStream::OnWriteEvent(AsyncSocket* socket) {
118 RTC_DCHECK(socket == socket_);
119 SignalEvent(this, SE_WRITE, 0);
120 }
121
OnCloseEvent(AsyncSocket * socket,int err)122 void SocketStream::OnCloseEvent(AsyncSocket* socket, int err) {
123 RTC_DCHECK(socket == socket_);
124 SignalEvent(this, SE_CLOSE, err);
125 }
126
127 } // namespace rtc
128