.gitignore
@@ -5,14 +5,14 @@ *.obj # Compiled Dynamic libraries *.so #*.so *.dylib *.dll # Compiled Static libraries *.lai *.la *.a #*.a *.lib # Executables README.md
@@ -2,3 +2,25 @@ Git上的开源代码 --- #### 指定安装目录 * cmake > cmake CMakeList.txt -DCMAKE_INSTALL_PREFIX=dir > > cmake ../ -DCMAKE_INSTALL_PREFIX=dir * configure > ./configure prefix==dir --- #### 编译命令 * 编译 > make -j * 安装 > make install Binary files differ
aBuild/nng/include/nng/compat/nanomsg/bus.h
New file @@ -0,0 +1,33 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_BUS_H #define NNG_COMPAT_BUS_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // BUS sockopt level. #define NN_PROTO_BUS 7 #define NN_BUS (NN_PROTO_BUS * 16 + 0) // BUS has no options. #ifdef __cplusplus } #endif #endif // NNG_COMPAT_BUS_H aBuild/nng/include/nng/compat/nanomsg/inproc.h
New file @@ -0,0 +1,31 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_INPROC_H #define NNG_COMPAT_INPROC_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // inproc sockopt level. // There are no inproc tunables. #define NN_INPROC (-1) #ifdef __cplusplus } #endif #endif // NNG_COMPAT_INPROC_H aBuild/nng/include/nng/compat/nanomsg/ipc.h
New file @@ -0,0 +1,39 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_IPC_H #define NNG_COMPAT_IPC_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // IPC sockopt level. #define NN_IPC (-2) // IPC options. Note that these are not currently supported. // IPC_SEC_ATTR works quite differently in NNG, and must be // configured using the new API. The buffer sizing options are // not supported at all. None of these were ever documente, and // are offered here only for source compatibility. #define NN_IPC_SEC_ATTR 1 #define NN_IPC_OUTBUFSZ 2 #define NN_IPC_INBUFSZ 3 #ifdef __cplusplus } #endif #endif // NNG_COMPAT_IPC_H aBuild/nng/include/nng/compat/nanomsg/nn.h
New file @@ -0,0 +1,284 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_NN_H #define NNG_COMPAT_NN_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. // Note that compatibility promises are limited to public portions of the // nanomsg API, and specifically do NOT extend to the ABI. Furthermore, // there may be other limitations around less commonly used portions of the // API; for example only SP headers may be transported in control data for // messages, there is almost no compatibility offered for statistics. // Error values may differ from those returned by nanomsg as well; the nng // error reporting facility expresses only a subset of the possibilities of // nanomsg. // Note that unlinke nanomsg, nng does not aggressively recycle socket or // endpoint IDs, which means applications which made assumptions that these // would be relatively small integers (e.g. to use them as array indices) // may break. (No promise about values was ever made.) #ifdef __cplusplus extern "C" { #endif #include <errno.h> #include <stddef.h> #include <stdint.h> // clang-format gets in the way of most of this file. // We turn it off, at least until it gets smarter about aligning // macro definitions or we adopt enums or somesuch. // clang-format off // NNG_DECL is used on declarations to deal with scope. // For building Windows DLLs, it should be the appropriate __declspec(). // For shared libraries with platforms that support hidden visibility, // it should evaluate to __attribute__((visibility("default"))). #ifndef NN_DECL #if defined(_WIN32) && !defined(NNG_STATIC_LIB) #if defined(NNG_SHARED_LIB) #define NN_DECL __declspec(dllexport) #else #define NN_DECL __declspec(dllimport) #endif // NNG_SHARED_LIB #else #if defined(NNG_SHARED_LIB) && defined(NNG_HIDDEN_VISIBILITY) #define NN_DECL __attribute__((visibility("default"))) #else #define NN_DECL extern #endif #endif // _WIN32 && !NNG_STATIC_LIB #endif // NN_DECL #define AF_SP 1 #define AF_SP_RAW 2 #define NN_SOCKADDR_MAX 128 #define NN_SOL_SOCKET 0 // Flag for send/recv (nonblocking) #define NN_DONTWAIT 1 // CMSG data type #define PROTO_SP 1 #define SP_HDR 1 // Errnos. Legacy nanomsg uses posix errnos where possible. // If a define is not set, use add NN_ERRBASE. nng does not // return all of these values, so there may be some loss of // of information for edge cases, but we don't expect that to be // a problem really. #define NN_ERRBASE (0x10000000) #ifndef ENOTSUP #define ENOTSUP (NN_ERRBASE+1) #endif #ifndef EPROTONOSUPPORT #define EPROTONOSUPPORT (NN_ERRBASE+2) #endif #ifndef ENOBUFS #define ENOBUFS (NN_ERRBASE+3) #endif #ifndef ENETDOWN #define ENETDOWN (NN_ERRBASE+4) #endif #ifndef EADDRINUSE #define EADDRINUSE (NN_ERRBASE+5) #endif #ifndef EADDRNOTAVAIL #define EADDRNOTAVAIL (NN_ERRBASE+6) #endif #ifndef ENOTSOCK #define ENOTSOCK (NN_ERRBASE+7) #endif #ifndef EAGAIN #define EAGAIN (NN_ERRBASE+8) #endif #ifndef EBADF #define EBADF (NN_ERRBASE+9) #endif #ifndef EINVAL #define EINVAL (NN_ERRBASE+10) #endif #ifndef EMFILE #define EMFILE (NN_ERRBASE+11) #endif #ifndef EFAULT #define EFAULT (NN_ERRBASE+12) #endif #ifndef EACCES #define EACCES (NN_ERRBASE+13) #endif #ifndef ENETRESET #define ENETRESET (NN_ERRBASE+14) #endif #ifndef ENETUNREACH #define ENETUNREACH (NN_ERRBASE+15) #endif #ifndef EHOSTUNREACH #define EHOSTUNREACH (NN_ERRBASE+16) #endif #ifndef EAFNOSUPPORT #define EAFNOSUPPORT (NN_ERRBASE+17) #endif #ifndef EINPROGRESS #define EINPROGRESS (NN_ERRBASE+18) #endif #ifndef EPROTO #define EPROTO (NN_ERRBASE+19) #endif #ifndef ECONNREFUSED #define ECONNREFUSED (NN_ERRBASE+20) #endif #ifndef ENOTCONN #define ENOTCONN (NN_ERRBASE+21) #endif #ifndef EMSGSIZE #define EMSGSIZE (NN_ERRBASE+22) #endif #ifndef ETIMEDOUT #define ETIMEDOUT (NN_ERRBASE+23) #endif #ifndef ECONNABORTED #define ECONNABORTED (NN_ERRBASE+24) #endif #ifndef ECONNRESET #define ECONNRESET (NN_ERRBASE+25) #endif #ifndef ENOPROTOOPT #define ENOPROTOOPT (NN_ERRBASE+26) #endif #ifndef EISCONN #define EISCONN (NN_ERRBASE+27) #endif #ifndef ESOCKNOSUPPORT #define ESOCKNOSPPORT (NN_ERRBASE+28) #endif #ifndef ETERM #define ETERM (NN_ERRBASE+29) #endif #ifndef EFSM #define EFSM (NN_ERRBASE+30) #endif #ifndef ENOENT #define ENOENT (NN_ERRBASE+31) #endif #ifndef EIO #define EIO (NN_ERRBASE+32) #endif #ifndef EEXIST #define EEXIST (NN_ERRBASE+33) #endif #ifndef ENOSPC #define ENOSPC (NN_ERRBASE+34) #endif // Socket options #define NN_LINGER 1 #define NN_SNDBUF 2 #define NN_RCVBUF 3 #define NN_SNDTIMEO 4 #define NN_RCVTIMEO 5 #define NN_RECONNECT_IVL 6 #define NN_RECONNECT_IVL_MAX 7 #define NN_SNDPRIO 8 #define NN_RCVPRIO 9 #define NN_SNDFD 10 #define NN_RCVFD 11 #define NN_DOMAIN 12 #define NN_PROTOCOL 13 #define NN_IPV4ONLY 14 #define NN_SOCKET_NAME 15 #define NN_RCVMAXSIZE 16 #define NN_MAXTTL 17 // from this point on formatting is fine // clang-format on // Poll stuff #define NN_POLLIN 1 #define NN_POLLOUT 2 struct nn_pollfd { int fd; uint16_t events; uint16_t revents; }; // Magical size for allocation #define NN_MSG ((size_t) -1) struct nn_iovec { void * iov_base; size_t iov_len; }; struct nn_msghdr { struct nn_iovec *msg_iov; int msg_iovlen; void * msg_control; size_t msg_controllen; }; struct nn_cmsghdr { size_t cmsg_len; int cmsg_level; int cmsg_type; }; #define NN_CMSG_ALIGN(len) \ (((len) + sizeof(size_t) - 1) & (size_t) ~(sizeof(size_t) - 1)) // Unlike old nanomsg, we explicitly only support the SP header as attached // cmsg data. It turns out that old nanomsg didn't really store anything // useful otherwise anyway. (One specific exception was that it stored the // message type of text or binary for the websocket transport. We don't think // anyone used that in practice though.) #define NN_CMSG_FIRSTHDR(mh) nn_cmsg_next((struct nn_msghdr *) (mh), NULL) #define NN_CMSG_NXTHDR(mh, ch) \ nn_cmsg_next((struct nn_msghdr *) (mh), (struct nn_cmsghdr *) ch) #define NN_CMSG_DATA(ch) ((unsigned char *) (((struct nn_cmsghdr *) (ch)) + 1)) #define NN_CMSG_SPACE(len) \ (NN_CMSG_ALIGN(len) + NN_CMSG_ALIGN(sizeof(struct nn_cmsghdr))) #define NN_CMSG_LEN(len) (NN_CMSG_ALIGN(sizeof(struct nn_cmsghdr)) + (len)) NN_DECL struct nn_cmsghdr *nn_cmsg_next( struct nn_msghdr *, struct nn_cmsghdr *); NN_DECL int nn_socket(int, int); NN_DECL int nn_setsockopt(int, int, int, const void *, size_t); NN_DECL int nn_getsockopt(int, int, int, void *, size_t *); NN_DECL int nn_bind(int, const char *); NN_DECL int nn_connect(int, const char *); NN_DECL int nn_shutdown(int, int); NN_DECL int nn_send(int, const void *, size_t, int); NN_DECL int nn_recv(int, void *, size_t, int); NN_DECL int nn_sendmsg(int, const struct nn_msghdr *, int); NN_DECL int nn_recvmsg(int, struct nn_msghdr *, int); NN_DECL int nn_close(int); NN_DECL int nn_poll(struct nn_pollfd *, int, int); NN_DECL int nn_device(int, int); NN_DECL uint64_t nn_get_statistic(int, int); NN_DECL void * nn_allocmsg(size_t, int); NN_DECL void * nn_reallocmsg(void *, size_t); NN_DECL int nn_freemsg(void *); NN_DECL int nn_errno(void); NN_DECL const char *nn_strerror(int); NN_DECL void nn_term(void); #ifdef __cplusplus } #endif #endif // NNG_COMPAT_NN_H aBuild/nng/include/nng/compat/nanomsg/pair.h
New file @@ -0,0 +1,39 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_PAIR_H #define NNG_COMPAT_PAIR_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // PAIR sockopt level. #define NN_PROTO_PAIR 1 #define NN_PAIR (NN_PROTO_PAIR * 16 + 0) // These are technically "new", and not available in nanomsg, but // offered here as a transition aid. If you want to use the advanced // PAIRv1 options (POLYAMOROUS mode) you still need to use the new API. #define NN_PAIR_v0 (NN_PROTO_PAIR * 16 + 0) #define NN_PAIR_V1 (NN_PROTO_PAIR * 16 + 1) // PAIR has no options. #ifdef __cplusplus } #endif #endif // NNG_COMPAT_PAIR_H aBuild/nng/include/nng/compat/nanomsg/pipeline.h
New file @@ -0,0 +1,34 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_PIPELINE_H #define NNG_COMPAT_PIPELINE_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // PUSH and PULL sockopt level. #define NN_PROTO_PIPELINE 5 #define NN_PUSH (NN_PROTO_PIPELINE * 16 + 0) #define NN_PULL (NN_PROTO_PIPELINE * 16 + 1) // PUSH and PULL have no options. #ifdef __cplusplus } #endif #endif // NNG_COMPAT_PIPELINE_H aBuild/nng/include/nng/compat/nanomsg/pubsub.h
New file @@ -0,0 +1,36 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_PUBSUB_H #define NNG_COMPAT_PUBSUB_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // PUB and SUB sockopt level. #define NN_PROTO_PUBSUB 2 #define NN_PUB (NN_PROTO_PUBSUB * 16 + 0) #define NN_SUB (NN_PROTO_PUBSUB * 16 + 1) // SUB options. (PUB has none.) #define NN_SUB_SUBSCRIBE (NN_SUB * 16 + 1) #define NN_SUB_UNSUBSCRIBE (NN_SUB * 16 + 2) #ifdef __cplusplus } #endif #endif // NNG_COMPAT_PUBSUB_H aBuild/nng/include/nng/compat/nanomsg/reqrep.h
New file @@ -0,0 +1,35 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_REQREP_H #define NNG_COMPAT_REQREP_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // REQ and REP sockopt level. #define NN_PROTO_REQREP 3 #define NN_REQ (NN_PROTO_REQREP * 16 + 0) #define NN_REP (NN_PROTO_REQREP * 16 + 1) // REQ options. (REP has none.) #define NN_REQ_RESEND_IVL (NN_REQ * 16 + 1) #ifdef __cplusplus } #endif #endif // NNG_COMPAT_REQREP_H aBuild/nng/include/nng/compat/nanomsg/survey.h
New file @@ -0,0 +1,36 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_SURVEY_H #define NNG_COMPAT_SURVEY_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // SURVEYOR and RESPONDENT sockopt level. #define NN_PROTO_SURVEY 6 #define NN_SURVEYOR (NN_PROTO_SURVEY * 16 + 2) #define NN_RESPONDENT (NN_PROTO_SURVEY * 16 + 3) // SURVEYOR options. (RESPONDENT has none.) #define NN_SURVEYOR_DEADLINE (NN_SURVEYOR * 16 + 1) #ifdef __cplusplus } #endif #endif // NNG_COMPAT_SURVEY_H aBuild/nng/include/nng/compat/nanomsg/tcp.h
New file @@ -0,0 +1,33 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_TCP_H #define NNG_COMPAT_TCP_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // TCP sockopt level. #define NN_TCP (-3) // TCP options. #define NN_TCP_NODELAY 1 #ifdef __cplusplus } #endif #endif // NNG_COMPAT_TCP_H aBuild/nng/include/nng/compat/nanomsg/ws.h
New file @@ -0,0 +1,41 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_COMPAT_WS_H #define NNG_COMPAT_WS_H // This header contains interfaces that are intended to offer compatibility // with nanomsg v1.0. These are not the "preferred" interfaces for nng, // and consumers should only use these if they are porting software that // previously used nanomsg. New programs should use the nng native APIs. #ifdef __cplusplus extern "C" { #endif // WS sockopt level. #define NN_WS (-4) // WS options. // Note that while legacy libnanomsg had *some* support for text messages, // NNG only supports binary. Binary types are required to pass protocol // headers with NNG and nanomsg in any event. This means that the NNG // WebSocket support will not be compatible with some very old browsers. #define NN_WS_MSG_TYPE 1 #define NN_WS_MSG_TYPE_TEXT 0x1 #define NN_WS_MSG_TYPE_BINARY 0x2 #ifdef __cplusplus } #endif #endif // NNG_COMPAT_WS_H aBuild/nng/include/nng/nng.h
New file @@ -0,0 +1,980 @@ // // Copyright 2019 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_H #define NNG_H // NNG (nanomsg-next-gen) is an improved implementation of the SP protocols. // The APIs have changed, and there is no attempt to provide API compatibility // with legacy libnanomsg. This file defines the library consumer-facing // Public API. Use of definitions or declarations not found in this header // file is specfically unsupported and strongly discouraged. #ifdef __cplusplus extern "C" { #endif #include <stdbool.h> #include <stddef.h> #include <stdint.h> // NNG_DECL is used on declarations to deal with scope. // For building Windows DLLs, it should be the appropriate __declspec(). // For shared libraries with platforms that support hidden visibility, // it should evaluate to __attribute__((visibility("default"))). #ifndef NNG_DECL #if defined(_WIN32) && !defined(NNG_STATIC_LIB) #if defined(NNG_SHARED_LIB) #define NNG_DECL __declspec(dllexport) #else #define NNG_DECL __declspec(dllimport) #endif // NNG_SHARED_LIB #else #if defined(NNG_SHARED_LIB) && defined(NNG_HIDDEN_VISIBILITY) #define NNG_DECL __attribute__((visibility("default"))) #else #define NNG_DECL extern #endif #endif // _WIN32 && !NNG_STATIC_LIB #endif // NNG_DECL // NNG Library & API version. // We use SemVer, and these versions are about the API, and // may not necessarily match the ABI versions. Right now at // version 0, you should not be making any forward compatibility // assumptions. #define NNG_MAJOR_VERSION 1 #define NNG_MINOR_VERSION 1 #define NNG_PATCH_VERSION 1 #define NNG_RELEASE_SUFFIX "" // if non-empty, this is a pre-release // Maximum length of a socket address. This includes the terminating NUL. // This limit is built into other implementations, so do not change it. // Note that some transports are quite happy to let you use addresses // in excess of this, but if you do you may not be able to communicate // with other implementations. #define NNG_MAXADDRLEN (128) // Types common to nng. // Identifiers are wrapped in a structure to improve compiler validation // of incorrect passing. This gives us strong type checking. Modern // compilers compile passing these by value to identical code as passing // the integer type (at least with optimization applied). Please do not // access the ID member directly. typedef struct nng_ctx_s { uint32_t id; } nng_ctx; typedef struct nng_dialer_s { uint32_t id; } nng_dialer; typedef struct nng_listener_s { uint32_t id; } nng_listener; typedef struct nng_pipe_s { uint32_t id; } nng_pipe; typedef struct nng_socket_s { uint32_t id; } nng_socket; typedef int32_t nng_duration; // in milliseconds typedef struct nng_msg nng_msg; typedef struct nng_stat nng_stat; typedef struct nng_aio nng_aio; // Initializers. // clang-format off #define NNG_PIPE_INITIALIZER { 0 } #define NNG_SOCKET_INITIALIZER { 0 } #define NNG_DIALER_INITIALIZER { 0 } #define NNG_LISTENER_INITIALIZER { 0 } #define NNG_CTX_INITIALIZER { 0 } // clang-format on // Some address details. This is in some ways like a traditional sockets // sockaddr, but we have our own to cope with our unique families, etc. // The details of this structure are directly exposed to applications. // These structures can be obtained via property lookups, etc. struct nng_sockaddr_inproc { uint16_t sa_family; char sa_name[NNG_MAXADDRLEN]; }; typedef struct nng_sockaddr_inproc nng_sockaddr_inproc; struct nng_sockaddr_path { uint16_t sa_family; char sa_path[NNG_MAXADDRLEN]; }; typedef struct nng_sockaddr_path nng_sockaddr_path; typedef struct nng_sockaddr_path nng_sockaddr_ipc; struct nng_sockaddr_in6 { uint16_t sa_family; uint16_t sa_port; uint8_t sa_addr[16]; }; typedef struct nng_sockaddr_in6 nng_sockaddr_in6; typedef struct nng_sockaddr_in6 nng_sockaddr_udp6; typedef struct nng_sockaddr_in6 nng_sockaddr_tcp6; struct nng_sockaddr_in { uint16_t sa_family; uint16_t sa_port; uint32_t sa_addr; }; struct nng_sockaddr_zt { uint16_t sa_family; uint64_t sa_nwid; uint64_t sa_nodeid; uint32_t sa_port; }; typedef struct nng_sockaddr_in nng_sockaddr_in; typedef struct nng_sockaddr_in nng_sockaddr_udp; typedef struct nng_sockaddr_in nng_sockaddr_tcp; typedef struct nng_sockaddr_zt nng_sockaddr_zt; typedef union nng_sockaddr { uint16_t s_family; nng_sockaddr_ipc s_ipc; nng_sockaddr_inproc s_inproc; nng_sockaddr_in6 s_in6; nng_sockaddr_in s_in; nng_sockaddr_zt s_zt; } nng_sockaddr; enum nng_sockaddr_family { NNG_AF_UNSPEC = 0, NNG_AF_INPROC = 1, NNG_AF_IPC = 2, NNG_AF_INET = 3, NNG_AF_INET6 = 4, NNG_AF_ZT = 5 // ZeroTier }; // Scatter/gather I/O. typedef struct nng_iov { void * iov_buf; size_t iov_len; } nng_iov; // Some definitions for durations used with timeouts. #define NNG_DURATION_INFINITE (-1) #define NNG_DURATION_DEFAULT (-2) #define NNG_DURATION_ZERO (0) // nng_fini is used to terminate the library, freeing certain global resources. // This should only be called during atexit() or just before dlclose(). // THIS FUNCTION MUST NOT BE CALLED CONCURRENTLY WITH ANY OTHER FUNCTION // IN THIS LIBRARY; IT IS NOT REENTRANT OR THREADSAFE. // // For most cases, this call is unnecessary, but it is provided to assist // when debugging with memory checkers (e.g. valgrind). Calling this // function prevents global library resources from being reported incorrectly // as memory leaks. In those cases, we recommend doing this with atexit(). NNG_DECL void nng_fini(void); // nng_close closes the socket, terminating all activity and // closing any underlying connections and releasing any associated // resources. NNG_DECL int nng_close(nng_socket); // nng_socket_id returns the positive socket id for the socket, or -1 // if the socket is not valid. NNG_DECL int nng_socket_id(nng_socket); // nng_closeall closes all open sockets. Do not call this from // a library; it will affect all sockets. NNG_DECL void nng_closeall(void); // nng_setopt sets an option for a specific socket. NNG_DECL int nng_setopt(nng_socket, const char *, const void *, size_t); NNG_DECL int nng_setopt_bool(nng_socket, const char *, bool); NNG_DECL int nng_setopt_int(nng_socket, const char *, int); NNG_DECL int nng_setopt_ms(nng_socket, const char *, nng_duration); NNG_DECL int nng_setopt_size(nng_socket, const char *, size_t); NNG_DECL int nng_setopt_uint64(nng_socket, const char *, uint64_t); NNG_DECL int nng_setopt_string(nng_socket, const char *, const char *); NNG_DECL int nng_setopt_ptr(nng_socket, const char *, void *); // nng_socket_getopt obtains the option for a socket. NNG_DECL int nng_getopt(nng_socket, const char *, void *, size_t *); NNG_DECL int nng_getopt_bool(nng_socket, const char *, bool *); NNG_DECL int nng_getopt_int(nng_socket, const char *, int *); NNG_DECL int nng_getopt_ms(nng_socket, const char *, nng_duration *); NNG_DECL int nng_getopt_size(nng_socket, const char *, size_t *); NNG_DECL int nng_getopt_uint64(nng_socket, const char *, uint64_t *); NNG_DECL int nng_getopt_ptr(nng_socket, const char *, void **); // Arguably the pipe callback functions could be handled as an option, // but with the need to specify an argument, we find it best to unify // this as a separate function to pass in the argument and the callback. // Only one callback can be set on a given socket, and there is no way // to retrieve the old value. typedef enum { NNG_PIPE_EV_ADD_PRE, // Called just before pipe added to socket NNG_PIPE_EV_ADD_POST, // Called just after pipe added to socket NNG_PIPE_EV_REM_POST, // Called just after pipe removed from socket NNG_PIPE_EV_NUM, // Used internally, must be last. } nng_pipe_ev; typedef void (*nng_pipe_cb)(nng_pipe, int, void *); // nng_pipe_notify registers a callback to be executed when the // given event is triggered. To watch for different events, register // multiple times. Each event can have at most one callback registered. NNG_DECL int nng_pipe_notify(nng_socket, int, nng_pipe_cb, void *); // nng_getopt_string is special -- it allocates a string to hold the // resulting string, which should be freed with nng_strfree when it is // no logner needed. NNG_DECL int nng_getopt_string(nng_socket, const char *, char **); // nng_listen creates a listening endpoint with no special options, // and starts it listening. It is functionally equivalent to the legacy // nn_bind(). The underlying endpoint is returned back to the caller in the // endpoint pointer, if it is not NULL. The flags are ignored at present. NNG_DECL int nng_listen(nng_socket, const char *, nng_listener *, int); // nng_dial creates a dialing endpoint, with no special options, and // starts it dialing. Dialers have at most one active connection at a time // This is similar to the legacy nn_connect(). The underlying endpoint // is returned back to the caller in the endpoint pointer, if it is not NULL. // The flags may be NNG_FLAG_NONBLOCK to indicate that the first attempt to // dial will be made in the background, returning control to the caller // immediately. In this case, if the connection fails, the function will // keep retrying in the background. (If the connection is dropped in either // case, it will still be reconnected in the background -- only the initial // connection attempt is normally synchronous.) NNG_DECL int nng_dial(nng_socket, const char *, nng_dialer *, int); // nng_dialer_create creates a new dialer, that is not yet started. NNG_DECL int nng_dialer_create(nng_dialer *, nng_socket, const char *); // nng_listener_create creates a new listener, that is not yet started. NNG_DECL int nng_listener_create(nng_listener *, nng_socket, const char *); // nng_dialer_start starts the endpoint dialing. This is only possible if // the dialer is not already dialing. NNG_DECL int nng_dialer_start(nng_dialer, int); // nng_listener_start starts the endpoint listening. This is only possible if // the listener is not already listening. NNG_DECL int nng_listener_start(nng_listener, int); // nng_dialer_close closes the dialer, shutting down all underlying // connections and releasing all associated resources. NNG_DECL int nng_dialer_close(nng_dialer); // nng_listener_close closes the listener, shutting down all underlying // connections and releasing all associated resources. NNG_DECL int nng_listener_close(nng_listener); // nng_dialer_id returns the positive dialer ID, or -1 if the dialer is // invalid. NNG_DECL int nng_dialer_id(nng_dialer); // nng_listener_id returns the positive listener ID, or -1 if the listener is // invalid. NNG_DECL int nng_listener_id(nng_listener); // nng_dialer_setopt sets an option for a specific dialer. Note // dialer options may not be altered on a running dialer. NNG_DECL int nng_dialer_setopt(nng_dialer, const char *, const void *, size_t); NNG_DECL int nng_dialer_setopt_bool(nng_dialer, const char *, bool); NNG_DECL int nng_dialer_setopt_int(nng_dialer, const char *, int); NNG_DECL int nng_dialer_setopt_ms(nng_dialer, const char *, nng_duration); NNG_DECL int nng_dialer_setopt_size(nng_dialer, const char *, size_t); NNG_DECL int nng_dialer_setopt_uint64(nng_dialer, const char *, uint64_t); NNG_DECL int nng_dialer_setopt_ptr(nng_dialer, const char *, void *); NNG_DECL int nng_dialer_setopt_string(nng_dialer, const char *, const char *); // nng_dialer_getopt obtains the option for a dialer. This will // fail for options that a particular dialer is not interested in, // even if they were set on the socket. NNG_DECL int nng_dialer_getopt(nng_dialer, const char *, void *, size_t *); NNG_DECL int nng_dialer_getopt_bool(nng_dialer, const char *, bool *); NNG_DECL int nng_dialer_getopt_int(nng_dialer, const char *, int *); NNG_DECL int nng_dialer_getopt_ms(nng_dialer, const char *, nng_duration *); NNG_DECL int nng_dialer_getopt_size(nng_dialer, const char *, size_t *); NNG_DECL int nng_dialer_getopt_sockaddr( nng_dialer, const char *, nng_sockaddr *); NNG_DECL int nng_dialer_getopt_uint64(nng_dialer, const char *, uint64_t *); NNG_DECL int nng_dialer_getopt_ptr(nng_dialer, const char *, void **); // nng_dialer_getopt_string is special -- it allocates a string to hold the // resulting string, which should be freed with nng_strfree when it is // no logner needed. NNG_DECL int nng_dialer_getopt_string(nng_dialer, const char *, char **); // nng_listener_setopt sets an option for a dialer. This value is // not stored in the socket. Subsequent setopts on the socket may // override these value however. Note listener options may not be altered // on a running listener. NNG_DECL int nng_listener_setopt( nng_listener, const char *, const void *, size_t); NNG_DECL int nng_listener_setopt_bool(nng_listener, const char *, bool); NNG_DECL int nng_listener_setopt_int(nng_listener, const char *, int); NNG_DECL int nng_listener_setopt_ms(nng_listener, const char *, nng_duration); NNG_DECL int nng_listener_setopt_size(nng_listener, const char *, size_t); NNG_DECL int nng_listener_setopt_uint64(nng_listener, const char *, uint64_t); NNG_DECL int nng_listener_setopt_ptr(nng_listener, const char *, void *); NNG_DECL int nng_listener_setopt_string( nng_listener, const char *, const char *); // nng_listener_getopt obtains the option for a listener. This will // fail for options that a particular listener is not interested in, // even if they were set on the socket. NNG_DECL int nng_listener_getopt(nng_listener, const char *, void *, size_t *); NNG_DECL int nng_listener_getopt_bool(nng_listener, const char *, bool *); NNG_DECL int nng_listener_getopt_int(nng_listener, const char *, int *); NNG_DECL int nng_listener_getopt_ms( nng_listener, const char *, nng_duration *); NNG_DECL int nng_listener_getopt_size(nng_listener, const char *, size_t *); NNG_DECL int nng_listener_getopt_sockaddr( nng_listener, const char *, nng_sockaddr *); NNG_DECL int nng_listener_getopt_uint64( nng_listener, const char *, uint64_t *); NNG_DECL int nng_listener_getopt_ptr(nng_listener, const char *, void **); // nng_listener_getopt_string is special -- it allocates a string to hold the // resulting string, which should be freed with nng_strfree when it is // no logner needed. NNG_DECL int nng_listener_getopt_string(nng_listener, const char *, char **); // nng_strerror returns a human readable string associated with the error // code supplied. NNG_DECL const char *nng_strerror(int); // nng_send sends (or arranges to send) the data on the socket. Note that // this function may (will!) return before any receiver has actually // received the data. The return value will be zero to indicate that the // socket has accepted the entire data for send, or an errno to indicate // failure. The flags may include NNG_FLAG_NONBLOCK or NNG_FLAG_ALLOC. // If the flag includes NNG_FLAG_ALLOC, then the function will call // nng_free() on the supplied pointer & size on success. (If the call // fails then the memory is not freed.) NNG_DECL int nng_send(nng_socket, void *, size_t, int); // nng_recv receives message data into the socket, up to the supplied size. // The actual size of the message data will be written to the value pointed // to by size. The flags may include NNG_FLAG_NONBLOCK and NNG_FLAG_ALLOC. // If NNG_FLAG_ALLOC is supplied then the library will allocate memory for // the caller. In that case the pointer to the allocated will be stored // instead of the data itself. The caller is responsible for freeing the // associated memory with nng_free(). NNG_DECL int nng_recv(nng_socket, void *, size_t *, int); // nng_sendmsg is like nng_send, but offers up a message structure, which // gives the ability to provide more control over the message, including // providing backtrace information. It also can take a message that was // obtain via nn_recvmsg, allowing for zero copy forwarding. NNG_DECL int nng_sendmsg(nng_socket, nng_msg *, int); // nng_recvmsg is like nng_recv, but is used to obtain a message structure // as well as the data buffer. This can be used to obtain more information // about where the message came from, access raw headers, etc. It also // can be passed off directly to nng_sendmsg. NNG_DECL int nng_recvmsg(nng_socket, nng_msg **, int); // nng_send_aio sends data on the socket asynchronously. As with nng_send, // the completion may be executed before the data has actually been delivered, // but only when it is accepted for delivery. The supplied AIO must have // been initialized, and have an associated message. The message will be // "owned" by the socket if the operation completes successfully. Otherwise // the caller is responsible for freeing it. NNG_DECL void nng_send_aio(nng_socket, nng_aio *); // nng_recv_aio receives data on the socket asynchronously. On a successful // result, the AIO will have an associated message, that can be obtained // with nng_aio_get_msg(). The caller takes ownership of the message at // this point. NNG_DECL void nng_recv_aio(nng_socket, nng_aio *); // Context support. User contexts are not supported by all protocols, // but for those that do, they give a way to create multiple contexts // on a single socket, each of which runs the protocol's state machinery // independently, offering a way to achieve concurrent protocol support // without resorting to raw mode sockets. See the protocol specific // documentation for further details. (Note that at this time, only // asynchronous send/recv are supported for contexts, but its easy enough // to make synchronous versions with nng_aio_wait().) Note that nng_close // of the parent socket will *block* as long as any contexts are open. // nng_ctx_open creates a context. This returns NNG_ENOTSUP if the // protocol implementation does not support separate contexts. NNG_DECL int nng_ctx_open(nng_ctx *, nng_socket); // nng_ctx_close closes the context. NNG_DECL int nng_ctx_close(nng_ctx); // nng_ctx_id returns the numeric id for the context; this will be // a postive value for a valid context, or < 0 for an invalid context. // A valid context is not necessarily an *open* context. NNG_DECL int nng_ctx_id(nng_ctx); // nng_ctx_recv receives asynchronously. It works like nng_recv_aio, but // uses a local context instead of the socket global context. NNG_DECL void nng_ctx_recv(nng_ctx, nng_aio *); // nng_ctx_send sends asynchronously. It works like nng_send_aio, but // uses a local context instead of the socket global context. NNG_DECL void nng_ctx_send(nng_ctx, nng_aio *); // nng_ctx_getopt is used to retrieve a context-specific option. This // can only be used for those options that relate to specific context // tunables (which does include NNG_OPT_SENDTIMEO and NNG_OPT_RECVTIMEO); // see the protocol documentation for more details. NNG_DECL int nng_ctx_getopt(nng_ctx, const char *, void *, size_t *); NNG_DECL int nng_ctx_getopt_bool(nng_ctx, const char *, bool *); NNG_DECL int nng_ctx_getopt_int(nng_ctx, const char *, int *); NNG_DECL int nng_ctx_getopt_ms(nng_ctx, const char *, nng_duration *); NNG_DECL int nng_ctx_getopt_size(nng_ctx, const char *, size_t *); // nng_ctx_setopt is used to set a context-specific option. This // can only be used for those options that relate to specific context // tunables (which does include NNG_OPT_SENDTIMEO and NNG_OPT_RECVTIMEO); // see the protocol documentation for more details. NNG_DECL int nng_ctx_setopt(nng_ctx, const char *, const void *, size_t); NNG_DECL int nng_ctx_setopt_bool(nng_ctx, const char *, bool); NNG_DECL int nng_ctx_setopt_int(nng_ctx, const char *, int); NNG_DECL int nng_ctx_setopt_ms(nng_ctx, const char *, nng_duration); NNG_DECL int nng_ctx_setopt_size(nng_ctx, const char *, size_t); // nng_alloc is used to allocate memory. It's intended purpose is for // allocating memory suitable for message buffers with nng_send(). // Applications that need memory for other purposes should use their platform // specific API. NNG_DECL void *nng_alloc(size_t); // nng_free is used to free memory allocated with nng_alloc, which includes // memory allocated by nng_recv() when the NNG_FLAG_ALLOC message is supplied. // As the application is required to keep track of the size of memory, this // is probably less convenient for general uses than the C library malloc and // calloc. NNG_DECL void nng_free(void *, size_t); // nng_strdup duplicates the source string, using nng_alloc. The result // should be freed with nng_strfree (or nng_free(strlen(s)+1)). NNG_DECL char *nng_strdup(const char *); // nng_strfree is equivalent to nng_free(strlen(s)+1). NNG_DECL void nng_strfree(char *); // Async IO API. AIO structures can be thought of as "handles" to // support asynchronous operations. They contain the completion callback, and // a pointer to consumer data. This is similar to how overlapped I/O // works in Windows, when used with a completion callback. // // AIO structures can carry up to 4 distinct input values, and up to // 4 distinct output values, and up to 4 distinct "private state" values. // The meaning of the inputs and the outputs are determined by the // I/O functions being called. // nng_aio_alloc allocates a new AIO, and associated the completion // callback and its opaque argument. If NULL is supplied for the // callback, then the caller must use nng_aio_wait() to wait for the // operation to complete. If the completion callback is not NULL, then // when a submitted operation completes (or is canceled or fails) the // callback will be executed, generally in a different thread, with no // locks held. NNG_DECL int nng_aio_alloc(nng_aio **, void (*)(void *), void *); // nng_aio_free frees the AIO and any associated resources. // It *must not* be in use at the time it is freed. NNG_DECL void nng_aio_free(nng_aio *); // nng_aio_stop stops any outstanding operation, and waits for the // AIO to be free, including for the callback to have completed // execution. Therefore the caller must NOT hold any locks that // are acquired in the callback, or deadlock will occur. NNG_DECL void nng_aio_stop(nng_aio *); // nng_aio_result returns the status/result of the operation. This // will be zero on successful completion, or an nng error code on // failure. NNG_DECL int nng_aio_result(nng_aio *); // nng_aio_count returns the number of bytes transferred for certain // I/O operations. This is meaningless for other operations (e.g. // DNS lookups or TCP connection setup). NNG_DECL size_t nng_aio_count(nng_aio *); // nng_aio_cancel attempts to cancel any in-progress I/O operation. // The AIO callback will still be executed, but if the cancellation is // successful then the status will be NNG_ECANCELED. NNG_DECL void nng_aio_cancel(nng_aio *); // nng_aio_abort is like nng_aio_cancel, but allows for a different // error result to be returned. NNG_DECL void nng_aio_abort(nng_aio *, int); // nng_aio_wait waits synchronously for any pending operation to complete. // It also waits for the callback to have completed execution. Therefore, // the caller of this function must not hold any locks acquired by the // callback or deadlock may occur. NNG_DECL void nng_aio_wait(nng_aio *); // nng_aio_set_msg sets the message structure to use for asynchronous // message send operations. NNG_DECL void nng_aio_set_msg(nng_aio *, nng_msg *); // nng_aio_get_msg returns the message structure associated with a completed // receive operation. NNG_DECL nng_msg *nng_aio_get_msg(nng_aio *); // nng_aio_set_input sets an input parameter at the given index. NNG_DECL int nng_aio_set_input(nng_aio *, unsigned, void *); // nng_aio_get_input retrieves the input parameter at the given index. NNG_DECL void *nng_aio_get_input(nng_aio *, unsigned); // nng_aio_set_output sets an output result at the given index. NNG_DECL int nng_aio_set_output(nng_aio *, unsigned, void *); // nng_aio_get_output retrieves the output result at the given index. NNG_DECL void *nng_aio_get_output(nng_aio *, unsigned); // nng_aio_set_timeout sets a timeout on the AIO. This should be called for // operations that should time out after a period. The timeout should be // either a positive number of milliseconds, or NNG_DURATION_INFINITE to // indicate that the operation has no timeout. A poll may be done by // specifying NNG_DURATION_ZERO. The value NNG_DURATION_DEFAULT indicates // that any socket specific timeout should be used. NNG_DECL void nng_aio_set_timeout(nng_aio *, nng_duration); // nng_aio_set_iov sets a scatter/gather vector on the aio. The iov array // itself is copied. Data members (the memory regions referenced) *may* be // copied as well, depending on the operation. This operation is guaranteed // to succeed if n <= 4, otherwise it may fail due to NNG_ENOMEM. NNG_DECL int nng_aio_set_iov(nng_aio *, unsigned, const nng_iov *); // nng_aio_begin is called by the provider to mark the operation as // beginning. If it returns false, then the provider must take no // further action on the aio. NNG_DECL bool nng_aio_begin(nng_aio *); // nng_aio_finish is used to "finish" an asynchronous operation. // It should only be called by "providers" (such as HTTP server API users). // The argument is the value that nng_aio_result() should return. // IMPORTANT: Callers must ensure that this is called EXACTLY ONCE on any // given aio. NNG_DECL void nng_aio_finish(nng_aio *, int); // nng_aio_defer is used to register a cancellation routine, and indicate // that the operation will be completed asynchronously. It must only be // called once per operation on an aio, and must only be called by providers. // If the operation is canceled by the consumer, the cancellation callback // will be called. The provider *must* still ensure that the nng_aio_finish() // function is called EXACTLY ONCE. If the operation cannot be canceled // for any reason, the cancellation callback should do nothing. The // final argument is passed to the cancelfn. The final argument of the // cancellation function is the error number (will not be zero) corresponding // to the reason for cancellation, e.g. NNG_ETIMEDOUT or NNG_ECANCELED. typedef void (*nng_aio_cancelfn)(nng_aio *, void *, int); NNG_DECL void nng_aio_defer(nng_aio *, nng_aio_cancelfn, void *); // nng_aio_sleep does a "sleeping" operation, basically does nothing // but wait for the specified number of milliseconds to expire, then // calls the callback. This returns 0, rather than NNG_ETIMEDOUT. NNG_DECL void nng_sleep_aio(nng_duration, nng_aio *); // Message API. NNG_DECL int nng_msg_alloc(nng_msg **, size_t); NNG_DECL void nng_msg_free(nng_msg *); NNG_DECL int nng_msg_realloc(nng_msg *, size_t); NNG_DECL void *nng_msg_header(nng_msg *); NNG_DECL size_t nng_msg_header_len(const nng_msg *); NNG_DECL void * nng_msg_body(nng_msg *); NNG_DECL size_t nng_msg_len(const nng_msg *); NNG_DECL int nng_msg_append(nng_msg *, const void *, size_t); NNG_DECL int nng_msg_insert(nng_msg *, const void *, size_t); NNG_DECL int nng_msg_trim(nng_msg *, size_t); NNG_DECL int nng_msg_chop(nng_msg *, size_t); NNG_DECL int nng_msg_header_append(nng_msg *, const void *, size_t); NNG_DECL int nng_msg_header_insert(nng_msg *, const void *, size_t); NNG_DECL int nng_msg_header_trim(nng_msg *, size_t); NNG_DECL int nng_msg_header_chop(nng_msg *, size_t); NNG_DECL int nng_msg_header_append_u16(nng_msg *, uint16_t); NNG_DECL int nng_msg_header_append_u32(nng_msg *, uint32_t); NNG_DECL int nng_msg_header_append_u64(nng_msg *, uint64_t); NNG_DECL int nng_msg_header_insert_u16(nng_msg *, uint16_t); NNG_DECL int nng_msg_header_insert_u32(nng_msg *, uint32_t); NNG_DECL int nng_msg_header_insert_u64(nng_msg *, uint64_t); NNG_DECL int nng_msg_header_chop_u16(nng_msg *, uint16_t *); NNG_DECL int nng_msg_header_chop_u32(nng_msg *, uint32_t *); NNG_DECL int nng_msg_header_chop_u64(nng_msg *, uint64_t *); NNG_DECL int nng_msg_header_trim_u16(nng_msg *, uint16_t *); NNG_DECL int nng_msg_header_trim_u32(nng_msg *, uint32_t *); NNG_DECL int nng_msg_header_trim_u64(nng_msg *, uint64_t *); NNG_DECL int nng_msg_append_u16(nng_msg *, uint16_t); NNG_DECL int nng_msg_append_u32(nng_msg *, uint32_t); NNG_DECL int nng_msg_append_u64(nng_msg *, uint64_t); NNG_DECL int nng_msg_insert_u16(nng_msg *, uint16_t); NNG_DECL int nng_msg_insert_u32(nng_msg *, uint32_t); NNG_DECL int nng_msg_insert_u64(nng_msg *, uint64_t); NNG_DECL int nng_msg_chop_u16(nng_msg *, uint16_t *); NNG_DECL int nng_msg_chop_u32(nng_msg *, uint32_t *); NNG_DECL int nng_msg_chop_u64(nng_msg *, uint64_t *); NNG_DECL int nng_msg_trim_u16(nng_msg *, uint16_t *); NNG_DECL int nng_msg_trim_u32(nng_msg *, uint32_t *); NNG_DECL int nng_msg_trim_u64(nng_msg *, uint64_t *); NNG_DECL int nng_msg_dup(nng_msg **, const nng_msg *); NNG_DECL void nng_msg_clear(nng_msg *); NNG_DECL void nng_msg_header_clear(nng_msg *); NNG_DECL void nng_msg_set_pipe(nng_msg *, nng_pipe); NNG_DECL nng_pipe nng_msg_get_pipe(const nng_msg *); NNG_DECL int nng_msg_getopt(nng_msg *, int, void *, size_t *); // Pipe API. Generally pipes are only "observable" to applications, but // we do permit an application to close a pipe. This can be useful, for // example during a connection notification, to disconnect a pipe that // is associated with an invalid or untrusted remote peer. NNG_DECL int nng_pipe_getopt(nng_pipe, const char *, void *, size_t *); NNG_DECL int nng_pipe_getopt_bool(nng_pipe, const char *, bool *); NNG_DECL int nng_pipe_getopt_int(nng_pipe, const char *, int *); NNG_DECL int nng_pipe_getopt_ms(nng_pipe, const char *, nng_duration *); NNG_DECL int nng_pipe_getopt_size(nng_pipe, const char *, size_t *); NNG_DECL int nng_pipe_getopt_sockaddr(nng_pipe, const char *, nng_sockaddr *); NNG_DECL int nng_pipe_getopt_uint64(nng_pipe, const char *, uint64_t *); NNG_DECL int nng_pipe_getopt_ptr(nng_pipe, const char *, void **); NNG_DECL int nng_pipe_getopt_string(nng_pipe, const char *, char **); NNG_DECL int nng_pipe_close(nng_pipe); NNG_DECL int nng_pipe_id(nng_pipe); NNG_DECL nng_socket nng_pipe_socket(nng_pipe); NNG_DECL nng_dialer nng_pipe_dialer(nng_pipe); NNG_DECL nng_listener nng_pipe_listener(nng_pipe); // Flags. enum nng_flag_enum { NNG_FLAG_ALLOC = 1, // Recv to allocate receive buffer. NNG_FLAG_NONBLOCK = 2 // Non-blocking operations. }; // Options. #define NNG_OPT_SOCKNAME "socket-name" #define NNG_OPT_RAW "raw" #define NNG_OPT_PROTO "protocol" #define NNG_OPT_PROTONAME "protocol-name" #define NNG_OPT_PEER "peer" #define NNG_OPT_PEERNAME "peer-name" #define NNG_OPT_RECVBUF "recv-buffer" #define NNG_OPT_SENDBUF "send-buffer" #define NNG_OPT_RECVFD "recv-fd" #define NNG_OPT_SENDFD "send-fd" #define NNG_OPT_RECVTIMEO "recv-timeout" #define NNG_OPT_SENDTIMEO "send-timeout" #define NNG_OPT_LOCADDR "local-address" #define NNG_OPT_REMADDR "remote-address" #define NNG_OPT_URL "url" #define NNG_OPT_MAXTTL "ttl-max" #define NNG_OPT_RECVMAXSZ "recv-size-max" #define NNG_OPT_RECONNMINT "reconnect-time-min" #define NNG_OPT_RECONNMAXT "reconnect-time-max" // TLS options are only used when the underlying transport supports TLS. // NNG_OPT_TLS_CONFIG is a pointer to an nng_tls_config object. Generally // this can used with endpoints, although once an endpoint is started, or // once a configuration is used, the value becomes read-only. Note that // when configuring the object, a hold is placed on the TLS configuration, // using a reference count. When retrieving the object, no such hold is // placed, and so the caller must take care not to use the associated object // after the endpoint it is associated with is closed. #define NNG_OPT_TLS_CONFIG "tls-config" // NNG_OPT_TLS_AUTH_MODE is a write-only integer (int) option that specifies // whether peer authentication is needed. The option can take one of the // values of NNG_TLS_AUTH_MODE_NONE, NNG_TLS_AUTH_MODE_OPTIONAL, or // NNG_TLS_AUTH_MODE_REQUIRED. The default is typically NNG_TLS_AUTH_MODE_NONE // for listeners, and NNG_TLS_AUTH_MODE_REQUIRED for dialers. If set to // REQUIRED, then connections will be rejected if the peer cannot be verified. // If set to OPTIONAL, then a verification step takes place, but the connection // is still permitted. (The result can be checked with NNG_OPT_TLS_VERIFIED). #define NNG_OPT_TLS_AUTH_MODE "tls-authmode" // NNG_OPT_TLS_CERT_KEY_FILE names a single file that contains a certificate // and key identifying the endpoint. This is a write-only value. This can be // set multiple times for times for different keys/certs corresponding to // different algorithms on listeners, whereas dialers only support one. The // file must contain both cert and key as PEM blocks, and the key must // not be encrypted. (If more flexibility is needed, use the TLS configuration // directly, via NNG_OPT_TLS_CONFIG.) #define NNG_OPT_TLS_CERT_KEY_FILE "tls-cert-key-file" // NNG_OPT_TLS_CA_FILE names a single file that contains certificate(s) for a // CA, and optionally CRLs, which are used to validate the peer's certificate. // This is a write-only value, but multiple CAs can be loaded by setting this // multiple times. #define NNG_OPT_TLS_CA_FILE "tls-ca-file" // NNG_OPT_TLS_SERVER_NAME is a write-only string that can typically be // set on dialers to check the CN of the server for a match. This // can also affect SNI (server name indication). It usually has no effect // on listeners. #define NNG_OPT_TLS_SERVER_NAME "tls-server-name" // NNG_OPT_TLS_VERIFIED returns a boolean indicating whether the peer has // been verified (true) or not (false). Typically this is read-only, and // only available for pipes. This option may return incorrect results if // peer authentication is disabled with `NNG_TLS_AUTH_MODE_NONE`. #define NNG_OPT_TLS_VERIFIED "tls-verified" // TCP options. These may be supported on various transports that use // TCP underneath such as TLS, or not. // TCP nodelay disables the use of Nagle, so that messages are sent // as soon as data is available. This tends to reduce latency, but // can come at the cost of extra messages being sent, and may have // a detrimental effect on performance. For most uses, we recommend // enabling this. (Disable it if you are on a very slow network.) // This is a boolean. #define NNG_OPT_TCP_NODELAY "tcp-nodelay" // TCP keepalive causes the underlying transport to send keep-alive // messages, and keep the session active. Keepalives are zero length // messages with the ACK flag turned on. If we don't get an ACK back, // then we know the other side is gone. This is useful for detecting // dead peers, and is also used to prevent disconnections caused by // middle boxes thinking the session has gone idle (e.g. keeping NAT // state current). This is a boolean. #define NNG_OPT_TCP_KEEPALIVE "tcp-keepalive" // IPC options. These will largely vary depending on the platform, // as POSIX systems have very different options than Windows. // Security Descriptor. This option may only be set on listeners // on the Windows platform, where the object is a pointer to a // a Windows SECURITY_DESCRIPTOR. #define NNG_OPT_IPC_SECURITY_DESCRIPTOR "ipc:security-descriptor" // Permissions bits. This option is only valid for listeners on // POSIX platforms and others that honor UNIX style permission bits. // Note that some platforms may not honor the permissions here, although // at least Linux and macOS seem to do so. Check before you rely on // this for security. #define NNG_OPT_IPC_PERMISSIONS "ipc:permissions" // Peer UID. This is only available on POSIX style systems. #define NNG_OPT_IPC_PEER_UID "ipc:peer-uid" // Peer GID (primary group). This is only available on POSIX style systems. #define NNG_OPT_IPC_PEER_GID "ipc:peer-gid" // Peer process ID. Available on Windows, Linux, and SunOS. // In theory we could obtain this with the first message sent, // but we have elected not to do this for now. (Nice RFE for a FreeBSD // guru though.) #define NNG_OPT_IPC_PEER_PID "ipc:peer-pid" // Peer Zone ID. Only on SunOS systems. (Linux containers have no // definable kernel identity; they are a user-land fabrication made up // from various pieces of different namespaces. FreeBSD does have // something called JailIDs, but it isn't obvious how to determine this, // or even if processes can use IPC across jail boundaries.) #define NNG_OPT_IPC_PEER_ZONEID "ipc:peer-zoneid" // XXX: TBD: priorities, ipv4only // Statistics. These are for informational purposes only, and subject // to change without notice. The API for accessing these is stable, // but the individual statistic names, values, and meanings are all // subject to change. // nng_stats_get takes a snapshot of the entire set of statistics. // While the operation can be somewhat expensive (allocations), it // is done in a way that minimizes impact to running operations. // Note that the statistics are provided as tree, with parents // used for grouping, and with child statistics underneath. The // top stat returned will be of type NNG_STAT_SCOPE with name "". // Applications may choose to consider this root scope as "root", if // the empty string is not suitable. NNG_DECL int nng_stats_get(nng_stat **); // nng_stats_free frees a previous list of snapshots. This should only // be called on the parent statistic that obtained via nng_stats_get. NNG_DECL void nng_stats_free(nng_stat *); // nng_stats_dump is a debugging function that dumps the entire set of // statistics to stdout. NNG_DECL void nng_stats_dump(nng_stat *); // nng_stat_next finds the next sibling for the current stat. If there // are no more siblings, it returns NULL. NNG_DECL nng_stat *nng_stat_next(nng_stat *); // nng_stat_child finds the first child of the current stat. If no children // exist, then NULL is returned. NNG_DECL nng_stat *nng_stat_child(nng_stat *); // nng_stat_name is used to determine the name of the statistic. // This is a human readable name. Statistic names, as well as the presence // or absence or semantic of any particular statistic are not part of any // stable API, and may be changed without notice in future updates. NNG_DECL const char *nng_stat_name(nng_stat *); // nng_stat_type is used to determine the type of the statistic. // At present, only NNG_STAT_TYPE_LEVEL and and NNG_STAT_TYPE_COUNTER // are defined. Counters generally increment, and therefore changes in the // value over time are likely more interesting than the actual level. Level // values reflect some absolute state however, and should be presented to the // user as is. NNG_DECL int nng_stat_type(nng_stat *); enum nng_stat_type_enum { NNG_STAT_SCOPE = 0, // Stat is for scoping, and carries no value NNG_STAT_LEVEL = 1, // Numeric "absolute" value, diffs meaningless NNG_STAT_COUNTER = 2, // Incrementing value (diffs are meaningful) NNG_STAT_STRING = 3, // Value is a string NNG_STAT_BOOLEAN = 4, // Value is a boolean NNG_STAT_ID = 5, // Value is a numeric ID }; // nng_stat_unit provides information about the unit for the statistic, // such as NNG_UNIT_BYTES or NNG_UNIT_BYTES. If no specific unit is // applicable, such as a relative priority, then NN_UNIT_NONE is returned. NNG_DECL int nng_stat_unit(nng_stat *); enum nng_unit_enum { NNG_UNIT_NONE = 0, // No special units NNG_UNIT_BYTES = 1, // Bytes, e.g. bytes sent, etc. NNG_UNIT_MESSAGES = 2, // Messages, one per message NNG_UNIT_MILLIS = 3, // Milliseconds NNG_UNIT_EVENTS = 4 // Some other type of event }; // nng_stat_value returns returns the actual value of the statistic. // Statistic values reflect their value at the time that the corresponding // snapshot was updated, and are undefined until an update is performed. NNG_DECL uint64_t nng_stat_value(nng_stat *); // nng_stat_string returns the string associated with a string statistic, // or NULL if the statistic is not part of the string. The value returned // is valid until the associated statistic is freed. NNG_DECL const char *nng_stat_string(nng_stat *); // nng_stat_desc returns a human readable description of the statistic. // This may be useful for display in diagnostic interfaces, etc. NNG_DECL const char *nng_stat_desc(nng_stat *); // nng_stat_timestamp returns a timestamp (milliseconds) when the statistic // was captured. The base offset is the same as used by nng_clock(). // We don't use nng_time though, because that's in the supplemental header. NNG_DECL uint64_t nng_stat_timestamp(nng_stat *); // Device functionality. This connects two sockets together in a device, // which means that messages from one side are forwarded to the other. NNG_DECL int nng_device(nng_socket, nng_socket); // Symbol name and visibility. TBD. The only symbols that really should // be directly exported to runtimes IMO are the option symbols. And frankly // they have enough special logic around them that it might be best not to // automate the promotion of them to other APIs. This is an area open // for discussion. // Error codes. These generally have different values from UNIX errnos, // so take care about converting them. The one exception is that 0 is // unambigiously "success". // // NNG_SYSERR is a special code, which allows us to wrap errors from the // underlying operating system. We generally prefer to map errors to one // of the above, but if we cannot, then we just encode an error this way. // The bit is large enough to accommodate all known UNIX and Win32 error // codes. We try hard to match things semantically to one of our standard // errors. For example, a connection reset or aborted we treat as a // closed connection, because that's basically what it means. (The remote // peer closed the connection.) For certain kinds of resource exhaustion // we treat it the same as memory. But for files, etc. that's OS-specific, // and we use the generic below. Some of the above error codes we use // internally, and the application should never see (e.g. NNG_EINTR). // // NNG_ETRANERR is like ESYSERR, but is used to wrap transport specific // errors, from different transports. It should only be used when none // of the other options are available. enum nng_errno_enum { NNG_EINTR = 1, NNG_ENOMEM = 2, NNG_EINVAL = 3, NNG_EBUSY = 4, NNG_ETIMEDOUT = 5, NNG_ECONNREFUSED = 6, NNG_ECLOSED = 7, NNG_EAGAIN = 8, NNG_ENOTSUP = 9, NNG_EADDRINUSE = 10, NNG_ESTATE = 11, NNG_ENOENT = 12, NNG_EPROTO = 13, NNG_EUNREACHABLE = 14, NNG_EADDRINVAL = 15, NNG_EPERM = 16, NNG_EMSGSIZE = 17, NNG_ECONNABORTED = 18, NNG_ECONNRESET = 19, NNG_ECANCELED = 20, NNG_ENOFILES = 21, NNG_ENOSPC = 22, NNG_EEXIST = 23, NNG_EREADONLY = 24, NNG_EWRITEONLY = 25, NNG_ECRYPTO = 26, NNG_EPEERAUTH = 27, NNG_ENOARG = 28, NNG_EAMBIGUOUS = 29, NNG_EBADTYPE = 30, NNG_EINTERNAL = 1000, NNG_ESYSERR = 0x10000000, NNG_ETRANERR = 0x20000000 }; // URL support. We frequently want to process a URL, and these methods // give us a convenient way of doing so. typedef struct nng_url { char *u_rawurl; // never NULL char *u_scheme; // never NULL char *u_userinfo; // will be NULL if not specified char *u_host; // including colon and port char *u_hostname; // name only, will be "" if not specified char *u_port; // port, will be "" if not specified char *u_path; // path, will be "" if not specified char *u_query; // without '?', will be NULL if not specified char *u_fragment; // without '#', will be NULL if not specified char *u_requri; // includes query and fragment, "" if not specified } nng_url; // nng_url_parse parses a URL string into a structured form. // Note that the u_port member will be filled out with a numeric // port if one isn't specified and a default port is appropriate for // the scheme. The URL structure is allocated, along with individual // members. It can be freed with nng_url_free. NNG_DECL int nng_url_parse(nng_url **, const char *); // nng_url_free frees a URL structure that was created by nng_url_parse9(). NNG_DECL void nng_url_free(nng_url *); // nng_url_clone clones a URL structure. NNG_DECL int nng_url_clone(nng_url **, const nng_url *); // nng_version returns the library version as a human readable string. NNG_DECL const char *nng_version(void); #ifdef __cplusplus } #endif #endif // NNG_H aBuild/nng/include/nng/protocol/bus0/bus.h
New file @@ -0,0 +1,34 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_BUS0_BUS_H #define NNG_PROTOCOL_BUS0_BUS_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_bus0_open(nng_socket *); NNG_DECL int nng_bus0_open_raw(nng_socket *); #ifndef nng_bus_open #define nng_bus_open nng_bus0_open #endif #ifndef nng_bus_open_raw #define nng_bus_open_raw nng_bus0_open_raw #endif #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_BUS0_BUS_H aBuild/nng/include/nng/protocol/pair0/pair.h
New file @@ -0,0 +1,34 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_PAIR0_PAIR_H #define NNG_PROTOCOL_PAIR0_PAIR_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_pair0_open(nng_socket *); NNG_DECL int nng_pair0_open_raw(nng_socket *); #ifndef nng_pair_open #define nng_pair_open nng_pair0_open #endif #ifndef nng_pair_open_raw #define nng_pair_open_raw nng_pair0_open_raw #endif #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_PAIR0_PAIR_H aBuild/nng/include/nng/protocol/pair1/pair.h
New file @@ -0,0 +1,35 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_PAIR1_PAIR_H #define NNG_PROTOCOL_PAIR1_PAIR_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_pair1_open(nng_socket *); NNG_DECL int nng_pair1_open_raw(nng_socket *); #ifndef nng_pair_open #define nng_pair_open nng_pair1_open #endif #ifndef nng_pair_open_raw #define nng_pair_open_raw nng_pair1_open_raw #endif #define NNG_OPT_PAIR1_POLY "pair1:polyamorous" #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_PAIR1_PAIR_H aBuild/nng/include/nng/protocol/pipeline0/pull.h
New file @@ -0,0 +1,33 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_PIPELINE0_PULL_H #define NNG_PROTOCOL_PIPELINE0_PULL_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_pull0_open(nng_socket *); NNG_DECL int nng_pull0_open_raw(nng_socket *); #ifndef nng_pull_open #define nng_pull_open nng_pull0_open #endif #ifndef nng_pull_open_raw #define nng_pull_open_raw nng_pull0_open_raw #endif #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_PIPELINE0_PULL_H aBuild/nng/include/nng/protocol/pipeline0/push.h
New file @@ -0,0 +1,33 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_PIPELINE0_PUSH_H #define NNG_PROTOCOL_PIPELINE0_PUSH_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_push0_open(nng_socket *); NNG_DECL int nng_push0_open_raw(nng_socket *); #ifndef nng_push_open #define nng_push_open nng_push0_open #endif #ifndef nng_push_open_raw #define nng_push_open_raw nng_push0_open_raw #endif #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_PIPELINE0_PUSH_H aBuild/nng/include/nng/protocol/pubsub0/pub.h
New file @@ -0,0 +1,33 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_PUBSUB0_PUB_H #define NNG_PROTOCOL_PUBSUB0_PUB_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_pub0_open(nng_socket *); NNG_DECL int nng_pub0_open_raw(nng_socket *); #ifndef nng_pub_open #define nng_pub_open nng_pub0_open #endif #ifndef nng_pub_open_raw #define nng_pub_open_raw nng_pub0_open_raw #endif #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_PUBSUB0_PUB_H aBuild/nng/include/nng/protocol/pubsub0/sub.h
New file @@ -0,0 +1,37 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_PUBSUB0_SUB_H #define NNG_PROTOCOL_PUBSUB0_SUB_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_sub0_open(nng_socket *); NNG_DECL int nng_sub0_open_raw(nng_socket *); #ifndef nng_sub_open #define nng_sub_open nng_sub0_open #endif #ifndef nng_sub_open_raw #define nng_sub_open_raw nng_sub0_open_raw #endif #define NNG_OPT_SUB_SUBSCRIBE "sub:subscribe" #define NNG_OPT_SUB_UNSUBSCRIBE "sub:unsubscribe" #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_PUBSUB0_SUB_H aBuild/nng/include/nng/protocol/reqrep0/rep.h
New file @@ -0,0 +1,33 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_REQREP0_REP_H #define NNG_PROTOCOL_REQREP0_REP_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_rep0_open(nng_socket *); NNG_DECL int nng_rep0_open_raw(nng_socket *); #ifndef nng_rep_open #define nng_rep_open nng_rep0_open #endif #ifndef nng_rep_open #define nng_rep_open_raw nng_rep0_open_raw #endif #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_REQREP0_REP_H aBuild/nng/include/nng/protocol/reqrep0/req.h
New file @@ -0,0 +1,34 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_REQREP0_REQ_H #define NNG_PROTOCOL_REQREP0_REQ_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_req0_open(nng_socket *); NNG_DECL int nng_req0_open_raw(nng_socket *); #ifndef nng_req_open #define nng_req_open nng_req0_open #endif #ifndef nng_req_open_raw #define nng_req_open_raw nng_req0_open_raw #endif #define NNG_OPT_REQ_RESENDTIME "req:resend-time" #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_REQREP0_REQ_H aBuild/nng/include/nng/protocol/survey0/respond.h
New file @@ -0,0 +1,33 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_SURVEY0_RESPOND_H #define NNG_PROTOCOL_SURVEY0_RESPOND_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_respondent0_open(nng_socket *); NNG_DECL int nng_respondent0_open_raw(nng_socket *); #ifndef nng_respondent_open #define nng_respondent_open nng_respondent0_open #endif #ifndef nng_respondent_open_raw #define nng_respondent_open_raw nng_respondent0_open_raw #endif #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_SURVEY0_RESPOND_H aBuild/nng/include/nng/protocol/survey0/survey.h
New file @@ -0,0 +1,35 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_PROTOCOL_SURVEY0_SURVEY_H #define NNG_PROTOCOL_SURVEY0_SURVEY_H #ifdef __cplusplus extern "C" { #endif NNG_DECL int nng_surveyor0_open(nng_socket *); NNG_DECL int nng_surveyor0_open_raw(nng_socket *); #ifndef nng_surveyor_open #define nng_surveyor_open nng_surveyor0_open #endif #ifndef nng_surveyor_open_raw #define nng_surveyor_open_raw nng_surveyor0_open_raw #endif #define NNG_OPT_SURVEYOR_SURVEYTIME "surveyor:survey-time" #ifdef __cplusplus } #endif #endif // NNG_PROTOCOL_SURVEY0_SURVEY_H aBuild/nng/include/nng/supplemental/http/http.h
New file @@ -0,0 +1,528 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_SUPPLEMENTAL_HTTP_HTTP_H #define NNG_SUPPLEMENTAL_HTTP_HTTP_H // HTTP API. Only present if HTTP support compiled into the library. // Functions will return NNG_ENOTSUP (or NULL or 0 as appropriate) // if the library lacks support for HTTP. #ifdef __cplusplus extern "C" { #endif #include <stdint.h> struct nng_tls_config; // HTTP status codes. This list is not exhaustive. enum nng_http_status { NNG_HTTP_STATUS_CONTINUE = 100, NNG_HTTP_STATUS_SWITCHING = 101, NNG_HTTP_STATUS_PROCESSING = 102, NNG_HTTP_STATUS_OK = 200, NNG_HTTP_STATUS_CREATED = 201, NNG_HTTP_STATUS_ACCEPTED = 202, NNG_HTTP_STATUS_NOT_AUTHORITATIVE = 203, NNG_HTTP_STATUS_NO_CONTENT = 204, NNG_HTTP_STATUS_RESET_CONTENT = 205, NNG_HTTP_STATUS_PARTIAL_CONTENT = 206, NNG_HTTP_STATUS_MULTI_STATUS = 207, NNG_HTTP_STATUS_ALREADY_REPORTED = 208, NNG_HTTP_STATUS_IM_USED = 226, NNG_HTTP_STATUS_MULTIPLE_CHOICES = 300, NNG_HTTP_STATUS_STATUS_MOVED_PERMANENTLY = 301, NNG_HTTP_STATUS_FOUND = 302, NNG_HTTP_STATUS_SEE_OTHER = 303, NNG_HTTP_STATUS_NOT_MODIFIED = 304, NNG_HTTP_STATUS_USE_PROXY = 305, NNG_HTTP_STATUS_TEMPORARY_REDIRECT = 307, NNG_HTTP_STATUS_PERMANENT_REDIRECT = 308, NNG_HTTP_STATUS_BAD_REQUEST = 400, NNG_HTTP_STATUS_UNAUTHORIZED = 401, NNG_HTTP_STATUS_PAYMENT_REQUIRED = 402, NNG_HTTP_STATUS_FORBIDDEN = 403, NNG_HTTP_STATUS_NOT_FOUND = 404, NNG_HTTP_STATUS_METHOD_NOT_ALLOWED = 405, NNG_HTTP_STATUS_NOT_ACCEPTABLE = 406, NNG_HTTP_STATUS_PROXY_AUTH_REQUIRED = 407, NNG_HTTP_STATUS_REQUEST_TIMEOUT = 408, NNG_HTTP_STATUS_CONFLICT = 409, NNG_HTTP_STATUS_GONE = 410, NNG_HTTP_STATUS_LENGTH_REQUIRED = 411, NNG_HTTP_STATUS_PRECONDITION_FAILED = 412, NNG_HTTP_STATUS_PAYLOAD_TOO_LARGE = 413, NNG_HTTP_STATUS_ENTITY_TOO_LONG = 414, NNG_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415, NNG_HTTP_STATUS_RANGE_NOT_SATISFIABLE = 416, NNG_HTTP_STATUS_EXPECTATION_FAILED = 417, NNG_HTTP_STATUS_TEAPOT = 418, NNG_HTTP_STATUS_UNPROCESSABLE_ENTITY = 422, NNG_HTTP_STATUS_LOCKED = 423, NNG_HTTP_STATUS_FAILED_DEPENDENCY = 424, NNG_HTTP_STATUS_UPGRADE_REQUIRED = 426, NNG_HTTP_STATUS_PRECONDITION_REQUIRED = 428, NNG_HTTP_STATUS_TOO_MANY_REQUESTS = 429, NNG_HTTP_STATUS_HEADERS_TOO_LARGE = 431, NNG_HTTP_STATUS_UNAVAIL_LEGAL_REASONS = 451, NNG_HTTP_STATUS_INTERNAL_SERVER_ERROR = 500, NNG_HTTP_STATUS_NOT_IMPLEMENTED = 501, NNG_HTTP_STATUS_BAD_GATEWAY = 502, NNG_HTTP_STATUS_SERVICE_UNAVAILABLE = 503, NNG_HTTP_STATUS_GATEWAY_TIMEOUT = 504, NNG_HTTP_STATUS_HTTP_VERSION_NOT_SUPP = 505, NNG_HTTP_STATUS_VARIANT_ALSO_NEGOTIATES = 506, NNG_HTTP_STATUS_INSUFFICIENT_STORAGE = 507, NNG_HTTP_STATUS_LOOP_DETECTED = 508, NNG_HTTP_STATUS_NOT_EXTENDED = 510, NNG_HTTP_STATUS_NETWORK_AUTH_REQUIRED = 511, }; // nng_http_req represents an HTTP request. typedef struct nng_http_req nng_http_req; // nng_http_req_alloc creates a vanilla HTTP request object. The object is // initialized with the given URL object for an HTTP/1.1 GET request by // default. It also adds the Host: header required for HTTP/1.1. If the // url is NULL, then the uri and Host: header are uninitialized, and will // need to be set explicitly. NNG_DECL int nng_http_req_alloc(nng_http_req **, const nng_url *); // nng_http_req_free frees an HTTP request object. NNG_DECL void nng_http_req_free(nng_http_req *); // nng_http_req_get_method returns the method. NNG_DECL const char *nng_http_req_get_method(nng_http_req *); // nng_http_req_get_version returns the version, usually HTTP/1.1. NNG_DECL const char *nng_http_req_get_version(nng_http_req *); // nng_http_req_get_uri returns the "abs-uri", which is URL without // the scheme, host, or port. NNG_DECL const char *nng_http_req_get_uri(nng_http_req *); // nng_http_req_set_header sets an HTTP header, replacing any previous value // that might have been present. NNG_DECL int nng_http_req_set_header( nng_http_req *, const char *, const char *); // nng_http_req_add_header adds an HTTP header, without disrupting any other // with the same name that might have been present. NNG_DECL int nng_http_req_add_header( nng_http_req *, const char *, const char *); // nng_http_req_del_header deletes all occurrences of a named header. NNG_DECL int nng_http_req_del_header(nng_http_req *, const char *); // nng_http_req_get_header looks up a header with the named, returns NULL // if not found. NNG_DECL const char *nng_http_req_get_header(nng_http_req *, const char *); // nng_http_req_set_method is used to change the method of a request. // The method should be an upper case HTTP method, like POST, or DELETE. // Null sets the default ("GET"). NNG_DECL int nng_http_req_set_method(nng_http_req *, const char *); // nng_http_req_set_version is used to change the version of a request. // Normally the version is "HTTP/1.1". Note that the framework does // not support HTTP/2 at all. Null sets the default ("HTTP/1.1"). NNG_DECL int nng_http_req_set_version(nng_http_req *, const char *); // nng_http_req_set_uri is used to change the URI of a request. This // should be an "abs-uri", that is a path, plus query and fragment if // needed. The scheme, host, and port don't belong here. The URI should // start with a leading '/' per HTTP. NNG_DECL int nng_http_req_set_uri(nng_http_req *, const char *); // nng_http_req_set_data adds entity data to the request. The // data object must persist (so only really useful for static data). // The content-length header is updated as well, but the caller should // probably set the content-type header. NNG_DECL int nng_http_req_set_data(nng_http_req *, const void *, size_t); // nng_http_req_copy_data adds entity data to the response. A private // copy of the data is made (will be freed with the request). // The content-length header is updated as well, but the caller should // probably set the content-type header. NNG_DECL int nng_http_req_copy_data(nng_http_req *, const void *, size_t); // nng_http_req_get_data gets the data for the response. NNG_DECL void nng_http_req_get_data(nng_http_req *, void **, size_t *); // nng_http_res represents an HTTP response. typedef struct nng_http_res nng_http_res; // nng_http_res_alloc creates a vanilla HTTP response object. The object is // initialized for an HTTP/1.1 200 OK response by default. NNG_DECL int nng_http_res_alloc(nng_http_res **); // nng_http_res_alloc_error creates an error HTTP response object. The object // is initialized for an HTTP/1.1 response, and contains an associated // generic HTML error page. NNG_DECL int nng_http_res_alloc_error(nng_http_res **, uint16_t); // nng_http_res_free frees an HTTP response object. NNG_DECL void nng_http_res_free(nng_http_res *); // nng_http_res_get_status returns the HTTP status code from the server. NNG_DECL uint16_t nng_http_res_get_status(nng_http_res *); // nng_http_res_set_status sets the HTTP status code. NNG_DECL int nng_http_res_set_status(nng_http_res *, uint16_t); // nng_http_res_get_reason returns the human readable status message // that the server responds (or responded) with. NNG_DECL const char *nng_http_res_get_reason(nng_http_res *); // nng_http_res_set_rason sets the human readable status message. // NULL means that a default reason is used based on the status code. NNG_DECL int nng_http_res_set_reason(nng_http_res *, const char *); // nng_http_res_set_header sets an HTTP header, replacing any previous value // that might have been present. NNG_DECL int nng_http_res_set_header( nng_http_res *, const char *, const char *); // nng_http_res_add_header adds an HTTP header, without disrupting any other // with the same name that might have been present. NNG_DECL int nng_http_res_add_header( nng_http_res *, const char *, const char *); // nng_http_res_del_header deletes all occurrences of a named header. NNG_DECL int nng_http_res_del_header(nng_http_res *, const char *); // nng_http_res_get_header looks up a header with the named, returns NULL // if not found. NNG_DECL const char *nng_http_res_get_header(nng_http_res *, const char *); // nng_http_res_set_version is used to change the version of a response. // Normally the version is "HTTP/1.1". Note that the framework does // not support HTTP/2 at all. NULL sets the default ("HTTP/1.1"). NNG_DECL int nng_http_res_set_version(nng_http_res *, const char *); // nng_http_res_get_version returns the version, usually HTTP/1.1. NNG_DECL const char *nng_http_res_get_version(nng_http_res *); // nng_http_res_get_data gets the data for the response. NNG_DECL void nng_http_res_get_data(nng_http_res *, void **, size_t *); // nng_http_res_set_data adds entity data to the response. The // data object must persist (so only really useful for static data). // The content-length header is updated as well, but the caller should // probably set the content-type header. NNG_DECL int nng_http_res_set_data(nng_http_res *, const void *, size_t); // nng_http_res_copy_data adds entity data to the response. A private // copy of the data is made (will be freed with the request). // The content-length header is updated as well, but the caller should // probably set the content-type header. NNG_DECL int nng_http_res_copy_data(nng_http_res *, const void *, size_t); // An nng_http_conn represents an underlying "connection". It may be // a TCP channel, or a TLS channel, but the main thing is that this is // normally only used for exchanging HTTP requests and responses. typedef struct nng_http_conn nng_http_conn; // nng_http_conn_close closes the underlying channel. Applications should // not use this channel after this operation is performed. NNG_DECL void nng_http_conn_close(nng_http_conn *); // nng_http_conn_read attempts to read data from the connection. This // completes as soon as at least one byte is read; it does not wait // for the entire aio to be filled. NNG_DECL void nng_http_conn_read(nng_http_conn *, nng_aio *); // nng_http_conn_read_all is like nng_http_conn_read, but it does not // finish until either all the requested data is read, or an error occurs. NNG_DECL void nng_http_conn_read_all(nng_http_conn *, nng_aio *); // nng_http_conn_write attempts to write data, but it can write less // than the amount requested. (It completes as soon as at least one // byte is written.) NNG_DECL void nng_http_conn_write(nng_http_conn *, nng_aio *); // nng_http_conn_write_all is like nng_http_conn_write, but it does not // finish until either all the requested data is written, or an error occurs. NNG_DECL void nng_http_conn_write_all(nng_http_conn *, nng_aio *); // nng_http_conn_write_req writes the entire request. It will also write any // data that has been attached. NNG_DECL void nng_http_conn_write_req( nng_http_conn *, nng_http_req *, nng_aio *); // nng_http_conn_write_res writes the entire response. It will also write any // data that has been attached. NNG_DECL void nng_http_conn_write_res( nng_http_conn *, nng_http_res *, nng_aio *); // nng_http_conn_read_req reads an entire request, EXCEPT for any entity // data. The caller is responsible for processing the headers in the request // and reading any submitted entity data itself. NNG_DECL void nng_http_conn_read_req( nng_http_conn *, nng_http_req *, nng_aio *); // nng_http_conn_read_res reads an entire response, EXCEPT for any entity // data. The caller is responsible for processing the headers in the response // and reading any submitted entity data itself. NNG_DECL void nng_http_conn_read_res( nng_http_conn *, nng_http_res *, nng_aio *); // nng_http_req_reset resets the request to an initially allocated state. NNG_DECL void nng_http_req_reset(nng_http_req *); // nng_http_res_reset resets the response to an initially allocated state. NNG_DECL void nng_http_res_reset(nng_http_res *); // nng_http_handler is a handler used on the server side to handle HTTP // requests coming into a specific URL. typedef struct nng_http_handler nng_http_handler; // nng_http_handler_alloc creates a server handler object, for the supplied // absolute URI (path only) with the callback. By default the handler // is assumed to handle only GET requests (and implictly HEAD requests // as well.) // // Note that methods which modify a handler cannot be called while the handler // is registered with the server, and that a handler can only be registered // once per server. // // The callback function will receive the following arguments (via // nng_aio_get_input(): nng_http_request *, nng_http_handler *, and // nng_http_conn *. The first is a request object, for convenience. // The second is the handler, from which the callback can obtain any other // data it has set. The final is the http connection, which can be used // to hijack the session. // // Upon completion, the handler should store an nng_http_res * as the // first output using nng_aio_set_output. If it does not do so, or supplies // NULL, then it must send a response itself. // // The callback should return 0 in most circumstances; if it returns anything // other than 0 then the connection is terminated (after possibly sending // a 500 error response to the client.) NNG_DECL int nng_http_handler_alloc( nng_http_handler **, const char *, void (*)(nng_aio *)); // nng_http_handler_free frees the handler. This actually just drops a // reference count on the handler, as it may be in use by an existing // server. The server will also call this when it is destroyed. NNG_DECL void nng_http_handler_free(nng_http_handler *); // nng_http_handler_alloc_file creates a "file" based handler, that // serves up static content from the given file path. The content-type // supplied is determined from the file name using a simple built-in map. NNG_DECL int nng_http_handler_alloc_file( nng_http_handler **, const char *, const char *); // nng_http_handler_alloc_static creates a static-content handler. // The last argument is the content-type, which may be NULL (in which case // "application/octet-stream" is assumed.) NNG_DECL int nng_http_handler_alloc_static( nng_http_handler **, const char *, const void *, size_t, const char *); // nng_http_handler_alloc_redirect creates an HTTP redirect handler. // The status is given, along with the new URL. If the status is 0, // then 301 will be used instead. NNG_DECL int nng_http_handler_alloc_redirect( nng_http_handler **, const char *, uint16_t, const char *); // nng_http_handler_alloc_file creates a "directory" based handler, that // serves up static content from the given directory tree. Directories // that contain an index.html or index.htm file use that file for the // directory content, otherwise a suitable error page is returned (the server // does not generate index pages automatically.) The content-type for // files is determined from the file name using a simple built-in map. NNG_DECL int nng_http_handler_alloc_directory( nng_http_handler **, const char *, const char *); // nng_http_handler_set_method sets the method that the handler will be // called for. By default this is GET. If NULL is supplied for the // method, then the handler is executed regardless of method, and must // inspect the method itself. NNG_DECL int nng_http_handler_set_method(nng_http_handler *, const char *); // nng_http_handler_set_host sets the Host: that the handler will be // called for (to allow for virtual hosts). If the value is NULL (the // default, then the Host: header is not considered when matching the // handler.) Note that the Host: header must match *exactly* (except // that case is not considered.) NNG_DECL int nng_http_handler_set_host(nng_http_handler *, const char *); // nng_http_handler_collect_body is used to indicate the server should // check for, and process, data sent by the client, which will be attached // to the request. If this is false, then the handler will need to check // for and process any content data. By default the server will accept // up to 1MB. If the client attempts to send more data than requested, // then a 400 Bad Request will be sent back to the client. To set an // unlimited value, use (size_t)-1. To preclude the client from sending // *any* data, use 0. (The static and file handlers use 0 by default.) NNG_DECL int nng_http_handler_collect_body(nng_http_handler *, bool, size_t); // nng_http_handler_set_tree indicates that the handler is being registered // for a heirarchical tree, rather than just a single path, so it will be // called for all child paths supplied. By default the handler is only // called for an exact path match. NNG_DECL int nng_http_handler_set_tree(nng_http_handler *); // nng_http_handler_set_data is used to store additional data, along with // a possible clean up routine. (The clean up is a custom deallocator and // will be called with the supplied data as an argument, when the handler // is being deallocated.) NNG_DECL int nng_http_handler_set_data( nng_http_handler *, void *, void (*)(void *)); // nng_http_handler_get_data returns the data that was previously stored. NNG_DECL void *nng_http_handler_get_data(nng_http_handler *); // nng_http_server is a handle to an HTTP server instance. Servers // only serve a single port / address at this time. typedef struct nng_http_server nng_http_server; // nng_http_server_hold gets a server structure, using the address determined // from the URL. If a server already exists, then a hold is placed on it, and // that instance is returned. If no such server exists, then a new instance // is created. NNG_DECL int nng_http_server_hold(nng_http_server **, const nng_url *); // nng_http_server_release releases the hold on the server. If this is the // last instance of the server, then it is shutdown and resources are freed. NNG_DECL void nng_http_server_release(nng_http_server *); // nng_http_server_start starts the server handling HTTP. Once this is // called, it will not be possible to change certain parameters (such as // any TLS configuration). NNG_DECL int nng_http_server_start(nng_http_server *); // nng_http_server_stop stops the server. No new client connections are // accepted after this returns. Once a server is stopped fully, the // instance will no longer be returned by nng_http_server_hold, as the // server may not be reused. NNG_DECL void nng_http_server_stop(nng_http_server *); // nng_http_server_add_handler registers a handler on the server. // This function will return NNG_EADDRINUSE if a conflicting handler // is already registered (i.e. a handler with the same value for Host, // Method, and URL.) NNG_DECL int nng_http_server_add_handler( nng_http_server *, nng_http_handler *); // nni_http_del_handler removes the given handler. The caller is // responsible for finalizing it afterwards. If the handler was not found // (not registered), NNG_ENOENT is returned. In this case it is unsafe // to make assumptions about the validity of the handler. NNG_DECL int nng_http_server_del_handler( nng_http_server *, nng_http_handler *); // nng_http_server_set_tls adds a TLS configuration to the server, // and enables the use of it. This returns NNG_EBUSY if the server is // already started. This wipes out the entire TLS configuration on the // server client, so the caller must have configured it reasonably. // This API is not recommended unless the caller needs complete control // over the TLS configuration. NNG_DECL int nng_http_server_set_tls( nng_http_server *, struct nng_tls_config *); // nng_http_server_get_tls obtains the TLS configuration if one is present, // or returns NNG_EINVAL. The TLS configuration is invalidated if the // nng_http_server_set_tls function is called, so be careful. NNG_DECL int nng_http_server_get_tls( nng_http_server *, struct nng_tls_config **); // nng_http_server_set_error_page sets a custom error page (HTML) content // to be sent for the given error code. This is used when the error is // generated internally by the framework, or when the application returns // the response back to the server via the handler's aio, and the response // was allocated with nng_http_res_alloc_error. If the response was not // allocated this way, or the application writes the response itself instead // of letting the server do so, then this setting will be ignored. NNG_DECL int nng_http_server_set_error_page( nng_http_server *, uint16_t, const char *); // nng_http_server_set_error_file works like nng_http_server_error_page, // except that the content is loaded from the named file path. The contents // are loaded at the time this function is called, so this function should be // called anytime the contents of the named file have changed. NNG_DECL int nng_http_server_set_error_file( nng_http_server *, uint16_t, const char *); // nng_http_server_res_error takes replaces the body of the response with // a custom error page previously set for the server, using the status // of the response. The response must have the status set first using // nng_http_res_set_status or implicitly via nng_http_res_alloc_error. NNG_DECL int nng_http_server_res_error(nng_http_server *, nng_http_res *); // nng_http_hijack is intended to be called by a handler that wishes to // take over the processing of the HTTP session -- usually to change protocols // (such as in the case of websocket). The caller is responsible for the // final disposal of the associated nng_http_conn. Also, this completely // disassociates the http session from the server, so the server may be // stopped or destroyed without affecting the hijacked session. Note also // that the hijacker will need to issue any HTTP reply itself. Finally, // when a session is hijacked, the caller is also responsible for disposing // of the request structure. (Some hijackers may keep the request for // further processing.) NNG_DECL int nng_http_hijack(nng_http_conn *); // nng_http_client represents a "client" object. Clients can be used // to create HTTP connections. At present, connections are not cached // or reused, but that could change in the future. typedef struct nng_http_client nng_http_client; // nng_http_client_alloc allocates a client object, associated with // the given URL. NNG_DECL int nng_http_client_alloc(nng_http_client **, const nng_url *); // nng_http_client_free frees the client. Connections created by the // the client are not necessarily closed. NNG_DECL void nng_http_client_free(nng_http_client *); // nng_http_client_set_tls sets the TLS configuration. This wipes out // the entire TLS configuration on the client, so the caller must have // configured it reasonably. This API is not recommended unless the // caller needs complete control over the TLS configuration. NNG_DECL int nng_http_client_set_tls( nng_http_client *, struct nng_tls_config *); // nng_http_client_get_tls obtains the TLS configuration if one is present, // or returns NNG_EINVAL. The supplied TLS configuration object may // be invalidated by any future calls to nni_http_client_set_tls. NNG_DECL int nng_http_client_get_tls( nng_http_client *, struct nng_tls_config **); // nng_http_client_connect establishes a new connection with the server // named in the URL used when the client was created. Once the connection // is established, the associated nng_http_conn object pointer is returned // in the first (index 0) output for the aio. NNG_DECL void nng_http_client_connect(nng_http_client *, nng_aio *); // nng_http_conn_transact is used to perform a round-trip exchange (i.e. a // single HTTP transaction). It will not automatically close the connection, // unless some kind of significant error occurs. The caller should close // the connection if the aio does not complete successfully. // Note that this will fail with NNG_ENOTSUP if the server attempts to reply // with a chunked transfer encoding. NNG_DECL void nng_http_conn_transact( nng_http_conn *, nng_http_req *, nng_http_res *, nng_aio *); // nng_http_client_transact is used to execute a single transaction to a // server. The connection is opened, and will be closed when the transaction is // complete. Note that this will fail with NNG_ENOTSUP if the server attempts // to reply with a chunked transfer encoding. NNG_DECL void nng_http_client_transact( nng_http_client *, nng_http_req *, nng_http_res *, nng_aio *); #ifdef __cplusplus } #endif #endif // NNG_H aBuild/nng/include/nng/supplemental/ipc/ipc.h
New file @@ -0,0 +1,133 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // Copyright 2018 Devolutions <info@devolutions.net> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_SUPPLEMENTAL_IPC_IPC_H #define NNG_SUPPLEMENTAL_IPC_IPC_H #ifdef __cplusplus extern "C" { #endif #include <stddef.h> #include <stdint.h> #include <nng/nng.h> #include <nng/transport/ipc/ipc.h> // For IPC option names. // This is our "public" IPC API. This allows applications to access // basic IPC functions, using our AIO framework. Most applications will // not need this. This supports both UNIX domain sockets (AF_LOCAL), // and Windows Named Pipes, depending on the underlying platform. // nng_ipc represents a single IPC connection. This is generally // a connected stream. typedef struct nng_ipc_s nng_ipc; // nng_ipc_dialer is a dialer object used to create outgoing connections. // This is a bit different than a typical BSD socket API, but doing it // helps keep the API orthogonal to the listener API. typedef struct nng_ipc_dialer_s nng_ipc_dialer; // nng_ipc_listener is a listener object. This is used to accept incoming // connections. typedef struct nng_ipc_listener_s nng_ipc_listener; // nng_ipc_close closes the connection, but does not release the // underlying object. Operations that may be pending on the connect, // as well as further operations, will result in NNG_ECLOSED. NNG_DECL void nng_ipc_close(nng_ipc *); // nng_ipc_free frees the IPC connection, closing it if it is open. // This is necessary to release the resources of the IPC object. // (It is an error to refer to the IPC object after this is called.) NNG_DECL void nng_ipc_free(nng_ipc *); // nng_ipc_send sends the data in the aio, which should be stored in // an iov for the message. Note that the iov in the aio may be modified, // so applications should not assume otherwise. NNG_DECL void nng_ipc_send(nng_ipc *, nng_aio *); // nng_ipc_recv receives data into the iov supplied. It is possible for // the callback to be executed with less data read than requested. (This // is actually pretty likely for bulk transfers.) The caller should update // the iov's and resubmit as needed. NNG_DECL void nng_ipc_recv(nng_ipc *, nng_aio *); // nng_ipc_getopt is used to get options. The options available are: // // NNG_OPT_REMADDR - nng_sockaddr for the connection. // NNG_OPT_LOCADD - nng_sockaddr for the connection. // NNG_OPT_IPC_PEER_UID - peer user ID (if available), uint64_t // NNG_OPT_IPC_PEER_GID - peer group ID (if available), uint64_t // NNG_OPT_IPC_PEER_ZONEID - peer zone ID (illumos/Solaris only), uint64_t NNG_DECL int nng_ipc_getopt(nng_ipc *, const char *, void *, size_t *); // nng_ipc_setopt is used to set options. There are presently no such // options defined for connections. NNG_DECL int nng_ipc_setopt(nng_ipc *, const char *, const void *, size_t); // nng_ipc_dialer_alloc is used to allocate an IPC dialer. NNG_DECL int nng_ipc_dialer_alloc(nng_ipc_dialer **); // nng_ipc_dialer_close closes the dialer, aborting any pending outbound // connection attempts (and preventing any new ones) with NNG_ECLOSED. // This does not free the resources associated with the dialer, so the // application should still call nng_ipc_dialer_free. Connections already // established by the dialer are unaffected by this call. NNG_DECL void nng_ipc_dialer_close(nng_ipc_dialer *); // nng_ipc_dialer_free is used to free the dialer. This implicitly calls // nng_ipc_dialer_close, then releases the resources associated with the // dialer. It is therefore an error for the application to attempt to use // the dialer after this call. NNG_DECL void nng_ipc_dialer_free(nng_ipc_dialer *); // nng_ipc_dialer_dial attempts to create a new connection (nng_ipc *) // may making an outbound connect call. If this succeeds, the aio // will return a suitable nng_ipc * in the first output of the aio. // (I.e. nng_aio_get_output(aio, 0).) The destination address to dial // is stored in the 2nd argument. NNG_DECL void nng_ipc_dialer_dial( nng_ipc_dialer *, const nng_sockaddr *, nng_aio *); // nng_ipc_listener_alloc creates a listener. NNG_DECL int nng_ipc_listener_alloc(nng_ipc_listener **); // nng_ipc_listener_close closes the listener, unbinding it from // any active path if it was previously bound with nng_ipc_listener_listen. // This does not completely release the resources associated with the // listener, so nng_ipc_listener_free should still be called. // Any pending accept calls will be aborted with NNG_ECLOSED, and any // future attempts will also result in NNG_ECLOSED. Connections already // established by this listener are unaffected by this call. NNG_DECL void nng_ipc_listener_close(nng_ipc_listener *); // nng_ipc_listener_free frees the listener. This causes any other // outstanding accept calls to return NNG_ECLOSED. The listener cannot // be used by the application after this is called. This implictly // includes a call to nng_ipc_listener_close(). NNG_DECL void nng_ipc_listener_free(nng_ipc_listener *); // nng_ipc_listener_listen binds to the IPC address and arranges for // the IPC path to be created and bound. It does not accept any new // incoming connections. This operation is synchronous. NNG_DECL int nng_ipc_listener_listen(nng_ipc_listener *, const nng_sockaddr *); // nng_ipc_listener_accept accepts an incoming connection (creating an // nng_ipc * object), and returns it in the nng_aio as the first output // on success. NNG_DECL void nng_ipc_listener_accept(nng_ipc_listener *, nng_aio *); #ifdef __cplusplus } #endif #endif // NNG_SUPPLEMENTAL_IPC_IPC_H aBuild/nng/include/nng/supplemental/tcp/tcp.h
New file @@ -0,0 +1,154 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_SUPPLEMENTAL_TCP_TCP_H #define NNG_SUPPLEMENTAL_TCP_TCP_H #ifdef __cplusplus extern "C" { #endif #include <stddef.h> #include <stdint.h> #include <nng/nng.h> // This is our "public" TCP API. This allows applications to access // basic TCP functions, using our AIO framework. Most applications will // not need this. // nng_tcp represents a single TCP connection. This is generally // a connected stream. typedef struct nng_tcp_s nng_tcp; // nng_tcp_dialer is a dialer object used to create outgoing connections. // This is a bit different than a typical BSD socket API, but doing it // helps keep the API orthogonal to the listener API. typedef struct nng_tcp_dialer_s nng_tcp_dialer; // nng_tcp_listener is a listener object. This is used to accept incoming // connections. typedef struct nng_tcp_listener_s nng_tcp_listener; // nng_tcp_close closes the connection, but does not release the // underlying object. Operations that may be pending on the connect, // as well as further operations, will result in NNG_ECLOSED. NNG_DECL void nng_tcp_close(nng_tcp *); // nng_tcp_free frees the TCP connection, closing it if it is open. // This is necessary to release the resources of the TCP object. // (It is an error to refer to the TCP object after this is called.) NNG_DECL void nng_tcp_free(nng_tcp *); // nng_tcp_send sends the data in the aio, which should be stored in // an iov for the message. Note that the iov in the aio may be modified, // so applications should not assume otherwise. NNG_DECL void nng_tcp_send(nng_tcp *, nng_aio *); // nng_tcp_recv receives data into the iov supplied. It is possible for // the callback to be executed with less data read than requested. (This // is actually pretty likely for bulk transfers.) The caller should update // the iov's and resubmit as needed. NNG_DECL void nng_tcp_recv(nng_tcp *, nng_aio *); // nng_tcp_getopt is used to retrieve socket options, using the named // option values, like NNG_OPT_TCP_NODELAY or NNG_OPT_REMADDR. NNG_DECL int nng_tcp_getopt(nng_tcp *, const char *, void *, size_t *); // nng_tcp_setopt is used to set socket options, using the named // option values, like NNG_OPT_TCP_KEEPALIVE. NNG_DECL int nng_tcp_setopt(nng_tcp *, const char *, const void *, size_t); // nng_tcp_dialer_alloc is used to allocate a TCP dialer. NNG_DECL int nng_tcp_dialer_alloc(nng_tcp_dialer **); // nng_tcp_dialer_close closes the dialer, aborting any pending outbound // connection attempts (and preventing any new ones) with NNG_ECLOSED. // This does not free the resources associated with the dialer, so the // application should still call nng_tcp_dialer_free. Connections already // established by the dialer are unaffected by this call. NNG_DECL void nng_tcp_dialer_close(nng_tcp_dialer *); // nng_tcp_dialer_free is used to free the dialer. This implicitly calls // nng_tcp_dialer_close, then releases the resources associated with the // dialer. It is therefore an error for the application to attempt to use // the dialer after this call. NNG_DECL void nng_tcp_dialer_free(nng_tcp_dialer *); // nng_tcp_dialer_dial attempts to create a new connection (nng_tcp *) // may making an outbound connect call. If this succeeds, the aio // will return a suitable nng_tcp * in the first output of the aio. // (I.e. nng_aio_get_output(aio, 0).) The destination address to dial // is stored in the 2nd argument. NNG_DECL void nng_tcp_dialer_dial( nng_tcp_dialer *, const nng_sockaddr *, nng_aio *); // nng_tcp_dialer_getopt gets an option. NNG_DECL int nng_tcp_dialer_getopt( nng_tcp_dialer *, const char *, void *, size_t *); // nng_tcp_dialer_setopt sets an option. This can be done to set the // initial values of NNG_OPT_TCP_NODELAY or NNG_OPT_TCP_KEEPALIVE for // created connections, for example. Also, the NNG_OPT_LOCADDR can // be set, which sets the source address new connections will be // established from -- except that the port is ignored as it is always // randomly chosen. NNG_DECL int nng_tcp_dialer_setopt( nng_tcp_dialer *, const char *, const void *, size_t); // nng_tcp_listener_alloc creates a listener. NNG_DECL int nng_tcp_listener_alloc(nng_tcp_listener **); // nng_tcp_listener_close closes the listener, unbinding it from // any active ports if it was previously bound with nng_tcp_listener_listen. // This does not completely release the resources associated with the // listener, so nng_tcp_listener_free should still be called. // Any pending accept calls will be aborted with NNG_ECLOSED, and any // future attempts will also result in NNG_ECLOSED. Connections already // established by this listener are unaffected by this call. NNG_DECL void nng_tcp_listener_close(nng_tcp_listener *); // nng_tcp_listener_free frees the listener. This causes any other // outstanding accept calls to return NNG_ECLOSED. The listener cannot // be used by the application after this is called. This implictly // includes a call to nng_tcp_listener_close(). NNG_DECL void nng_tcp_listener_free(nng_tcp_listener *); // nng_tcp_listener_listen binds to the TCP address and arranges for // the TCP port / address to be allocated. It does not accept any new // incoming connections. (The listenq depth is configured to some reasonable // default -- typically around 128.) This operation is synchronous. // A zero valued port may be supplied in the sockaddr, in which case // a follow up call to get the NNG_OPT_LOCADDR can be used to determine the // bound address. NNG_DECL int nng_tcp_listener_listen(nng_tcp_listener *, const nng_sockaddr *); // nng_tcp_listener_accept accepts an incoming connection (creating an // nng_tcp * object), and returns it in the nng_aio as the first output // on success. NNG_DECL void nng_tcp_listener_accept(nng_tcp_listener *, nng_aio *); // nng_tcp_listener_getopt gets an option. A good example of this is to // obtain the NNG_OPT_LOCADDR local address after starting the listener // on a wild card port (0). NNG_DECL int nng_tcp_listener_getopt( nng_tcp_listener *, const char *, void *, size_t *); // nng_tcp_listener_setopt sets an option. This can be done to set the // initial values of NNG_OPT_TCP_NODELAY or NNG_OPT_TCP_KEEPALIVE for // created connections, for example. NNG_DECL int nng_tcp_listener_setopt( nng_tcp_listener *, const char *, const void *, size_t); #ifdef __cplusplus } #endif #endif // NNG_SUPPLEMENTAL_TCP_TCP_H aBuild/nng/include/nng/supplemental/tls/tls.h
New file @@ -0,0 +1,180 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_SUPPLEMENTAL_TLS_TLS_H #define NNG_SUPPLEMENTAL_TLS_TLS_H #ifdef __cplusplus extern "C" { #endif #include <stddef.h> #include <stdint.h> // Note that TLS functions may be stubbed out if TLS is not enabled in // the build. // For some transports, we need TLS configuration, including certificates // and so forth. A TLS configuration cannot be changed once it is in use. typedef struct nng_tls_config nng_tls_config; typedef enum nng_tls_mode { NNG_TLS_MODE_CLIENT = 0, NNG_TLS_MODE_SERVER = 1, } nng_tls_mode; typedef enum nng_tls_auth_mode { NNG_TLS_AUTH_MODE_NONE = 0, // No verification is performed NNG_TLS_AUTH_MODE_OPTIONAL = 1, // Verify cert if presented NNG_TLS_AUTH_MODE_REQUIRED = 2, // Verify cert, close if invalid } nng_tls_auth_mode; // nng_tls_config_alloc creates a TLS configuration using // reasonable defaults. This configuration can be shared // with multiple pipes or services/servers. NNG_DECL int nng_tls_config_alloc(nng_tls_config **, nng_tls_mode); // nng_tls_config_hold increments the reference count on the TLS // configuration object. The hold can be dropped by calling // nng_tls_config_free later. NNG_DECL void nng_tls_config_hold(nng_tls_config *); // nng_tls_config_free drops the reference count on the TLS // configuration object, and if zero, deallocates it. NNG_DECL void nng_tls_config_free(nng_tls_config *); // nng_tls_config_server_name sets the server name. This is // called by clients to set the name that the server supplied // certificate should be matched against. This can also cause // the SNI to be sent to the server to tell it which cert to // use if it supports more than one. NNG_DECL int nng_tls_config_server_name(nng_tls_config *, const char *); // nng_tls_config_ca_cert configures one or more CAs used for validation // of peer certificates. Multiple CAs (and their chains) may be configured // by either calling this multiple times, or by specifying a list of // certificates as concatenated data. The final argument is an optional CRL // (revokation list) for the CA, also in PEM. Both PEM strings are ASCIIZ // format (except that the CRL may be NULL). NNG_DECL int nng_tls_config_ca_chain( nng_tls_config *, const char *, const char *); // nng_tls_config_own_cert is used to load our own certificate and public // key. For servers, this may be called more than once to configure multiple // different keys, for example with different algorithms depending on what // the peer supports. On the client, only a single option is available. // The first two arguments are the cert (or validation chain) and the // key as PEM format ASCIIZ strings. The final argument is an optional // password and may be NULL. NNG_DECL int nng_tls_config_own_cert( nng_tls_config *, const char *, const char *, const char *); // nng_tls_config_key is used to pass our own private key. NNG_DECL int nng_tls_config_key(nng_tls_config *, const uint8_t *, size_t); // nng_tls_config_pass is used to pass a password used to decrypt // private keys that are encrypted. NNG_DECL int nng_tls_config_pass(nng_tls_config *, const char *); // nng_tls_config_auth_mode is used to configure the authentication mode use. // The default is that servers have this off (i.e. no client authentication) // and clients have it on (they verify the server), which matches typical // practice. NNG_DECL int nng_tls_config_auth_mode(nng_tls_config *, nng_tls_auth_mode); // nng_tls_config_ca_file is used to pass a CA chain and optional CRL // via the filesystem. If CRL data is present, it must be contained // in the file, along with the CA certificate data. The format is PEM. // The path name must be a legal file name. NNG_DECL int nng_tls_config_ca_file(nng_tls_config *, const char *); // nng_tls_config_cert_key_file is used to pass our own certificate and // private key data via the filesystem. Both the key and certificate // must be present as PEM blocks in the same file. A password is used to // decrypt the private key if it is encrypted and the password supplied is not // NULL. This may be called multiple times on servers, but only once on a // client. (Servers can support multiple different certificates and keys for // different cryptographic algorithms. Clients only get one.) NNG_DECL int nng_tls_config_cert_key_file( nng_tls_config *, const char *, const char *); // The rest of the definitions in this file rely upon having support for the // TLS supplemental API enabled. If you don't have this configured in your // library, then your programs will not link. // nng_tls represents a TLS connection over TCP. typedef struct nng_tls_s nng_tls; // nng_tls_dialer is a dialer that creates TLS connections (nng_tls objects) // by establishing outgoing connections. typedef struct nng_tls_dialer_s nng_tls_dialer; // nng_tls_listener is a listener that creates TLS connections (nng_tls // objects) by accepting incoming connections. typedef struct nng_tls_listener_s nng_tls_listener; // nng_tls_close closes a TLS connection, without releasing the underlying // resources. Use nng_tls_free to release the resources. NNG_DECL void nng_tls_close(nng_tls *); // nng_tls_free frees a TLS connection, and will implicity also close the // connection if not already done so. NNG_DECL void nng_tls_free(nng_tls *); NNG_DECL void nng_tls_send(nng_tls *, nng_aio *); NNG_DECL void nng_tls_recv(nng_tls *, nng_aio *); NNG_DECL int nng_tls_getopt(nng_tls *, const char *, void *, size_t *); // nng_tls_dialer_alloc allocates a dialer that creates TLS connections // (nng_tls structures) by connecting to remote servers. NNG_DECL int nng_tls_dialer_alloc(nng_tls_dialer **); // nng_tls_dialer_close closes the dialer, but does not free it's resources. NNG_DECL void nng_tls_dialer_close(nng_tls_dialer *); // nng_tls_dialer_free frees the dialer, implicitly closing it as well. NNG_DECL void nng_tls_dialer_free(nng_tls_dialer *); // nng_tls_dialer_dial attempts to create a new connection (nng_tls object) // by dialing to the remote server specified in the aio. Note that the // TLS connection may be returned before the TLS handshake is complete. // The remote server will only be verified if a server name has been configured // with the NNG_OPT_TLS_SERVER_NAME option (using nng_tls_dialer_setopt). NNG_DECL void nng_tls_dialer_dial( nng_tls_dialer *, const nng_sockaddr *, nng_aio *); // nng_tls_dialer_getopt returns options from the dialer. NNG_DECL int nng_tls_dialer_getopt( nng_tls_dialer *, const char *, void *, size_t *); // nng_tls_dialer_setopt sets options on the dialer. Options may include // NNG_OPT_TLS_CONFIG, as well as various other NNG_OPT_TLS_ options and // the TCP options that are valid for TCP dialers as well. NNG_DECL int nng_tls_dialer_setopt( nng_tls_dialer *, const char *, const void *, size_t); NNG_DECL int nng_tls_listener_alloc(nng_tls_listener **); NNG_DECL void nng_tls_listener_close(nng_tls_listener *); NNG_DECL void nng_tls_listener_free(nng_tls_listener *); NNG_DECL int nng_tls_listener_listen(nng_tls_listener *, const nng_sockaddr *); NNG_DECL void nng_tls_listener_accept(nng_tls_listener *, nng_aio *); NNG_DECL int nng_tls_listener_getopt( nng_tls_listener *, const char *, void *, size_t *); NNG_DECL int nng_tls_listener_setopt( nng_tls_listener *, const char *, const void *, size_t); #ifdef __cplusplus } #endif #endif // NNG_SUPPLEMENTAL_TLS_TLS_H aBuild/nng/include/nng/supplemental/util/options.h
New file @@ -0,0 +1,48 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_SUPPLEMENTAL_UTIL_OPTIONS_H #define NNG_SUPPLEMENTAL_UTIL_OPTIONS_H #include <stdbool.h> #ifdef __cplusplus extern "C" { #endif // This is a relatively simple "options parsing" library, used to // parse command line options. We would use getopt(3), but there are // two problems with getopt(3). First, it isn't available on all // platforms (especially Win32), and second, it doesn't support long // options. We *exclusively* support long options. POSIX style // short option clustering is *NOT* supported. struct nng_optspec { const char *o_name; // Long style name (may be NULL for short only) int o_short; // Short option (no clustering!) int o_val; // Value stored on a good parse (>0) bool o_arg; // Option takes an argument if true }; typedef struct nng_optspec nng_optspec; // Call with *optidx set to 1 to start parsing for a standard program. // The val will store the value of the matched "o_val", optarg will be // set to match the option string, and optidx will be increment appropriately. // Returns -1 when the end of options is reached, 0 on success, or // NNG_EINVAL if the option parse is invalid for any reason. NNG_DECL int nng_opts_parse(int argc, char *const *argv, const nng_optspec *opts, int *val, char **optarg, int *optidx); #ifdef __cplusplus } #endif #endif // NNG_SUPPLEMENTAL_UTIL_OPTIONS_H aBuild/nng/include/nng/supplemental/util/platform.h
New file @@ -0,0 +1,106 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_SUPPLEMENTAL_UTIL_PLATFORM_H #define NNG_SUPPLEMENTAL_UTIL_PLATFORM_H // The declarations in this file are provided to assist with application // portability. Conceptually these APIs are based on work we have already // done for NNG internals, and we find that they are useful in building // portable applications. // If it is more natural to use native system APIs like pthreads or C11 // APIs or Windows APIs, then by all means please feel free to simply // ignore this. #include <stddef.h> #include <stdint.h> #ifdef __cplusplus extern "C" { #endif // nng_time represents an absolute time since some arbitrary point in the // past, measured in milliseconds. The values are always positive. typedef uint64_t nng_time; // Return an absolute time from some arbitrary point. The value is // provided in milliseconds, and is of limited resolution based on the // system clock. (Do not use it for fine grained performance measurements.) NNG_DECL nng_time nng_clock(void); // Sleep for specified msecs. NNG_DECL void nng_msleep(nng_duration); // nng_thread is a handle to a "thread", which may be a real system // thread, or a coroutine on some platforms. typedef struct nng_thread nng_thread; // Create and start a thread. Note that on some platforms, this might // actually be a coroutine, with limitations about what system APIs // you can call. Therefore, these threads should only be used with the // I/O APIs provided by nng. The thread runs until completion. NNG_DECL int nng_thread_create(nng_thread **, void (*)(void *), void *); // Destroy a thread (waiting for it to complete.) When this function // returns all resources for the thread are cleaned up. NNG_DECL void nng_thread_destroy(nng_thread *); // nng_mtx represents a mutex, which is a simple, non-retrant, boolean lock. typedef struct nng_mtx nng_mtx; // nng_mtx_alloc allocates a mutex structure. NNG_DECL int nng_mtx_alloc(nng_mtx **); // nng_mtx_free frees the mutex. It most not be locked. NNG_DECL void nng_mtx_free(nng_mtx *); // nng_mtx_lock locks the mutex; if it is already locked it will block // until it can be locked. If the caller already holds the lock, the // results are undefined (a panic may occur). NNG_DECL void nng_mtx_lock(nng_mtx *); // nng_mtx_unlock unlocks a previously locked mutex. It is an error to // call this on a mutex which is not owned by caller. NNG_DECL void nng_mtx_unlock(nng_mtx *); // nng_cv is a condition variable. It is always allocated with an // associated mutex, which must be held when waiting for it, or // when signaling it. typedef struct nng_cv nng_cv; NNG_DECL int nng_cv_alloc(nng_cv **, nng_mtx *); // nng_cv_free frees the condition variable. NNG_DECL void nng_cv_free(nng_cv *); // nng_cv_wait waits until the condition variable is "signaled". NNG_DECL void nng_cv_wait(nng_cv *); // nng_cv_until waits until either the condition is signaled, or // the timeout expires. It returns NNG_ETIMEDOUT in that case. NNG_DECL int nng_cv_until(nng_cv *, nng_time); // nng_cv_wake wakes all threads waiting on the condition. NNG_DECL void nng_cv_wake(nng_cv *); // nng_cv_wake1 wakes only one thread waiting on the condition. This may // reduce the thundering herd problem, but care must be taken to ensure // that no waiter starves forvever. NNG_DECL void nng_cv_wake1(nng_cv *); // nng_random returns a "strong" (cryptographic sense) random number. NNG_DECL uint32_t nng_random(void); #ifdef __cplusplus } #endif #endif // NNG_SUPPLEMENTAL_UTIL_PLATFORM_H aBuild/nng/include/nng/transport/inproc/inproc.h
New file @@ -0,0 +1,18 @@ // // Copyright 2017 Garrett D'Amore <garrett@damore.org> // Copyright 2017 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_TRANSPORT_INPROC_INPROC_H #define NNG_TRANSPORT_INPROC_INPROC_H // inproc transport. This is used for intra-process communication. NNG_DECL int nng_inproc_register(void); #endif // NNG_TRANSPORT_INPROC_INPROC_H aBuild/nng/include/nng/transport/ipc/ipc.h
New file @@ -0,0 +1,19 @@ // // Copyright 2019 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_TRANSPORT_IPC_IPC_H #define NNG_TRANSPORT_IPC_IPC_H // ipc transport. This is used for inter-process communication on // the same host computer. NNG_DECL int nng_ipc_register(void); #endif // NNG_TRANSPORT_IPC_IPC_H aBuild/nng/include/nng/transport/tcp/tcp.h
New file @@ -0,0 +1,18 @@ // // Copyright 2017 Garrett D'Amore <garrett@damore.org> // Copyright 2017 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_TRANSPORT_TCP_TCP_H #define NNG_TRANSPORT_TCP_TCP_H // TCP transport. This is used for communication over TCP/IP. NNG_DECL int nng_tcp_register(void); #endif // NNG_TRANSPORT_TCP_TCP_H aBuild/nng/include/nng/transport/tls/tls.h
New file @@ -0,0 +1,18 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_TRANSPORT_TLS_TLS_H #define NNG_TRANSPORT_TLS_TLS_H // TLS transport. This is used for communication via TLS v1.2 over TCP/IP. NNG_DECL int nng_tls_register(void); #endif // NNG_TRANSPORT_TLS_TLS_H aBuild/nng/include/nng/transport/ws/websocket.h
New file @@ -0,0 +1,32 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_TRANSPORT_WS_WEBSOCKET_H #define NNG_TRANSPORT_WS_WEBSOCKET_H // WebSocket transport. This is used for communication via WebSocket. NNG_DECL int nng_ws_register(void); // NNG_OPT_WS_REQUEST_HEADERS is a string containing the // request headers, formatted as CRLF terminated lines. #define NNG_OPT_WS_REQUEST_HEADERS "ws:request-headers" // NNG_OPT_WS_RESPONSE_HEADERS is a string containing the // response headers, formatted as CRLF terminated lines. #define NNG_OPT_WS_RESPONSE_HEADERS "ws:response-headers" // These aliases are for WSS naming consistency. #define NNG_OPT_WSS_REQUEST_HEADERS NNG_OPT_WS_REQUEST_HEADERS #define NNG_OPT_WSS_RESPONSE_HEADERS NNG_OPT_WS_RESPONSE_HEADERS NNG_DECL int nng_wss_register(void); #endif // NNG_TRANSPORT_WS_WEBSOCKET_H aBuild/nng/include/nng/transport/zerotier/zerotier.h
New file @@ -0,0 +1,149 @@ // // Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this // file was obtained (LICENSE.txt). A copy of the license may also be // found online at https://opensource.org/licenses/MIT. // #ifndef NNG_TRANSPORT_ZEROTIER_ZEROTIER_H #define NNG_TRANSPORT_ZEROTIER_ZEROTIER_H // ZeroTier Transport. This sits on the ZeroTier L2 network, which itself // is implemented on top of UDP. This requires the 3rd party // libzerotiercore library (which is GPLv3!) and platform specific UDP // functionality to be built in. Note that care must be taken to link // dynamically if one wishes to avoid making your entire application GPL3. // (Alternatively ZeroTier offers commercial licenses which may prevent // this particular problem.) This implementation does not make use of // certain advanced capabilities in ZeroTier such as more sophisticated // route management and TCP fallback. You need to have connectivity // to the Internet to use this. (Or at least to your Planetary root.) // // The ZeroTier URL format we support is zt://<ztid>.<nwid>:<port> where // the <nwid> component represents the 64-bit hexadecimal ZeroTier // network ID,the <ztid> represents the 40-bit hexadecimal ZeroTier // node (device) ID, and the <port> is a 24-bit (decimal) port number. // // A listener may replace the <ztid> with a wildcard, to just bind to itself, // in which case the format will be zt://*.<nwid>:<port> // // A listener may also use either 0 or * for the <port> to indicate that // a random local ephemeral port should be used. // // Because ZeroTier takes a while to establish connectivity, it is even // more important that applications using the ZeroTier transport not // assume that a connection will be immediately available. It can take // quite a few seconds for peer-to-peer connectivity to be established. // // The ZeroTier transport was funded by Capitar IT Group, BV. // // The protocol itself is documented online at: // http://nanomsg.org/rfcs/sp-zerotier-v0.html // // This transport is highly experimental. // ZeroTier transport-specific options. // NNG_OPT_ZT_HOME is a string containing a directory, where persistent // state (key files, etc.) will be stored. It should be protected from // unauthorized viewing and modification. This option must be set on an // endpoint or socket before the endpoint(s) are started. If the unset, // or an empty string, then no persistence is used and an ephemeral node // will be created instead. Note that different endpoints may use different // values for this option, and that will lead to each endpoint having a // different ZeroTier identity -- however only one ephemeral node will // be created for the application. #define NNG_OPT_ZT_HOME "zt:home" // NNG_OPT_ZT_NWID is the 64-bit network ID, represented using a uint64_t in // native byte order. This is a read-only option; it is derived automatically // from the URL. #define NNG_OPT_ZT_NWID "zt:nwid" // NNG_OPT_ZT_NODE is the 40-bit node ID, stored in native order in the low // 40-bits of a uint64_t, of the node. This is a read-only option. #define NNG_OPT_ZT_NODE "zt:node" // NNG_OPT_ZT_NETWORK_STATUS represents the status of the ZeroTier virtual // network. The option is a read-only value, stored as an integer, which // takes of the nng_zt_network_status_xxx values listed below. #define NNG_OPT_ZT_NETWORK_STATUS "zt:network-status" // NNG_OPT_ZT_NETWORK_NAME is a human-readable name for the ZeroTier virtual // network. This will only be set once the ZeroTier network has come up // as the name comes from the network controller. This is read-only, and // is presented as an ASCIIZ string. #define NNG_OPT_ZT_NETWORK_NAME "zt:network-name" // NNG_OPT_ZT_PING_TIME and NNG_OPT_ZT_PING_TRIES are used to send ping // requests when a connection appears to be idled. If a logical session // has not received traffic from it's peer for ping-time, then a ping packet // is sent. This will be done up to ping-count times. If no traffic from // the remote peer is seen after all ping requests are sent, then the peer // is assumed to be dead or offline, and the session is closed. The // NNG_OPT_ZT_PING_TIME is a duration (msec, stored as an nng_duration, and // NNG_OPT_ZT_PING_COUNT is an integer.) This ping process can be disabled // by setting either ping-time or ping-count to zero. #define NNG_OPT_ZT_PING_TIME "zt:ping-time" #define NNG_OPT_ZT_PING_TRIES "zt:ping-tries" // NNG_OPT_ZT_CONN_TIME and NNG_OPT_ZT_CONN_TRIES are used to control // the interval between connection attempts, and the maximum number of // connection attempts to make before assuming that the peer is absent // (and returning NNG_ETIMEDOUT). The NNG_OPT_ZT_CONN_TIME is a duration, // the NNG_OPT_ZT_CONN_TRIES is an integer. #define NNG_OPT_ZT_CONN_TIME "zt:conn-time" #define NNG_OPT_ZT_CONN_TRIES "zt:conn-tries" // NNG_OPT_ZT_MTU is a read-only size_t and contains the ZeroTier virtual // network MTU (i.e. the L2 payload MTU). Messages that are larger than this // (including our 20-byte header data) will be fragmented into multiple // virtual L2 frames. #define NNG_OPT_ZT_MTU "zt:mtu" // NNG_OPT_ZT_ORBIT is a write-only API to add a "moon" -- this affects the // endpoint, and all other endpoints using the same node. The value is // a pair of 64-bit integers -- the first is the moon ID, and the second, if // non-zero, is the node ID of a server. Conventionally this is the same // as the moon ID. #define NNG_OPT_ZT_ORBIT "zt:orbit" // NNG_OPT_ZT_DEORBIT removes the moon ID from the node, so that it will // no longer use that moon. The argument is a moon ID to remove. If the // node is not already orbiting, then this operation does nothing. #define NNG_OPT_ZT_DEORBIT "zt:deorbit" // NNG_OPT_ZT_ADD_LOCAL_ADDR adds the local address (IP address) as // local interface address. This facilitates the local startup and // discovery. Note that this can be called multiple times to add // additional address. This is optional, and usually not needed. // The value is an nng_sockaddr corresponding to an IP (or IPv6) address. #define NNG_OPT_ZT_ADD_LOCAL_ADDR "zt:add-local-addr" // NNG_OPT_ZT_CLEAR_LOCAL_ADDRS clears ZeroTier's notion of all // local addresses. This may be useful when used on a mobile node, // to reset the notion of what the local addresses are. This // option takes no argument really. #define NNG_OPT_ZT_CLEAR_LOCAL_ADDRS "zt:clear-local-addrs" // Network status values. // These values are supplied to help folks checking status. They are the // return values from zt_opt_status. We avoid hard coding them as defines, // to keep applications from baking in values that may change if the // underlying ZeroTier transport changes. enum nng_zt_status { NNG_ZT_STATUS_UP, NNG_ZT_STATUS_CONFIG, NNG_ZT_STATUS_DENIED, NNG_ZT_STATUS_NOTFOUND, NNG_ZT_STATUS_ERROR, NNG_ZT_STATUS_OBSOLETE, NNG_ZT_STATUS_UNKNOWN, }; NNG_DECL int nng_zt_register(void); #endif // NNG_TRANSPORT_ZEROTIER_ZEROTIER_H aBuild/nng/lib/cmake/nng/nng-config-version.cmake
New file @@ -0,0 +1,46 @@ # This is a basic version file for the Config-mode of find_package(). # It is used by write_basic_package_version_file() as input file for configure_file() # to create a version-file which can be installed along a config.cmake file. # # The created file sets PACKAGE_VERSION_EXACT if the current version string and # the requested version string are exactly the same and it sets # PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, # but only if the requested major version is the same as the current one. # The variable CVF_VERSION must be set before calling configure_file(). set(PACKAGE_VERSION "1.1.1-37-g82afec9") if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() if("1.1.1-37-g82afec9" MATCHES "^([0-9]+)\\.") set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") else() set(CVF_VERSION_MAJOR "1.1.1-37-g82afec9") endif() if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) set(PACKAGE_VERSION_COMPATIBLE TRUE) else() set(PACKAGE_VERSION_COMPATIBLE FALSE) endif() if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) set(PACKAGE_VERSION_EXACT TRUE) endif() endif() # if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") return() endif() # check that the installed version has the same 32/64bit-ness as the one which is currently searching: if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") math(EXPR installedBits "8 * 8") set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") set(PACKAGE_VERSION_UNSUITABLE TRUE) endif() aBuild/nng/lib/cmake/nng/nng-config.cmake
New file @@ -0,0 +1,50 @@ # Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> # # This software is supplied under the terms of the MIT License, a # copy of which should be located in the distribution where this # file was obtained (LICENSE.txt). A copy of the license may also be # found online at https://opensource.org/licenses/MIT. ####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### ####### Any changes to this file will be overwritten by the next CMake run #### ####### The input file was nng-config.cmake.in ######## get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) macro(set_and_check _var _file) set(${_var} "${_file}") if(NOT EXISTS "${_file}") message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") endif() endmacro() macro(check_required_components _NAME) foreach(comp ${${_NAME}_FIND_COMPONENTS}) if(NOT ${_NAME}_${comp}_FOUND) if(${_NAME}_FIND_REQUIRED_${comp}) set(${_NAME}_FOUND FALSE) endif() endif() endforeach() endmacro() #################################################################################### set(NNG_VERSION_MAJOR "1") set(NNG_VERSION_MINOR "1") set(NNG_VERSION_PATCH "1") set_and_check(NNG_INCLUDE_DIRS "${PACKAGE_PREFIX_DIR}/include/nng") include("${CMAKE_CURRENT_LIST_DIR}/nng-targets.cmake") # Make sure we find packages for our dependencies foreach(_PKG IN ITEMS Threads) find_package(${_PKG} REQUIRED) endforeach () set(NNG_LIBRARY nng::nng) check_required_components(nng) aBuild/nng/lib/cmake/nng/nng-targets-noconfig.cmake
New file @@ -0,0 +1,19 @@ #---------------------------------------------------------------- # Generated CMake target import file. #---------------------------------------------------------------- # Commands may need to know the format version. set(CMAKE_IMPORT_FILE_VERSION 1) # Import target "nng::nng" for configuration "" set_property(TARGET nng::nng APPEND PROPERTY IMPORTED_CONFIGURATIONS NOCONFIG) set_target_properties(nng::nng PROPERTIES IMPORTED_LOCATION_NOCONFIG "${_IMPORT_PREFIX}/lib/libnng.so.1.1.0" IMPORTED_SONAME_NOCONFIG "libnng.so.1" ) list(APPEND _IMPORT_CHECK_TARGETS nng::nng ) list(APPEND _IMPORT_CHECK_FILES_FOR_nng::nng "${_IMPORT_PREFIX}/lib/libnng.so.1.1.0" ) # Commands beyond this point should not need to know the version. set(CMAKE_IMPORT_FILE_VERSION) aBuild/nng/lib/cmake/nng/nng-targets.cmake
New file @@ -0,0 +1,88 @@ # Generated by CMake 3.5.1 if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5) message(FATAL_ERROR "CMake >= 2.6.0 required") endif() cmake_policy(PUSH) cmake_policy(VERSION 2.6) #---------------------------------------------------------------- # Generated CMake target import file. #---------------------------------------------------------------- # Commands may need to know the format version. set(CMAKE_IMPORT_FILE_VERSION 1) # Protect against multiple inclusion, which would fail when already imported targets are added once more. set(_targetsDefined) set(_targetsNotDefined) set(_expectedTargets) foreach(_expectedTarget nng::nng) list(APPEND _expectedTargets ${_expectedTarget}) if(NOT TARGET ${_expectedTarget}) list(APPEND _targetsNotDefined ${_expectedTarget}) endif() if(TARGET ${_expectedTarget}) list(APPEND _targetsDefined ${_expectedTarget}) endif() endforeach() if("${_targetsDefined}" STREQUAL "${_expectedTargets}") set(CMAKE_IMPORT_FILE_VERSION) cmake_policy(POP) return() endif() if(NOT "${_targetsDefined}" STREQUAL "") message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n") endif() unset(_targetsDefined) unset(_targetsNotDefined) unset(_expectedTargets) # Compute the installation prefix relative to this file. get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) # Create imported target nng::nng add_library(nng::nng SHARED IMPORTED) set_target_properties(nng::nng PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" ) # Load information for each installed configuration. get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) file(GLOB CONFIG_FILES "${_DIR}/nng-targets-*.cmake") foreach(f ${CONFIG_FILES}) include(${f}) endforeach() # Cleanup temporary variables. set(_IMPORT_PREFIX) # Loop over all imported files and verify that they actually exist foreach(target ${_IMPORT_CHECK_TARGETS} ) foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} ) if(NOT EXISTS "${file}" ) message(FATAL_ERROR "The imported target \"${target}\" references the file \"${file}\" but this file does not exist. Possible reasons include: * The file was deleted, renamed, or moved to another location. * An install or uninstall procedure did not complete successfully. * The installation package was faulty and contained \"${CMAKE_CURRENT_LIST_FILE}\" but not all the files it references. ") endif() endforeach() unset(_IMPORT_CHECK_FILES_FOR_${target}) endforeach() unset(_IMPORT_CHECK_TARGETS) # This file does not depend on other imported targets which have # been exported from the same project but in a separate export set. # Commands beyond this point should not need to know the version. set(CMAKE_IMPORT_FILE_VERSION) cmake_policy(POP) aBuild/nng/lib/libnng.aBinary files differ
aBuild/nng/lib/libnng.so.1.1.0Binary files differ
nng
New file @@ -1 +1 @@ Subproject commit 0000000000000000000000000000000000000000 Subproject commit 82afec95496fd2e4b8fb404aa90e961f93db1fe8
