QoreSocket.h

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    QoreSocket.h
 
    IPv4, IPv6, unix socket class with SSL support
 
    Qore Programming Language
 
    Copyright (C) 2003 - 2024 Qore Technologies, s.r.o.
 
    will unlink (delete) UNIX domain socket files when closed
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
 
    Note that the Qore library is released under a choice of three open-source
    licenses: MIT (as above), LGPL 2+, or GPL 2+; see README-LICENSE for more
    information.
*/
 
#ifndef _QORE_QORESOCKET_H
 
#define _QORE_QORESOCKET_H
 
#include <qore/Qore.h>
#include <qore/InputStream.h>
#include <qore/OutputStream.h>
#include <qore/AbstractPollState.h>
 
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <strings.h>
#include <sys/types.h>
#include <unistd.h>
 
#include <openssl/ssl.h>
#include <openssl/err.h>
 
#define QSE_MISC_ERR      0 
#define QSE_RECV_ERR     -1 
#define QSE_NOT_OPEN     -2 
#define QSE_TIMEOUT      -3 
#define QSE_SSL_ERR      -4 
#define QSE_IN_OP        -5 
#define QSE_IN_OP_THREAD -6 
 
// forward references
class Queue;
class QoreSSLCertificate;
class QoreSSLPrivateKey;
 
 
class SocketSource {
    friend hashdecl qore_socket_private;
 
private:
    hashdecl qore_socketsource_private *priv; // private implementation
 
    DLLLOCAL SocketSource(const SocketSource&);
 
    DLLLOCAL SocketSource& operator=(const SocketSource&);
 
public:
    DLLEXPORT SocketSource();
 
    DLLEXPORT ~SocketSource();
 
 
    DLLEXPORT QoreStringNode* takeAddress();
 
 
    DLLEXPORT QoreStringNode* takeHostName();
 
 
    DLLEXPORT const char* getAddress() const;
 
 
    DLLEXPORT const char* getHostName() const;
 
    DLLLOCAL void setAll(QoreObject* o, ExceptionSink* xsink);
};
 
 
class QoreSocket {
    friend hashdecl qore_socket_private;
    friend hashdecl qore_httpclient_priv;
    friend class QoreSocketObject;
    friend class QoreFtpClient;
    friend class HttpClientRecvHeaderPollState;
    friend class HttpClientRecvChunkedPollState;
    friend class HttpClientRecvUntilClosePollState;
    friend class HttpClientConnectSendRecvPollOperation;
    friend class SocketAcceptPollOperation;
    friend class SocketReadHttpHeaderPollOperation;
    friend class my_socket_priv;
 
public:
    DLLEXPORT QoreSocket();
 
    DLLEXPORT ~QoreSocket();
 
 
    DLLEXPORT AbstractPollState* startConnect(ExceptionSink* xsink, const char* name);
 
 
    DLLEXPORT AbstractPollState* startSslConnect(ExceptionSink* xsink, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT AbstractPollState* startSend(ExceptionSink* xsink, const char* data, size_t size);
 
 
    DLLEXPORT AbstractPollState* startAccept(ExceptionSink* xsink);
 
 
    DLLEXPORT AbstractPollState* startSslAccept(ExceptionSink* xsink, QoreSSLCertificate* cert = nullptr,
        QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT AbstractPollState* startRecv(ExceptionSink* xsink, size_t size);
 
 
    DLLEXPORT AbstractPollState* startRecvUntilBytes(ExceptionSink* xsink, const char* pattern, size_t size);
 
 
    DLLEXPORT AbstractPollState* startRecvPacket(ExceptionSink* xsink);
 
#if 0
 
    DLLEXPORT AbstractPollState* startAccept(ExceptionSink* xsink);
 
 
    DLLEXPORT AbstractPollState* startSslAccept(ExceptionSink* xsink, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
#endif
 
 
    DLLEXPORT int connect(const char* name, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int connect(const char* name, int timeout_ms, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int connectINET(const char* host, int prt, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int connectINET2(const char* name, const char* service, int family = Q_AF_UNSPEC,
            int sock_type = Q_SOCK_STREAM, int protocol = 0, int timeout_ms = -1, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int connectINET(const char* host, int prt, int timeout_ms, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int connectUNIX(const char* p, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int connectUNIX(const char* p, int socktype, int protocol = 0, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int connectSSL(ExceptionSink* xsink, const char* name, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int connectSSL(ExceptionSink* xsink, const char* name, int timeout_ms, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int connectINETSSL(ExceptionSink* xsink, const char* host, int prt, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int connectINETSSL(ExceptionSink* xsink, const char* host, int prt, int timeout_ms,
            QoreSSLCertificate* cert = nullptr, QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int connectINET2SSL(ExceptionSink* xsink, const char* name, const char* service, int family,
            int sock_type, int protocol, int timeout_ms, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int connectUNIXSSL(ExceptionSink* xsink, const char* p, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int connectUNIXSSL(ExceptionSink* xsink, const char* p, int socktype, int protocol,
            QoreSSLCertificate* cert = nullptr, QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int bind(const char* name, bool reuseaddr = false);
 
 
    DLLEXPORT int bind(int prt, bool reuseaddr);
 
 
    DLLEXPORT int bind(const char* iface, int prt, bool reuseaddr = false);
 
 
    DLLEXPORT int bind(const struct sockaddr *addr, int addr_size);
 
 
    DLLEXPORT int bind(int family, const struct sockaddr *addr, int addr_size, int socktype = Q_SOCK_STREAM,
            int protocol = 0);
 
 
    DLLEXPORT int bindUNIX(const char* name, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int bindUNIX(const char* name, int socktype, int protocol = 0, ExceptionSink* xsink = nullptr);
 
 
    DLLEXPORT int bindINET(const char* name, const char* service, bool reuseaddr = true, int family = Q_AF_UNSPEC,
            int socktype = Q_SOCK_STREAM, int protocol = 0, ExceptionSink* xsink = nullptr);
 
    DLLEXPORT int getPort();
 
 
    DLLEXPORT QoreSocket* accept(SocketSource* source, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreSocket* acceptSSL(ExceptionSink* xsink, SocketSource* source, QoreSSLCertificate* cert,
            QoreSSLPrivateKey* pkey);
 
 
    DLLEXPORT int acceptAndReplace(SocketSource* source);
 
 
    DLLEXPORT QoreSocket* accept(int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreSocket* acceptSSL(ExceptionSink* xsink, int timeout_ms, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int acceptAndReplace(int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int listen();
 
 
    DLLEXPORT int listen(int backlog);
 
 
    DLLEXPORT int send(const char* buf, size_t size);
 
 
    DLLEXPORT int send(const char* buf, size_t size, ExceptionSink* xsink);
 
 
    DLLEXPORT int send(const char* buf, size_t size, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int send(const QoreString *msg, ExceptionSink* xsink);
 
 
    DLLEXPORT int send(const QoreString *msg, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int send(const QoreStringNode& msg, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int send(const BinaryNode* msg);
 
 
    DLLEXPORT int send(const BinaryNode* msg, ExceptionSink* xsink);
 
 
    DLLEXPORT int send(const BinaryNode* msg, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int send(int fd, qore_offset_t size = -1);
 
 
    DLLEXPORT int send(int fd, qore_offset_t size, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int sendi1(char i);
 
 
    DLLEXPORT int sendi2(short i);
 
 
    DLLEXPORT int sendi4(int i);
 
 
    DLLEXPORT int sendi8(int64 i);
 
 
    DLLEXPORT int sendi2LSB(short i);
 
 
    DLLEXPORT int sendi4LSB(int i);
 
 
    DLLEXPORT int sendi8LSB(int64 i);
 
 
    DLLEXPORT int sendi1(char i, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int sendi2(short i, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int sendi4(int i, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int sendi8(int64 i, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int sendi2LSB(short i, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int sendi4LSB(int i, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int sendi8LSB(int64 i, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int recvi1(int timeout_ms, char* val);
 
 
    DLLEXPORT int recvi2(int timeout_ms, short *val);
 
 
    DLLEXPORT int recvi4(int timeout_ms, int* val);
 
 
    DLLEXPORT int recvi8(int timeout_ms, int64 *val);
 
 
    DLLEXPORT int recvi2LSB(int timeout_ms, short *val);
 
 
    DLLEXPORT int recvi4LSB(int timeout_ms, int* val);
 
 
    DLLEXPORT int recvi8LSB(int timeout_ms, int64 *val);
 
 
    DLLEXPORT int recvu1(int timeout_ms, unsigned char* val);
 
 
    DLLEXPORT int recvu2(int timeout_ms, unsigned short *val);
 
 
    DLLEXPORT int recvu4(int timeout_ms, unsigned int* val);
 
 
    DLLEXPORT int recvu2LSB(int timeout_ms, unsigned short *val);
 
 
    DLLEXPORT int recvu4LSB(int timeout_ms, unsigned int* val);
 
 
    DLLEXPORT int64 recvi1(int timeout_ms, char* val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvi2(int timeout_ms, short *val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvi4(int timeout_ms, int* val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvi8(int timeout_ms, int64 *val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvi2LSB(int timeout_ms, short *val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvi4LSB(int timeout_ms, int* val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvi8LSB(int timeout_ms, int64 *val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvu1(int timeout_ms, unsigned char* val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvu2(int timeout_ms, unsigned short *val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvu4(int timeout_ms, unsigned int* val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvu2LSB(int timeout_ms, unsigned short *val, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 recvu4LSB(int timeout_ms, unsigned int* val, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreStringNode* recv(qore_offset_t bufsize, int timeout_ms, int* prc);
 
 
    DLLEXPORT QoreStringNode* recv(qore_offset_t bufsize, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT BinaryNode* recvBinary(qore_offset_t bufsize, int timeout_ms, int* prc);
 
 
    DLLEXPORT BinaryNode* recvBinary(qore_offset_t bufsize, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreStringNode* recv(int timeout_ms, int* prc);
 
 
    DLLEXPORT QoreStringNode* recv(int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT BinaryNode* recvBinary(int timeout_ms, int* prc);
 
 
    DLLEXPORT BinaryNode* recvBinary(int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int recv(int fd, qore_offset_t size, int timeout_ms);
 
 
    DLLEXPORT int recv(int fd, qore_offset_t size, int timeout_ms, ExceptionSink* xsink);
 
 
    DLLEXPORT int sendHTTPMessage(const char* method, const char* path, const char* http_version, const QoreHashNode* headers, const void* data, size_t size, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT int sendHTTPMessage(QoreHashNode* info, const char* method, const char* path, const char* http_version, const QoreHashNode* headers, const void* data, size_t size, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT int sendHTTPMessage(ExceptionSink* xsink, QoreHashNode* info, const char* method, const char* path, const char* http_version, const QoreHashNode* headers, const void* data, size_t size, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT int sendHTTPMessage(ExceptionSink* xsink, QoreHashNode* info, const char* method, const char* path, const char* http_version, const QoreHashNode* headers, const void* data, size_t size, int source, int timeout_ms);
 
 
    DLLEXPORT int sendHTTPMessageWithCallback(ExceptionSink* xsink, QoreHashNode* info, const char* method, const char* path, const char* http_version, const QoreHashNode* headers, const ResolvedCallReferenceNode& send_callback, int source, int timeout_ms);
 
 
    DLLEXPORT int sendHTTPResponse(int code, const char* desc, const char* http_version, const QoreHashNode* headers, const void* data, size_t size, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT int sendHTTPResponse(ExceptionSink* xsink, int code, const char* desc, const char* http_version, const QoreHashNode* headers, const void* data, size_t size, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT int sendHTTPResponse(ExceptionSink* xsink, int code, const char* desc, const char* http_version, const QoreHashNode* headers, const void* data, size_t size, int source, int timeout_ms);
 
 
    DLLEXPORT int sendHTTPResponse(ExceptionSink* xsink, QoreHashNode* info, int code, const char* desc,
        const char* http_version, const QoreHashNode* headers, const void* data, size_t size, int source,
        int timeout_ms);
 
 
    DLLEXPORT AbstractQoreNode* readHTTPHeader(int timeout_ms, int* prc, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT AbstractQoreNode* readHTTPHeader(QoreHashNode* info, int timeout_ms, int* prc, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT QoreHashNode* readHTTPHeader(ExceptionSink* xsink, QoreHashNode* info, int timeout_ms, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT QoreStringNode* readHTTPHeaderString(ExceptionSink* xsink, int timeout_ms, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT QoreHashNode* readHTTPChunkedBodyBinary(int timeout_ms, ExceptionSink* xsink, int source = QORE_SOURCE_SOCKET);
 
 
    DLLEXPORT QoreHashNode* readHTTPChunkedBody(int timeout_ms, ExceptionSink* xsink, int source = QORE_SOURCE_SOCKET);
 
 
   DLLEXPORT QoreHashNode* readHttpChunk(int timeout, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreHashNode* readServerSentEvent(ExceptionSink* xsink, const QoreStringNode* content_encoding,
            int timeout_ms);
 
 
    DLLEXPORT static QoreHashNode* parseServerSentEvent(ExceptionSink* xsink, const QoreString& buf);
 
    DLLEXPORT int setSendTimeout(int ms);
 
    DLLEXPORT int setRecvTimeout(int ms);
 
    DLLEXPORT int getSendTimeout() const;
 
    DLLEXPORT int getRecvTimeout() const;
 
 
    DLLEXPORT bool isDataAvailable(int timeout_ms = 0) const;
 
 
    DLLEXPORT bool isDataAvailable(ExceptionSink* xsink, int timeout_ms = 0) const;
 
 
    DLLEXPORT int asyncIoWait(int timeout_ms, bool read, bool write) const;
 
 
    DLLEXPORT int close();
 
 
    DLLEXPORT int shutdown();
 
 
    DLLEXPORT int shutdownSSL(ExceptionSink* xsink);
 
 
    DLLEXPORT int getSocket() const;
 
 
    DLLEXPORT const QoreEncoding *getEncoding() const;
 
 
    DLLEXPORT void setEncoding(const QoreEncoding *id);
 
 
    DLLEXPORT bool isOpen() const;
 
 
    DLLEXPORT const char* getSSLCipherName() const;
 
 
    DLLEXPORT const char* getSSLCipherVersion() const;
 
 
    DLLEXPORT bool isSecure() const;
 
    DLLEXPORT long verifyPeerCertificate() const;
 
 
    DLLEXPORT int upgradeServerToSSL(ExceptionSink* xsink, int timeout_ms = -1, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT int upgradeClientToSSL(ExceptionSink* xsink, int timeout_ms = -1, QoreSSLCertificate* cert = nullptr,
            QoreSSLPrivateKey* pkey = nullptr);
 
 
    DLLEXPORT bool isWriteFinished(int timeout_ms = 0) const;
 
 
    DLLEXPORT bool isWriteFinished(ExceptionSink* xsink, int timeout_ms = 0) const;
 
 
    DLLEXPORT QoreHashNode* getPeerInfo(ExceptionSink* xsink) const;
 
 
    DLLEXPORT QoreHashNode* getPeerInfo(ExceptionSink* xsink, bool host_lookup) const;
 
 
    DLLEXPORT QoreHashNode* getSocketInfo(ExceptionSink* xsink) const;
 
 
    DLLEXPORT QoreHashNode* getSocketInfo(ExceptionSink* xsink, bool host_lookup) const;
 
    DLLEXPORT void clearWarningQueue(ExceptionSink* xsink);
    DLLEXPORT void setWarningQueue(ExceptionSink* xsink, int64 warning_ms, int64 warning_bs, Queue* wq, QoreValue arg, int64 min_ms = 1000);
    DLLEXPORT QoreHashNode* getUsageInfo() const;
    DLLEXPORT void clearStats();
 
    DLLEXPORT void cleanup(ExceptionSink* xsink);
 
    DLLEXPORT bool pendingHttpChunkedBody() const;
 
 
    DLLEXPORT void setSslVerifyMode(int mode);
 
 
    DLLEXPORT int getSslVerifyMode() const;
 
 
    DLLEXPORT void acceptAllCertificates(bool accept_all = true);
 
 
    DLLEXPORT bool getAcceptAllCertificates() const;
 
 
    DLLEXPORT bool captureRemoteCertificates(bool set);
 
 
    DLLEXPORT QoreObject* getRemoteCertificate() const;
 
 
    DLLEXPORT int64 getConnectionId() const;
 
    DLLLOCAL static void doException(int rc, const char* meth, int timeout_ms, ExceptionSink* xsink);
 
    DLLLOCAL void setEventQueue(ExceptionSink* xsink, Queue* q, QoreValue arg, bool with_data);
 
    DLLLOCAL Queue* getQueue();
 
    DLLLOCAL int64 getObjectIDForEvents() const;
 
    DLLLOCAL int setNoDelay(int nodelay);
    DLLLOCAL int getNoDelay() const;
 
    DLLLOCAL void setAccept(QoreObject* o);
 
private:
    hashdecl qore_socket_private *priv;
 
    DLLLOCAL QoreSocket(int n_sock, int n_sfamily, int n_stype, int s_prot, const QoreEncoding* csid);
 
    DLLLOCAL static void convertHeaderToHash(QoreHashNode* h, char* p);
 
    DLLLOCAL QoreSocket(const QoreSocket&) = delete;
    DLLLOCAL QoreSocket& operator=(const QoreSocket&) = delete;
};
 
class QoreSocketTimeoutHelper {
protected:
    class PrivateQoreSocketTimeoutHelper* priv;
public:
    DLLEXPORT QoreSocketTimeoutHelper(QoreSocket& s, const char* op);
    DLLEXPORT ~QoreSocketTimeoutHelper();
};
 
class QoreSocketThroughputHelper {
protected:
    class PrivateQoreSocketThroughputHelper* priv;
public:
    DLLEXPORT QoreSocketThroughputHelper(QoreSocket& s, bool snd);
    DLLEXPORT ~QoreSocketThroughputHelper();
    DLLEXPORT void finalize(int64 bytes);
};
 
#endif // _QORE_QORESOCKET_H