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#ifdef HAVE_CONFIG_H
29#include <config.h>
30#endif
31
32#include <errno.h>
33#include "talk/base/basicdefs.h"
34#include "talk/base/logging.h"
35#include "talk/base/thread.h"
36#ifdef FEATURE_ENABLE_SSL
37#include "talk/base/ssladapter.h"
38#endif
39#include "xmppsocket.h"
40
41#ifdef USE_SSLSTREAM
42#include "talk/base/socketstream.h"
43#ifdef FEATURE_ENABLE_SSL
44#include "talk/base/sslstreamadapter.h"
45#endif  // FEATURE_ENABLE_SSL
46#endif  // USE_SSLSTREAM
47
48XmppSocket::XmppSocket(bool tls) : tls_(tls) {
49  talk_base::Thread* pth = talk_base::Thread::Current();
50  talk_base::AsyncSocket* socket =
51    pth->socketserver()->CreateAsyncSocket(SOCK_STREAM);
52#ifndef USE_SSLSTREAM
53#ifdef FEATURE_ENABLE_SSL
54  if (tls_) {
55    socket = talk_base::SSLAdapter::Create(socket);
56  }
57#endif  // FEATURE_ENABLE_SSL
58  cricket_socket_ = socket;
59  cricket_socket_->SignalReadEvent.connect(this, &XmppSocket::OnReadEvent);
60  cricket_socket_->SignalWriteEvent.connect(this, &XmppSocket::OnWriteEvent);
61  cricket_socket_->SignalConnectEvent.connect(this,
62                                              &XmppSocket::OnConnectEvent);
63  cricket_socket_->SignalCloseEvent.connect(this, &XmppSocket::OnCloseEvent);
64#else  // USE_SSLSTREAM
65  cricket_socket_ = socket;
66  stream_ = new talk_base::SocketStream(cricket_socket_);
67#ifdef FEATURE_ENABLE_SSL
68  if (tls_)
69    stream_ = talk_base::SSLStreamAdapter::Create(stream_);
70#endif  // FEATURE_ENABLE_SSL
71  stream_->SignalEvent.connect(this, &XmppSocket::OnEvent);
72#endif  // USE_SSLSTREAM
73
74  state_ = buzz::AsyncSocket::STATE_CLOSED;
75}
76
77XmppSocket::~XmppSocket() {
78  Close();
79#ifndef USE_SSLSTREAM
80  delete cricket_socket_;
81#else  // USE_SSLSTREAM
82  delete stream_;
83#endif  // USE_SSLSTREAM
84}
85
86#ifndef USE_SSLSTREAM
87void XmppSocket::OnReadEvent(talk_base::AsyncSocket * socket) {
88  SignalRead();
89}
90
91void XmppSocket::OnWriteEvent(talk_base::AsyncSocket * socket) {
92  // Write bytes if there are any
93  while (buffer_.Length() != 0) {
94    int written = cricket_socket_->Send(buffer_.Data(), buffer_.Length());
95    if (written > 0) {
96      buffer_.Shift(written);
97      continue;
98    }
99    if (!cricket_socket_->IsBlocking())
100      LOG(LS_ERROR) << "Send error: " << cricket_socket_->GetError();
101    return;
102  }
103}
104
105void XmppSocket::OnConnectEvent(talk_base::AsyncSocket * socket) {
106#if defined(FEATURE_ENABLE_SSL)
107  if (state_ == buzz::AsyncSocket::STATE_TLS_CONNECTING) {
108    state_ = buzz::AsyncSocket::STATE_TLS_OPEN;
109    SignalSSLConnected();
110    OnWriteEvent(cricket_socket_);
111    return;
112  }
113#endif  // !defined(FEATURE_ENABLE_SSL)
114  state_ = buzz::AsyncSocket::STATE_OPEN;
115  SignalConnected();
116}
117
118void XmppSocket::OnCloseEvent(talk_base::AsyncSocket * socket, int error) {
119  SignalCloseEvent(error);
120}
121
122#else  // USE_SSLSTREAM
123
124void XmppSocket::OnEvent(talk_base::StreamInterface* stream,
125                         int events, int err) {
126  if ((events & talk_base::SE_OPEN)) {
127#if defined(FEATURE_ENABLE_SSL)
128    if (state_ == buzz::AsyncSocket::STATE_TLS_CONNECTING) {
129      state_ = buzz::AsyncSocket::STATE_TLS_OPEN;
130      SignalSSLConnected();
131      events |= talk_base::SE_WRITE;
132    } else
133#endif
134    {
135      state_ = buzz::AsyncSocket::STATE_OPEN;
136      SignalConnected();
137    }
138  }
139  if ((events & talk_base::SE_READ))
140    SignalRead();
141  if ((events & talk_base::SE_WRITE)) {
142    // Write bytes if there are any
143    while (buffer_.Length() != 0) {
144      talk_base::StreamResult result;
145      size_t written;
146      int error;
147      result = stream_->Write(buffer_.Data(), buffer_.Length(),
148                              &written, &error);
149      if (result == talk_base::SR_ERROR) {
150        LOG(LS_ERROR) << "Send error: " << error;
151        return;
152      }
153      if (result == talk_base::SR_BLOCK)
154        return;
155      ASSERT(result == talk_base::SR_SUCCESS);
156      ASSERT(written > 0);
157      buffer_.Shift(written);
158    }
159  }
160  if ((events & talk_base::SE_CLOSE))
161    SignalCloseEvent(err);
162}
163#endif  // USE_SSLSTREAM
164
165buzz::AsyncSocket::State XmppSocket::state() {
166  return state_;
167}
168
169buzz::AsyncSocket::Error XmppSocket::error() {
170  return buzz::AsyncSocket::ERROR_NONE;
171}
172
173int XmppSocket::GetError() {
174  return 0;
175}
176
177bool XmppSocket::Connect(const talk_base::SocketAddress& addr) {
178  if (cricket_socket_->Connect(addr) < 0) {
179    return cricket_socket_->IsBlocking();
180  }
181  return true;
182}
183
184bool XmppSocket::Read(char * data, size_t len, size_t* len_read) {
185#ifndef USE_SSLSTREAM
186  int read = cricket_socket_->Recv(data, len);
187  if (read > 0) {
188    *len_read = (size_t)read;
189    return true;
190  }
191#else  // USE_SSLSTREAM
192  talk_base::StreamResult result = stream_->Read(data, len, len_read, NULL);
193  if (result == talk_base::SR_SUCCESS)
194    return true;
195#endif  // USE_SSLSTREAM
196  return false;
197}
198
199bool XmppSocket::Write(const char * data, size_t len) {
200  buffer_.WriteBytes(data, len);
201#ifndef USE_SSLSTREAM
202  OnWriteEvent(cricket_socket_);
203#else  // USE_SSLSTREAM
204  OnEvent(stream_, talk_base::SE_WRITE, 0);
205#endif  // USE_SSLSTREAM
206  return true;
207}
208
209bool XmppSocket::Close() {
210  if (state_ != buzz::AsyncSocket::STATE_OPEN)
211    return false;
212#ifndef USE_SSLSTREAM
213  if (cricket_socket_->Close() == 0) {
214    state_ = buzz::AsyncSocket::STATE_CLOSED;
215    SignalClosed();
216    return true;
217  }
218  return false;
219#else  // USE_SSLSTREAM
220  state_ = buzz::AsyncSocket::STATE_CLOSED;
221  stream_->Close();
222  SignalClosed();
223  return true;
224#endif  // USE_SSLSTREAM
225}
226
227bool XmppSocket::StartTls(const std::string & domainname) {
228#if defined(FEATURE_ENABLE_SSL)
229  if (!tls_)
230    return false;
231#ifndef USE_SSLSTREAM
232  talk_base::SSLAdapter* ssl_adapter =
233    static_cast<talk_base::SSLAdapter *>(cricket_socket_);
234  ssl_adapter->set_ignore_bad_cert(true);
235  if (ssl_adapter->StartSSL(domainname.c_str(), false) != 0)
236    return false;
237#else  // USE_SSLSTREAM
238  talk_base::SSLStreamAdapter* ssl_stream =
239    static_cast<talk_base::SSLStreamAdapter *>(stream_);
240  ssl_stream->set_ignore_bad_cert(true);
241  if (ssl_stream->StartSSLWithServer(domainname.c_str()) != 0)
242    return false;
243#endif  // USE_SSLSTREAM
244  state_ = buzz::AsyncSocket::STATE_TLS_CONNECTING;
245  return true;
246#else  // !defined(FEATURE_ENABLE_SSL)
247  return false;
248#endif  // !defined(FEATURE_ENABLE_SSL)
249}
250