1 /*
2 * libjingle
3 * Copyright 2004--2005, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "xmppsocket.h"
29
30 #ifdef HAVE_CONFIG_H
31 #include <config.h>
32 #endif
33
34 #include <errno.h>
35 #include "talk/base/basicdefs.h"
36 #include "talk/base/logging.h"
37 #include "talk/base/thread.h"
38 #ifdef FEATURE_ENABLE_SSL
39 #include "talk/base/ssladapter.h"
40 #endif
41
42 #ifdef USE_SSLSTREAM
43 #include "talk/base/socketstream.h"
44 #ifdef FEATURE_ENABLE_SSL
45 #include "talk/base/sslstreamadapter.h"
46 #endif // FEATURE_ENABLE_SSL
47 #endif // USE_SSLSTREAM
48
49 namespace buzz {
50
XmppSocket(buzz::TlsOptions tls)51 XmppSocket::XmppSocket(buzz::TlsOptions tls) : cricket_socket_(NULL),
52 tls_(tls) {
53 state_ = buzz::AsyncSocket::STATE_CLOSED;
54 }
55
CreateCricketSocket(int family)56 void XmppSocket::CreateCricketSocket(int family) {
57 talk_base::Thread* pth = talk_base::Thread::Current();
58 if (family == AF_UNSPEC) {
59 family = AF_INET;
60 }
61 talk_base::AsyncSocket* socket =
62 pth->socketserver()->CreateAsyncSocket(family, SOCK_STREAM);
63 #ifndef USE_SSLSTREAM
64 #ifdef FEATURE_ENABLE_SSL
65 if (tls_ != buzz::TLS_DISABLED) {
66 socket = talk_base::SSLAdapter::Create(socket);
67 }
68 #endif // FEATURE_ENABLE_SSL
69 cricket_socket_ = socket;
70 cricket_socket_->SignalReadEvent.connect(this, &XmppSocket::OnReadEvent);
71 cricket_socket_->SignalWriteEvent.connect(this, &XmppSocket::OnWriteEvent);
72 cricket_socket_->SignalConnectEvent.connect(this,
73 &XmppSocket::OnConnectEvent);
74 cricket_socket_->SignalCloseEvent.connect(this, &XmppSocket::OnCloseEvent);
75 #else // USE_SSLSTREAM
76 cricket_socket_ = socket;
77 stream_ = new talk_base::SocketStream(cricket_socket_);
78 #ifdef FEATURE_ENABLE_SSL
79 if (tls_ != buzz::TLS_DISABLED)
80 stream_ = talk_base::SSLStreamAdapter::Create(stream_);
81 #endif // FEATURE_ENABLE_SSL
82 stream_->SignalEvent.connect(this, &XmppSocket::OnEvent);
83 #endif // USE_SSLSTREAM
84 }
85
~XmppSocket()86 XmppSocket::~XmppSocket() {
87 Close();
88 #ifndef USE_SSLSTREAM
89 delete cricket_socket_;
90 #else // USE_SSLSTREAM
91 delete stream_;
92 #endif // USE_SSLSTREAM
93 }
94
95 #ifndef USE_SSLSTREAM
OnReadEvent(talk_base::AsyncSocket * socket)96 void XmppSocket::OnReadEvent(talk_base::AsyncSocket * socket) {
97 SignalRead();
98 }
99
OnWriteEvent(talk_base::AsyncSocket * socket)100 void XmppSocket::OnWriteEvent(talk_base::AsyncSocket * socket) {
101 // Write bytes if there are any
102 while (buffer_.Length() != 0) {
103 int written = cricket_socket_->Send(buffer_.Data(), buffer_.Length());
104 if (written > 0) {
105 buffer_.Consume(written);
106 continue;
107 }
108 if (!cricket_socket_->IsBlocking())
109 LOG(LS_ERROR) << "Send error: " << cricket_socket_->GetError();
110 return;
111 }
112 }
113
OnConnectEvent(talk_base::AsyncSocket * socket)114 void XmppSocket::OnConnectEvent(talk_base::AsyncSocket * socket) {
115 #if defined(FEATURE_ENABLE_SSL)
116 if (state_ == buzz::AsyncSocket::STATE_TLS_CONNECTING) {
117 state_ = buzz::AsyncSocket::STATE_TLS_OPEN;
118 SignalSSLConnected();
119 OnWriteEvent(cricket_socket_);
120 return;
121 }
122 #endif // !defined(FEATURE_ENABLE_SSL)
123 state_ = buzz::AsyncSocket::STATE_OPEN;
124 SignalConnected();
125 }
126
OnCloseEvent(talk_base::AsyncSocket * socket,int error)127 void XmppSocket::OnCloseEvent(talk_base::AsyncSocket * socket, int error) {
128 SignalCloseEvent(error);
129 }
130
131 #else // USE_SSLSTREAM
132
OnEvent(talk_base::StreamInterface * stream,int events,int err)133 void XmppSocket::OnEvent(talk_base::StreamInterface* stream,
134 int events, int err) {
135 if ((events & talk_base::SE_OPEN)) {
136 #if defined(FEATURE_ENABLE_SSL)
137 if (state_ == buzz::AsyncSocket::STATE_TLS_CONNECTING) {
138 state_ = buzz::AsyncSocket::STATE_TLS_OPEN;
139 SignalSSLConnected();
140 events |= talk_base::SE_WRITE;
141 } else
142 #endif
143 {
144 state_ = buzz::AsyncSocket::STATE_OPEN;
145 SignalConnected();
146 }
147 }
148 if ((events & talk_base::SE_READ))
149 SignalRead();
150 if ((events & talk_base::SE_WRITE)) {
151 // Write bytes if there are any
152 while (buffer_.Length() != 0) {
153 talk_base::StreamResult result;
154 size_t written;
155 int error;
156 result = stream_->Write(buffer_.Data(), buffer_.Length(),
157 &written, &error);
158 if (result == talk_base::SR_ERROR) {
159 LOG(LS_ERROR) << "Send error: " << error;
160 return;
161 }
162 if (result == talk_base::SR_BLOCK)
163 return;
164 ASSERT(result == talk_base::SR_SUCCESS);
165 ASSERT(written > 0);
166 buffer_.Shift(written);
167 }
168 }
169 if ((events & talk_base::SE_CLOSE))
170 SignalCloseEvent(err);
171 }
172 #endif // USE_SSLSTREAM
173
state()174 buzz::AsyncSocket::State XmppSocket::state() {
175 return state_;
176 }
177
error()178 buzz::AsyncSocket::Error XmppSocket::error() {
179 return buzz::AsyncSocket::ERROR_NONE;
180 }
181
GetError()182 int XmppSocket::GetError() {
183 return 0;
184 }
185
Connect(const talk_base::SocketAddress & addr)186 bool XmppSocket::Connect(const talk_base::SocketAddress& addr) {
187 if (cricket_socket_ == NULL) {
188 CreateCricketSocket(addr.family());
189 }
190 if (cricket_socket_->Connect(addr) < 0) {
191 return cricket_socket_->IsBlocking();
192 }
193 return true;
194 }
195
Read(char * data,size_t len,size_t * len_read)196 bool XmppSocket::Read(char * data, size_t len, size_t* len_read) {
197 #ifndef USE_SSLSTREAM
198 int read = cricket_socket_->Recv(data, len);
199 if (read > 0) {
200 *len_read = (size_t)read;
201 return true;
202 }
203 #else // USE_SSLSTREAM
204 talk_base::StreamResult result = stream_->Read(data, len, len_read, NULL);
205 if (result == talk_base::SR_SUCCESS)
206 return true;
207 #endif // USE_SSLSTREAM
208 return false;
209 }
210
Write(const char * data,size_t len)211 bool XmppSocket::Write(const char * data, size_t len) {
212 buffer_.WriteBytes(data, len);
213 #ifndef USE_SSLSTREAM
214 OnWriteEvent(cricket_socket_);
215 #else // USE_SSLSTREAM
216 OnEvent(stream_, talk_base::SE_WRITE, 0);
217 #endif // USE_SSLSTREAM
218 return true;
219 }
220
Close()221 bool XmppSocket::Close() {
222 if (state_ != buzz::AsyncSocket::STATE_OPEN)
223 return false;
224 #ifndef USE_SSLSTREAM
225 if (cricket_socket_->Close() == 0) {
226 state_ = buzz::AsyncSocket::STATE_CLOSED;
227 SignalClosed();
228 return true;
229 }
230 return false;
231 #else // USE_SSLSTREAM
232 state_ = buzz::AsyncSocket::STATE_CLOSED;
233 stream_->Close();
234 SignalClosed();
235 return true;
236 #endif // USE_SSLSTREAM
237 }
238
StartTls(const std::string & domainname)239 bool XmppSocket::StartTls(const std::string & domainname) {
240 #if defined(FEATURE_ENABLE_SSL)
241 if (tls_ == buzz::TLS_DISABLED)
242 return false;
243 #ifndef USE_SSLSTREAM
244 talk_base::SSLAdapter* ssl_adapter =
245 static_cast<talk_base::SSLAdapter *>(cricket_socket_);
246 if (ssl_adapter->StartSSL(domainname.c_str(), false) != 0)
247 return false;
248 #else // USE_SSLSTREAM
249 talk_base::SSLStreamAdapter* ssl_stream =
250 static_cast<talk_base::SSLStreamAdapter *>(stream_);
251 if (ssl_stream->StartSSLWithServer(domainname.c_str()) != 0)
252 return false;
253 #endif // USE_SSLSTREAM
254 state_ = buzz::AsyncSocket::STATE_TLS_CONNECTING;
255 return true;
256 #else // !defined(FEATURE_ENABLE_SSL)
257 return false;
258 #endif // !defined(FEATURE_ENABLE_SSL)
259 }
260
261 } // namespace buzz
262
263