172 lines
5.4 KiB
C
172 lines
5.4 KiB
C
|
/*
|
||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||
|
* or more contributor license agreements. See the NOTICE file
|
||
|
* distributed with this work for additional information
|
||
|
* regarding copyright ownership. The ASF licenses this file
|
||
|
* to you under the Apache License, Version 2.0 (the
|
||
|
* "License"); you may not use this file except in compliance
|
||
|
* with the License. You may obtain a copy of the License at
|
||
|
*
|
||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
*
|
||
|
* Unless required by applicable law or agreed to in writing,
|
||
|
* software distributed under the License is distributed on an
|
||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||
|
* KIND, either express or implied. See the License for the
|
||
|
* specific language governing permissions and limitations
|
||
|
* under the License.
|
||
|
*/
|
||
|
#ifndef THRIFT_ASYNC_TASYNCSSLSERVERSOCKET_H_
|
||
|
#define THRIFT_ASYNC_TASYNCSSLSERVERSOCKET_H_ 1
|
||
|
|
||
|
#include "thrift/lib/cpp/async/TAsyncServerSocket.h"
|
||
|
#include "thrift/lib/cpp/transport/TSSLSocket.h"
|
||
|
|
||
|
namespace apache { namespace thrift {
|
||
|
|
||
|
namespace transport {
|
||
|
class TSocketAddress;
|
||
|
}
|
||
|
|
||
|
namespace async {
|
||
|
|
||
|
class TAsyncSSLSocket;
|
||
|
|
||
|
class TAsyncSSLServerSocket : public TDelayedDestruction,
|
||
|
private TAsyncServerSocket::AcceptCallback {
|
||
|
public:
|
||
|
class SSLAcceptCallback {
|
||
|
public:
|
||
|
virtual ~SSLAcceptCallback() {}
|
||
|
|
||
|
/**
|
||
|
* connectionAccepted() is called whenever a new client connection is
|
||
|
* received.
|
||
|
*
|
||
|
* The SSLAcceptCallback will remain installed after connectionAccepted()
|
||
|
* returns.
|
||
|
*
|
||
|
* @param sock The newly accepted client socket. The
|
||
|
* SSLAcceptCallback
|
||
|
* assumes ownership of this socket, and is responsible
|
||
|
* for closing it when done.
|
||
|
*/
|
||
|
virtual void connectionAccepted(
|
||
|
const boost::shared_ptr<TAsyncSSLSocket> &sock)
|
||
|
THRIFT_NOEXCEPT = 0;
|
||
|
|
||
|
/**
|
||
|
* acceptError() is called if an error occurs while accepting.
|
||
|
*
|
||
|
* The SSLAcceptCallback will remain installed even after an accept error.
|
||
|
* If the callback wants to uninstall itself and stop trying to accept new
|
||
|
* connections, it must explicit call setAcceptCallback(NULL).
|
||
|
*
|
||
|
* @param ex An exception representing the error.
|
||
|
*/
|
||
|
virtual void acceptError(const std::exception& ex) THRIFT_NOEXCEPT = 0;
|
||
|
};
|
||
|
|
||
|
/**
|
||
|
* Create a new TAsyncSSLServerSocket with the specified TEventBase.
|
||
|
*
|
||
|
* @param eventBase The TEventBase to use for driving the asynchronous I/O.
|
||
|
* If this parameter is NULL, attachEventBase() must be
|
||
|
* called before this socket can begin accepting
|
||
|
* connections. All TAsyncSSLSocket objects accepted by
|
||
|
* this server socket will be attached to this TEventBase
|
||
|
* when they are created.
|
||
|
*/
|
||
|
explicit TAsyncSSLServerSocket(
|
||
|
const boost::shared_ptr<apache::thrift::transport::SSLContext>& ctx,
|
||
|
TEventBase* eventBase = NULL);
|
||
|
|
||
|
/**
|
||
|
* Destroy the socket.
|
||
|
*
|
||
|
* destroy() must be called to destroy the socket. The normal destructor is
|
||
|
* private, and should not be invoked directly. This prevents callers from
|
||
|
* deleting a TAsyncSSLServerSocket while it is invoking a callback.
|
||
|
*/
|
||
|
virtual void destroy();
|
||
|
|
||
|
void bind(const transport::TSocketAddress& address) {
|
||
|
serverSocket_->bind(address);
|
||
|
}
|
||
|
void bind(uint16_t port) {
|
||
|
serverSocket_->bind(port);
|
||
|
}
|
||
|
void getAddress(transport::TSocketAddress* addressReturn) {
|
||
|
serverSocket_->getAddress(addressReturn);
|
||
|
}
|
||
|
void listen(int backlog) {
|
||
|
serverSocket_->listen(backlog);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Helper function to create a shared_ptr<TAsyncSSLServerSocket>.
|
||
|
*
|
||
|
* This passes in the correct destructor object, since TAsyncSSLServerSocket's
|
||
|
* destructor is protected and cannot be invoked directly.
|
||
|
*/
|
||
|
static boost::shared_ptr<TAsyncSSLServerSocket> newSocket(
|
||
|
const boost::shared_ptr<apache::thrift::transport::SSLContext>& ctx,
|
||
|
TEventBase* evb) {
|
||
|
return boost::shared_ptr<TAsyncSSLServerSocket>(
|
||
|
new TAsyncSSLServerSocket(ctx, evb),
|
||
|
Destructor());
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Set the accept callback.
|
||
|
*
|
||
|
* This method may only be invoked from the TEventBase's loop thread.
|
||
|
*
|
||
|
* @param callback The callback to invoke when a new socket
|
||
|
* connection is accepted and a new TAsyncSSLSocket is
|
||
|
* created.
|
||
|
*
|
||
|
* Throws TTransportException on error.
|
||
|
*/
|
||
|
void setSSLAcceptCallback(SSLAcceptCallback* callback);
|
||
|
|
||
|
SSLAcceptCallback *getSSLAcceptCallback() const {
|
||
|
return sslCallback_;
|
||
|
}
|
||
|
|
||
|
void attachEventBase(TEventBase* eventBase);
|
||
|
void detachEventBase();
|
||
|
|
||
|
/**
|
||
|
* Returns the TEventBase that the handler is currently attached to.
|
||
|
*/
|
||
|
TEventBase* getEventBase() const {
|
||
|
return eventBase_;
|
||
|
}
|
||
|
|
||
|
protected:
|
||
|
/**
|
||
|
* Protected destructor.
|
||
|
*
|
||
|
* Invoke destroy() instead to destroy the TAsyncSSLServerSocket.
|
||
|
*/
|
||
|
virtual ~TAsyncSSLServerSocket();
|
||
|
|
||
|
private:
|
||
|
virtual void connectionAccepted(int fd,
|
||
|
const transport::TSocketAddress& clientAddr)
|
||
|
THRIFT_NOEXCEPT;
|
||
|
virtual void acceptError(const std::exception& ex) THRIFT_NOEXCEPT;
|
||
|
|
||
|
TEventBase* eventBase_;
|
||
|
TAsyncServerSocket* serverSocket_;
|
||
|
// SSL context
|
||
|
boost::shared_ptr<apache::thrift::transport::SSLContext> ctx_;
|
||
|
// The accept callback
|
||
|
SSLAcceptCallback* sslCallback_;
|
||
|
};
|
||
|
|
||
|
}}} // apache::thrift::async
|
||
|
|
||
|
#endif // THRIFT_ASYNC_TASYNCSSLSERVERSOCKET_H_
|