xssocket.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef XSSOCKET_H
#define XSSOCKET_H
 
#include "xsstring.h"
#include "xsbytearray.h"
#include "xsresultvalue.h"
#include "xstypedefs.h"
 
struct XsSocket;
struct XsSocketInterface;
typedef struct XsSocket XsSocket;
 
enum IpProtocol
{
        IP_UDP, 
        IP_TCP  
};
 
enum NetworkLayerProtocol
{
        NLP_IPV4, 
        NLP_IPV6, 
        NLP_IPVX  
};
 
enum XsSocketOption
{
        XSO_ReuseAddress,       
        XSO_ReusePort           
};
 
#ifdef WIN32
        #if defined(_WIN64)
                typedef unsigned __int64 XSOCKET;
        #else
                typedef unsigned int XSOCKET;
        #endif
#else
        typedef int XSOCKET;
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __cplusplus
#define XSSOCKET_INITIALIZER { NULL }
#endif
 
#define XSSOCKET_INFINITE_TIMEOUT -1
 
XSTYPES_DLL_API void XsSocket_create(XsSocket* thisPtr, enum NetworkLayerProtocol ip, enum IpProtocol protocol);
XSTYPES_DLL_API void XsSocket_createFromFileDescriptor(XsSocket* thisPtr, int sockfd, XsDataFlags flags);
XSTYPES_DLL_API void XsSocket_destroy(XsSocket* thisPtr);
XSTYPES_DLL_API XsResultValue XsSocket_close(XsSocket* thisPtr);
 
XSTYPES_DLL_API XSOCKET XsSocket_nativeDescriptor(XsSocket const* thisPtr);
 
XSTYPES_DLL_API int XsSocket_select(XsSocket* thisPtr, int mstimeout, int* canRead, int* canWrite);
XSTYPES_DLL_API int XsSocket_read(XsSocket* thisPtr, void* dest, XsSize size, int timeout);
XSTYPES_DLL_API int XsSocket_readFrom(XsSocket* thisPtr, void* dest, XsSize size, XsString* hostname, uint16_t* port, int timeout);
XSTYPES_DLL_API int XsSocket_read2ByteArray(XsSocket* thisPtr, XsByteArray* dest, int timeout);
XSTYPES_DLL_API int XsSocket_readFrom2ByteArray(XsSocket* thisPtr, XsByteArray* dest, XsString* hostname, uint16_t* port, int timeout);
 
XSTYPES_DLL_API int XsSocket_write(XsSocket* thisPtr, const void* buffer, XsSize size);
XSTYPES_DLL_API int XsSocket_writeTo(XsSocket* thisPtr, const void* buffer, XsSize size, const XsString* hostname, uint16_t port);
 
XSTYPES_DLL_API void XsSocket_flush(XsSocket* thisPtr);
 
XSTYPES_DLL_API XsSocket* XsSocket_accept(XsSocket* thisPtr, int mstimeout);
 
XSTYPES_DLL_API XsSocket* XsSocket_allocate();
XSTYPES_DLL_API void XsSocket_free(XsSocket* thisPtr);
 
XSTYPES_DLL_API XsResultValue XsSocket_setSocketOption(XsSocket* thisPtr, enum XsSocketOption option, void* valuePtr, int valueSize);
XSTYPES_DLL_API XsResultValue XsSocket_bind(XsSocket* thisPtr, const XsString* hostname, uint16_t port);
XSTYPES_DLL_API XsResultValue XsSocket_listen(XsSocket* thisPtr, int maxPending);
XSTYPES_DLL_API XsResultValue XsSocket_connect(XsSocket* thisPtr, const XsString* host, uint16_t port);
 
XSTYPES_DLL_API int XsSocket_isUsable(const XsSocket* thisPtr);
XSTYPES_DLL_API void XsSocket_getRemoteAddress(const XsSocket* thisPtr, XsString* address);
XSTYPES_DLL_API int XsSocket_getLastSystemError(const XsSocket* thisPtr);
XSTYPES_DLL_API int XsSocket_enableBroadcasts(XsSocket* thisPtr, int enable);
XSTYPES_DLL_API int XsSocket_broadcast(XsSocket* thisPtr, const void* buffer, XsSize size, uint16_t port);
 
#ifdef __cplusplus
}
#endif
 
struct XsSocket
{
#ifdef __cplusplus
 
        inline explicit XsSocket(IpProtocol protocol, NetworkLayerProtocol ipVersion = NLP_IPVX)
                : d(NULL)
        {
                (void)d;
                XsSocket_create(this, ipVersion, protocol);
        }
 
        inline explicit XsSocket(int sockfd, XsDataFlags flags = XSDF_None)
                : d(NULL)
        {
                (void)d;
                XsSocket_createFromFileDescriptor(this, sockfd, flags);
        }
 
        inline ~XsSocket()
        {
                XsSocket_destroy(this);
        }
 
        inline XsResultValue close()
        {
                return XsSocket_close(this);
        }
 
        inline XSOCKET nativeDescriptor() const
        {
                return XsSocket_nativeDescriptor(this);
        }
 
        inline int read(XsByteArray& buffer, int timeout = 0)
        {
                return XsSocket_read2ByteArray(this, &buffer, timeout);
        }
 
        inline int read(void* dest, XsSize size, int timeout = 0)
        {
                return XsSocket_read(this, dest, size, timeout);
        }
 
        inline int readFrom(XsByteArray& buffer, XsString* hostname = NULL, uint16_t* port = NULL, int timeout = 0)
        {
                return XsSocket_readFrom2ByteArray(this, &buffer, hostname, port, timeout);
        }
 
        inline int readFrom(void* dest, XsSize size, XsString* hostname = NULL, uint16_t* port = NULL, int timeout = 0)
        {
                return XsSocket_readFrom(this, dest, size, hostname, port, timeout);
        }
 
        int write(const XsByteArray& buffer)
        {
                return write(buffer.data(), buffer.size());
        }
 
        int write(const void* data, XsSize size)
        {
                return XsSocket_write(this, data, size);
        }
 
        int writeTo(const XsByteArray& buffer, const XsString& hostname, uint16_t port)
        {
                return writeTo(buffer.data(), buffer.size(), hostname, port);
        }
 
        int writeTo(const void* data, XsSize size, const XsString& hostname, uint16_t port)
        {
                return XsSocket_writeTo(this, data, size, &hostname, port);
        }
 
        void flush()
        {
                XsSocket_flush(this);
        }
 
        int select(int mstimeout, int* canRead, int* canWrite)
        {
                return XsSocket_select(this, mstimeout, canRead, canWrite);
        }
 
        XsSocket* accept(int mstimeout = XSSOCKET_INFINITE_TIMEOUT)
        {
                return XsSocket_accept(this, mstimeout);
        }
 
        inline void* operator new (size_t)
        {
                XsSocket* s = XsSocket_allocate();
                if (!s)
                        throw std::bad_alloc();
                return s;
        }
 
        inline void operator delete (void* p) noexcept
        {
                XsSocket_free(reinterpret_cast<XsSocket*>(p));
        }
 
        XsResultValue setSocketOption(XsSocketOption option, void* valuePtr, int valueSize)
        {
                return XsSocket_setSocketOption(this, option, valuePtr, valueSize);
        }
 
        XsResultValue setSocketOption(XsSocketOption option, int value)
        {
                return XsSocket_setSocketOption(this, option, (void*)&value, sizeof(int));
        }
 
        XsResultValue bind(uint16_t port)
        {
                return XsSocket_bind(this, NULL, port);
        }
 
        XsResultValue bind(const XsString& hostname, uint16_t port)
        {
                return XsSocket_bind(this, &hostname, port);
        }
 
        XsResultValue listen(int maxPending = 20)
        {
                return XsSocket_listen(this, maxPending);
        }
 
        XsResultValue connect(const XsString& host, uint16_t port)
        {
                return XsSocket_connect(this, &host, port);
        }
 
 
        bool isUsable() const
        {
                return XsSocket_isUsable(this) != 0;
        }
 
        XsString getRemoteAddress() const
        {
                XsString address;
                XsSocket_getRemoteAddress(this, &address);
                return address;
        }
 
        int getLastSystemError() const
        {
                return XsSocket_getLastSystemError(this);
        }
 
        int broadcast(const void* data, XsSize size, uint16_t port)
        {
                return XsSocket_broadcast(this, data, size, port);
        }
 
        bool enableBroadcasts(bool enable)
        {
                return 0 != XsSocket_enableBroadcasts(this, enable ? 1 : 0);
        }
private:
#endif
        struct XsSocketPrivate* d;
};
 
#endif