initial commit

lib/rtcvars/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 highno
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lib/rtcvars/RTCVars.cpp

@@ -0,0 +1,193 @@
+// https://github.com/highno/rtcvars
+
+#if defined(ESP8266)
+
+#include "Arduino.h"
+#include "RTCVars.h"
+
+#define RTC_BASE 28                   // this is a known good offset for unused RTC memory
+#define RTC_STATE_HEADER_SIZE 6       // 3 bytes signature, 1 byte state_id, 2 byte
+#define RTC_MAX_SIZE (511 - RTC_BASE) // 512 - RTC_BASE - 1 for checksum
+
+#define RTC_STATE_TYPE_NONE 0
+#define RTC_STATE_TYPE_INT 1
+#define RTC_STATE_TYPE_LONG 2
+#define RTC_STATE_TYPE_FLOAT 3
+#define RTC_STATE_TYPE_BYTE 4
+#define RTC_STATE_TYPE_CHAR 5
+#define RTC_STATE_TYPE_BOOL 6
+
+RTCVars::RTCVars() {
+    _state_size              = RTC_STATE_HEADER_SIZE;
+    _state_variables_counter = 0;
+    _state_id                = 0;
+    _last_read_state_id      = RTC_STATE_ID_INVALID;
+    _last_read_status        = RTC_OK;
+}
+
+bool RTCVars::registerVar(char * v) {
+    return _checkAndReserve((uintptr_t)v, RTC_STATE_TYPE_CHAR);
+}
+
+bool RTCVars::registerVar(byte * v) {
+    return _checkAndReserve((uintptr_t)v, RTC_STATE_TYPE_BYTE);
+}
+
+bool RTCVars::registerVar(int * v) {
+    return _checkAndReserve((uintptr_t)v, RTC_STATE_TYPE_INT);
+}
+
+bool RTCVars::registerVar(long * v) {
+    return _checkAndReserve((uintptr_t)v, RTC_STATE_TYPE_LONG);
+}
+
+bool RTCVars::registerVar(float * v) {
+    return _checkAndReserve((uintptr_t)v, RTC_STATE_TYPE_FLOAT);
+}
+
+bool RTCVars::registerVar(bool * v) {
+    return _checkAndReserve((uintptr_t)v, RTC_STATE_TYPE_BOOL);
+}
+
+bool RTCVars::_checkAndReserve(uintptr_t v, byte type_of_var) {
+    // check if there is enough room for this var
+    if ((_state_variables_counter >= RTC_MAX_VARIABLES) || (_state_variable_size[type_of_var] + _state_size >= RTC_MAX_SIZE))
+        return false;
+    // keep the pointer to the var
+    _state_variables_ptr[_state_variables_counter] = v;
+    // keep the type of var so we copy the correct number of bytes
+    _state_variables_type[_state_variables_counter] = type_of_var;
+    // remove these bytes from the free mem counter
+    _state_size += _state_variable_size[type_of_var];
+    // up to the next one
+    _state_variables_counter++;
+    return true;
+}
+
+bool RTCVars::saveToRTC() {
+    unsigned char buf[_state_size + 1];
+    int           p = RTC_STATE_HEADER_SIZE;
+    int           s = 0;
+
+    // migic bytes signature
+    buf[0] = 'M';
+    buf[1] = 'G';
+    buf[2] = 'C';
+    buf[3] = _state_id;
+    buf[4] = (unsigned char)((_state_size >> 8) & 0xff);
+    buf[5] = (unsigned char)(_state_size & 0xff);
+
+    // copy the values from the local variables' memory places into buffer
+    for (int i = 0; i < _state_variables_counter; i++) {
+        s = _state_variable_size[_state_variables_type[i]];
+        memcpy(&buf[p], reinterpret_cast<void *>(_state_variables_ptr[i]), s);
+        p += s;
+    }
+
+    buf[_state_size] = 0;
+    for (int j = 0; j < _state_size; j++) {
+        buf[_state_size] += buf[j]; // simple checksum
+    }
+    return ESP.rtcUserMemoryWrite(RTC_BASE, (uint32_t *)&buf, _state_size + 1);
+}
+
+bool RTCVars::loadFromRTC() {
+    if (!_checkValidRTCData())
+        return false;
+    _last_read_status = RTC_ERROR_READING_FAILED;
+    unsigned char buf[_state_size + 1];
+    if (!ESP.rtcUserMemoryRead(RTC_BASE, (uint32_t *)&buf, _state_size + 1))
+        return false;
+
+    // check if state id is ok
+    _last_read_status = RTC_ERROR_STATE_ID;
+    if (_last_read_state_id != _state_id)
+        return false;
+    // finally check if state sizes are equal
+    _last_read_status = RTC_ERROR_SIZE;
+    int size_in_rtc   = (int)(buf[4] * 256 + buf[5]);
+    if (size_in_rtc != _state_size)
+        return false;
+
+    // copy the values into the local variables' memory places
+    _last_read_status = RTC_ERROR_OTHER;
+    int p             = RTC_STATE_HEADER_SIZE;
+    int s             = 0;
+    for (int i = 0; i < _state_variables_counter; i++) {
+        s = _state_variable_size[_state_variables_type[i]];
+        memcpy(reinterpret_cast<void *>(_state_variables_ptr[i]), &buf[p], s);
+        p += s;
+    }
+    _last_read_status = RTC_OK;
+    return true;
+}
+
+bool RTCVars::_checkValidRTCData() {
+    // load header only from RTC
+    _last_read_status = RTC_ERROR_READING_FAILED;
+    unsigned char buf_head[RTC_STATE_HEADER_SIZE];
+    if (!ESP.rtcUserMemoryRead(RTC_BASE, (uint32_t *)&buf_head, RTC_STATE_HEADER_SIZE))
+        return false;
+
+    _last_read_status = RTC_ERROR_MAGIC_BYTES;
+    // check if magic bytes are ok
+    if (buf_head[0] != 'M')
+        return false;
+    if (buf_head[1] != 'G')
+        return false;
+    if (buf_head[2] != 'C')
+        return false;
+
+    _last_read_status = RTC_ERROR_SIZE;
+    // check for valid size
+    int size_in_rtc = (int)(buf_head[4] * 256 + buf_head[5]);
+    if (size_in_rtc > RTC_MAX_SIZE)
+        return false;
+
+    _last_read_status = RTC_ERROR_READING_FAILED;
+    // load the full state from RTC
+    unsigned char buf[size_in_rtc + 1];
+    if (!ESP.rtcUserMemoryRead(RTC_BASE, (uint32_t *)&buf, size_in_rtc + 1))
+        return false;
+
+    _last_read_status = RTC_ERROR_CHECKSUM;
+    // check for checksum
+    unsigned char temp = 0;
+    for (int j = 0; j < size_in_rtc; j++)
+        temp += buf[j]; //checksum
+    if (temp != buf[size_in_rtc])
+        return false;
+
+    _last_read_status   = RTC_OK;
+    _last_read_state_id = buf[3];
+    return true;
+}
+
+int RTCVars::getFreeRTCMem() {
+    return RTC_MAX_SIZE - _state_size;
+}
+
+int RTCVars::getFreeRTCVars() {
+    return RTC_MAX_VARIABLES - _state_variables_counter;
+}
+
+byte RTCVars::getStateID() {
+    return _state_id;
+}
+
+byte RTCVars::getStateIDFromRTC() {
+    if (!_checkValidRTCData())
+        return RTC_STATE_ID_INVALID;
+    return _last_read_state_id;
+}
+
+void RTCVars::setStateID(byte new_state_id) {
+    if (new_state_id != RTC_STATE_ID_INVALID)
+        _state_id = new_state_id;
+}
+
+byte RTCVars::getReadError() {
+    return _last_read_status;
+}
+
+#endif

lib/rtcvars/RTCVars.h

@@ -0,0 +1,51 @@
+#ifndef RTCVARS_H
+#define RTCVARS_H
+
+#include "Arduino.h"
+
+#ifndef RTC_MAX_VARIABLES
+#define RTC_MAX_VARIABLES 32
+#endif
+
+const static byte RTC_OK                   = 0;
+const static byte RTC_ERROR_MAGIC_BYTES    = 1;
+const static byte RTC_ERROR_SIZE           = 2;
+const static byte RTC_ERROR_READING_FAILED = 3;
+const static byte RTC_ERROR_CHECKSUM       = 4;
+const static byte RTC_ERROR_STATE_ID       = 5;
+const static byte RTC_ERROR_OTHER          = 99;
+const static byte RTC_STATE_ID_INVALID     = 255;
+
+class RTCVars {
+  public:
+    RTCVars();
+    bool registerVar(char * v);
+    bool registerVar(byte * v);
+    bool registerVar(bool * v);
+    bool registerVar(int * v);
+    bool registerVar(long * v);
+    bool registerVar(float * v);
+    void debugOutputRTCVars();
+    bool saveToRTC();
+    bool loadFromRTC();
+    int  getFreeRTCMem();
+    int  getFreeRTCVars();
+    byte getStateID();
+    byte getStateIDFromRTC();
+    void setStateID(byte new_state_id);
+    byte getReadError();
+
+  private:
+    byte       _state_id;
+    byte       _last_read_state_id;
+    byte       _last_read_status;
+    int        _state_size;
+    int        _state_variables_counter;
+    uintptr_t  _state_variables_ptr[RTC_MAX_VARIABLES];
+    byte       _state_variables_type[RTC_MAX_VARIABLES];
+    const byte _state_variable_size[7] = {0, sizeof(int), sizeof(long), sizeof(float), sizeof(byte), sizeof(char), sizeof(bool)};
+    bool       _checkAndReserve(uintptr_t v, byte type_of_var);
+    bool       _checkValidRTCData();
+};
+
+#endif

lib/uuid-common/COPYING

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

lib/uuid-common/README.rst

@@ -0,0 +1,25 @@
+mcu-uuid-common |Build Status|
+==============================
+
+Description
+-----------
+
+Microcontroller common utilities library
+
+Purpose
+-------
+
+The primary purpose of this library is to maintain a common 64-bit uptime in
+milliseconds with overflow handling, as long as the loop function is called
+regularly.
+
+Documentation
+-------------
+
+`Read the documentation <https://mcu-uuid-common.readthedocs.io/>`_ generated
+from the docs_ directory.
+
+.. _docs: docs/
+
+.. |Build Status| image:: https://travis-ci.org/nomis/mcu-uuid-common.svg?branch=master
+   :target: https://travis-ci.org/nomis/mcu-uuid-common

lib/uuid-common/library.json

@@ -0,0 +1,31 @@
+{
+	"name": "uuid-common",
+	"description": "Common utilities library",
+	"keywords": "utility, uptime",
+	"authors": [
+		{
+			"name": "Simon Arlott",
+			"maintainer": true
+		}
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/nomis/mcu-uuid-common.git"
+	},
+	"version": "1.1.0",
+	"license": "GPL-3.0-or-later",
+	"homepage": "https://mcu-uuid-common.readthedocs.io/",
+	"export": {
+		"exclude": [
+			".travis.yml",
+			"test/*"
+		]
+	},
+	"frameworks": [
+		"arduino"
+	],
+	"build": {
+		"flags": "-Wall -Wextra",
+		"libLDFMode": "off"
+	}
+}

lib/uuid-common/src/common.cpp

@@ -0,0 +1,19 @@
+/*
+ * uuid-common - Microcontroller common utilities
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/common.h>

lib/uuid-common/src/get_uptime_ms.cpp

@@ -0,0 +1,40 @@
+/*
+ * uuid-common - Microcontroller common utilities
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/common.h>
+
+#include <Arduino.h>
+
+namespace uuid {
+
+uint64_t get_uptime_ms() {
+    static uint32_t high_millis = 0;
+    static uint32_t low_millis  = 0;
+
+    uint32_t now_millis = ::millis();
+
+    if (now_millis < low_millis) {
+        high_millis++;
+    }
+
+    low_millis = now_millis;
+
+    return ((uint64_t)high_millis << 32) | low_millis;
+}
+
+} // namespace uuid

lib/uuid-common/src/loop.cpp

@@ -0,0 +1,27 @@
+/*
+ * uuid-common - Microcontroller common utilities
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/common.h>
+
+namespace uuid {
+
+void loop() {
+    get_uptime_ms();
+}
+
+} // namespace uuid

lib/uuid-common/src/printable_to_string.cpp

@@ -0,0 +1,62 @@
+/*
+ * uuid-common - Microcontroller common utilities
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/common.h>
+
+#include <Arduino.h>
+
+#include <string>
+
+namespace uuid {
+
+class PrintableString : public ::Print {
+  public:
+    explicit PrintableString(std::string & output)
+        : output_(output) {
+    }
+    ~PrintableString() = default;
+
+    size_t write(uint8_t data) final override {
+        output_.append(1, reinterpret_cast<unsigned char>(data));
+        return 1;
+    }
+
+    size_t write(const uint8_t * buffer, size_t size) final override {
+        output_.append(reinterpret_cast<const char *>(buffer), size);
+        return size;
+    }
+
+  private:
+    std::string & output_;
+};
+
+size_t print_to_string(const Printable & printable, std::string & output) {
+    PrintableString pstr{output};
+
+    return printable.printTo(pstr);
+}
+
+std::string printable_to_string(const Printable & printable) {
+    std::string str;
+
+    print_to_string(printable, str);
+
+    return str;
+}
+
+} // namespace uuid

lib/uuid-common/src/read_flash_string.cpp

@@ -0,0 +1,35 @@
+/*
+ * uuid-common - Microcontroller common utilities
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/common.h>
+
+#include <Arduino.h>
+
+#include <string>
+
+namespace uuid {
+
+std::string read_flash_string(const __FlashStringHelper * flash_str) {
+    std::string str(::strlen_P(reinterpret_cast<PGM_P>(flash_str)), '\0');
+
+    ::strncpy_P(&str[0], reinterpret_cast<PGM_P>(flash_str), str.capacity() + 1);
+
+    return str;
+}
+
+} // namespace uuid

lib/uuid-common/src/uuid/common.h

@@ -0,0 +1,91 @@
+/*
+ * uuid-common - Microcontroller common utilities
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UUID_COMMON_H_
+#define UUID_COMMON_H_
+
+#include <Arduino.h>
+
+#include <string>
+#include <vector>
+
+/**
+ * Common utilities.
+ *
+ * - <a href="https://github.com/nomis/mcu-uuid-common/">Git Repository</a>
+ * - <a href="https://mcu-uuid-common.readthedocs.io/">Documentation</a>
+ */
+namespace uuid {
+
+/**
+ * Read a string from flash and convert it to a std::string.
+ *
+ * The flash string must be stored with appropriate alignment for
+ * reading it on the platform.
+ *
+ * @param[in] flash_str Pointer to string stored in flash.
+ * @return A string copy of the flash string.
+ * @since 1.0.0
+ */
+std::string read_flash_string(const __FlashStringHelper * flash_str);
+
+/**
+ * Append to a std::string by printing a Printable object.
+ *
+ * @param[in] printable Printable object.
+ * @param[in,out] output String to append to.
+ * @return The number of bytes that were written.
+ * @since 1.1.0
+ */
+size_t print_to_string(const Printable & printable, std::string & output);
+
+/**
+ * Create a std::string from a Printable object.
+ *
+ * @param[in] printable Printable object.
+ * @return A string containing the printed output.
+ * @since 1.1.0
+ */
+std::string printable_to_string(const Printable & printable);
+
+/**
+ * Type definition for a std::vector of flash strings.
+ *
+ * @since 1.0.0
+ */
+using flash_string_vector = std::vector<const __FlashStringHelper *>;
+
+/**
+ * Loop function that must be called regularly to detect a 32-bit
+ * uptime overflow.
+ *
+ * @since 1.0.0
+ */
+void loop();
+
+/**
+ * Get the current uptime as a 64-bit milliseconds value.
+ *
+ * @return The current uptime in milliseconds.
+ * @since 1.0.0
+ */
+uint64_t get_uptime_ms();
+
+} // namespace uuid
+
+#endif

lib/uuid-console/COPYING

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

lib/uuid-console/README.rst

@@ -0,0 +1,25 @@
+mcu-uuid-console |Build Status|
+===============================
+
+Description
+-----------
+
+Microcontroller console shell
+
+Purpose
+-------
+
+Provides a framework for creating a console shell with commands. The
+container of commands (``uuid::console::Commands``) can be shared
+across multiple shell instances.
+
+Documentation
+-------------
+
+`Read the documentation <https://mcu-uuid-console.readthedocs.io/>`_ generated
+from the docs_ directory.
+
+.. _docs: docs/
+
+.. |Build Status| image:: https://travis-ci.org/nomis/mcu-uuid-console.svg?branch=master
+   :target: https://travis-ci.org/nomis/mcu-uuid-console

lib/uuid-console/library.json

@@ -0,0 +1,35 @@
+{
+	"name": "uuid-console",
+	"description": "Console shell",
+	"keywords": "console, shell, command line",
+	"authors": [
+		{
+			"name": "Simon Arlott",
+			"maintainer": true
+		}
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/nomis/mcu-uuid-console.git"
+	},
+	"version": "0.7.3",
+	"license": "GPL-3.0-or-later",
+	"homepage": "https://mcu-uuid-console.readthedocs.io/",
+	"export": {
+		"exclude": [
+			".travis.yml",
+			"test/*"
+		]
+	},
+	"frameworks": [
+		"arduino"
+	],
+	"dependencies": {
+		"uuid-common": "^1.0.0",
+		"uuid-log": "^2.0.3"
+	},
+	"build": {
+		"flags": "-Wall -Wextra",
+		"libLDFMode": "off"
+	}
+}

lib/uuid-console/src/command_line.cpp

@@ -0,0 +1,166 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <string>
+#include <vector>
+
+namespace uuid {
+
+namespace console {
+
+CommandLine::CommandLine(const std::string & line) {
+    bool string_escape_double = false;
+    bool string_escape_single = false;
+    bool char_escape          = false;
+    bool quoted_argument      = false;
+
+    if (!line.empty()) {
+        parameters_.emplace_back(std::string{});
+    }
+
+    for (char c : line) {
+        switch (c) {
+        case ' ':
+            if (string_escape_double || string_escape_single) {
+                if (char_escape) {
+                    parameters_.back().push_back('\\');
+                    char_escape = false;
+                }
+                parameters_.back().push_back(' ');
+            } else if (char_escape) {
+                parameters_.back().push_back(' ');
+                char_escape = false;
+            } else {
+                // Begin a new argument if the previous
+                // one is not empty or it was quoted
+                if (quoted_argument || !parameters_.back().empty()) {
+                    parameters_.emplace_back(std::string{});
+                }
+                quoted_argument = false;
+            }
+            break;
+
+        case '"':
+            if (char_escape || string_escape_single) {
+                parameters_.back().push_back('"');
+                char_escape = false;
+            } else {
+                string_escape_double = !string_escape_double;
+                quoted_argument      = true;
+            }
+            break;
+
+        case '\'':
+            if (char_escape || string_escape_double) {
+                parameters_.back().push_back('\'');
+                char_escape = false;
+            } else {
+                string_escape_single = !string_escape_single;
+                quoted_argument      = true;
+            }
+            break;
+
+        case '\\':
+            if (char_escape) {
+                parameters_.back().push_back('\\');
+                char_escape = false;
+            } else {
+                char_escape = true;
+            }
+            break;
+
+        default:
+            if (char_escape) {
+                parameters_.back().push_back('\\');
+                char_escape = false;
+            }
+            parameters_.back().push_back(c);
+            break;
+        }
+    }
+
+    if (!parameters_.empty() && parameters_.back().empty() && !quoted_argument) {
+        parameters_.pop_back();
+        if (!parameters_.empty()) {
+            trailing_space = true;
+        }
+    }
+}
+
+CommandLine::CommandLine(std::initializer_list<const std::vector<std::string>> arguments) {
+    for (auto & argument : arguments) {
+        parameters_.insert(parameters_.end(), argument.begin(), argument.end());
+    }
+}
+
+std::string CommandLine::to_string(size_t reserve) const {
+    std::string line;
+    size_t      escape = escape_parameters_;
+
+    line.reserve(reserve);
+
+    for (auto & item : parameters_) {
+        if (!line.empty()) {
+            line += ' ';
+        }
+
+        if (item.empty()) {
+            line += '\"';
+            line += '\"';
+            goto next;
+        }
+
+        for (char c : item) {
+            switch (c) {
+            case ' ':
+            case '\"':
+            case '\'':
+            case '\\':
+                if (escape > 0) {
+                    line += '\\';
+                }
+                break;
+            }
+
+            line += c;
+        }
+
+    next:
+        if (escape > 0) {
+            escape--;
+        }
+    }
+
+    if (trailing_space && !line.empty()) {
+        line += ' ';
+    }
+
+    return line;
+}
+
+void CommandLine::reset() {
+    parameters_.clear();
+    escape_all_parameters();
+    trailing_space = false;
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-console/src/commands.cpp

@@ -0,0 +1,543 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a std::copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <Arduino.h>
+
+#include <algorithm>
+#include <memory>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#ifndef __cpp_lib_make_unique
+namespace std {
+
+template <typename _Tp, typename... _Args>
+inline unique_ptr<_Tp> make_unique(_Args &&... __args) {
+    return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...));
+}
+
+} // namespace std
+#endif
+
+namespace uuid {
+
+namespace console {
+
+void Commands::add_command(const flash_string_vector & name, command_function function) {
+    add_command(0, 0, name, flash_string_vector{}, function, nullptr);
+}
+
+void Commands::add_command(const flash_string_vector & name, const flash_string_vector & arguments, command_function function) {
+    add_command(0, 0, name, arguments, function, nullptr);
+}
+
+void Commands::add_command(const flash_string_vector &  name,
+                           const flash_string_vector &  arguments,
+                           command_function             function,
+                           argument_completion_function arg_function) {
+    add_command(0, 0, name, arguments, function, arg_function);
+}
+
+void Commands::add_command(unsigned int context, unsigned int flags, const flash_string_vector & name, command_function function) {
+    add_command(context, flags, name, flash_string_vector{}, function, nullptr);
+}
+
+void Commands::add_command(unsigned int                context,
+                           unsigned int                flags,
+                           const flash_string_vector & name,
+                           const flash_string_vector & arguments,
+                           command_function            function) {
+    add_command(context, flags, name, arguments, function, nullptr);
+}
+
+void Commands::add_command(unsigned int                 context,
+                           unsigned int                 flags,
+                           const flash_string_vector &  name,
+                           const flash_string_vector &  arguments,
+                           command_function             function,
+                           argument_completion_function arg_function) {
+    commands_.emplace(std::piecewise_construct, std::forward_as_tuple(context), std::forward_as_tuple(flags, name, arguments, function, arg_function));
+}
+
+// added by proddy
+void Commands::remove_context_commands(unsigned int context) {
+     commands_.erase(context);
+     /*
+
+    auto commands = commands_.equal_range(context);
+    for (auto command_it = commands.first; command_it != commands.second; command_it++) {
+        shell.printf("Got: ");
+        for (auto flash_name : command_it->second.name_) {
+            shell.printf("%s ", read_flash_string(flash_name).c_str());
+        }
+        shell.println();
+    }
+
+    size_t nun = commands_.erase(context);
+    shell.printfln("Erased %d commands", nun);
+    */
+}
+
+Commands::Execution Commands::execute_command(Shell & shell, CommandLine && command_line) {
+    auto      commands = find_command(shell, command_line);
+    auto      longest  = commands.exact.crbegin();
+    Execution result;
+
+    result.error = nullptr;
+
+    if (commands.exact.empty()) {
+        result.error = F("Command not found");
+    } else if (commands.exact.count(longest->first) == 1) {
+        auto &                   command = longest->second;
+        std::vector<std::string> arguments;
+
+        for (auto it = std::next(command_line->cbegin(), command->name_.size()); it != command_line->cend(); it++) {
+            arguments.push_back(std::move(*it));
+        }
+        command_line.reset();
+
+        if (commands.partial.upper_bound(longest->first) != commands.partial.end() && !arguments.empty()) {
+            result.error = F("Command not found");
+        } else if (arguments.size() < command->minimum_arguments()) {
+            result.error = F("Not enough arguments for command");
+        } else if (arguments.size() > command->maximum_arguments()) {
+            result.error = F("Too many arguments for command");
+        } else {
+            command->function_(shell, arguments);
+        }
+    } else {
+        result.error = F("Fatal error (multiple commands found)");
+    }
+
+    return result;
+}
+
+bool Commands::find_longest_common_prefix(const std::multimap<size_t, const Command *> & commands, std::vector<std::string> & longest_name) {
+    size_t component_prefix = 0;
+    size_t shortest_match   = commands.begin()->first;
+
+    longest_name.reserve(shortest_match);
+
+    {
+        // Check if any of the commands have a common prefix of components
+        auto & first     = commands.begin()->second->name_;
+        bool   all_match = true;
+
+        for (size_t length = 0; all_match && length < shortest_match; length++) {
+            for (auto command_it = std::next(commands.begin()); command_it != commands.end(); command_it++) {
+                if (read_flash_string(*std::next(first.begin(), length)) != read_flash_string(*std::next(command_it->second->name_.begin(), length))) {
+                    all_match = false;
+                    break;
+                }
+            }
+
+            if (all_match) {
+                component_prefix = length + 1;
+            }
+        }
+
+        auto name_it = first.begin();
+        for (size_t i = 0; i < component_prefix; i++) {
+            longest_name.push_back(std::move(read_flash_string(*name_it)));
+            name_it++;
+        }
+    }
+
+    if (component_prefix < shortest_match) {
+        // Check if the next component has a common substring
+        auto   first        = *std::next(commands.begin()->second->name_.begin(), component_prefix);
+        bool   all_match    = true;
+        size_t chars_prefix = 0;
+
+        for (size_t length = 0; all_match; length++) {
+            for (auto command_it = std::next(commands.begin()); command_it != commands.end(); command_it++) {
+                // This relies on the null terminator character limiting the
+                // length before it becomes longer than any of the strings
+                if (pgm_read_byte(reinterpret_cast<PGM_P>(first) + length)
+                    != pgm_read_byte(reinterpret_cast<PGM_P>(*std::next(command_it->second->name_.begin(), component_prefix)) + length)) {
+                    all_match = false;
+                    break;
+                }
+            }
+
+            if (all_match) {
+                chars_prefix = length + 1;
+            }
+        }
+
+        if (chars_prefix > 0) {
+            longest_name.push_back(std::move(read_flash_string(first).substr(0, chars_prefix)));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+std::string Commands::find_longest_common_prefix(const std::vector<std::string> & arguments) {
+    auto & first        = *arguments.begin();
+    bool   all_match    = true;
+    size_t chars_prefix = 0;
+
+    for (size_t length = 0; all_match; length++) {
+        for (auto argument_it = std::next(arguments.begin()); argument_it != arguments.end(); argument_it++) {
+            // This relies on the null terminator character limiting the
+            // length before it becomes longer than any of the strings
+            if (first[length] != (*argument_it)[length]) {
+                all_match = false;
+                break;
+            }
+        }
+
+        if (all_match) {
+            chars_prefix = length + 1;
+        }
+    }
+
+    return arguments.begin()->substr(0, chars_prefix);
+}
+
+Commands::Completion Commands::complete_command(Shell & shell, const CommandLine & command_line) {
+    auto       commands = find_command(shell, command_line);
+    Completion result;
+
+    auto   match = commands.partial.begin();
+    size_t count;
+    if (match != commands.partial.end()) {
+        count = commands.partial.count(match->first);
+    } else if (!commands.exact.empty()) {
+        // Use prev() because both iterators must be forwards
+        match = std::prev(commands.exact.end());
+        count = commands.exact.count(match->first);
+    } else {
+        return result;
+    }
+
+    std::unique_ptr<Command>                         temp_command;
+    std::vector<std::string>                         temp_command_name;
+    std::multimap<size_t, const Command *>::iterator temp_command_it;
+
+    if (commands.partial.size() > 1 && (commands.exact.empty() || command_line.total_size() > commands.exact.begin()->second->name_.size())) {
+        // There are multiple partial matching commands, find the longest common prefix
+        bool whole_components = find_longest_common_prefix(commands.partial, temp_command_name);
+
+        if (count == 1 && whole_components && temp_command_name.size() == match->first) {
+            // If the longest common prefix is the same as the single shortest matching command
+            // then there's no need for a temporary command, but add a trailing space because
+            // there are longer commands that matched.
+            temp_command_name.clear();
+            result.replacement.trailing_space = true;
+        }
+
+        if (!temp_command_name.empty() && command_line.total_size() <= temp_command_name.size()) {
+            temp_command                      = std::make_unique<Command>(0, flash_string_vector{}, flash_string_vector{}, nullptr, nullptr);
+            count                             = 1;
+            match                             = commands.partial.end();
+            result.replacement.trailing_space = whole_components;
+
+            for (auto & name : temp_command_name) {
+                result.replacement->emplace_back(name);
+            }
+        }
+    }
+
+    if (count == 1 && !temp_command) {
+        // Construct a replacement string for a single matching command
+        auto & matching_command = match->second;
+
+        for (auto & name : matching_command->name_) {
+            result.replacement->push_back(std::move(read_flash_string(name)));
+        }
+
+        if (command_line.total_size() > result.replacement->size()
+            && command_line.total_size() <= matching_command->name_.size() + matching_command->maximum_arguments()) {
+            // Try to auto-complete arguments
+            std::vector<std::string> arguments{std::next(command_line->cbegin(), result.replacement->size()), command_line->cend()};
+
+            result.replacement->insert(result.replacement->end(), arguments.cbegin(), arguments.cend());
+            result.replacement.trailing_space = command_line.trailing_space;
+
+            auto        current_args_count = arguments.size();
+            std::string last_argument;
+
+            if (!command_line.trailing_space) {
+                // Remove the last argument so that it can be auto-completed
+                last_argument = std::move(result.replacement->back());
+                result.replacement->pop_back();
+                if (!arguments.empty()) {
+                    arguments.pop_back();
+                    current_args_count--;
+                }
+            }
+
+            auto potential_arguments = matching_command->arg_function_ ? matching_command->arg_function_(shell, arguments) : std::vector<std::string>{};
+
+            // Remove arguments that can't match
+            if (!command_line.trailing_space) {
+                for (auto it = potential_arguments.begin(); it != potential_arguments.end();) {
+                    if (it->rfind(last_argument, 0) == std::string::npos) {
+                        it = potential_arguments.erase(it);
+                    } else {
+                        it++;
+                    }
+                }
+            }
+
+            // Auto-complete if there's something present in the last argument
+            // or the only potential argument is an empty string.
+            if (!command_line.trailing_space) {
+                if (potential_arguments.size() == 1) {
+                    if (last_argument == *potential_arguments.begin()) {
+                        if (result.replacement->size() + 1 < matching_command->name_.size() + matching_command->maximum_arguments()) {
+                            // Add a space because this argument is complete and there are more arguments for this command
+                            result.replacement.trailing_space = true;
+                        }
+                    }
+
+                    last_argument = *potential_arguments.begin();
+                    potential_arguments.clear();
+
+                    // Remaining help should skip the replaced argument
+                    current_args_count++;
+                } else if (potential_arguments.size() > 1) {
+                    last_argument = find_longest_common_prefix(potential_arguments);
+                }
+            }
+
+            // Put the last argument back
+            if (!command_line.trailing_space) {
+                result.replacement->push_back(std::move(last_argument));
+            }
+
+            CommandLine remaining_help;
+
+            if (!potential_arguments.empty()) {
+                // Remaining help should skip the suggested argument
+                current_args_count++;
+            }
+
+            if (current_args_count < matching_command->maximum_arguments()) {
+                remaining_help.escape_initial_parameters();
+
+                for (auto it = std::next(matching_command->arguments_.cbegin(), current_args_count); it != matching_command->arguments_.cend(); it++) {
+                    remaining_help->push_back(std::move(read_flash_string(*it)));
+                }
+            }
+
+            if (potential_arguments.empty()) {
+                if (!remaining_help->empty()) {
+                    result.help.push_back(std::move(remaining_help));
+                }
+            } else {
+                for (auto potential_argument : potential_arguments) {
+                    CommandLine help;
+
+                    help->emplace_back(potential_argument);
+
+                    if (!remaining_help->empty()) {
+                        help.escape_initial_parameters();
+                        help->insert(help->end(), remaining_help->begin(), remaining_help->end());
+                    }
+
+                    result.help.push_back(std::move(help));
+                }
+            }
+        } else if (result.replacement->size() < matching_command->name_.size() + matching_command->maximum_arguments()) {
+            // Add a space because there are more arguments for this command
+            result.replacement.trailing_space = true;
+        }
+    } else if (count > 1 || temp_command) {
+        // Provide help for all of the potential commands
+        for (auto command_it = commands.partial.begin(); command_it != commands.partial.end(); command_it++) {
+            CommandLine help;
+
+            auto line_it       = command_line->cbegin();
+            auto flash_name_it = command_it->second->name_.cbegin();
+
+            if (temp_command) {
+                // Skip parts of the command name/line when the longest common prefix was used
+                size_t skip = temp_command_name.size();
+                if (!result.replacement.trailing_space) {
+                    skip--;
+                }
+
+                flash_name_it += skip;
+                while (line_it != command_line->cend()) {
+                    line_it++;
+                }
+            }
+
+            for (; flash_name_it != command_it->second->name_.cend(); flash_name_it++) {
+                std::string name = read_flash_string(*flash_name_it);
+
+                // Skip parts of the command name that match the command line
+                if (line_it != command_line->cend()) {
+                    if (name == *line_it++) {
+                        continue;
+                    } else {
+                        line_it = command_line->cend();
+                    }
+                }
+
+                help->emplace_back(name);
+            }
+
+            help.escape_initial_parameters();
+
+            for (auto argument : command_it->second->arguments_) {
+                // Skip parts of the command arguments that exist in the command line
+                if (line_it != command_line->cend()) {
+                    line_it++;
+                    continue;
+                }
+
+                help->push_back(std::move(read_flash_string(argument)));
+            }
+
+            result.help.push_back(std::move(help));
+        }
+    }
+
+    if (count > 1 && !commands.exact.empty()) {
+        // Try to add a space to exact matches
+        auto longest = commands.exact.crbegin();
+
+        if (commands.exact.count(longest->first) == 1) {
+            for (auto & name : longest->second->name_) {
+                result.replacement->push_back(std::move(read_flash_string(name)));
+            }
+
+            // Add a space because there are sub-commands for a command that has matched exactly
+            result.replacement.trailing_space = true;
+        }
+    }
+
+    // Don't try to shorten the command line or offer an identical replacement
+    if (command_line.total_size() > result.replacement.total_size() || result.replacement == command_line) {
+        result.replacement.reset();
+    }
+
+    return result;
+}
+
+Commands::Match Commands::find_command(Shell & shell, const CommandLine & command_line) {
+    Match commands;
+    auto  context_commands = commands_.equal_range(shell.context());
+
+    for (auto it = context_commands.first; it != context_commands.second; it++) {
+        auto & command = it->second;
+        bool   match   = true;
+        bool   exact   = true;
+
+        if (!shell.has_flags(command.flags_)) {
+            continue;
+        }
+
+        auto name_it = command.name_.cbegin();
+        auto line_it = command_line->cbegin();
+
+        for (; name_it != command.name_.cend() && line_it != command_line->cend(); name_it++, line_it++) {
+            std::string name  = read_flash_string(*name_it);
+            size_t      found = name.rfind(*line_it, 0);
+
+            if (found == std::string::npos) {
+                match = false;
+                break;
+            } else if (line_it->length() != name.length()) {
+                for (auto line_check_it = std::next(line_it); line_check_it != command_line->cend(); line_check_it++) {
+                    if (!line_check_it->empty()) {
+                        // If there's more in the command line then this can't match
+                        match = false;
+                    }
+                }
+
+                if (command_line.trailing_space) {
+                    // If there's a trailing space in the command line then this can't be a partial match
+                    match = false;
+                }
+
+                // Don't check the rest of the command if this is only a partial match
+                break;
+            }
+        }
+
+        if (name_it != command.name_.cend()) {
+            exact = false;
+        }
+
+        if (match) {
+            if (exact) {
+                commands.exact.emplace(command.name_.size(), &command);
+            } else {
+                commands.partial.emplace(command.name_.size(), &command);
+            }
+        }
+    }
+
+    return commands;
+}
+
+void Commands::for_each_available_command(Shell & shell, apply_function f) const {
+    auto commands = commands_.equal_range(shell.context());
+
+    for (auto command_it = commands.first; command_it != commands.second; command_it++) {
+        if (shell.has_flags(command_it->second.flags_)) {
+            std::vector<std::string> name;
+            std::vector<std::string> arguments;
+
+            name.reserve(command_it->second.name_.size());
+            for (auto flash_name : command_it->second.name_) {
+                name.push_back(std::move(read_flash_string(flash_name)));
+            }
+
+            arguments.reserve(command_it->second.arguments_.size());
+            for (auto flash_argument : command_it->second.arguments_) {
+                arguments.push_back(std::move(read_flash_string(flash_argument)));
+            }
+
+            f(name, arguments);
+        }
+    }
+}
+
+Commands::Command::Command(unsigned int                 flags,
+                           const flash_string_vector    name,
+                           const flash_string_vector    arguments,
+                           command_function             function,
+                           argument_completion_function arg_function)
+    : flags_(flags)
+    , name_(name)
+    , arguments_(arguments)
+    , function_(function)
+    , arg_function_(arg_function) {
+}
+
+Commands::Command::~Command() {
+}
+
+size_t Commands::Command::minimum_arguments() const {
+    return std::count_if(arguments_.cbegin(), arguments_.cend(), [](const __FlashStringHelper * argument) { return pgm_read_byte(argument) == '<'; });
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-console/src/console.cpp

@@ -0,0 +1,19 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>

lib/uuid-console/src/shell.cpp

@@ -0,0 +1,519 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <Arduino.h>
+#include <stdarg.h>
+
+#include <algorithm>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <uuid/common.h>
+#include <uuid/log.h>
+
+#ifndef __cpp_lib_make_unique
+namespace std {
+
+template <typename _Tp, typename... _Args>
+inline unique_ptr<_Tp> make_unique(_Args &&... __args) {
+    return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...));
+}
+
+} // namespace std
+#endif
+
+namespace uuid {
+
+namespace console {
+
+// cppcheck-suppress passedByValue
+Shell::Shell(std::shared_ptr<Commands> commands, unsigned int context, unsigned int flags)
+    : commands_(std::move(commands))
+    , flags_(flags) {
+    enter_context(context);
+}
+
+Shell::~Shell() {
+    uuid::log::Logger::unregister_handler(this);
+}
+
+void Shell::start() {
+    // Added by proddy - default log level
+#ifdef EMSESP_DEBUG
+    uuid::log::Logger::register_handler(this, uuid::log::Level::NOTICE); // was debug
+#else
+    uuid::log::Logger::register_handler(this, uuid::log::Level::NOTICE);
+#endif
+
+    line_buffer_.reserve(maximum_command_line_length_);
+    display_banner();
+    display_prompt();
+    shells_.insert(shared_from_this());
+    idle_time_ = uuid::get_uptime_ms();
+    started();
+};
+
+void Shell::started() {
+}
+
+bool Shell::running() const {
+    return !stopped_;
+}
+
+void Shell::stop() {
+    if (mode_ == Mode::BLOCKING) {
+        auto * blocking_data = reinterpret_cast<Shell::BlockingData *>(mode_data_.get());
+
+        blocking_data->stop_ = true;
+    } else {
+        if (running()) {
+            stopped_ = true;
+            stopped();
+        }
+    }
+}
+
+void Shell::stopped() {
+}
+
+bool Shell::exit_context() {
+    if (context_.size() > 1) {
+        context_.pop_back();
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void Shell::loop_one() {
+    if (!running()) {
+        return;
+    }
+
+    switch (mode_) {
+    case Mode::NORMAL:
+        output_logs();
+        loop_normal();
+        break;
+
+    case Mode::PASSWORD:
+        output_logs();
+        loop_password();
+        break;
+
+    case Mode::DELAY:
+        output_logs();
+        loop_delay();
+        break;
+
+    case Mode::BLOCKING:
+        loop_blocking();
+        break;
+    }
+}
+
+void Shell::loop_normal() {
+    const int input = read_one_char();
+
+    if (input < 0) {
+        check_idle_timeout();
+        return;
+    }
+
+    const unsigned char c = input;
+
+    switch (c) {
+    case '\x03':
+        // Interrupt (^C)
+        line_buffer_.clear();
+        println();
+        prompt_displayed_ = false;
+        display_prompt();
+        break;
+
+    case '\x04':
+        // End of transmission (^D)
+        if (line_buffer_.empty()) {
+            end_of_transmission();
+        }
+        break;
+
+    case '\x08':
+    case '\x7F':
+        // Backspace (^H)
+        // Delete (^?)
+        if (!line_buffer_.empty()) {
+            erase_characters(1);
+            line_buffer_.pop_back();
+        }
+        break;
+
+    case '\x09':
+        // Tab (^I)
+        process_completion();
+        break;
+
+    case '\x0A':
+        // Line feed (^J)
+        if (previous_ != '\x0D') {
+            process_command();
+        }
+        break;
+
+    case '\x0C':
+        // New page (^L)
+        erase_current_line();
+        prompt_displayed_ = false;
+        display_prompt();
+        break;
+
+    case '\x0D':
+        // Carriage return (^M)
+        process_command();
+        break;
+
+    case '\x15':
+        // Delete line (^U)
+        erase_current_line();
+        prompt_displayed_ = false;
+        line_buffer_.clear();
+        display_prompt();
+        break;
+
+    case '\x17':
+        // Delete word (^W)
+        delete_buffer_word(true);
+        break;
+
+    default:
+        if (c >= '\x20' && c <= '\x7E') {
+            // ASCII text
+            if (line_buffer_.length() < maximum_command_line_length_) {
+                line_buffer_.push_back(c);
+                write((uint8_t)c);
+            }
+        }
+        break;
+    }
+
+    previous_ = c;
+
+    // This is a hack to let TelnetStream know that command
+    // execution is complete and that output can be flushed.
+    available_char();
+
+    idle_time_ = uuid::get_uptime_ms();
+}
+
+Shell::PasswordData::PasswordData(const __FlashStringHelper * password_prompt, password_function && password_function)
+    : password_prompt_(password_prompt)
+    , password_function_(std::move(password_function)) {
+}
+
+void Shell::loop_password() {
+    const int input = read_one_char();
+
+    if (input < 0) {
+        check_idle_timeout();
+        return;
+    }
+
+    const unsigned char c = input;
+
+    switch (c) {
+    case '\x03':
+        // Interrupt (^C)
+        process_password(false);
+        break;
+
+    case '\x08':
+    case '\x7F':
+        // Backspace (^H)
+        // Delete (^?)
+        if (!line_buffer_.empty()) {
+            line_buffer_.pop_back();
+        }
+        break;
+
+    case '\x0A':
+        // Line feed (^J)
+        if (previous_ != '\x0D') {
+            process_password(true);
+        }
+        break;
+
+    case '\x0C':
+        // New page (^L)
+        erase_current_line();
+        prompt_displayed_ = false;
+        display_prompt();
+        break;
+
+    case '\x0D':
+        // Carriage return (^M)
+        process_password(true);
+        break;
+
+    case '\x15':
+        // Delete line (^U)
+        line_buffer_.clear();
+        break;
+
+    case '\x17':
+        // Delete word (^W)
+        delete_buffer_word(false);
+        break;
+
+    default:
+        if (c >= '\x20' && c <= '\x7E') {
+            // ASCII text
+            if (line_buffer_.length() < maximum_command_line_length_) {
+                line_buffer_.push_back(c);
+            }
+        }
+        break;
+    }
+
+    previous_ = c;
+
+    // This is a hack to let TelnetStream know that command
+    // execution is complete and that output can be flushed.
+    available_char();
+
+    idle_time_ = uuid::get_uptime_ms();
+}
+
+Shell::DelayData::DelayData(uint64_t delay_time, delay_function && delay_function)
+    : delay_time_(delay_time)
+    , delay_function_(std::move(delay_function)) {
+}
+
+void Shell::loop_delay() {
+    auto * delay_data = reinterpret_cast<Shell::DelayData *>(mode_data_.get());
+
+    if (uuid::get_uptime_ms() >= delay_data->delay_time_) {
+        auto function_copy = delay_data->delay_function_;
+
+        mode_ = Mode::NORMAL;
+        mode_data_.reset();
+
+        function_copy(*this);
+
+        if (running()) {
+            display_prompt();
+        }
+
+        idle_time_ = uuid::get_uptime_ms();
+    }
+}
+
+Shell::BlockingData::BlockingData(blocking_function && blocking_function)
+    : blocking_function_(std::move(blocking_function)) {
+}
+
+void Shell::loop_blocking() {
+    auto * blocking_data = reinterpret_cast<Shell::BlockingData *>(mode_data_.get());
+
+    /* It is not possible to change mode while executing this function,
+	 * because that would require copying either the std::shared_ptr or
+	 * the std::function on every loop execution (to ensure that the
+	 * function captures aren't destroyed while executing).
+	 */
+    if (blocking_data->blocking_function_(*this, blocking_data->stop_)) {
+        bool stop_pending = blocking_data->stop_;
+
+        mode_ = Mode::NORMAL;
+        mode_data_.reset();
+
+        if (stop_pending) {
+            stop();
+        }
+
+        if (running()) {
+            display_prompt();
+        }
+
+        idle_time_ = uuid::get_uptime_ms();
+    }
+}
+
+void Shell::enter_password(const __FlashStringHelper * prompt, password_function function) {
+    if (mode_ == Mode::NORMAL) {
+        mode_      = Mode::PASSWORD;
+        mode_data_ = std::make_unique<Shell::PasswordData>(prompt, std::move(function));
+    }
+}
+
+void Shell::delay_for(unsigned long ms, delay_function function) {
+    delay_until(uuid::get_uptime_ms() + ms, std::move(function));
+}
+
+void Shell::delay_until(uint64_t ms, delay_function function) {
+    if (mode_ == Mode::NORMAL) {
+        mode_      = Mode::DELAY;
+        mode_data_ = std::make_unique<Shell::DelayData>(ms, std::move(function));
+    }
+}
+
+void Shell::block_with(blocking_function function) {
+    if (mode_ == Mode::NORMAL) {
+        mode_      = Mode::BLOCKING;
+        mode_data_ = std::make_unique<Shell::BlockingData>(std::move(function));
+    }
+}
+
+void Shell::delete_buffer_word(bool display) {
+    size_t pos = line_buffer_.find_last_of(' ');
+
+    if (pos == std::string::npos) {
+        line_buffer_.clear();
+        if (display) {
+            erase_current_line();
+            prompt_displayed_ = false;
+            display_prompt();
+        }
+    } else {
+        if (display) {
+            erase_characters(line_buffer_.length() - pos);
+        }
+        line_buffer_.resize(pos);
+    }
+}
+
+size_t Shell::maximum_command_line_length() const {
+    return maximum_command_line_length_;
+}
+
+void Shell::maximum_command_line_length(size_t length) {
+    maximum_command_line_length_ = std::max((size_t)1, length);
+    line_buffer_.reserve(maximum_command_line_length_);
+}
+
+void Shell::process_command() {
+    CommandLine command_line{line_buffer_};
+
+    line_buffer_.clear();
+    println();
+    prompt_displayed_ = false;
+
+    if (!command_line->empty()) {
+        if (commands_) {
+            auto execution = commands_->execute_command(*this, std::move(command_line));
+
+            if (execution.error != nullptr) {
+                println(execution.error);
+            }
+        } else {
+            println(F("No commands configured"));
+        }
+    }
+
+    if (running()) {
+        display_prompt();
+    }
+    ::yield();
+}
+
+void Shell::process_completion() {
+    CommandLine command_line{line_buffer_};
+
+    if (!command_line->empty() && commands_) {
+        auto completion = commands_->complete_command(*this, command_line);
+        bool redisplay  = false;
+
+        if (!completion.help.empty()) {
+            println();
+            redisplay = true;
+
+            for (auto & help : completion.help) {
+                std::string help_line = help.to_string(maximum_command_line_length_);
+
+                println(help_line);
+            }
+        }
+
+        if (!completion.replacement->empty()) {
+            if (!redisplay) {
+                erase_current_line();
+                prompt_displayed_ = false;
+                redisplay         = true;
+            }
+
+            line_buffer_ = completion.replacement.to_string(maximum_command_line_length_);
+        }
+
+        if (redisplay) {
+            display_prompt();
+        }
+    }
+
+    ::yield();
+}
+
+void Shell::process_password(bool completed) {
+    println();
+
+    auto * password_data = reinterpret_cast<Shell::PasswordData *>(mode_data_.get());
+    auto   function_copy = password_data->password_function_;
+
+    mode_ = Mode::NORMAL;
+    mode_data_.reset();
+
+    function_copy(*this, completed, line_buffer_);
+    line_buffer_.clear();
+
+    if (running()) {
+        display_prompt();
+    }
+}
+
+void Shell::invoke_command(const std::string & line) {
+    if (!line_buffer_.empty()) {
+        println();
+        prompt_displayed_ = false;
+    }
+    if (!prompt_displayed_) {
+        display_prompt();
+    }
+    line_buffer_ = line;
+    print(line_buffer_);
+    process_command();
+}
+
+unsigned long Shell::idle_timeout() const {
+    return idle_timeout_ / 1000;
+}
+
+void Shell::idle_timeout(unsigned long timeout) {
+    idle_timeout_ = (uint64_t)timeout * 1000;
+}
+
+void Shell::check_idle_timeout() {
+    if (idle_timeout_ > 0 && uuid::get_uptime_ms() - idle_time_ >= idle_timeout_) {
+        println();
+        stop();
+    }
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-console/src/shell_log.cpp

@@ -0,0 +1,108 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <Arduino.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+
+#include <uuid/log.h>
+
+namespace uuid {
+
+namespace console {
+
+static const char       __pstr__logger_name[] __attribute__((__aligned__(sizeof(int)))) PROGMEM = "shell";
+const uuid::log::Logger Shell::logger_{reinterpret_cast<const __FlashStringHelper *>(__pstr__logger_name), uuid::log::Facility::LPR};
+
+Shell::QueuedLogMessage::QueuedLogMessage(unsigned long id, std::shared_ptr<uuid::log::Message> && content)
+    : id_(id)
+    , content_(std::move(content)) {
+}
+
+void Shell::operator<<(std::shared_ptr<uuid::log::Message> message) {
+    if (log_messages_.size() >= maximum_log_messages_) {
+        log_messages_.pop_front();
+    }
+
+    log_messages_.emplace_back(log_message_id_++, std::move(message));
+}
+
+uuid::log::Level Shell::log_level() const {
+    return uuid::log::Logger::get_log_level(this);
+}
+
+void Shell::log_level(uuid::log::Level level) {
+    uuid::log::Logger::register_handler(this, level);
+}
+
+size_t Shell::maximum_log_messages() const {
+    return maximum_log_messages_;
+}
+
+void Shell::maximum_log_messages(size_t count) {
+    maximum_log_messages_ = std::max((size_t)1, count);
+    while (log_messages_.size() > maximum_log_messages_) {
+        log_messages_.pop_front();
+    }
+}
+
+void Shell::output_logs() {
+    if (!log_messages_.empty()) {
+        if (mode_ != Mode::DELAY) {
+            erase_current_line();
+            prompt_displayed_ = false;
+        }
+
+        while (!log_messages_.empty()) {
+            auto message = std::move(log_messages_.front());
+            log_messages_.pop_front();
+
+
+            print(uuid::log::format_timestamp_ms(message.content_->uptime_ms, 3));
+            printf(F(" %c %lu: [%S] "), uuid::log::format_level_char(message.content_->level), message.id_, message.content_->name);
+
+            if ((message.content_->level == uuid::log::Level::ERR) || (message.content_->level == uuid::log::Level::WARNING)) {
+                print(COLOR_RED);
+                println(message.content_->text);
+                print(COLOR_RESET);
+            } else if (message.content_->level == uuid::log::Level::INFO) {
+                print(COLOR_YELLOW);
+                println(message.content_->text);
+                print(COLOR_RESET);
+            } else if (message.content_->level == uuid::log::Level::DEBUG) {
+                print(COLOR_CYAN);
+                println(message.content_->text);
+                print(COLOR_RESET);
+            } else {
+                println(message.content_->text);
+            }
+
+            ::yield();
+
+            display_prompt();
+        }
+    }
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-console/src/shell_loop_all.cpp

@@ -0,0 +1,45 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <memory>
+#include <set>
+
+namespace uuid {
+
+namespace console {
+
+std::set<std::shared_ptr<Shell>> Shell::shells_;
+
+void Shell::loop_all() {
+    for (auto shell = shells_.begin(); shell != shells_.end();) {
+        shell->get()->loop_one();
+
+        // This avoids copying the shared_ptr every time loop_one() is called
+        if (!shell->get()->running()) {
+            shell = shells_.erase(shell);
+        } else {
+            shell++;
+        }
+    }
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-console/src/shell_print.cpp

@@ -0,0 +1,165 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <Arduino.h>
+#include <stdarg.h>
+
+#include <string>
+
+namespace uuid {
+
+namespace console {
+
+size_t Shell::print(const std::string & data) {
+    if (data.empty()) {
+        return 0;
+    } else {
+        return write(reinterpret_cast<const uint8_t *>(data.c_str()), data.length());
+    }
+}
+
+size_t Shell::println(const std::string & data) {
+    size_t len = print(data);
+    len += println();
+    return len;
+}
+
+size_t Shell::printf(const char * format, ...) {
+    va_list ap;
+
+    va_start(ap, format);
+    size_t len = vprintf(format, ap);
+    va_end(ap);
+
+    return len;
+}
+
+size_t Shell::printf(const __FlashStringHelper * format, ...) {
+    va_list ap;
+
+    va_start(ap, format);
+    size_t len = vprintf(format, ap);
+    va_end(ap);
+
+    return len;
+}
+
+size_t Shell::printfln(const char * format, ...) {
+    va_list ap;
+
+    va_start(ap, format);
+    size_t len = vprintf(format, ap);
+    va_end(ap);
+
+    len += println();
+    return len;
+}
+
+size_t Shell::printfln(const __FlashStringHelper * format, ...) {
+    va_list ap;
+
+    va_start(ap, format);
+    size_t len = vprintf(format, ap);
+    va_end(ap);
+
+    len += println();
+    return len;
+}
+
+size_t Shell::vprintf(const char * format, va_list ap) {
+    size_t  print_len = 0;
+    va_list copy_ap;
+
+    va_copy(copy_ap, ap);
+
+    int format_len = ::vsnprintf(nullptr, 0, format, ap);
+    if (format_len > 0) {
+        std::string text(static_cast<std::string::size_type>(format_len), '\0');
+
+        ::vsnprintf(&text[0], text.capacity() + 1, format, copy_ap);
+        print_len = print(text);
+    }
+
+    va_end(copy_ap);
+    return print_len;
+}
+
+size_t Shell::vprintf(const __FlashStringHelper * format, va_list ap) {
+    size_t  print_len = 0;
+    va_list copy_ap;
+
+    va_copy(copy_ap, ap);
+
+    int format_len = ::vsnprintf_P(nullptr, 0, reinterpret_cast<PGM_P>(format), ap);
+    if (format_len > 0) {
+        std::string text(static_cast<std::string::size_type>(format_len), '\0');
+
+        ::vsnprintf_P(&text[0], text.capacity() + 1, reinterpret_cast<PGM_P>(format), copy_ap);
+        print_len = print(text);
+    }
+
+    va_end(copy_ap);
+    return print_len;
+}
+
+// modified by proddy
+void Shell::print_all_available_commands() {
+    /*
+    commands_->for_each_available_command(*this, [this](std::vector<std::string> & name, std::vector<std::string> & arguments) {
+        CommandLine command_line{name, arguments};
+
+        command_line.escape_initial_parameters(name.size());
+        name.clear();
+        arguments.clear();
+        print(" "); // added by proddy
+        println(command_line.to_string(maximum_command_line_length()));
+    });
+    */
+
+    // changed by proddy - sort the help commands
+    std::list<std::string> sorted_cmds;
+
+    commands_->for_each_available_command(*this, [&](std::vector<std::string> & name, std::vector<std::string> & arguments) {
+        CommandLine command_line{name, arguments};
+        command_line.escape_initial_parameters(name.size());
+        name.clear();
+        arguments.clear();
+        sorted_cmds.push_back(command_line.to_string(maximum_command_line_length()));
+    });
+
+    sorted_cmds.sort();
+    for (auto & cl : sorted_cmds) {
+        // print(" ");
+        println(cl);
+    }
+}
+
+void Shell::erase_current_line() {
+    print(F("\033[0G\033[K"));
+}
+
+void Shell::erase_characters(size_t count) {
+    print(std::string(count, '\x08'));
+    print(F("\033[K"));
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-console/src/shell_prompt.cpp

@@ -0,0 +1,93 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <string>
+
+namespace uuid {
+
+namespace console {
+
+void Shell::display_banner() {
+}
+
+std::string Shell::hostname_text() {
+    return std::string{};
+}
+
+std::string Shell::context_text() {
+    return std::string{};
+}
+
+std::string Shell::prompt_prefix() {
+    return std::string{};
+}
+
+std::string Shell::prompt_suffix() {
+    return std::string{'$'};
+}
+
+void Shell::end_of_transmission() {
+    if (idle_timeout_ > 0) {
+        println();
+        stop();
+    }
+}
+
+void Shell::display_prompt() {
+    switch (mode_) {
+    case Mode::DELAY:
+    case Mode::BLOCKING:
+        break;
+
+    case Mode::PASSWORD:
+        print(reinterpret_cast<Shell::PasswordData *>(mode_data_.get())->password_prompt_);
+        break;
+
+    case Mode::NORMAL:
+        std::string hostname = hostname_text();
+        std::string context  = context_text();
+
+        print(prompt_prefix());
+        // colors added by proddy
+        if (!hostname.empty()) {
+            print(COLOR_BRIGHT_GREEN);
+            print(COLOR_BOLD_ON);
+            print(hostname);
+            print(COLOR_RESET);
+            print(':');
+        }
+        if (!context.empty()) {
+            print(COLOR_BRIGHT_BLUE);
+            print(COLOR_BOLD_ON);
+            print(context);
+            print(COLOR_RESET);
+            // print(' ');
+        }
+        print(prompt_suffix());
+        print(' ');
+        print(line_buffer_);
+        prompt_displayed_ = true;
+        break;
+    }
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-console/src/shell_stream.cpp

@@ -0,0 +1,125 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <Arduino.h>
+
+namespace uuid {
+
+namespace console {
+
+int Shell::available() {
+    if (mode_ == Mode::BLOCKING) {
+        auto * blocking_data = reinterpret_cast<Shell::BlockingData *>(mode_data_.get());
+
+        if (!available_char()) {
+            return 0;
+        }
+
+        if (blocking_data->consume_line_feed_) {
+            const int input = peek_one_char();
+
+            if (input >= 0) {
+                const unsigned char c = input;
+
+                blocking_data->consume_line_feed_ = false;
+
+                if (previous_ == '\x0D' && c == '\x0A') {
+                    // Consume the first LF following a CR
+                    read_one_char();
+                    previous_ = c;
+                    return available();
+                }
+            } else {
+                // The underlying stream has not implemented peek,
+                // so the next read() could return -1 if LF is
+                // filtered out.
+            }
+        }
+
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int Shell::read() {
+    if (mode_ == Mode::BLOCKING) {
+        auto *    blocking_data = reinterpret_cast<Shell::BlockingData *>(mode_data_.get());
+        const int input         = read_one_char();
+
+        if (input >= 0) {
+            const unsigned char c = input;
+
+            if (blocking_data->consume_line_feed_) {
+                blocking_data->consume_line_feed_ = false;
+
+                if (previous_ == '\x0D' && c == '\x0A') {
+                    // Consume the first LF following a CR
+                    previous_ = c;
+                    return read();
+                }
+            }
+
+            // Track read characters so that a final CR means we ignore the next LF
+            previous_ = c;
+        }
+
+        return input;
+    } else {
+        return -1;
+    }
+}
+
+int Shell::peek() {
+    if (mode_ == Mode::BLOCKING) {
+        auto *    blocking_data = reinterpret_cast<Shell::BlockingData *>(mode_data_.get());
+        const int input         = peek_one_char();
+
+        if (blocking_data->consume_line_feed_) {
+            if (input >= 0) {
+                const unsigned char c = input;
+
+                blocking_data->consume_line_feed_ = false;
+
+                if (previous_ == '\x0D' && c == '\x0A') {
+                    // Consume the first LF following a CR
+                    read_one_char();
+                    previous_ = c;
+                    return peek();
+                }
+            }
+        }
+
+        return input;
+    } else {
+        return -1;
+    }
+}
+
+void Shell::flush() {
+    // This is a pure virtual function in Arduino's Stream class, which
+    // makes no sense because that class is for input and this is an
+    // output function. Later versions move it to Print as an empty
+    // virtual function so this is here for backward compatibility.
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-console/src/stream_console.cpp

@@ -0,0 +1,63 @@
+/*
+ * uuid-console - Microcontroller console shell
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/console.h>
+
+#include <Arduino.h>
+
+#include <memory>
+#include <string>
+
+namespace uuid {
+
+namespace console {
+
+StreamConsole::StreamConsole(Stream & stream)
+    : Shell()
+    , stream_(stream) {
+}
+
+// cppcheck-suppress passedByValue
+StreamConsole::StreamConsole(std::shared_ptr<Commands> commands, Stream & stream, unsigned int context, unsigned int flags)
+    : Shell(std::move(commands), context, flags)
+    , stream_(stream) {
+}
+
+size_t StreamConsole::write(uint8_t data) {
+    return stream_.write(data);
+}
+
+size_t StreamConsole::write(const uint8_t * buffer, size_t size) {
+    return stream_.write(buffer, size);
+}
+
+bool StreamConsole::available_char() {
+    return stream_.available() > 0;
+}
+
+int StreamConsole::read_one_char() {
+    return stream_.read();
+}
+
+int StreamConsole::peek_one_char() {
+    return stream_.peek();
+}
+
+} // namespace console
+
+} // namespace uuid

lib/uuid-log/COPYING

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

lib/uuid-log/README.rst

@@ -0,0 +1,25 @@
+mcu-uuid-log |Build Status|
+===========================
+
+Description
+-----------
+
+Microcontroller logging framework
+
+Purpose
+-------
+
+Provides a framework for handling log messages. This library is for
+single threaded applications and cannot be used from an interrupt
+context.
+
+Documentation
+-------------
+
+`Read the documentation <https://mcu-uuid-log.readthedocs.io/>`_ generated
+from the docs_ directory.
+
+.. _docs: docs/
+
+.. |Build Status| image:: https://travis-ci.org/nomis/mcu-uuid-log.svg?branch=master
+   :target: https://travis-ci.org/nomis/mcu-uuid-log

lib/uuid-log/library.json

@@ -0,0 +1,34 @@
+{
+	"name": "uuid-log",
+	"description": "Logging framework",
+	"keywords": "logging",
+	"authors": [
+		{
+			"name": "Simon Arlott",
+			"maintainer": true
+		}
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/nomis/mcu-uuid-log.git"
+	},
+	"version": "2.1.1",
+	"license": "GPL-3.0-or-later",
+	"homepage": "https://mcu-uuid-log.readthedocs.io/",
+	"export": {
+		"exclude": [
+			".travis.yml",
+			"test/*"
+		]
+	},
+	"frameworks": [
+		"arduino"
+	],
+	"dependencies": {
+		"uuid-common": "^1.0.0"
+	},
+	"build": {
+		"flags": "-Wall -Wextra",
+		"libLDFMode": "off"
+	}
+}

lib/uuid-log/src/format_level_char.cpp

@@ -0,0 +1,32 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+namespace uuid {
+
+namespace log {
+
+char format_level_char(Level level) {
+    constexpr char log_level_chars[(int)Level::ALL - (int)Level::OFF + 1] = {' ', 'P', 'A', 'C', 'E', 'W', 'N', 'I', 'T', 'D', ' '}; // changed by proddy
+    return log_level_chars[(int)level + 1];
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/format_level_lowercase.cpp

@@ -0,0 +1,60 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <Arduino.h>
+
+#include <string>
+
+namespace uuid {
+
+namespace log {
+
+static constexpr const char * pstr_level_lowercase_off __attribute__((__aligned__(sizeof(int)))) PROGMEM     = "off";
+static constexpr const char * pstr_level_lowercase_emerg __attribute__((__aligned__(sizeof(int)))) PROGMEM   = "emerg";
+static constexpr const char * pstr_level_lowercase_crit __attribute__((__aligned__(sizeof(int)))) PROGMEM    = "crit";
+static constexpr const char * pstr_level_lowercase_alert __attribute__((__aligned__(sizeof(int)))) PROGMEM   = "alert";
+static constexpr const char * pstr_level_lowercase_err __attribute__((__aligned__(sizeof(int)))) PROGMEM     = "err";
+static constexpr const char * pstr_level_lowercase_warning __attribute__((__aligned__(sizeof(int)))) PROGMEM = "warning";
+static constexpr const char * pstr_level_lowercase_notice __attribute__((__aligned__(sizeof(int)))) PROGMEM  = "notice";
+static constexpr const char * pstr_level_lowercase_info __attribute__((__aligned__(sizeof(int)))) PROGMEM    = "info";
+static constexpr const char * pstr_level_lowercase_debug __attribute__((__aligned__(sizeof(int)))) PROGMEM   = "debug";
+static constexpr const char * pstr_level_lowercase_trace __attribute__((__aligned__(sizeof(int)))) PROGMEM   = "trace";
+static constexpr const char * pstr_level_lowercase_all __attribute__((__aligned__(sizeof(int)))) PROGMEM     = "all";
+
+static const __FlashStringHelper * log_level_lowercase[(int)Level::ALL - (int)Level::OFF + 1] __attribute__((__aligned__(sizeof(int))))
+PROGMEM = {reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_off),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_emerg),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_crit),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_alert),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_err),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_warning),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_notice),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_info),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_trace), // switched by proddy
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_debug),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_lowercase_all)};
+
+const __FlashStringHelper * format_level_lowercase(Level level) {
+    return log_level_lowercase[(int)level + 1];
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/format_level_uppercase.cpp

@@ -0,0 +1,60 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <Arduino.h>
+
+#include <string>
+
+namespace uuid {
+
+namespace log {
+
+static constexpr const char * pstr_level_uppercase_off __attribute__((__aligned__(sizeof(int)))) PROGMEM     = "OFF";
+static constexpr const char * pstr_level_uppercase_emerg __attribute__((__aligned__(sizeof(int)))) PROGMEM   = "EMERG";
+static constexpr const char * pstr_level_uppercase_crit __attribute__((__aligned__(sizeof(int)))) PROGMEM    = "CRIT";
+static constexpr const char * pstr_level_uppercase_alert __attribute__((__aligned__(sizeof(int)))) PROGMEM   = "ALERT";
+static constexpr const char * pstr_level_uppercase_err __attribute__((__aligned__(sizeof(int)))) PROGMEM     = "ERR";
+static constexpr const char * pstr_level_uppercase_warning __attribute__((__aligned__(sizeof(int)))) PROGMEM = "WARNING";
+static constexpr const char * pstr_level_uppercase_notice __attribute__((__aligned__(sizeof(int)))) PROGMEM  = "NOTICE";
+static constexpr const char * pstr_level_uppercase_info __attribute__((__aligned__(sizeof(int)))) PROGMEM    = "INFO";
+static constexpr const char * pstr_level_uppercase_debug __attribute__((__aligned__(sizeof(int)))) PROGMEM   = "DEBUG";
+static constexpr const char * pstr_level_uppercase_trace __attribute__((__aligned__(sizeof(int)))) PROGMEM   = "TRACE";
+static constexpr const char * pstr_level_uppercase_all __attribute__((__aligned__(sizeof(int)))) PROGMEM     = "ALL";
+
+static const __FlashStringHelper * log_level_uppercase[(int)Level::ALL - (int)Level::OFF + 1] __attribute__((__aligned__(sizeof(int))))
+PROGMEM = {reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_off),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_emerg),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_crit),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_alert),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_err),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_warning),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_notice),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_info),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_trace), // switched by proddy
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_debug),
+           reinterpret_cast<const __FlashStringHelper *>(pstr_level_uppercase_all)};
+
+const __FlashStringHelper * format_level_uppercase(Level level) {
+    return log_level_uppercase[(int)level + 1];
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/format_timestamp_ms.cpp

@@ -0,0 +1,57 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <Arduino.h>
+
+#include <cstdint>
+#include <string>
+
+namespace uuid {
+
+namespace log {
+
+std::string format_timestamp_ms(uint64_t timestamp_ms, unsigned int days_width) {
+    unsigned long days;
+    unsigned int  hours, minutes, seconds, milliseconds;
+
+    days = timestamp_ms / 86400000UL;
+    timestamp_ms %= 86400000UL;
+
+    hours = timestamp_ms / 3600000UL;
+    timestamp_ms %= 3600000UL;
+
+    minutes = timestamp_ms / 60000UL;
+    timestamp_ms %= 60000UL;
+
+    seconds = timestamp_ms / 1000UL;
+    timestamp_ms %= 1000UL;
+
+    milliseconds = timestamp_ms;
+
+    std::vector<char> text(10 + 1 /* days */ + 2 + 1 /* hours */ + 2 + 1 /* minutes */ + 2 + 1 /* seconds */ + 3 /* milliseconds */ + 1);
+
+    snprintf_P(text.data(), text.size(), PSTR("%0*lu+%02u:%02u:%02u.%03u"), std::min(days_width, 10U), days, hours, minutes, seconds, milliseconds);
+
+    return text.data();
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/levels.cpp

@@ -0,0 +1,43 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <vector>
+
+namespace uuid {
+
+namespace log {
+
+std::vector<Level> levels() {
+    return {Level::OFF,
+            Level::EMERG,
+            Level::ALERT,
+            Level::CRIT,
+            Level::ERR,
+            Level::WARNING,
+            Level::NOTICE,
+            Level::INFO,
+            Level::TRACE,
+            Level::DEBUG, // switched by proddy
+            Level::ALL};
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/levels_lowercase.cpp

@@ -0,0 +1,45 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <vector>
+
+#include <uuid/common.h>
+
+namespace uuid {
+
+namespace log {
+
+std::vector<std::string> levels_lowercase() {
+    return {uuid::read_flash_string(format_level_lowercase(Level::OFF)),
+            uuid::read_flash_string(format_level_lowercase(Level::EMERG)),
+            uuid::read_flash_string(format_level_lowercase(Level::ALERT)),
+            uuid::read_flash_string(format_level_lowercase(Level::CRIT)),
+            uuid::read_flash_string(format_level_lowercase(Level::ERR)),
+            uuid::read_flash_string(format_level_lowercase(Level::WARNING)),
+            uuid::read_flash_string(format_level_lowercase(Level::NOTICE)),
+            uuid::read_flash_string(format_level_lowercase(Level::INFO)),
+            uuid::read_flash_string(format_level_lowercase(Level::TRACE)), // switched by proddy
+            uuid::read_flash_string(format_level_lowercase(Level::DEBUG)),
+            uuid::read_flash_string(format_level_lowercase(Level::ALL))};
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/levels_uppercase.cpp

@@ -0,0 +1,45 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <vector>
+
+#include <uuid/common.h>
+
+namespace uuid {
+
+namespace log {
+
+std::vector<std::string> levels_uppercase() {
+    return {uuid::read_flash_string(format_level_uppercase(Level::OFF)),
+            uuid::read_flash_string(format_level_uppercase(Level::EMERG)),
+            uuid::read_flash_string(format_level_uppercase(Level::ALERT)),
+            uuid::read_flash_string(format_level_uppercase(Level::CRIT)),
+            uuid::read_flash_string(format_level_uppercase(Level::ERR)),
+            uuid::read_flash_string(format_level_uppercase(Level::WARNING)),
+            uuid::read_flash_string(format_level_uppercase(Level::NOTICE)),
+            uuid::read_flash_string(format_level_uppercase(Level::INFO)),
+            uuid::read_flash_string(format_level_uppercase(Level::TRACE)), // switched by proddy
+            uuid::read_flash_string(format_level_uppercase(Level::DEBUG)),
+            uuid::read_flash_string(format_level_uppercase(Level::ALL))};
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/log.cpp

@@ -0,0 +1,335 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <Arduino.h>
+
+#include <cstdarg>
+#include <cstdint>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace uuid {
+
+namespace log {
+
+std::map<Handler *, Level> Logger::handlers_;
+Level                      Logger::level_ = Level::OFF;
+
+Message::Message(uint64_t uptime_ms, Level level, Facility facility, const __FlashStringHelper * name, const std::string && text)
+    : uptime_ms(uptime_ms)
+    , level(level)
+    , facility(facility)
+    , name(name)
+    , text(std::move(text)) {
+}
+
+Logger::Logger(const __FlashStringHelper * name, Facility facility)
+    : name_(name)
+    , facility_(facility){
+
+      };
+
+void Logger::register_handler(Handler * handler, Level level) {
+    handlers_[handler] = level;
+    refresh_log_level();
+};
+
+void Logger::unregister_handler(Handler * handler) {
+    handlers_.erase(handler);
+    refresh_log_level();
+};
+
+Level Logger::get_log_level(const Handler * handler) {
+    const auto level = handlers_.find(const_cast<Handler *>(handler));
+
+    if (level != handlers_.end()) {
+        return level->second;
+    }
+
+    return Level::OFF;
+}
+
+void Logger::emerg(const char * format, ...) const {
+    if (enabled(Level::EMERG)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::EMERG, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::emerg(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::EMERG)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::EMERG, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::crit(const char * format, ...) const {
+    if (enabled(Level::CRIT)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::CRIT, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::crit(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::CRIT)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::CRIT, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::alert(const char * format, ...) const {
+    if (enabled(Level::ALERT)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::ALERT, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::alert(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::ALERT)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::ALERT, format, ap);
+        va_end(ap);
+    }
+};
+void Logger::err(const char * format, ...) const {
+    if (enabled(Level::ERR)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::ERR, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::err(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::ERR)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::ERR, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::warning(const char * format, ...) const {
+    if (enabled(Level::WARNING)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::WARNING, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::warning(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::WARNING)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::WARNING, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::notice(const char * format, ...) const {
+    if (enabled(Level::NOTICE)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::NOTICE, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::notice(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::NOTICE)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::NOTICE, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::info(const char * format, ...) const {
+    if (enabled(Level::INFO)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::INFO, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::info(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::INFO)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::INFO, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::debug(const char * format, ...) const {
+    if (enabled(Level::DEBUG)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::DEBUG, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::debug(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::DEBUG)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::DEBUG, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::trace(const char * format, ...) const {
+    if (enabled(Level::TRACE)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::TRACE, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::trace(const __FlashStringHelper * format, ...) const {
+    if (enabled(Level::TRACE)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(Level::TRACE, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::log(Level level, Facility facility, const char * format, ...) const {
+    if (level < Level::EMERG) {
+        level = Level::EMERG;
+    } else if (level > Level::TRACE) {
+        level = Level::TRACE;
+    }
+
+    if (enabled(level)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(level, facility, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::log(Level level, Facility facility, const __FlashStringHelper * format, ...) const {
+    if (level < Level::EMERG) {
+        level = Level::EMERG;
+    } else if (level > Level::TRACE) {
+        level = Level::TRACE;
+    }
+
+    if (enabled(level)) {
+        va_list ap;
+
+        va_start(ap, format);
+        vlog(level, facility, format, ap);
+        va_end(ap);
+    }
+};
+
+void Logger::vlog(Level level, const char * format, va_list ap) const {
+    vlog(level, facility_, format, ap);
+}
+
+void Logger::vlog(Level level, Facility facility, const char * format, va_list ap) const {
+    std::vector<char> text(MAX_LOG_LENGTH + 1);
+
+    if (vsnprintf(text.data(), text.size(), format, ap) <= 0) {
+        return;
+    }
+
+    dispatch(level, facility, text);
+}
+
+void Logger::vlog(Level level, const __FlashStringHelper * format, va_list ap) const {
+    vlog(level, facility_, format, ap);
+}
+
+void Logger::vlog(Level level, Facility facility, const __FlashStringHelper * format, va_list ap) const {
+    std::vector<char> text(MAX_LOG_LENGTH + 1);
+
+    if (vsnprintf_P(text.data(), text.size(), reinterpret_cast<PGM_P>(format), ap) <= 0) {
+        return;
+    }
+
+    dispatch(level, facility, text);
+}
+
+void Logger::dispatch(Level level, Facility facility, std::vector<char> & text) const {
+    std::shared_ptr<Message> message = std::make_shared<Message>(get_uptime_ms(), level, facility, name_, text.data());
+    text.resize(0);
+
+    for (auto & handler : handlers_) {
+        if (level <= handler.second) {
+            *handler.first << message;
+        }
+    }
+}
+
+void Logger::refresh_log_level() {
+    level_ = Level::OFF;
+
+    for (auto & handler : handlers_) {
+        if (level_ < handler.second) {
+            level_ = handler.second;
+        }
+    }
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/parse_level_lowercase.cpp

@@ -0,0 +1,41 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <Arduino.h>
+
+#include <string>
+
+namespace uuid {
+
+namespace log {
+
+bool parse_level_lowercase(const std::string & name, Level & level) {
+    for (auto value : levels()) {
+        if (!strcmp_P(name.c_str(), reinterpret_cast<PGM_P>(format_level_lowercase(value)))) {
+            level = value;
+            return true;
+        }
+    }
+    return false;
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/parse_level_uppercase.cpp

@@ -0,0 +1,41 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <uuid/log.h>
+
+#include <Arduino.h>
+
+#include <string>
+
+namespace uuid {
+
+namespace log {
+
+bool parse_level_uppercase(const std::string & name, Level & level) {
+    for (auto value : levels()) {
+        if (!strcmp_P(name.c_str(), reinterpret_cast<PGM_P>(format_level_uppercase(value)))) {
+            level = value;
+            return true;
+        }
+    }
+    return false;
+}
+
+} // namespace log
+
+} // namespace uuid

lib/uuid-log/src/uuid/log.h

@@ -0,0 +1,656 @@
+/*
+ * uuid-log - Microcontroller logging framework
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UUID_LOG_H_
+#define UUID_LOG_H_
+
+#include <Arduino.h>
+
+#include <cstdarg>
+#include <cstdint>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <uuid/common.h>
+
+namespace uuid {
+
+/**
+ * Logging framework.
+ *
+ * Provides a framework for handling log messages. This library is for
+ * single threaded applications and cannot be used from an interrupt
+ * context.
+ *
+ * - <a href="https://github.com/nomis/mcu-uuid-log/">Git Repository</a>
+ * - <a href="https://mcu-uuid-log.readthedocs.io/">Documentation</a>
+ */
+
+// ANSI Colors - added by Proddy
+// See https://www.lihaoyi.com/post/BuildyourownCommandLinewithANSIescapecodes.html
+#define COLOR_RESET "\x1B[0m"
+#define COLOR_BLACK "\x1B[0;30m"
+#define COLOR_RED "\x1B[0;31m"
+#define COLOR_GREEN "\x1B[0;32m"
+#define COLOR_YELLOW "\x1B[0;33m"
+#define COLOR_BLUE "\x1B[0;34m"
+#define COLOR_MAGENTA "\x1B[0;35m"
+#define COLOR_CYAN "\x1B[0;36m"
+#define COLOR_WHITE "\x1B[0;37m"
+#define COLOR_BOLD_ON "\x1B[1m"
+#define COLOR_BOLD_OFF "\x1B[22m"
+#define COLOR_BRIGHT_BLACK "\x1B[0;90m"
+#define COLOR_BRIGHT_RED "\x1B[0;91m"
+#define COLOR_BRIGHT_GREEN "\x1B[0;92m"
+#define COLOR_BRIGHT_YELLOW "\x1B[0;99m"
+#define COLOR_BRIGHT_BLUE "\x1B[0;94m"
+#define COLOR_BRIGHT_MAGENTA "\x1B[0;95m"
+#define COLOR_BRIGHT_CYAN "\x1B[0;96m"
+#define COLOR_BRIGHT_WHITE "\x1B[0;97m"
+#define COLOR_UNDERLINE "\x1B[4m"
+
+/*
+Background Black: \u001b[40m
+Background Red: \u001b[41m
+Background Green: \u001b[42m
+Background Yellow: \u001b[43m
+Background Blue: \u001b[44m
+Background Magenta: \u001b[45m
+Background Cyan: \u001b[46m
+Background White: \u001b[47m
+With the bright versions being:
+
+Background Bright Black: \u001b[40;1m
+Background Bright Red: \u001b[41;1m
+Background Bright Green: \u001b[42;1m
+Background Bright Yellow: \u001b[43;1m
+Background Bright Blue: \u001b[44;1m
+Background Bright Magenta: \u001b[45;1m
+Background Bright Cyan: \u001b[46;1m
+Background Bright White: \u001b[47;1m
+*/
+
+#define COLOR_BRIGHT_RED_BACKGROUND "\x1B[41;1m"
+
+
+namespace log {
+
+/**
+ * Severity level of log messages. Proddy added a VERBOSE
+ *
+ * @since 1.0.0
+ */
+enum Level : int8_t {
+    OFF   = -1, /*!< Meta level representing no log messages. @since 1.0.0 */
+    EMERG = 0,  /*!< System is unusable. @since 1.0.0 */
+    ALERT,      /*!< Action must be taken immediately. @since 1.0.0 */
+    CRIT,       /*!< Critical conditions. @since 1.0.0 */
+    ERR,        /*!< Error conditions. @since 1.0.0 */
+    WARNING,    /*!< Warning conditions. @since 1.0.0 */
+    NOTICE,     /*!< Normal but significant conditions. @since 1.0.0 */
+    INFO,       /*!< Informational messages. @since 1.0.0 */
+    TRACE,      /*!< Trace messages. @since 1.0.0 */
+    DEBUG,      /*!< Debug-level messages. @since 1.0.0 */
+    ALL,        /*!< Meta level representing all log messages. @since 1.0.0 */
+};
+
+/**
+ * Facility type of the process logging a message.
+ *
+ *  @since 1.0.0
+ */
+enum Facility : uint8_t {
+    KERN = 0, /*!< Kernel messages. @since 1.0.0 */
+    USER,     /*!< User-level messages. @since 1.0.0 */
+    MAIL,     /*!< Mail system. @since 1.0.0 */
+    DAEMON,   /*!< System daemons. @since 1.0.0 */
+    AUTH,     /*!< Security/authentication messages. @since 1.0.0 */
+    SYSLOG,   /*!< Messages generated internally by logger. @since 1.0.0 */
+    LPR,      /*!< Line printer subsystem. @since 1.0.0 */
+    NEWS,     /*!< Network news subsystem. @since 1.0.0 */
+    UUCP,     /*!< UUCP subsystem. @since 1.0.0 */
+    CRON,     /*!< Clock daemon. @since 1.0.0 */
+    AUTHPRIV, /*!< Security/authentication messages (private). @since 1.0.0 */
+    FTP,      /*!< FTP daemon. @since 1.0.0 */
+    NTP,      /*!< NTP subsystem. @since 1.0.0 */
+    SECURITY, /*!< Log audit. @since 1.0.0 */
+    CONSOLE,  /*!< Log alert. @since 1.0.0 */
+    CRON2,    /*!< Scheduling daemon. @since 1.0.0 */
+    LOCAL0,   /*!< Locally used facility 0. @since 1.0.0 */
+    LOCAL1,   /*!< Locally used facility 1. @since 1.0.0 */
+    LOCAL2,   /*!< Locally used facility 2. @since 1.0.0 */
+    LOCAL3,   /*!< Locally used facility 3. @since 1.0.0 */
+    LOCAL4,   /*!< Locally used facility 4. @since 1.0.0 */
+    LOCAL5,   /*!< Locally used facility 5. @since 1.0.0 */
+    LOCAL6,   /*!< Locally used facility 6. @since 1.0.0 */
+    LOCAL7,   /*!< Locally used facility 7. @since 1.0.0 */
+};
+
+/**
+ * Format a system uptime timestamp as a string.
+ *
+ * Using the format "d+HH:mm:ss.SSS" with leading zeros for the days.
+ *
+ * @param[in] timestamp_ms System uptime in milliseconds, see uuid::get_uptime_ms().
+ * @param[in] days_width Leading zeros for the days part of the output.
+ * @return String with the formatted system uptime.
+ * @since 1.0.0
+ */
+std::string format_timestamp_ms(uint64_t timestamp_ms, unsigned int days_width = 1);
+
+/**
+ * Get all log levels.
+ *
+ * @return A list of all log levels in priority order from
+ *         uuid::log::Level::OFF to uuid::log::Level::ALL.
+ * @since 2.1.0
+ */
+std::vector<Level> levels();
+
+/**
+ * Format a log level as a single character.
+ *
+ * Level::EMERG is represented as 'P' because it conflicts with
+ * Level::ERR and it used to be the "panic" level.
+ *
+ * @param[in] level Log level.
+ * @return Single character uppercase representation of the log level.
+ * @since 1.0.0
+ */
+char format_level_char(Level level);
+
+/**
+ * Format a log level as an uppercase string.
+ *
+ * @param[in] level Log level.
+ * @return Uppercase name of the log level (flash string).
+ * @since 1.0.0
+ */
+const __FlashStringHelper * format_level_uppercase(Level level);
+
+/**
+ * Get all log levels as uppercase strings.
+ *
+ * @return A list of all log levels in priority order from
+ *         uuid::log::Level::OFF to uuid::log::Level::ALL
+ *         as uppercase strings.
+ * @since 2.1.0
+ */
+std::vector<std::string> levels_uppercase();
+
+/**
+ * Parse an uppercase string to a log level.
+ *
+ * @param[in] name Uppercase name of the log level.
+ * @param[out] level Log level.
+ * @return True if the named level is valid, otherwise false.
+ * @since 2.1.0
+ */
+bool parse_level_uppercase(const std::string & name, Level & level);
+
+/**
+ * Format a log level as a lowercase string.
+ *
+ * @param[in] level Log level.
+ * @return Lowercase name of the log level (flash string).
+ * @since 1.0.0
+ */
+const __FlashStringHelper * format_level_lowercase(Level level);
+
+/**
+ * Get all log levels as lowercase strings.
+ *
+ * @return A list of all log levels in priority order from
+ *         uuid::log::Level::OFF to uuid::log::Level::ALL
+ *         as lowercase strings.
+ * @since 2.1.0
+ */
+std::vector<std::string> levels_lowercase();
+
+/**
+ * Parse a lowercase string to a log level.
+ *
+ * @param[in] name Lowercase name of the log level.
+ * @param[out] level Log level.
+ * @return True if the named level is valid, otherwise false.
+ * @since 2.1.0
+ */
+bool parse_level_lowercase(const std::string & name, Level & level);
+
+/**
+ * Log message text with timestamp and logger attributes.
+ *
+ * These will be created when a message is logged and then passed to
+ * all registered handlers.
+ *
+ * @since 1.0.0
+ */
+struct Message {
+    /**
+	 * Create a new log message (not directly useful).
+	 *
+	 * @param[in] uptime_ms System uptime, see uuid::get_uptime_ms().
+	 * @param[in] level Severity level of the message.
+	 * @param[in] facility Facility type of the process logging the message.
+	 * @param[in] name Logger name (flash string).
+	 * @param[in] text Log message text.
+	 * @since 1.0.0
+	 */
+    Message(uint64_t uptime_ms, Level level, Facility facility, const __FlashStringHelper * name, const std::string && text);
+    ~Message() = default;
+
+    /**
+	 * System uptime at the time the message was logged.
+	 *
+	 * @see uuid::get_uptime_ms()
+	 * @since 1.0.0
+	 */
+    const uint64_t uptime_ms;
+
+    /**
+	 * Severity level of the message.
+	 *
+	 * @since 1.0.0
+	 */
+    const Level level;
+
+    /**
+	 * Facility type of the process that logged the message.
+	 *
+	 * @since 1.0.0
+	 */
+    const Facility facility;
+
+    /**
+	 * Name of the logger used (flash string).
+	 *
+	 * @since 1.0.0
+	 */
+    const __FlashStringHelper * name;
+
+    /**
+	 * Formatted log message text.
+	 *
+	 * Does not include any of the other message attributes, those must
+	 * be added by the handler when outputting messages.
+	 *
+	 * @since 1.0.0
+	 */
+    const std::string text;
+};
+
+/**
+ * Logger handler used to process log messages.
+ *
+ * @since 1.0.0
+ */
+class Handler {
+  public:
+    virtual ~Handler() = default;
+
+    /**
+	 * Add a new log message.
+	 *
+	 * This should normally be put in a queue instead of being
+	 * processed immediately so that log messages have minimal impact
+	 * at the time of use.
+	 *
+	 * Queues should have a maximum size and discard the oldest message
+	 * when full.
+	 *
+	 * @param[in] message New log message, shared by all handlers.
+	 * @since 1.0.0
+	 */
+    virtual void operator<<(std::shared_ptr<Message> message) = 0;
+
+  protected:
+    Handler() = default;
+};
+
+/**
+ * Logger instance used to make log messages.
+ *
+ * @since 1.0.0
+ */
+class Logger {
+  public:
+    /**
+	 * This is the maximum length of any log message.
+	 *
+	 * Determines the size of the buffer used for format string
+	 * printing.
+	 *
+	 * @since 1.0.0
+	 */
+    static constexpr size_t MAX_LOG_LENGTH = 255; // proddy note, kept at 255
+
+    /**
+	 * Create a new logger with the given name and logging facility.
+	 *
+	 * @param[in] name Logger name (flash string).
+	 * @param[in] facility Default logging facility for messages.
+	 *
+	 * @since 1.0.0
+	 */
+    Logger(const __FlashStringHelper * name, Facility facility = Facility::LOCAL0);
+    ~Logger() = default;
+
+    /**
+	 * Register a log handler.
+	 *
+	 * Call again to change the log level.
+	 *
+	 * Do not call this function from a static initializer.
+	 *
+	 * @param[in] handler Handler object that will handle log
+	 *                    messages.
+	 * @param[in] level Minimum log level that the handler is
+	 *                  interested in.
+	 * @since 1.0.0
+	 */
+    static void register_handler(Handler * handler, Level level);
+
+    /**
+	 * Unregister a log handler.
+	 *
+	 * It is safe to call this with a handler that is not registered.
+	 *
+	 * Do not call this function from a static initializer.
+	 *
+	 * @param[in] handler Handler object that will no longer handle
+	 *                    log messages.
+	 * @since 1.0.0
+	 */
+    static void unregister_handler(Handler * handler);
+
+    /**
+	 * Get the current log level of a handler.
+	 *
+	 * It is safe to call this with a handler that is not registered.
+	 *
+	 * Do not call this function from a static initializer.
+	 *
+	 * @param[in] handler Handler object that may handle log
+	 *                    messages.
+	 * @return The current log level of the specified handler.
+	 * @since 1.0.0
+	 */
+    static Level get_log_level(const Handler * handler);
+
+    /**
+	 * Determine if the current log level is enabled by any registered
+	 * handlers.
+	 *
+	 * @return The current minimum global log level across all
+	 *         handlers.
+	 * @since 1.0.0
+	 */
+    static inline bool enabled(Level level) {
+        return level <= level_;
+    }
+
+    /**
+	 * Log a message at level Level::EMERG.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void emerg(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::EMERG.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void emerg(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message at level Level::ALERT.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void alert(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::ALERT.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void alert(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message at level Level::CRIT.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void crit(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::CRIT.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void crit(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message at level Level::ERR.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void err(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::ERR.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void err(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message at level Level::WARNING.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void warning(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::WARNING.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void warning(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message at level Level::NOTICE.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void notice(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::NOTICE.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void notice(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message at level Level::INFO.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void info(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::INFO.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 */
+    void info(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message at level Level::DEBUG.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void debug(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::DEBUG.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void debug(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message at level Level::TRACE.
+	 *
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void trace(const char * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+    /**
+	 * Log a message at level Level::TRACE.
+	 *
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void trace(const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 2, 3))) */;
+
+    /**
+	 * Log a message with a custom facility.
+	 *
+	 * @param[in] level Severity level of the message.
+	 * @param[in] facility Facility type of the process logging the message.
+	 * @param[in] format Format string.
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void log(Level level, Facility facility, const char * format, ...) const /* __attribute__((format (printf, 3, 4))) */;
+    /**
+	 * Log a message with a custom facility.
+	 *
+	 * @param[in] level Severity level of the message.
+	 * @param[in] facility Facility type of the process logging the message.
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ... Format string arguments.
+	 * @since 1.0.0
+	 */
+    void log(Level level, Facility facility, const __FlashStringHelper * format, ...) const /* __attribute__((format (printf, 4, 5))) */;
+
+  private:
+    /**
+	 * Refresh the minimum global log level across all handlers.
+	 *
+	 * @since 1.0.0
+	 */
+    static void refresh_log_level();
+
+    /**
+	 * Log a message at the specified level.
+	 *
+	 * @param[in] level Severity level of the message.
+	 * @param[in] format Format string.
+	 * @param[in] ap Variable arguments pointer for format string.
+	 * @since 1.0.0
+	 */
+    void vlog(Level level, const char * format, va_list ap) const;
+    /**
+	 * Log a message at the specified level.
+	 *
+	 * @param[in] level Severity level of the message.
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ap Variable arguments pointer for format string.
+	 * @since 1.0.0
+	 */
+    void vlog(Level level, const __FlashStringHelper * format, va_list ap) const;
+
+    /**
+	 * Log a message at the specified level and facility.
+	 *
+	 * @param[in] level Severity level of the message.
+	 * @param[in] facility Facility type of the process logging the message.
+	 * @param[in] format Format string.
+	 * @param[in] ap Variable arguments pointer for format string.
+	 * @since 1.0.0
+	 */
+    void vlog(Level level, Facility facility, const char * format, va_list ap) const;
+    /**
+	 * Log a message at the specified level and facility.
+	 *
+	 * @param[in] level Severity level of the message.
+	 * @param[in] facility Facility type of the process logging the message.
+	 * @param[in] format Format string (flash string).
+	 * @param[in] ap Variable arguments pointer for format string.
+	 * @since 1.0.0
+	 */
+    void vlog(Level level, Facility facility, const __FlashStringHelper * format, va_list ap) const;
+
+    /**
+	 * Dispatch a log message to all handlers that are registered to
+	 * handle messages of the specified level.
+	 *
+	 * Automatically sets the timestamp of the message to the current
+	 * system uptime.
+	 *
+	 * @param[in] level Severity level of the message.
+	 * @param[in] facility Facility type of the process logging the message.
+	 * @param[in] text Log message text.
+	 * @since 1.0.0
+	 */
+    void dispatch(Level level, Facility facility, std::vector<char> & text) const;
+
+    static std::map<Handler *, Level> handlers_; /*!< Registered log handlers. @since 1.0.0 */
+    static Level                      level_;    /*!< Minimum global log level across all handlers. @since 1.0.0 */
+
+    const __FlashStringHelper * name_;     /*!< Logger name (flash string). @since 1.0.0 */
+    const Facility              facility_; /*!< Default logging facility for messages. @since 1.0.0 */
+};
+
+} // namespace log
+
+} // namespace uuid
+
+#endif

lib/uuid-syslog/COPYING

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

lib/uuid-syslog/README.rst

@@ -0,0 +1,24 @@
+mcu-uuid-syslog |Build Status|
+==============================
+
+Description
+-----------
+
+Microcontroller syslog service
+
+Purpose
+-------
+
+Provides a log handler that sends messages to a syslog server (using
+the `RFC 5424 protocol <https://tools.ietf.org/html/rfc5424>`_).
+
+Documentation
+-------------
+
+`Read the documentation <https://mcu-uuid-syslog.readthedocs.io/>`_
+generated from the docs_ directory.
+
+.. _docs: docs/
+
+.. |Build Status| image:: https://travis-ci.org/nomis/mcu-uuid-syslog.svg?branch=master
+   :target: https://travis-ci.org/nomis/mcu-uuid-syslog

lib/uuid-syslog/library.json

@@ -0,0 +1,35 @@
+{
+	"name": "uuid-syslog",
+	"description": "Syslog service",
+	"keywords": "logging,syslog",
+	"authors": [
+		{
+			"name": "Simon Arlott",
+			"maintainer": true
+		}
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/nomis/mcu-uuid-syslog.git"
+	},
+	"version": "2.0.4",
+	"license": "GPL-3.0-or-later",
+	"homepage": "https://mcu-uuid-syslog.readthedocs.io/",
+	"export": {
+		"exclude": [
+			".travis.yml",
+			"test/*"
+		]
+	},
+	"frameworks": [
+		"arduino"
+	],
+	"dependencies": {
+		"uuid-common": "^1.0.2",
+		"uuid-log": "^2.0.3"
+	},
+	"build": {
+		"flags": "-Wall -Wextra",
+		"libLDFMode": "chain+"
+	}
+}

lib/uuid-syslog/src/syslog.cpp

@@ -0,0 +1,430 @@
+/*
+ * uuid-syslog - Syslog service
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "uuid/syslog.h"
+
+#include <Arduino.h>
+#ifdef ARDUINO_ARCH_ESP8266
+#include <ESP8266WiFi.h>
+#else
+#include <WiFi.h>
+#endif
+#include <WiFiUdp.h>
+
+#ifndef UUID_SYSLOG_HAVE_GETTIMEOFDAY
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+// time() does not return UTC on the ESP8266: https://github.com/esp8266/Arduino/issues/4637
+#define UUID_SYSLOG_HAVE_GETTIMEOFDAY 1
+#endif
+#endif
+
+#ifndef UUID_SYSLOG_HAVE_GETTIMEOFDAY
+#define UUID_SYSLOG_HAVE_GETTIMEOFDAY 0
+#endif
+
+#ifndef UUID_SYSLOG_HAVE_IPADDRESS_TYPE
+#if defined(ARDUINO_ARCH_ESP8266)
+#define UUID_SYSLOG_HAVE_IPADDRESS_TYPE 1
+#endif
+#endif
+
+#ifndef UUID_SYSLOG_HAVE_IPADDRESS_TYPE
+#define UUID_SYSLOG_HAVE_IPADDRESS_TYPE 0
+#endif
+
+#ifndef UUID_SYSLOG_ARP_CHECK
+#if defined(LWIP_VERSION_MAJOR) && defined(LWIP_IPV4) && LWIP_VERSION_MAJOR >= 2 && LWIP_IPV4
+#define UUID_SYSLOG_ARP_CHECK 1
+#endif
+#endif
+
+#ifndef UUID_SYSLOG_ARP_CHECK
+#define UUID_SYSLOG_ARP_CHECK 0
+#endif
+
+#ifndef UUID_SYSLOG_NDP_CHECK
+#if defined(LWIP_VERSION_MAJOR) && defined(LWIP_IPV6) && LWIP_VERSION_MAJOR >= 2 && LWIP_IPV6
+#define UUID_SYSLOG_NDP_CHECK 1
+#endif
+#endif
+
+#ifndef UUID_SYSLOG_NDP_CHECK
+#define UUID_SYSLOG_NDP_CHECK 0
+#endif
+
+#if UUID_SYSLOG_ARP_CHECK or UUID_SYSLOG_NDP_CHECK
+#include <lwip/netif.h>
+#endif
+#if UUID_SYSLOG_ARP_CHECK
+#include <lwip/ip4_addr.h>
+#include <lwip/etharp.h>
+#endif
+#if UUID_SYSLOG_NDP_CHECK
+#include <lwip/ip6_addr.h>
+#include <lwip/nd6.h>
+#endif
+
+#include <algorithm>
+#include <list>
+#include <memory>
+#include <string>
+
+#include <uuid/common.h>
+#include <uuid/log.h>
+
+static const char __pstr__logger_name[] __attribute__((__aligned__(sizeof(int)))) PROGMEM = "syslog";
+
+namespace uuid {
+
+namespace syslog {
+
+uuid::log::Logger SyslogService::logger_{FPSTR(__pstr__logger_name), uuid::log::Facility::SYSLOG};
+bool              SyslogService::QueuedLogMessage::time_good_ = false;
+
+SyslogService::~SyslogService() {
+    uuid::log::Logger::unregister_handler(this);
+}
+
+void SyslogService::start() {
+    uuid::log::Logger::register_handler(this, uuid::log::Level::ALL);
+}
+
+uuid::log::Level SyslogService::log_level() const {
+    return uuid::log::Logger::get_log_level(this);
+}
+
+void SyslogService::remove_queued_messages(uuid::log::Level level) {
+    unsigned long offset = 0;
+
+    for (auto it = log_messages_.begin(); it != log_messages_.end();) {
+        if (it->content_->level > level) {
+            offset++;
+            it = log_messages_.erase(it);
+        } else {
+            it->id_ -= offset;
+            it++;
+        }
+    }
+
+    log_message_id_ -= offset;
+}
+
+void SyslogService::log_level(uuid::log::Level level) {
+    if (!started_) {
+        remove_queued_messages(level);
+    }
+
+    static bool level_set     = false;
+    bool        level_changed = !level_set || (level != log_level());
+    level_set                 = true;
+
+    if (level_changed && level < uuid::log::Level::NOTICE) {
+        logger_.info(F("Log level set to %S"), uuid::log::format_level_uppercase(level));
+    }
+    uuid::log::Logger::register_handler(this, level);
+    if (level_changed && level >= uuid::log::Level::NOTICE) {
+        logger_.info(F("Log level set to %S"), uuid::log::format_level_uppercase(level));
+    }
+}
+
+size_t SyslogService::maximum_log_messages() const {
+    return maximum_log_messages_;
+}
+
+void SyslogService::maximum_log_messages(size_t count) {
+    maximum_log_messages_ = std::max((size_t)1, count);
+
+    while (log_messages_.size() > maximum_log_messages_) {
+        log_messages_.pop_front();
+    }
+}
+
+std::pair<IPAddress, uint16_t> SyslogService::destination() const {
+    return std::make_pair(host_, port_);
+}
+
+void SyslogService::destination(IPAddress host, uint16_t port) {
+    host_ = host;
+    port_ = port;
+
+    if ((uint32_t)host_ == (uint32_t)0) {
+        started_ = false;
+        remove_queued_messages(log_level());
+    }
+}
+
+std::string SyslogService::hostname() const {
+    return hostname_;
+}
+
+void SyslogService::hostname(std::string hostname) {
+    if (hostname.empty() || hostname.find(' ') != std::string::npos) {
+        hostname_ = '-';
+    } else {
+        hostname_ = std::move(hostname);
+    }
+}
+
+unsigned long SyslogService::mark_interval() const {
+    return mark_interval_ / 1000;
+}
+
+void SyslogService::mark_interval(unsigned long interval) {
+    mark_interval_ = (uint64_t)interval * 1000;
+}
+
+SyslogService::QueuedLogMessage::QueuedLogMessage(unsigned long id, std::shared_ptr<uuid::log::Message> && content)
+    : id_(id)
+    , content_(std::move(content)) {
+    if (time_good_ || WiFi.status() == WL_CONNECTED) {
+#if UUID_SYSLOG_HAVE_GETTIMEOFDAY
+        if (gettimeofday(&time_, nullptr) != 0) {
+            time_.tv_sec = (time_t)-1;
+        }
+#else
+        time_.tv_sec  = time(nullptr);
+        time_.tv_usec = 0;
+#endif
+
+        if (time_.tv_sec >= 0 && time_.tv_sec < 18140 * 86400) {
+            time_.tv_sec = (time_t)-1;
+        }
+
+        if (time_.tv_sec != (time_t)-1) {
+            time_good_ = true;
+        }
+    } else {
+        time_.tv_sec = (time_t)-1;
+    }
+}
+
+void SyslogService::operator<<(std::shared_ptr<uuid::log::Message> message) {
+    if (log_messages_.size() >= maximum_log_messages_) {
+        log_messages_overflow_ = true;
+        log_messages_.pop_front();
+    }
+
+    log_messages_.emplace_back(log_message_id_++, std::move(message));
+}
+
+void SyslogService::loop() {
+    while (!log_messages_.empty() && can_transmit()) {
+        auto message = log_messages_.front();
+
+        started_               = true;
+        log_messages_overflow_ = false;
+        auto ok                = transmit(message);
+        if (ok) {
+            // The transmit() may have called yield() allowing
+            // other messages to have been added to the queue.
+            if (!log_messages_overflow_) {
+                log_messages_.pop_front();
+            }
+            last_message_ = uuid::get_uptime_ms();
+        }
+
+        ::yield();
+
+        if (!ok) {
+            break;
+        }
+    }
+
+    if (started_ && mark_interval_ != 0 && log_messages_.empty()) {
+        if (uuid::get_uptime_ms() - last_message_ >= mark_interval_) {
+            // This is generated manually because the log level may not
+            // be high enough to receive INFO messages.
+            operator<<(std::make_shared<uuid::log::Message>(uuid::get_uptime_ms(),
+                                                            uuid::log::Level::INFO,
+                                                            uuid::log::Facility::SYSLOG,
+                                                            reinterpret_cast<const __FlashStringHelper *>(__pstr__logger_name),
+                                                            uuid::read_flash_string(F("-- MARK --"))));
+        }
+    }
+}
+
+bool SyslogService::can_transmit() {
+#if UUID_SYSLOG_HAVE_IPADDRESS_TYPE
+    if (host_.isV4() && (uint32_t)host_ == (uint32_t)0) {
+        return false;
+    }
+#else
+    if ((uint32_t)host_ == (uint32_t)0) {
+        return false;
+    }
+#endif
+
+    if (WiFi.status() != WL_CONNECTED) {
+        return false;
+    }
+
+    const uint64_t now           = uuid::get_uptime_ms();
+    uint64_t       message_delay = 100;
+
+#if UUID_SYSLOG_ARP_CHECK
+#if UUID_SYSLOG_HAVE_IPADDRESS_TYPE
+    if (host_.isV4())
+#endif
+    {
+        message_delay = 10;
+    }
+#endif
+#if UUID_SYSLOG_NDP_CHECK && UUID_SYSLOG_HAVE_IPADDRESS_TYPE
+    if (host_.isV6()) {
+        message_delay = 10;
+    }
+#endif
+
+    if (now < last_transmit_ || now - last_transmit_ < message_delay) {
+        return false;
+    }
+
+#if UUID_SYSLOG_ARP_CHECK
+#if UUID_SYSLOG_HAVE_IPADDRESS_TYPE
+    if (host_.isV4())
+#endif
+    {
+        ip4_addr_t ipaddr;
+
+        ip4_addr_set_u32(&ipaddr, (uint32_t)host_);
+
+        if (!ip4_addr_isloopback(&ipaddr) && !ip4_addr_ismulticast(&ipaddr) && !ip4_addr_isbroadcast(&ipaddr, netif_default)) {
+            struct eth_addr *  eth_ret = nullptr;
+            const ip4_addr_t * ip_ret  = nullptr;
+
+            if (!ip4_addr_netcmp(&ipaddr, netif_ip4_addr(netif_default), netif_ip4_netmask(netif_default))) {
+                // Replace addresses outside the network with the gateway address
+                const ip4_addr_t * gw_addr = netif_ip4_gw(netif_default);
+
+                if (gw_addr != nullptr) {
+                    ipaddr = *gw_addr;
+                }
+            }
+
+            if (etharp_find_addr(netif_default, &ipaddr, &eth_ret, &ip_ret) == -1) {
+                etharp_query(netif_default, &ipaddr, NULL);
+                // Avoid querying lwIP again for 1 second
+                last_transmit_ = uuid::get_uptime_ms() + (uint64_t)1000 - message_delay;
+
+                return false;
+            }
+        }
+    }
+#endif
+
+#if UUID_SYSLOG_NDP_CHECK && UUID_SYSLOG_HAVE_IPADDRESS_TYPE
+    if (host_.isV6()) {
+        ip6_addr_t ip6addr;
+
+        IP6_ADDR(&ip6addr, host_.raw6()[0], host_.raw6()[1], host_.raw6()[2], host_.raw6()[3]);
+        ip6_addr_assign_zone(&ip6addr, IP6_UNICAST, netif_default);
+
+        if (!ip6_addr_isloopback(&ip6addr) && !ip6_addr_ismulticast(&ip6addr)) {
+            // Don't send to a scoped address until we have a valid address of the same type
+            bool         have_address = false;
+            const u8_t * hwaddr       = nullptr;
+
+            for (size_t i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
+                if (ip6_addr_isvalid(netif_ip6_addr_state(netif_default, i))) {
+                    if (ip6_addr_isglobal(&ip6addr)) {
+                        if (ip6_addr_isglobal(netif_ip6_addr(netif_default, i))) {
+                            have_address = true;
+                            break;
+                        }
+                    } else if (ip6_addr_issitelocal(&ip6addr)) {
+                        if (ip6_addr_issitelocal(netif_ip6_addr(netif_default, i))) {
+                            have_address = true;
+                            break;
+                        }
+                    } else if (ip6_addr_isuniquelocal(&ip6addr)) {
+                        if (ip6_addr_isuniquelocal(netif_ip6_addr(netif_default, i))) {
+                            have_address = true;
+                            break;
+                        }
+                    } else if (ip6_addr_islinklocal(&ip6addr)) {
+                        if (ip6_addr_islinklocal(netif_ip6_addr(netif_default, i))) {
+                            have_address = true;
+                            break;
+                        }
+                    } else {
+                        have_address = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!have_address) {
+                // Avoid checking lwIP again for 1 second
+                last_transmit_ = uuid::get_uptime_ms() + (uint64_t)1000 - message_delay;
+
+                return false;
+            } else if (nd6_get_next_hop_addr_or_queue(netif_default, NULL, &ip6addr, &hwaddr) != ERR_OK) {
+                // Avoid querying lwIP again for 1 second
+                last_transmit_ = uuid::get_uptime_ms() + (uint64_t)1000 - message_delay;
+
+                return false;
+            }
+        }
+    }
+#endif
+
+    return true;
+}
+
+bool SyslogService::transmit(const QueuedLogMessage & message) {
+    struct tm tm;
+
+    tm.tm_year = 0;
+    if (message.time_.tv_sec != (time_t)-1) {
+        gmtime_r(&message.time_.tv_sec, &tm);
+    }
+
+    if (udp_.beginPacket(host_, port_) != 1) {
+        last_transmit_ = uuid::get_uptime_ms();
+        return false;
+    }
+    udp_.printf_P(PSTR("<%u>1 "), ((unsigned int)message.content_->facility * 8) + std::min(7U, (unsigned int)message.content_->level));
+    if (tm.tm_year != 0) {
+        udp_.printf_P(PSTR("%04u-%02u-%02uT%02u:%02u:%02u.%06luZ"),
+                      tm.tm_year + 1900,
+                      tm.tm_mon + 1,
+                      tm.tm_mday,
+                      tm.tm_hour,
+                      tm.tm_min,
+                      tm.tm_sec,
+                      (unsigned long)message.time_.tv_usec);
+    } else {
+        udp_.print('-');
+    }
+    udp_.printf_P(PSTR(" %s - - - - \xEF\xBB\xBF"), hostname_.c_str());
+    udp_.print(uuid::log::format_timestamp_ms(message.content_->uptime_ms, 3).c_str());
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat"
+    udp_.printf_P(PSTR(" %c %lu: [%S] "), uuid::log::format_level_char(message.content_->level), message.id_, message.content_->name);
+#pragma GCC diagnostic pop
+    udp_.print(message.content_->text.c_str());
+    bool ok = (udp_.endPacket() == 1);
+
+    last_transmit_ = uuid::get_uptime_ms();
+    return ok;
+}
+
+} // namespace syslog
+
+} // namespace uuid

lib/uuid-syslog/src/uuid/syslog.h

@@ -0,0 +1,263 @@
+/*
+ * uuid-syslog - Syslog service
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UUID_SYSLOG_H_
+#define UUID_SYSLOG_H_
+
+#include <Arduino.h>
+#ifdef ARDUINO_ARCH_ESP8266
+#include <ESP8266WiFi.h>
+#else
+#include <WiFi.h>
+#endif
+#include <WiFiUdp.h>
+#include <time.h>
+
+#include <atomic>
+#include <list>
+#include <memory>
+#include <string>
+
+#include <uuid/log.h>
+
+namespace uuid {
+
+/**
+ * Syslog service.
+ *
+ * - <a href="https://github.com/nomis/mcu-uuid-syslog/">Git Repository</a>
+ * - <a href="https://mcu-uuid-syslog.readthedocs.io/">Documentation</a>
+ */
+namespace syslog {
+
+/**
+ * Log handler for sending messages to a syslog server.
+ *
+ * @since 1.0.0
+ */
+class SyslogService : public uuid::log::Handler {
+  public:
+    static constexpr size_t   MAX_LOG_MESSAGES = 50;  /*!< Maximum number of log messages to buffer before they are output. @since 1.0.0 */
+    static constexpr uint16_t DEFAULT_PORT     = 514; /*!< Default UDP port to send messages to. @since 1.0.0 */
+
+    /**
+	 * Create a new syslog service log handler.
+	 *
+	 * @since 1.0.0
+	 */
+    SyslogService() = default;
+
+    ~SyslogService();
+
+    /**
+	 * Register the log handler with the logging framework.
+	 *
+	 * @since 1.0.0
+	 */
+    void start();
+
+    /**
+	 * Get the current log level.
+	 *
+	 * This only affects newly received log messages, not messages that
+	 * have already been queued.
+	 *
+	 * @return The current log level.
+	 * @since 2.0.0
+	 */
+    uuid::log::Level log_level() const;
+    /**
+	 * Set the current log level.
+	 *
+	 * Unless this is the first time the log level is being set, this
+	 * only affects newly received log messages, not messages that have
+	 * already been queued.
+	 *
+	 * @param[in] level Minimum log level that will be sent to the
+	 *                  syslog server.
+	 * @since 2.0.0
+	 */
+    void log_level(uuid::log::Level level);
+
+    /**
+	 * Get the maximum number of queued log messages.
+	 *
+	 * @return The maximum number of queued log messages.
+	 * @since 2.0.0
+	 */
+    size_t maximum_log_messages() const;
+    /**
+	 * Set the maximum number of queued log messages.
+	 *
+	 * Defaults to SyslogService::MAX_LOG_MESSAGES.
+	 *
+	 * @since 2.0.0
+	 */
+    void maximum_log_messages(size_t count);
+
+    /**
+	 * Get the server to send messages to.
+	 *
+	 * @since 2.0.0
+	 * @return IP address and UDP port of the syslog server.
+	 */
+    std::pair<IPAddress, uint16_t> destination() const;
+    /**
+	 * Set the server to send messages to.
+	 *
+	 * To disable sending messages, set the host to `0.0.0.0` and the
+	 * log level to uuid::log::Level::OFF (otherwise they will be
+	 * queued but not sent).
+	 *
+	 * @param[in] host IP address of the syslog server.
+	 * @param[in] port UDP port to send messages to.
+	 * @since 2.0.0
+	 */
+    void destination(IPAddress host, uint16_t port = DEFAULT_PORT);
+
+    /**
+	 * Get local hostname.
+	 *
+	 * @since 2.0.0
+	 * @return Hostname of this device.
+	 */
+    std::string hostname() const;
+    /**
+	 * Set local hostname.
+	 *
+	 * @param[in] hostname Hostname of this device.
+	 * @since 2.0.0
+	 */
+    void hostname(std::string hostname);
+
+    /**
+	 * Get mark interval.
+	 *
+	 * @since 2.0.0
+	 * @return Mark interval in seconds (0 = disable).
+	 */
+    unsigned long mark_interval() const;
+    /**
+	 * Set mark interval.
+	 *
+	 * When no messages have been sent for this period of time, a
+	 * `-- MARK --` message will be generated automatically.
+	 *
+	 * @param[in] interval Mark interval in seconds (0 = disable).
+	 * @since 2.0.0
+	 */
+    void mark_interval(unsigned long interval);
+
+    /**
+	 * Dispatch queued log messages.
+	 *
+	 * @since 1.0.0
+	 */
+    void loop();
+
+    /**
+	 * Add a new log message.
+	 *
+	 * This will be put in a queue for output at the next loop()
+	 * process. The queue has a maximum size of
+	 * get_maximum_log_messages() and will discard the oldest message
+	 * first.
+	 *
+	 * @param[in] message New log message, shared by all handlers.
+	 * @since 1.0.0
+	 */
+    virtual void operator<<(std::shared_ptr<uuid::log::Message> message);
+
+  private:
+    /**
+	 * Log message that has been queued.
+	 *
+	 * Contains an identifier sequence to indicate when log messages
+	 * could not be output because the queue discarded one or more
+	 * messages.
+	 *
+	 * @since 1.0.0
+	 */
+    class QueuedLogMessage {
+      public:
+        /**
+		 * Create a queued log message.
+		 *
+		 * @param[in] id Identifier to use for the log message on the queue.
+		 * @param[in] content Log message content.
+		 * @since 1.0.0
+		 */
+        QueuedLogMessage(unsigned long id, std::shared_ptr<uuid::log::Message> && content);
+        ~QueuedLogMessage() = default;
+
+        unsigned long                                   id_;      /*!< Sequential identifier for this log message. @since 1.0.0 */
+        struct timeval                                  time_;    /*!< Time message was received. @since 1.0.0 */
+        const std::shared_ptr<const uuid::log::Message> content_; /*!< Log message content. @since 1.0.0 */
+
+      private:
+        static bool time_good_; /*!< System time appears to be valid. @since 1.0.0 */
+    };
+
+    /**
+	 * Remove messages that were queued before the log level was set.
+	 *
+	 * @param[in] level New log level
+	 * @since 1.0.0
+	 */
+    void remove_queued_messages(uuid::log::Level level);
+
+    /**
+	 * Check if it is possible to transmit to the server.
+	 *
+	 * @return True if it is safe to transmit a message to the server,
+	 *         otherwise false.
+	 * @since 1.0.0
+	 */
+    bool can_transmit();
+
+    /**
+	 * Attempt to transmit one message to the server.
+	 *
+	 * @param[in] message Log message to be sent.
+	 * @return True if the message was successfully set, otherwise
+	 *         false.
+	 * @since 1.0.0
+	 */
+    bool transmit(const QueuedLogMessage & message);
+
+    static uuid::log::Logger logger_; /*!< uuid::log::Logger instance for syslog services. @since 1.0.0 */
+
+    bool                        started_ = false;                         /*!< Flag to indicate that messages have started being transmitted. @since 1.0.0 */
+    WiFiUDP                     udp_;                                     /*!< UDP client. @since 1.0.0 */
+    IPAddress                   host_;                                    /*!< Host to send messages to. @since 1.0.0 */
+    uint16_t                    port_          = DEFAULT_PORT;            /*!< Port to send messages to. @since 1.0.0 */
+    uint64_t                    last_transmit_ = 0;                       /*!< Last transmit time. @since 1.0.0 */
+    std::string                 hostname_{'-'};                           /*!< Local hostname. @since 1.0.0 */
+    size_t                      maximum_log_messages_ = MAX_LOG_MESSAGES; /*!< Maximum number of log messages to buffer before they are output. @since 1.0.0 */
+    unsigned long               log_message_id_       = 0;                /*!< The next identifier to use for queued log messages. @since 1.0.0 */
+    std::list<QueuedLogMessage> log_messages_;                            /*!< Queued log messages, in the order they were received. @since 1.0.0 */
+    std::atomic<bool>           log_messages_overflow_{false};            /*!< Check if log messages have overflowed the buffer. @since 1.0.0 */
+    uint64_t                    mark_interval_ = 0;                       /*!< Mark interval in milliseconds. @since 2.0.0 */
+    uint64_t                    last_message_  = 0;                       /*!< Last message/mark time. @since 2.0.0 */
+};
+
+} // namespace syslog
+
+} // namespace uuid
+
+#endif

lib/uuid-telnet/COPYING

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

lib/uuid-telnet/README.rst

@@ -0,0 +1,24 @@
+mcu-uuid-telnet |Build Status|
+==============================
+
+Description
+-----------
+
+Microcontroller telnet service
+
+Purpose
+-------
+
+Provides access to a console shell as a telnet server (using the
+`RFC 854 protocol <https://tools.ietf.org/html/rfc854>`_).
+
+Documentation
+-------------
+
+`Read the documentation <https://mcu-uuid-telnet.readthedocs.io/>`_
+generated from the docs_ directory.
+
+.. _docs: docs/
+
+.. |Build Status| image:: https://travis-ci.org/nomis/mcu-uuid-telnet.svg?branch=master
+   :target: https://travis-ci.org/nomis/mcu-uuid-telnet

lib/uuid-telnet/library.json

@@ -0,0 +1,36 @@
+{
+	"name": "uuid-telnet",
+	"description": "Telnet service",
+	"keywords": "communication,telnet",
+	"authors": [
+		{
+			"name": "Simon Arlott",
+			"maintainer": true
+		}
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/nomis/mcu-uuid-telnet.git"
+	},
+	"version": "0.1.0",
+	"license": "GPL-3.0-or-later",
+	"homepage": "https://mcu-uuid-telnet.readthedocs.io/",
+	"export": {
+		"exclude": [
+			".travis.yml",
+			"test/*"
+		]
+	},
+	"frameworks": [
+		"arduino"
+	],
+	"dependencies": {
+		"uuid-common": "^1.1.0",
+		"uuid-log": "^2.1.1",
+		"uuid-console": "^0.7.0"
+	},
+	"build": {
+		"flags": "-Wall -Wextra",
+		"libLDFMode": "chain+"
+	}
+}

lib/uuid-telnet/src/stream.cpp

@@ -0,0 +1,358 @@
+/*
+ * uuid-telnet - Telnet service
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "uuid/telnet.h"
+
+#include <Arduino.h>
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace uuid {
+
+namespace telnet {
+
+TelnetStream::TelnetStream(WiFiClient &client)
+		: client_(client) {
+	output_buffer_.reserve(BUFFER_SIZE);
+}
+
+void TelnetStream::start() {
+	raw_write({
+		IAC, WILL, OPT_ECHO,
+		IAC, WILL, OPT_BINARY,
+		IAC, WILL, OPT_SGA,
+		IAC, DONT, OPT_ECHO,
+		IAC, DO, OPT_BINARY,
+		IAC, DO, OPT_SGA
+	});
+}
+
+int TelnetStream::available() {
+	if (peek() == -1) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+int TelnetStream::read() {
+	if (peek_ != -1) {
+		int data = peek_;
+		peek_ = -1;
+		return data;
+	}
+
+	buffer_flush();
+
+restart:
+	int data = raw_read();
+
+	if (data == -1) {
+		return -1;
+	}
+
+	unsigned char c = data;
+
+	if (sub_negotiation_) {
+		if (previous_raw_in_ == IAC) {
+			switch (c) {
+			case SE:
+				sub_negotiation_ = false;
+				previous_raw_in_ = 0;
+				goto restart;
+
+			case IAC:
+				previous_raw_in_ = 0;
+				goto restart;
+			}
+		} else {
+			switch (c) {
+				case IAC:
+					previous_raw_in_ = c;
+					goto restart;
+
+				default:
+					previous_raw_in_ = 0;
+					goto restart;
+			}
+		}
+	} else {
+		if (previous_raw_in_ == IAC) {
+			switch (c) {
+			case IP:
+				// Interrupt (^C)
+				previous_raw_in_ = 0;
+				c = '\x03';
+				break;
+
+			case EC:
+				// Backspace (^H)
+				previous_raw_in_ = 0;
+				c = '\x08';
+				break;
+
+			case EL:
+				// Delete line (^U)
+				previous_raw_in_ = 0;
+				c = '\x15';
+				break;
+
+			case IAC:
+				previous_raw_in_ = 0;
+				break;
+
+			case SB:
+			case WILL:
+			case WONT:
+			case DO:
+			case DONT:
+				previous_raw_in_ = c;
+				goto restart;
+
+			case SE:
+			case DM:
+			case BRK:
+			case AO:
+			case AYT:
+			case GA:
+			case NOP:
+			default:
+				previous_raw_in_ = 0;
+				goto restart;
+			}
+		} else if (previous_raw_in_ == SB) {
+			sub_negotiation_ = true;
+			previous_raw_in_ = 0;
+			goto restart;
+		} else if (previous_raw_in_ == WILL || previous_raw_in_ == WONT) {
+			switch (c) {
+			case OPT_ECHO:
+				// Don't do these
+				raw_write({IAC, DONT, c});
+				break;
+
+			case OPT_BINARY:
+			case OPT_SGA:
+				// Do these
+				raw_write({IAC, DO, c});
+				break;
+
+			default:
+				// Don't do anything else
+				raw_write({IAC, DONT, c});
+				break;
+			}
+
+			previous_raw_in_ = 0;
+			goto restart;
+		} else if (previous_raw_in_ == DO) {
+			switch (c) {
+			case OPT_ECHO:
+			case OPT_BINARY:
+			case OPT_SGA:
+				// These are always enabled
+				break;
+
+			default:
+				// Refuse to do anything else
+				raw_write({IAC, WONT, c});
+				break;
+			}
+
+			previous_raw_in_ = 0;
+			goto restart;
+		} else if (previous_raw_in_ == DONT) {
+			switch (c) {
+			case OPT_ECHO:
+			case OPT_BINARY:
+			case OPT_SGA:
+				// Insist that we do these
+				raw_write({IAC, WILL, c});
+				break;
+
+			default:
+				// Everything else is always disabled
+				break;
+			}
+
+			previous_raw_in_ = 0;
+			goto restart;
+		} else {
+			switch (c) {
+			case IAC:
+				previous_raw_in_ = c;
+				goto restart;
+
+			default:
+				previous_raw_in_ = 0;
+				break;
+			}
+		}
+	}
+
+	if (previous_in_ == CR) {
+		if (c == NUL) {
+			previous_in_ = 0;
+			goto restart;
+		}
+	}
+
+	previous_in_ = c;
+	return c;
+}
+
+int TelnetStream::peek() {
+	buffer_flush();
+
+	// It's too complicated to implement this by calling peek()
+	// on the original stream, especially if the original stream
+	// doesn't actually support peeking.
+	if (peek_ == -1) {
+		peek_ = read();
+	}
+
+	return peek_;
+}
+
+size_t TelnetStream::write(uint8_t data) {
+	if (previous_out_ == CR && data != LF) {
+		previous_out_ = data;
+
+		if (raw_write({NUL, data}) != 2) {
+			return 0;
+		}
+	} else {
+		previous_out_ = data;
+	}
+
+	if (data == IAC) {
+		if (raw_write({IAC, IAC}) != 2) {
+			return 0;
+		}
+	} else {
+		if (raw_write(data) != 1) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+size_t TelnetStream::write(const uint8_t *buffer, size_t size) {
+	std::vector<unsigned char> data;
+	data.reserve(size);
+
+	while (size-- > 0) {
+		unsigned char c = *buffer++;
+
+		if (previous_out_ == CR && c != LF) {
+			data.push_back((unsigned char)NUL);
+		}
+
+		if (c == IAC) {
+			data.push_back((unsigned char)IAC);
+		}
+
+		previous_out_ = c;
+		data.push_back(c);
+	}
+
+	size_t len = raw_write(data);
+	if (len < size) {
+		len = 0;
+	}
+	return len;
+}
+
+void TelnetStream::flush() {
+	// This is a pure virtual function in Arduino's Stream class, which
+	// makes no sense because that class is for input and this is an
+	// output function. Later versions move it to Print as an empty
+	// virtual function so this is here for backward compatibility.
+}
+
+int TelnetStream::raw_available() {
+	return client_.available();
+}
+
+int TelnetStream::raw_read() {
+	return client_.read();
+}
+
+void TelnetStream::buffer_flush() {
+	if (!output_buffer_.empty()) {
+		size_t len = client_.write(reinterpret_cast<const unsigned char*>(output_buffer_.data()), output_buffer_.size());
+		if (len != output_buffer_.size()) {
+			client_.stop();
+		}
+		output_buffer_.clear();
+		output_buffer_.shrink_to_fit();
+	}
+}
+
+size_t TelnetStream::raw_write(unsigned char data) {
+	output_buffer_.push_back(data);
+
+	if (output_buffer_.size() >= BUFFER_SIZE) {
+		buffer_flush();
+	}
+
+	return 1;
+}
+
+size_t TelnetStream::raw_write(const std::vector<unsigned char> &data) {
+	return raw_write(reinterpret_cast<const unsigned char*>(data.data()), data.size());
+}
+
+size_t TelnetStream::raw_write(const uint8_t *buffer, size_t size) {
+	size_t offset = 0;
+	size_t remaining = size;
+
+	if (!output_buffer_.empty()) {
+		// Fill the rest of the buffer
+		size_t block = std::min(remaining, BUFFER_SIZE - output_buffer_.size());
+
+		output_buffer_.insert(output_buffer_.end(), buffer, buffer + block);
+		offset += block;
+		remaining -= block;
+
+		if (output_buffer_.size() >= BUFFER_SIZE) {
+			buffer_flush();
+		}
+	}
+
+	if (remaining >= BUFFER_SIZE) {
+		// Output directly if it won't fit in the buffer
+		size_t len = client_.write(buffer + offset, remaining);
+		if (len != remaining) {
+			client_.stop();
+			return offset + len;
+		}
+	} else if (remaining > 0) {
+		// Put the rest in the buffer
+		output_buffer_.insert(output_buffer_.end(), buffer + offset, buffer + offset + remaining);
+	}
+
+	return size;
+}
+
+} // namespace telnet
+
+} // namespace uuid

lib/uuid-telnet/src/telnet.cpp

@@ -0,0 +1,237 @@
+/*
+ * uuid-telnet - Telnet service
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "uuid/telnet.h"
+
+#include <Arduino.h>
+#if defined(ESP8266)
+#include <ESP8266WiFi.h>
+#elif defined(ESP32)
+#include <WiFi.h>
+#endif
+
+#include <WiFiUdp.h>
+
+#include <algorithm>
+#include <list>
+#include <memory>
+#include <string>
+
+#include <uuid/common.h>
+#include <uuid/log.h>
+
+#ifndef UUID_TELNET_HAVE_WIFICLIENT_REMOTE
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+#define UUID_TELNET_HAVE_WIFICLIENT_REMOTE 1
+#else
+#define UUID_TELNET_HAVE_WIFICLIENT_REMOTE 0
+#endif
+#endif
+
+#ifndef UUID_TELNET_HAVE_WIFICLIENT_NODELAY
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+#define UUID_TELNET_HAVE_WIFICLIENT_NODELAY 1
+#else
+#define UUID_TELNET_HAVE_WIFICLIENT_NODELAY 0
+#endif
+#endif
+
+#ifndef UUID_TELNET_HAVE_WIFICLIENT_KEEPALIVE
+#if defined(ARDUINO_ARCH_ESP8266)
+#define UUID_TELNET_HAVE_WIFICLIENT_KEEPALIVE 1
+#else
+#define UUID_TELNET_HAVE_WIFICLIENT_KEEPALIVE 0
+#endif
+#endif
+
+static const char __pstr__logger_name[] __attribute__((__aligned__(sizeof(int)))) PROGMEM = "telnet";
+
+namespace uuid {
+
+namespace telnet {
+
+uuid::log::Logger TelnetService::logger_{FPSTR(__pstr__logger_name), uuid::log::Facility::DAEMON};
+
+TelnetService::TelnetService(std::shared_ptr<uuid::console::Commands> commands, unsigned int context, unsigned int flags)
+    : TelnetService(DEFAULT_PORT, commands, context, flags) {
+}
+
+TelnetService::TelnetService(uint16_t port, std::shared_ptr<uuid::console::Commands> commands, unsigned int context, unsigned int flags)
+    : TelnetService(port,
+                    [commands, context, flags](Stream & stream, const IPAddress & addr __attribute__((unused)), uint16_t port __attribute__((unused)))
+                        -> std::shared_ptr<uuid::console::Shell> { return std::make_shared<uuid::console::StreamConsole>(commands, stream, context, flags); }) {
+}
+
+TelnetService::TelnetService(shell_factory_function shell_factory)
+    : TelnetService(DEFAULT_PORT, shell_factory) {
+}
+
+TelnetService::TelnetService(uint16_t port, shell_factory_function shell_factory)
+    : server_(port)
+    , shell_factory_(shell_factory) {
+}
+
+void TelnetService::start() {
+    server_.begin();
+}
+
+void TelnetService::close_all() {
+    while (!connections_.empty()) {
+        connections_.front().stop();
+        connections_.pop_front();
+    }
+}
+
+void TelnetService::stop() {
+    server_.stop();
+}
+
+size_t TelnetService::maximum_connections() const {
+    return maximum_connections_;
+}
+
+void TelnetService::maximum_connections(size_t count) {
+    maximum_connections_ = std::max((size_t)1, count);
+
+    while (connections_.size() > maximum_connections_) {
+        for (auto it = connections_.begin(); it != connections_.end();) {
+            if (it->active()) {
+                it->stop();
+                it = connections_.erase(it);
+                break;
+            } else {
+                it = connections_.erase(it);
+            }
+        }
+    }
+}
+
+unsigned long TelnetService::initial_idle_timeout() const {
+    return initial_idle_timeout_;
+}
+
+void TelnetService::initial_idle_timeout(unsigned long timeout) {
+    initial_idle_timeout_ = timeout;
+}
+
+unsigned long TelnetService::default_write_timeout() const {
+    return write_timeout_;
+}
+
+void TelnetService::default_write_timeout(unsigned long timeout) {
+    write_timeout_ = timeout;
+}
+
+void TelnetService::loop() {
+    for (auto it = connections_.begin(); it != connections_.end();) {
+        if (!it->loop()) {
+            it = connections_.erase(it);
+        } else {
+            it++;
+        }
+    }
+
+    WiFiClient client = server_.available();
+    if (client) {
+        if (connections_.size() >= maximum_connections_) {
+#if UUID_TELNET_HAVE_WIFICLIENT_REMOTE
+            logger_.info(F("New connection from [%s]:%u rejected (connection limit reached)"),
+                         uuid::printable_to_string(client.remoteIP()).c_str(),
+                         client.remotePort());
+#else
+            logger_.info(F("New connection rejected (connection limit reached)"));
+#endif
+            client.println(F("Maximum connection limit reached"));
+            client.stop();
+        } else {
+#if UUID_TELNET_HAVE_WIFICLIENT_REMOTE
+            logger_.info(F("New connection from [%s]:%u accepted"), uuid::printable_to_string(client.remoteIP()).c_str(), client.remotePort());
+#endif
+            connections_.emplace_back(shell_factory_, std::move(client), initial_idle_timeout_, write_timeout_);
+#if !(UUID_TELNET_HAVE_WIFICLIENT_REMOTE)
+            logger_.info(F("New connection %p accepted"), &connections_.back());
+#endif
+        }
+    }
+}
+
+TelnetService::Connection::Connection(shell_factory_function & shell_factory, WiFiClient && client, unsigned long idle_timeout, unsigned long write_timeout)
+    : client_(std::move(client))
+    , stream_(client_) {
+#if UUID_TELNET_HAVE_WIFICLIENT_REMOTE
+    // These have to be copied because they're not accessible on closed connections
+    addr_ = client_.remoteIP();
+    port_ = client_.remotePort();
+#else
+    port_ = 0;
+#endif
+
+#if UUID_TELNET_HAVE_WIFICLIENT_NODELAY
+    client_.setNoDelay(true);
+#endif
+
+#if UUID_TELNET_HAVE_WIFICLIENT_KEEPALIVE
+    // Disconnect after 30 seconds without a response
+    client_.keepAlive(5, 5, 5);
+#endif
+
+    if (write_timeout > 0) {
+        client_.setTimeout(write_timeout);
+    }
+
+    stream_.start();
+
+    if (client_.connected()) {
+        std::shared_ptr<uuid::console::Shell> shell = shell_factory(stream_, addr_, port_);
+        shell->idle_timeout(idle_timeout);
+        shell->start();
+        shell_ = shell;
+    } else {
+        shell_ = nullptr;
+    }
+}
+
+bool TelnetService::Connection::active() {
+    return shell_.use_count() > 1;
+}
+
+bool TelnetService::Connection::loop() {
+    if (active()) {
+        if (!client_.connected()) {
+            shell_->stop();
+        }
+        return true;
+    } else {
+#if UUID_TELNET_HAVE_WIFICLIENT_REMOTE
+        logger_.info(F("Connection from [%s]:%u closed"), uuid::printable_to_string(addr_).c_str(), port_);
+#else
+        logger_.info(F("Connection %p closed"), this);
+#endif
+        return false;
+    }
+}
+
+void TelnetService::Connection::stop() {
+    if (shell_) {
+        shell_->stop();
+    }
+}
+
+} // namespace telnet
+
+} // namespace uuid

lib/uuid-telnet/src/uuid/telnet.h

@@ -0,0 +1,441 @@
+/*
+ * uuid-telnet - Telnet service
+ * Copyright 2019  Simon Arlott
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UUID_TELNET_H_
+#define UUID_TELNET_H_
+
+#include <Arduino.h>
+#ifdef ARDUINO_ARCH_ESP8266
+# include <ESP8266WiFi.h>
+#else
+# include <WiFi.h>
+#endif
+#include <WiFiUdp.h>
+
+#include <functional>
+#include <list>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <uuid/console.h>
+
+namespace uuid {
+
+/**
+ * Telnet service.
+ *
+ * - <a href="https://github.com/nomis/mcu-uuid-telnet/">Git Repository</a>
+ * - <a href="https://mcu-uuid-telnet.readthedocs.io/">Documentation</a>
+ */
+namespace telnet {
+
+/**
+ * Stream wrapper that performs telnet protocol handling, option
+ * negotiation and output buffering.
+ *
+ * @since 0.1.0
+ */
+class TelnetStream: public ::Stream {
+public:
+	/**
+	 * Create a new telnet stream wrapper.
+	 *
+	 * @param[in] client Client connection.
+	 * @since 0.1.0
+	 */
+	explicit TelnetStream(WiFiClient &client);
+	virtual ~TelnetStream() = default;
+
+	/**
+	 * Perform initial negotiation.
+	 *
+	 * @since 0.1.0
+	 */
+	void start();
+
+	/**
+	 * Check for available input.
+	 *
+	 * @return The number of bytes available to read.
+	 * @since 0.1.0
+	 */
+	int available() override;
+	/**
+	 * Read one byte from the available input.
+	 *
+	 * @return An unsigned char if input is available, otherwise -1.
+	 * @since 0.1.0
+	 */
+	int read() override;
+	/**
+	 * Read one byte from the available input without advancing to the
+	 * next one.
+	 *
+	 * @return An unsigned char if input is available, otherwise -1.
+	 * @since 0.1.0
+	 */
+	int peek() override;
+	/**
+	 * Write one byte to the output stream.
+	 *
+	 * Disconnect the client if the socket buffer is full.
+	 *
+	 * @param[in] data Data to be output.
+	 * @return The number of bytes that were output.
+	 * @since 0.1.0
+	 */
+	size_t write(uint8_t data) override;
+	/**
+	 * Write an array of bytes to the output stream.
+	 *
+	 * Disconnect the client if the socket buffer is full.
+	 *
+	 * @param[in] buffer Buffer to be output.
+	 * @param[in] size Length of the buffer.
+	 * @return The number of bytes that were output.
+	 * @since 0.1.0
+	 */
+	size_t write(const uint8_t *buffer, size_t size) override;
+	/**
+	 * Does nothing.
+	 *
+	 * This is a pure virtual function in Arduino's Stream class, which
+	 * makes no sense because that class is for input and this is an
+	 * output function. Later versions move it to Print as an empty
+	 * virtual function so this is here for backward compatibility.
+	 *
+	 * @since 0.1.0
+	 */
+	void flush() override;
+
+private:
+	static constexpr const unsigned char NUL = 0; /*!< No operation. @since 0.1.0 */
+	static constexpr const unsigned char BEL = 7; /*!< Produces an audible or visible signal. @since 0.1.0 */
+	static constexpr const unsigned char BS = 8; /*!< Moves the print head one character position towards the left margin. @since 0.1.0 */
+	static constexpr const unsigned char HT = 9; /*!< Moves the printer to the next horizontal tab stop. @since 0.1.0 */
+	static constexpr const unsigned char LF = 10; /*!< Line Feed. @since 0.1.0 */
+	static constexpr const unsigned char VT = 11; /*!< Moves the printer to the next vertical tab stop. @since 0.1.0 */
+	static constexpr const unsigned char FF = 12; /*!< Moves the printer to the top of the next page, keeping the same horizontal position. @since 0.1.0 */
+	static constexpr const unsigned char CR = 13; /*!< Carriage Return. @since 0.1.0 */
+	static constexpr const unsigned char SE = 240; /*!< End of sub-negotiation parameters. @since 0.1.0 */
+	static constexpr const unsigned char NOP = 241; /*!< No operation. @since 0.1.0 */
+	static constexpr const unsigned char DM = 242; /*!< The data stream portion of a Synch. @since 0.1.0 */
+	static constexpr const unsigned char BRK = 243; /*!< NVT character BRK. @since 0.1.0 */
+	static constexpr const unsigned char IP = 244; /*!< Interrupt Process function. @since 0.1.0 */
+	static constexpr const unsigned char AO = 245; /*!< Abort Output function. @since 0.1.0 */
+	static constexpr const unsigned char AYT = 246; /*!< Are You There function. @since 0.1.0 */
+	static constexpr const unsigned char EC = 247; /*!< Erase Character function. @since 0.1.0 */
+	static constexpr const unsigned char EL = 248; /*!< Erase Line function. @since 0.1.0 */
+	static constexpr const unsigned char GA = 249; /*!< Go Ahead signal. @since 0.1.0 */
+	static constexpr const unsigned char SB = 250; /*!< Sub-negotiation of the indicated option. @since 0.1.0 */
+	static constexpr const unsigned char WILL = 251; /*!< Indicates the desire to begin performing, or confirmation that you are now performing, the indicated option. @since 0.1.0 */
+	static constexpr const unsigned char WONT = 252; /*!< Indicates the refusal to perform, or continue performing, the indicated option. @since 0.1.0 */
+	static constexpr const unsigned char DO = 253; /*!< Indicates the request that the other party perform, or confirmation that you are expecting the other party to perform, the indicated option. @since 0.1.0 */
+	static constexpr const unsigned char DONT = 254; /*!< Indicates the demand that the other party stop performing, or confirmation that you are no longer expecting the other party to perform, the indicated option. @since 0.1.0 */
+	static constexpr const unsigned char IAC = 255; /*!< Interpret As Command escape character. @since 0.1.0 */
+
+	static constexpr const unsigned char OPT_BINARY = 0; /*!< Binary (8-bit) transmission mode. (RFC 856). @since 0.1.0 */
+	static constexpr const unsigned char OPT_ECHO = 1; /*!< Remote Echo (RFC 857). @since 0.1.0 */
+	static constexpr const unsigned char OPT_SGA = 3; /*!< Suppress Go Ahead (RFC 858). @since 0.1.0 */
+
+	static constexpr const size_t BUFFER_SIZE = 536; /*!< Output buffer size. @since 0.1.0 */
+
+	TelnetStream(const TelnetStream&) = delete;
+	TelnetStream& operator=(const TelnetStream&) = delete;
+
+	/**
+	 * Directly check for available input.
+	 *
+	 * @return The number of bytes available to read.
+	 * @since 0.1.0
+	 */
+	int raw_available();
+	/**
+	 * Read one byte directly from the available input.
+	 *
+	 * @return An unsigned char if input is available, otherwise -1.
+	 * @since 0.1.0
+	 */
+	int raw_read();
+	/**
+	 * Flush output stream buffer.
+	 *
+	 * Disconnect the client if the socket buffer is full.
+	 *
+	 * @since 0.1.0
+	 */
+	void buffer_flush();
+	/**
+	 * Write one byte directly to the output stream.
+	 *
+	 * Disconnect the client if the socket buffer is full.
+	 *
+	 * @param[in] data Data to be output.
+	 * @return The number of bytes that were output.
+	 * @since 0.1.0
+	 */
+	size_t raw_write(unsigned char data);
+	/**
+	 * Write a vector of bytes directly to the output stream.
+	 *
+	 * Disconnect the client if the socket buffer is full.
+	 *
+	 * @param[in] data Data to be output.
+	 * @return The number of bytes that were output.
+	 * @since 0.1.0
+	 */
+	size_t raw_write(const std::vector<unsigned char> &data);
+	/**
+	 * Write an array of bytes directly to the output stream.
+	 *
+	 * Disconnect the client if the socket buffer is full.
+	 *
+	 * @param[in] buffer Buffer to be output.
+	 * @param[in] size Length of the buffer.
+	 * @return The number of bytes that were output.
+	 * @since 0.1.0
+	 */
+	size_t raw_write(const uint8_t *buffer, size_t size);
+
+	WiFiClient &client_; /*!< Client connection. @since 0.1.0 */
+	unsigned char previous_raw_in_ = 0; /*!< Previous raw character that was received. Used to detect commands. @since 0.1.0 */
+	bool sub_negotiation_ = false; /*!< Sub-negotiation mode. @since 0.1.0 */
+	unsigned char previous_in_ = 0; /*!< Previous character that was received. Used to detect CR NUL. @since 0.1.0 */
+	unsigned char previous_out_ = 0; /*!< Previous character that was sent. Used to insert NUL after CR without LF. @since 0.1.0 */
+	int peek_ = -1; /*!< Previously read data cached by peek(). @since 0.1.0 */
+	std::vector<char> output_buffer_; /*!< Buffer data to be output until a read function is called. @since 0.1.0 */
+};
+
+/**
+ * Provides access to a console shell as a telnet server.
+ *
+ * @since 0.1.0
+ */
+class TelnetService {
+public:
+	static constexpr size_t MAX_CONNECTIONS = 3; /*!< Maximum number of concurrent open connections. @since 0.1.0 */
+	static constexpr uint16_t DEFAULT_PORT = 23; /*!< Default TCP port to listen on. @since 0.1.0 */
+	static constexpr unsigned long DEFAULT_IDLE_TIMEOUT = 600; /*!< Default initial idle timeout (in seconds). @since 0.1.0 */
+	static constexpr unsigned long DEFAULT_WRITE_TIMEOUT = 0; /*!< Default write timeout (in milliseconds). @ since 0.1.0 */
+
+	/**
+	 * Function to handle the creation of a shell.
+	 *
+	 * @param[in] stream Stream for the telnet connection.
+	 * @param[in] addr Remote IP address.
+	 * @param[in] port Remote port.
+	 * @since 0.1.0
+	 */
+	using shell_factory_function = std::function<std::shared_ptr<uuid::console::Shell>(Stream &stream, const IPAddress &addr, uint16_t port)>;
+
+	/**
+	 * Create a new telnet service listening on the default port.
+	 *
+	 * @param[in] commands Commands available for execution in shells.
+	 * @param[in] context Default context for shells.
+	 * @param[in] flags Initial flags for shells.
+	 * @since 0.1.0
+	 */
+	TelnetService(std::shared_ptr<uuid::console::Commands> commands, unsigned int context = 0, unsigned int flags = 0);
+
+	/**
+	 * Create a new telnet service listening on a specific port.
+	 *
+	 * @param[in] port TCP listening port.
+	 * @param[in] commands Commands available for execution in shells.
+	 * @param[in] context Default context for shells.
+	 * @param[in] flags Initial flags for shells.
+	 * @since 0.1.0
+	 */
+	TelnetService(uint16_t port, std::shared_ptr<uuid::console::Commands> commands, unsigned int context = 0, unsigned int flags = 0);
+
+	/**
+	 * Create a new telnet service listening on the default port.
+	 *
+	 * @param[in] shell_factory Function to create a shell for new connections.
+	 * @since 0.1.0
+	 */
+	explicit TelnetService(shell_factory_function shell_factory);
+
+	/**
+	 * Create a new telnet service listening on a specific port.
+	 *
+	 * @param[in] port TCP listening port.
+	 * @param[in] shell_factory Function to create a shell for new connections.
+	 * @since 0.1.0
+	 */
+	TelnetService(uint16_t port, shell_factory_function shell_factory);
+
+	~TelnetService() = default;
+
+	/**
+	 * Start listening for connections on the configured port.
+	 *
+	 * @since 0.1.0
+	 */
+	void start();
+	/**
+	 * Close all connections.
+	 *
+	 * The listening status is not affected.
+	 *
+	 * @since 0.1.0
+	 */
+	void close_all();
+	/**
+	 * Stop listening for connections.
+	 *
+	 * Existing connections are not affected.
+	 *
+	 * @since 0.1.0
+	 */
+	void stop();
+
+	/**
+	 * Get the maximum number of concurrent open connections.
+	 *
+	 * @return The maximum number of concurrent open connections.
+	 * @since 0.1.0
+	 */
+	size_t maximum_connections() const;
+	/**
+	 * Set the maximum number of concurrent open connections.
+	 *
+	 * Defaults to TelnetService::MAX_CONNECTIONS.
+	 *
+	 * @since 0.1.0
+	 */
+	void maximum_connections(size_t count);
+
+	/**
+	 * Get the initial idle timeout for new connections.
+	 *
+	 * @return The initial idle timeout in seconds (or 0 for disabled).
+	 * @since 0.1.0
+	 */
+	unsigned long initial_idle_timeout() const;
+	/**
+	 * Set the initial idle timeout for new connections.
+	 *
+	 * Defaults to TelnetService::DEFAULT_IDLE_TIMEOUT.
+	 *
+	 * @param[in] timeout Idle timeout in seconds (or 0 to disable).
+	 * @since 0.1.0
+	 */
+	void initial_idle_timeout(unsigned long timeout);
+
+	/**
+	 * Get the default socket write timeout for new connections.
+	 *
+	 * @return The default socket write timeout in seconds (or 0 for
+	 *         platform default).
+	 * @since 0.1.0
+	 */
+	unsigned long default_write_timeout() const;
+	/**
+	 * Set the default socket write timeout for new connections.
+	 *
+	 * Defaults to TelnetService::DEFAULT_WRITE_TIMEOUT (platform
+	 * default).
+	 *
+	 * @param[in] timeout Socket write timeout in seconds (or 0 for
+	 *                    platform default).
+	 * @since 0.1.0
+	 */
+	void default_write_timeout(unsigned long timeout);
+
+	/**
+	 * Accept new connections.
+	 *
+	 * @since 0.1.0
+	 */
+	void loop();
+
+private:
+	/**
+	 * Telnet connection.
+	 *
+	 * Holds the client and stream instance for the lifetime of the shell.
+	 *
+	 * @since 0.1.0
+	 */
+	class Connection {
+	public:
+		/**
+		 * Create a telnet connection shell.
+		 *
+		 * @param[in] shell_factory Function to create a shell for new connections.
+		 * @param[in] client Client connection.
+		 * @param[in] idle_timeout Idle timeout in seconds.
+		 * @param[in] write_timeout Idle timeout in milliseconds.
+		 * @since 0.1.0
+		 */
+		Connection(shell_factory_function &shell_factory, WiFiClient &&client, unsigned long idle_timeout, unsigned long write_timeout);
+		~Connection() = default;
+
+		/**
+		 * Check if the shell is still active.
+		 *
+		 * @return Active status of the shell.
+		 * @since 0.1.0
+		 */
+		bool active();
+		/**
+		 * Stop the shell if the client is not connected.
+		 *
+		 * @return Active status of the shell.
+		 * @since 0.1.0
+		 */
+		bool loop();
+		/**
+		 * Stop the shell.
+		 *
+		 * @since 0.1.0
+		 */
+		void stop();
+
+	private:
+		Connection(const Connection&) = delete;
+		Connection& operator=(const Connection&) = delete;
+
+		WiFiClient client_; /*!< Client connection. @since 0.1.0 */
+		TelnetStream stream_; /*!< Telnet stream for the connection. @since 0.1.0 */
+		std::shared_ptr<uuid::console::Shell> shell_; /*!< Shell for connection. @since 0.1.0 */
+		IPAddress addr_; /*!< Remote address of connection. @since 0.1.0 */
+		uint16_t port_; /*!< Remote port of connection. @since 0.1.0 */
+	};
+
+	TelnetService(const TelnetService&) = delete;
+	TelnetService& operator=(const TelnetService&) = delete;
+
+	static uuid::log::Logger logger_; /*!< uuid::log::Logger instance for telnet services. @since 0.1.0 */
+
+	WiFiServer server_; /*!< TCP server. @since 0.1.0 */
+	size_t maximum_connections_ = MAX_CONNECTIONS; /*!< Maximum number of concurrent open connections. @since 0.1.0 */
+	std::list<Connection> connections_; /*!< Open connections. @since 0.1.0 */
+	shell_factory_function shell_factory_; /*!< Function to create a shell. @since 0.1.0 */
+	unsigned long initial_idle_timeout_ = DEFAULT_IDLE_TIMEOUT; /*!< Initial idle timeout (in seconds). @since 0.1.0 */
+	unsigned long write_timeout_ = DEFAULT_WRITE_TIMEOUT; /*!< Write timeout (in milliseconds). @since 0.1.0 */
+};
+
+} // namespace telnet
+
+} // namespace uuid
+
+#endif