[ PARENT ]

EDIT :: swoole_coroutine_socket.h

/* +----------------------------------------------------------------------+ | Swoole | +----------------------------------------------------------------------+ | This source file is subject to version 2.0 of the Apache license, | | that is bundled with this package in the file LICENSE, and is | | available through the world-wide-web at the following url: | | http://www.apache.org/licenses/LICENSE-2.0.html | | If you did not receive a copy of the Apache2.0 license and are unable| | to obtain it through the world-wide-web, please send a note to | | license@swoole.com so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Author: Tianfeng Han <rango@swoole.com> | | Twosee <twose@qq.com> | +----------------------------------------------------------------------+ */ #pragma once #include "swoole_socket.h" #include "swoole_coroutine.h" #include "swoole_protocol.h" #include "swoole_proxy.h" #include <vector> namespace swoole { namespace coroutine { //------------------------------------------------------------------------------- /** * @return true: continue to wait for events * @return false: stop event waiting and resume coroutine */ using EventBarrier = std::function<bool()>; class Socket { public: int errCode = 0; const char *errMsg = ""; std::string errString; bool open_length_check = false; bool open_eof_check = false; bool http2 = false; Protocol protocol = {}; std::unique_ptr<Socks5Proxy> socks5_proxy = nullptr; std::unique_ptr<HttpProxy> http_proxy = nullptr; static TimeoutType timeout_type_list[4]; Socket(int domain, int type, int protocol); Socket(int _fd, int _domain, int _type, int _protocol); explicit Socket(SocketType type = SW_SOCK_TCP); Socket(int _fd, SocketType _type); virtual ~Socket(); /** * If SSL is enabled, an SSL handshake will automatically take place during the connect() method. * When connect() returns true, it indicates that the TCP connection has been successfully * established and the SSL handshake has also succeeded. */ bool connect(const std::string &host, int port = 0, int flags = 0); virtual bool connect(const sockaddr *addr, socklen_t addrlen); bool shutdown(int how = SHUT_RDWR); bool cancel(EventType event); bool close(); bool is_connected() const { return connected && !is_closed(); } bool is_closed() const { return sock_fd == SW_BAD_SOCKET; } bool is_port_required() const { return type <= SW_SOCK_UDP6; } bool check_liveness(); ssize_t peek(void *_buf, size_t _n); virtual ssize_t recv(void *_buf, size_t _n); virtual ssize_t send(const void *_buf, size_t _n); ssize_t send(const std::string &buf) { return send(buf.c_str(), buf.length()); } /** * The read()/write()/recvmsg()/sendmsg() functions currently does not support SSL */ virtual ssize_t read(void *_buf, size_t _n); virtual ssize_t write(const void *_buf, size_t _n); virtual ssize_t recvmsg(msghdr *msg, int flags); virtual ssize_t sendmsg(const msghdr *msg, int flags); virtual ssize_t readv(network::IOVector *io_vector); virtual ssize_t readv_all(network::IOVector *io_vector); virtual ssize_t writev(network::IOVector *io_vector); virtual ssize_t writev_all(network::IOVector *io_vector); virtual ssize_t recv_all(void *_buf, size_t _n); virtual ssize_t send_all(const void *_buf, size_t _n); ssize_t recv_packet(double timeout = 0); ssize_t recv_line(void *_buf, size_t maxlen); ssize_t recv_with_buffer(void *_buf, size_t _n); char *pop_packet() const { if (read_buffer->offset == 0) { return nullptr; } else { return read_buffer->pop(buffer_init_size); } } virtual bool poll(EventType _type, double timeout = 0); /** * If the server has SSL enabled, you must explicitly call `ssl_handshake()`, * as it will not be automatically executed within the `accept()` function. * This behavior is inconsistent with `connect()`, which internally executes `ssl_handshake()` automatically, * thus not requiring an explicit call at the application level. * The reason for this design is that `ssl_handshake()` can typically be performed concurrently within a separate * client coroutine. If `ssl_handshake()` were to be automatically executed inside the `accept()` function, * it would block the server's listening coroutine, * causing the `ssl_handshake()` processes to execute sequentially rather than in parallel. */ Socket *accept(double timeout = 0); bool bind(const std::string &address, int port = 0); bool bind(const sockaddr *sa, socklen_t len); bool listen(int backlog = 0); virtual bool sendfile(const char *filename, off_t offset, size_t length); virtual ssize_t sendto(const std::string &host, int port, const void *_buf, size_t _n); ssize_t recvfrom(void *_buf, size_t _n); virtual ssize_t recvfrom(void *_buf, size_t _n, sockaddr *_addr, socklen_t *_socklen); /** * Operation sequence: * 1. enable_ssl_encrypt() * 2. Set SSL parameters, such as certificate file, key file * 3. ssl_handshake(), to be executed after connect or accept */ bool enable_ssl_encrypt() { if (ssl_context.get()) { return false; } ssl_context = std::make_shared<SSLContext>(); return true; } bool ssl_is_enable() const { return get_ssl_context() != nullptr; } SSLContext *get_ssl_context() const { return ssl_context.get(); } virtual bool ssl_handshake(); bool ssl_verify(bool allow_self_signed); std::string ssl_get_peer_cert(); bool set_ssl_key_file(const std::string &file) const { return ssl_context->set_key_file(file); } bool set_ssl_cert_file(const std::string &file) const { return ssl_context->set_cert_file(file); } void set_ssl_cafile(const std::string &file) const { ssl_context->cafile = file; } void set_ssl_capath(const std::string &path) const { ssl_context->capath = path; } void set_ssl_passphrase(const std::string &str) const { ssl_context->passphrase = str; } #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME void set_tls_host_name(const std::string &str) const { ssl_context->tls_host_name = str; // if user set empty ssl_host_name, disable it, otherwise the underlying may set it automatically ssl_context->disable_tls_host_name = ssl_context->tls_host_name.empty(); } #endif void set_ssl_dhparam(const std::string &file) const { ssl_context->dhparam = file; } void set_ssl_ecdh_curve(const std::string &str) const { ssl_context->ecdh_curve = str; } void set_ssl_protocols(long protocols) const { ssl_context->protocols = protocols; } void set_ssl_disable_compress(bool value) const { ssl_context->disable_compress = value; } void set_ssl_verify_peer(bool value) const { ssl_context->verify_peer = value; } void set_ssl_allow_self_signed(bool value) const { ssl_context->allow_self_signed = value; } void set_ssl_verify_depth(uint8_t value) const { ssl_context->verify_depth = value; } void set_ssl_ciphers(const std::string &str) const { ssl_context->ciphers = str; } #ifdef OPENSSL_IS_BORINGSSL void set_ssl_grease(uint8_t value) { ssl_context->grease = value; } #endif const std::string &get_ssl_cert_file() const { return ssl_context->cert_file; } const std::string &get_ssl_key_file() const { return ssl_context->key_file; } static inline void init_reactor(Reactor *reactor) { reactor->set_handler(SW_FD_CO_SOCKET, SW_EVENT_READ, readable_event_callback); reactor->set_handler(SW_FD_CO_SOCKET, SW_EVENT_WRITE, writable_event_callback); reactor->set_handler(SW_FD_CO_SOCKET, SW_EVENT_ERROR, error_event_callback); } SocketType get_type() const { return type; } FdType get_fd_type() const { return socket->fd_type; } int get_sock_domain() const { return sock_domain; } int get_sock_type() const { return sock_type; } int get_sock_protocol() const { return sock_protocol; } int get_fd() const { return sock_fd; } network::Socket *get_socket() const { return socket; } bool getsockname() const; bool getpeername(network::Address *sa); const char *get_addr() const { return socket->get_addr(); } int get_port() const { return socket->get_port(); } bool has_bound(const EventType event = SW_EVENT_RDWR) const { return get_bound_co(event) != nullptr; } Coroutine *get_bound_co(const EventType event) const { if (event & SW_EVENT_READ) { if (read_co) { return read_co; } } if (event & SW_EVENT_WRITE) { if (write_co) { return write_co; } } return nullptr; } long get_bound_cid(const EventType event = SW_EVENT_RDWR) const { Coroutine *co = get_bound_co(event); return co ? co->get_cid() : 0; } const char *get_event_str(EventType event) const; void check_bound_co(const EventType event) const { auto bound_cid = get_bound_cid(event); if (sw_unlikely(bound_cid)) { Coroutine::print_socket_bound_error(sock_fd, get_event_str(event), bound_cid); } } void set_err(const int e) { errCode = errno = e; swoole_set_last_error(errCode); errMsg = e ? swoole_strerror(e) : ""; } void set_err() { errCode = swoole_get_last_error() ? swoole_get_last_error() : errno; errMsg = swoole_strerror(errCode); } void set_err(const int e, const char *s) { errCode = errno = e; swoole_set_last_error(errCode); errMsg = s; } void set_err(const int e, const std::string &s) { errCode = errno = e; swoole_set_last_error(errCode); errString = s; errMsg = errString.c_str(); } const char *get_err() { return swoole_strerror(errCode); } /* set connect read write timeout */ void set_timeout(double timeout, int _type = SW_TIMEOUT_ALL) const; void set_timeout(const timeval *timeout, int _type = SW_TIMEOUT_ALL) const { set_timeout((double) timeout->tv_sec + ((double) timeout->tv_usec / 1000 / 1000), _type); } double get_timeout(TimeoutType _type) const; bool get_option(int level, int optname, void *optval, socklen_t *optlen) const; bool get_option(int level, int optname, int *optval) const; bool set_option(int level, int optname, const void *optval, socklen_t optlen) const; bool set_option(int level, int optname, int optval) const; void set_socks5_proxy(const std::string &host, int port, const std::string &user = "", const std::string &pwd = ""); void set_http_proxy(const std::string &host, int port, const std::string &user = "", const std::string &pwd = ""); String *get_read_buffer(); String *get_write_buffer(); String *pop_read_buffer(); String *pop_write_buffer(); void set_resolve_context(NameResolver::Context *ctx) { resolve_context_ = ctx; } void set_dtor(const std::function<void(Socket *)> &dtor) { dtor_ = dtor; } void set_zero_copy(bool enable) { zero_copy = enable; } void set_buffer_allocator(const Allocator *allocator) { buffer_allocator = allocator; } void set_buffer_init_size(size_t size) { if (size == 0) { return; } buffer_init_size = size; } int move_fd() { sock_fd = SW_BAD_SOCKET; return socket->move_fd(); } network::Socket *move_socket() { network::Socket *_socket = socket; socket = nullptr; return _socket; } bool ssl_is_available() const { return socket && ssl_handshaked; } SSL *get_ssl() const { return socket->ssl; } void ssl_close() const; protected: SocketType type; network::Socket *socket = nullptr; int sock_domain = 0; int sock_type = 0; int sock_protocol = 0; int sock_fd = -1; Coroutine *read_co = nullptr; Coroutine *write_co = nullptr; EventType want_event = SW_EVENT_NULL; std::string connect_host; int connect_port = 0; int backlog = 0; TimerNode *read_timer = nullptr; TimerNode *write_timer = nullptr; const Allocator *buffer_allocator = nullptr; size_t buffer_init_size = SW_BUFFER_SIZE_BIG; String *read_buffer = nullptr; String *write_buffer = nullptr; EventBarrier *recv_barrier = nullptr; EventBarrier *send_barrier = nullptr; bool ssl_is_server = false; bool ssl_handshaked = false; std::shared_ptr<SSLContext> ssl_context = nullptr; std::string ssl_host_name; bool ssl_context_create(); bool ssl_create(SSLContext *ssl_context); bool connected = false; bool shutdown_read = false; bool shutdown_write = false; bool zero_copy = false; NameResolver::Context *resolve_context_ = nullptr; std::function<void(Socket *)> dtor_; Socket(network::Socket *sock, const Socket *server_sock); static void timer_callback(Timer *timer, TimerNode *tnode); static int readable_event_callback(Reactor *reactor, Event *event); static int writable_event_callback(Reactor *reactor, Event *event); static int error_event_callback(Reactor *reactor, Event *event); void init_sock_type(SocketType _type); bool init_sock(); bool reinit_sock(SocketType _type); bool init_reactor_socket(int fd); void check_return_value(ssize_t retval) { if (retval >= 0) { set_err(0); } else if (errCode == 0) { set_err(errno); } } void init_options() { if (socket->is_tcp()) { set_option(IPPROTO_TCP, TCP_NODELAY, 1); } if (socket->is_udp()) { socket->set_buffer_size(network::Socket::default_buffer_size); } protocol.package_length_type = 'N'; protocol.package_length_size = 4; protocol.package_length_offset = 0; protocol.package_body_offset = 0; protocol.package_max_length = SW_INPUT_BUFFER_SIZE; } bool add_event(EventType event); bool wait_event(EventType event, const void **_buf = nullptr, size_t _n = 0); ssize_t recv_packet_with_length_protocol(); ssize_t recv_packet_with_eof_protocol(); bool is_available(const EventType event) { if (event != SW_EVENT_NULL) { check_bound_co(event); } if (sw_unlikely(is_closed())) { set_err(EBADF); return false; } if (sw_unlikely(socket->close_wait)) { set_err(SW_ERROR_CO_SOCKET_CLOSE_WAIT); return false; } return true; } bool socks5_handshake(); const std::string &get_http_proxy_host_name() const { if (ssl_context && !ssl_context->tls_host_name.empty()) { return ssl_context->tls_host_name; } return http_proxy->target_host; } bool http_proxy_handshake(); class TimerController { public: TimerController(TimerNode **_timer_pp, double _timeout, Socket *_socket, TimerCallback _callback) : timer_pp(_timer_pp), timeout(_timeout), socket_(_socket), callback(std::move(_callback)) {} bool start(); ~TimerController(); private: bool enabled = false; TimerNode **timer_pp; double timeout; Socket *socket_; TimerCallback callback; }; public: class TimeoutSetter { public: TimeoutSetter(Socket *socket, double _timeout, TimeoutType _type); ~TimeoutSetter(); protected: Socket *socket_; double timeout; TimeoutType type; double original_timeout[sizeof(timeout_type_list)] = {}; }; class TimeoutController : public TimeoutSetter { public: TimeoutController(Socket *_socket, double _timeout, const TimeoutType _type) : TimeoutSetter(_socket, _timeout, _type) {} bool has_timedout(TimeoutType _type); protected: double startup_time = 0; }; }; class ProtocolSwitch { bool ori_open_eof_check; bool ori_open_length_check; Protocol ori_protocol; Socket *socket_; public: explicit ProtocolSwitch(Socket *socket) { ori_open_eof_check = socket->open_eof_check; ori_open_length_check = socket->open_length_check; ori_protocol = socket->protocol; socket_ = socket; } ~ProtocolSwitch() { /* revert protocol settings */ socket_->open_eof_check = ori_open_eof_check; socket_->open_length_check = ori_open_length_check; socket_->protocol = ori_protocol; } }; std::vector<std::string> dns_lookup(const char *domain, int family = AF_INET, double timeout = 2.0); std::vector<std::string> dns_lookup_impl_with_socket(const char *domain, int family, double timeout); #ifdef SW_USE_CARES std::vector<std::string> dns_lookup_impl_with_cares(const char *domain, int family, double timeout); #endif std::string get_ip_by_hosts(const std::string &domain); //------------------------------------------------------------------------------- } // namespace coroutine } // namespace swoole

SAVE CANCEL