X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fmeshlink%2B%2B.h;h=b09ad75b449ee535b65e722394aa8df74c688b43;hb=a8c5d9fc9f1274608bf9b3a2430f3f72f00ecbcc;hp=df0a72b594431cf779df8cabbc9e87375c56bc94;hpb=196806f90f40fcc0cf727abd4bed6bc5aefff5ff;p=meshlink diff --git a/src/meshlink++.h b/src/meshlink++.h index df0a72b5..b09ad75b 100644 --- a/src/meshlink++.h +++ b/src/meshlink++.h @@ -1,6 +1,9 @@ +#ifndef MESHLINKPP_H +#define MESHLINKPP_H + /* meshlink++.h -- MeshLink C++ API - Copyright (C) 2014 Guus Sliepen + Copyright (C) 2014, 2017 Guus Sliepen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,9 +20,6 @@ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef MESHLINKPP_H -#define MESHLINKPP_H - #include #include // for 'placement new' @@ -108,7 +108,7 @@ public: } bool isOpen() const { - return (handle!=0); + return (handle != 0); } // TODO: please enable C++11 in autoconf to enable "move constructors": @@ -137,15 +137,17 @@ public: * * @return This function will return a pointer to a meshlink::mesh if MeshLink has succesfully set up its configuration files, NULL otherwise. */ - bool open(const char *confbase, const char *name, const char* appname, dev_class_t devclass) { + bool open(const char *confbase, const char *name, const char *appname, dev_class_t devclass) { handle = meshlink_open(confbase, name, appname, devclass); - if(handle) + + if(handle) { handle->priv = this; + } return isOpen(); } - mesh(const char *confbase, const char *name, const char* appname, dev_class_t devclass) { + mesh(const char *confbase, const char *name, const char *appname, dev_class_t devclass) { open(confbase, name, appname, devclass); } @@ -159,7 +161,8 @@ public: handle->priv = 0; meshlink_close(handle); } - handle=0; + + handle = 0; } /** instead of registerin callbacks you derive your own class and overwrite the following abstract member functions. @@ -171,13 +174,13 @@ public: */ /// This function is called whenever another node sends data to the local node. - virtual void receive(node* source, const void* data, size_t length) { /* do nothing */ } + virtual void receive(node *source, const void *data, size_t length) { /* do nothing */ (void)source; (void)data; (void) length; } /// This functions is called whenever another node's status changed. - virtual void node_status(node* peer, bool reachable) { /* do nothing */ } + virtual void node_status(node *peer, bool reachable) { /* do nothing */ (void)peer; (void)reachable; } /// This functions is called whenever MeshLink has some information to log. - virtual void log(log_level_t level, const char* message) { /* do nothing */ } + virtual void log(log_level_t level, const char *message) { /* do nothing */ (void)level; (void)message; } /// This functions is called whenever another node attemps to open a channel to the local node. /** @@ -200,6 +203,7 @@ public: */ virtual bool channel_accept(channel *channel, uint16_t port, const void *data, size_t len) { /* by default reject all channels */ + (void)channel; (void)port; (void)data; (void)len; return false; } @@ -214,7 +218,7 @@ public: * @param data A pointer to a buffer containing data sent by the source. * @param len The length of the data. */ - virtual void channel_receive(channel *channel, const void *data, size_t len) { /* do nothing */ } + virtual void channel_receive(channel *channel, const void *data, size_t len) { /* do nothing */ (void)channel; (void)data; (void)len; } /// This function is called by Meshlink when data can be send on a channel. /** @@ -226,7 +230,7 @@ public: * @param channel A handle for the channel. * @param len The maximum length of data that is guaranteed to be accepted by a call to channel_send(). */ - virtual void channel_poll(channel *channel, size_t len) { /* do nothing */ } + virtual void channel_poll(channel *channel, size_t len) { /* do nothing */ (void)channel; (void)len; } /// Start MeshLink. /** This function causes MeshLink to open network sockets, make outgoing connections, and @@ -356,12 +360,15 @@ public: * There is no guarantee it will be able to resolve the external address. * Failures might be because by temporary network outages. * + * @param family The address family to check, for example AF_INET or AF_INET6. If AF_UNSPEC is given, + * this might return the external address for any working address family. + * * @return This function returns a pointer to a C string containing the discovered external address, * or NULL if there was an error looking up the address. * After get_external_address() returns, the application is free to overwrite or free this string. */ - bool get_external_address() { - return meshlink_get_external_address(handle); + bool get_external_address(int family = AF_UNSPEC) { + return meshlink_get_external_address_for_family(handle, family); } /// Try to discover the external address for the local node, and add it to its list of addresses. @@ -558,63 +565,87 @@ public: return meshlink_channel_send(handle, channel, data, len); } + /// Enable or disable zeroconf discovery of local peers + /** This controls whether zeroconf discovery using the Catta library will be + * enabled to search for peers on the local network. By default, it is enabled. + * + * @param enable Set to true to enable discovery, false to disable. + */ + void enable_discovery(bool enable = true) { + meshlink_enable_discovery(handle, enable); + } + private: // non-copyable: - mesh(const mesh&) /* TODO: C++11: = delete */; - void operator=(const mesh&) /* TODO: C++11: = delete */ ; + mesh(const mesh &) /* TODO: C++11: = delete */; + void operator=(const mesh &) /* TODO: C++11: = delete */ ; /// static callback trampolines: - static void receive_trampoline(meshlink_handle_t* handle, meshlink_node_t* source, const void* data, size_t length) { - if(!(handle->priv)) + static void receive_trampoline(meshlink_handle_t *handle, meshlink_node_t *source, const void *data, size_t length) { + if(!(handle->priv)) { return; - meshlink::mesh* that = static_cast(handle->priv); - that->receive(static_cast(source), data, length); + } + + meshlink::mesh *that = static_cast(handle->priv); + that->receive(static_cast(source), data, length); } - static void node_status_trampoline(meshlink_handle_t* handle, meshlink_node_t* peer, bool reachable) { - if(!(handle->priv)) + static void node_status_trampoline(meshlink_handle_t *handle, meshlink_node_t *peer, bool reachable) { + if(!(handle->priv)) { return; - meshlink::mesh* that = static_cast(handle->priv); - that->node_status(static_cast(peer), reachable); + } + + meshlink::mesh *that = static_cast(handle->priv); + that->node_status(static_cast(peer), reachable); } - static void log_trampoline(meshlink_handle_t* handle, log_level_t level, const char* message) { - if(!(handle->priv)) + static void log_trampoline(meshlink_handle_t *handle, log_level_t level, const char *message) { + if(!(handle->priv)) { return; - meshlink::mesh* that = static_cast(handle->priv); + } + + meshlink::mesh *that = static_cast(handle->priv); that->log(level, message); } static bool channel_accept_trampoline(meshlink_handle_t *handle, meshlink_channel *channel, uint16_t port, const void *data, size_t len) { - if(!(handle->priv)) + if(!(handle->priv)) { return false; - meshlink::mesh* that = static_cast(handle->priv); - bool accepted = that->channel_accept(static_cast(channel), port, data, len); + } + + meshlink::mesh *that = static_cast(handle->priv); + bool accepted = that->channel_accept(static_cast(channel), port, data, len); + if(accepted) { meshlink_set_channel_receive_cb(handle, channel, &channel_receive_trampoline); meshlink_set_channel_poll_cb(handle, channel, &channel_poll_trampoline); } + return accepted; } - static void channel_receive_trampoline(meshlink_handle_t *handle, meshlink_channel *channel, const void* data, size_t len) { - if(!(handle->priv)) + static void channel_receive_trampoline(meshlink_handle_t *handle, meshlink_channel *channel, const void *data, size_t len) { + if(!(handle->priv)) { return; - meshlink::mesh* that = static_cast(handle->priv); - that->channel_receive(static_cast(channel), data, len); + } + + meshlink::mesh *that = static_cast(handle->priv); + that->channel_receive(static_cast(channel), data, len); } static void channel_poll_trampoline(meshlink_handle_t *handle, meshlink_channel *channel, size_t len) { - if(!(handle->priv)) + if(!(handle->priv)) { return; - meshlink::mesh* that = static_cast(handle->priv); - that->channel_poll(static_cast(channel), len); + } + + meshlink::mesh *that = static_cast(handle->priv); + that->channel_poll(static_cast(channel), len); } - meshlink_handle_t* handle; + meshlink_handle_t *handle; }; -static const char *strerror(errno_t err = meshlink_errno) { +static inline const char *strerror(errno_t err = meshlink_errno) { return meshlink_strerror(err); } @@ -628,9 +659,9 @@ static const char *strerror(errno_t err = meshlink_errno) { * * @return This function will return true if the MeshLink instance was succesfully destroyed, false otherwise. */ -static bool destroy(const char *confbase) { +static inline bool destroy(const char *confbase) { return meshlink_destroy(confbase); } } -#endif // MESHLINKPP_H +#endif