mosquitto-0.15/ 0000775 0001750 0001750 00000000000 11713444064 012527 5 ustar roger roger mosquitto-0.15/config.h 0000664 0001750 0001750 00000005412 11713444064 014147 0 ustar roger roger /* ============================================================
* Control compile time options.
*
* Largely, these are options that are designed to make mosquitto run more
* easily in restrictive environments by removing features.
* ============================================================ */
#ifndef CMAKE
/* Only use the compile time options defined here from the standard Makefile. */
/* Uncomment to compile with tcpd/libwrap support. */
//#define WITH_WRAP
/* Compile with database upgrading support? If disabled, mosquitto won't
* automatically upgrade old database versions. */
//#define WITH_DB_UPGRADE
/* Compile with memory tracking support? If disabled, mosquitto won't track
* heap memory usage nor export '$SYS/broker/heap/current size', but will use
* slightly less memory and CPU time. */
#define WITH_MEMORY_TRACKING
/* Compile with persistent database support. This allows the broker to store
* retained messages and durable subscriptions to a file periodically and on
* shutdown. This is usually desirable (and is suggested by the MQTT spec), but
* it can be disabled by commenting out this define if required.
*/
#define WITH_PERSISTENCE
/* Compile with bridge support included. This allow the broker to connect to
* other brokers and subscribe/publish to topics. You probably want to leave
* this included unless you want to save a very small amount of memory size and
* CPU time.
*/
#define WITH_BRIDGE
/* Compile with strict protocol support. This means that both the client
* library and the broker will be very strict about protocol compliance on
* incoming data. Neither of them will return an error on incorrect "remaining
* length" values if this is commented out. The old behaviour (prior to 0.12)
* is equivalent to compiling with WITH_STRICT_PROTOCOL defined and means that
* clients will be immediately disconnected from the broker on non-compliance.
*/
//#define WITH_STRICT_PROTOCOL
/* Use the username/password and ACL checks defined in security_external.c
* This is empty by default, but gives a more straightforward way of adding
* support for existing username/password databases to mosquitto.
* Uncommenting without adding your own code to security_external.c will
* result in all access being denied.
* It also enables the db_* config options in mosquitto.conf.
* Get in touch with the authors if you need help adding support for your
* system.
*/
//#define WITH_EXTERNAL_SECURITY_CHECKS
#endif
/* ============================================================
* Compatibility defines
*
* Generally for Windows native support.
* ============================================================ */
#ifdef WIN32
#define snprintf sprintf_s
#define strcasecmp strcmpi
#define strtok_r strtok_s
#define strerror_r(e, b, l) strerror_s(b, l, e)
#endif
mosquitto-0.15/logo/ 0000775 0001750 0001750 00000000000 11713444064 013467 5 ustar roger roger mosquitto-0.15/logo/mosquitto-16x16.png 0000664 0001750 0001750 00000001066 11713444064 017027 0 ustar roger roger PNG
IHDR h6 sRGB bKGD P P PƇ pHYs tIME :4 IDAT(ϵ?P}$J
h!XJ,,l? XWYYhaao/` DD%hPTDz,X:3)f J)7LUh0 !r
7ZVTt:e2vK)EwHRH$r< ~n81> ~*n{β, x^< ,d2 zXg1! Xy>vFNS>7M3je#$Ir(fl?>??UU\.$q gFZ%0 s8 t] NSEAV+v8 jD"1LfۍF Bn_MS 0
uCQ eB,,{4E)tz8 l6PJ5M4
{IKcB IENDB` mosquitto-0.15/logo/mosquitto.svg 0000664 0001750 0001750 00000021127 11713444064 016257 0 ustar roger roger
mosquitto-0.15/logo/mosquitto-14x14.png 0000664 0001750 0001750 00000001001 11713444064 017010 0 ustar roger roger PNG
IHDR * sRGB bKGD pHYs 0 tIME
~5 IDAT(ϵP 3&Yq
Te` .ڴhY˅Ap
)\6|۸{t8|p0 I@cx<өmۂ xt7jYrD"t:P("TU?vBl6[B1 )
7 ` X,h4H$dY$i0$Inw]7Ns Zipn1Mzhx9? X,nE4
j(0RTTmq 4,J"I>PJzn6ۍRl ˡh : z hZ,c! p>)d]W' / pE IENDB` mosquitto-0.15/CMakeLists.txt 0000664 0001750 0001750 00000002646 11713444064 015277 0 ustar roger roger # This is a cmake script.
# It is intended to be the default means of building mosquitto, but isn't
# quite ready for all cases yet.
set(CMAKE_LEGACY_CYGWIN_WIN32 0)
project(mosquitto)
cmake_minimum_required(VERSION 2.6)
set (VERSION 0.15)
if (WIN32)
execute_process(COMMAND echo "%DATE% %TIME%" OUTPUT_VARIABLE TIMESTAMP
OUTPUT_STRIP_TRAILING_WHITESPACE)
else (WIN32)
execute_process(COMMAND date "+%F %T%z" OUTPUT_VARIABLE TIMESTAMP
OUTPUT_STRIP_TRAILING_WHITESPACE)
endif (WIN32)
add_definitions (-DCMAKE -DVERSION=\"${VERSION}\" -DTIMESTAMP=\"${TIMESTAMP}\")
if (WIN32)
set (BINDIR .)
set (SBINDIR .)
set (SYSCONFDIR .)
set (LIBDIR .)
set (INCLUDEDIR include)
set (DATAROOTDIR share)
set (MANDIR man)
set (SHAREDEST .)
add_definitions("-D_CRT_SECURE_NO_WARNINGS")
else (WIN32)
set (BINDIR bin)
set (SBINDIR sbin)
set (SYSCONFDIR etc/mosquitto)
set (LIBDIR lib${LIB_SUFFIX})
set (INCLUDEDIR include)
set (DATAROOTDIR share)
set (MANDIR ${DATAROOTDIR}/man)
set (SHAREDIR ${DATAROOTDIR}/mosquitto)
endif (WIN32)
# ========================================
# Include projects
# ========================================
add_subdirectory(lib)
add_subdirectory(client)
add_subdirectory(src)
add_subdirectory(man)
# ========================================
# Install config file
# ========================================
install(FILES mosquitto.conf aclfile.example pwfile.example DESTINATION ${SYSCONFDIR})
mosquitto-0.15/ChangeLog.txt 0000664 0001750 0001750 00000055137 11713444064 015132 0 ustar roger roger 0.15 - 20120205
===============
- Add support for $SYS/broker/clients/maximum and $SYS/broker/clients/active
topics.
- Add support for $SYS messages/byte per second received/sent topics.
- Updated mosquitto man page - $SYS hierarchy and signal support were out of
date.
- Auto generated pub/sub client ids now include the hostname.
- Tool for dumping persistent DB contents is available in src/db_dump. It isn't
installed by default.
- Enforce topic length checks in client library.
- Implement "once" and "lazy" bridge start types.
- Add new return type MOSQ_ERR_ERRNO to indicate that the errno variable should
be checked for the real error code.
- Add support for connection_messages config option.
- mosquitto_sub will now refuse to run if the -c option (disable clean session)
is given and no client id is provided.
- mosquitto_pub now gives more useful error messages on invalid input or other
error conditions.
- Fix Python will_set() true/True typo.
- Fix messages to topic "a/b" incorrectly matching on a subscription "a" if
another subscription "a/#" exists.
0.14.4 - 20120106
=================
- Fix local bridge notification messages.
- Fix return values for more internal library calls.
- Fix incorrect out of memory checks in library and broker.
- Never time out local bridge connections.
0.14.3 - 20111210
=================
- Fix potential crash when client connects with an invalid CONNECT packet.
- Fix incorrect invalid socket comparison on Windows.
- Server shouldn't crash when a message is published to foo/ when a
subscription to foo/# exists (bug #901697).
- SO_REUSEADDR doesn't work the same on Windows, so don't use it.
- Cygwin builds now support Windows service features.
- Fix $SYS/broker/bytes/sent reporting.
0.14.2 - 20111123
=================
- Add uninstall target for libs.
- Don't try to write packet whilst in a callback.
0.14.1 - 20111117
=================
- Fix Python sytax errors (bug #891673).
0.14 - 20111116
===============
- Add support for matching ACLs based on client id and username.
- Add a Windows installer file (NSIS based).
- Add native support for running the broker as a Windows service. This is the
default when installed using the new installer.
- Fix client count for listeners. When clients disconnect, decrement the
count. Allow max_connections to work again.
- Attempt to send all packets immediately upon being queued. This will result
in more immediate network communication in many cases.
- Log IP address when reporting CONNACK packets if the client id isn't yet
known.
- Fix payload length calculation in python will_set function.
- Fix Python publish and will_set functions for payload=None.
- Fix keepalive value being lost when reconnecting a client (bug #880863).
- Persistence file writing now uses portable file functions, so the Cygwin
broker build should no longer be necessary.
- Duplicate code between the client and broker side has been reduced.
- Queued messages for clients reconnecting with clean_session=false set were
not being sent until the next message for that client was received. This has
been fixed (bug #890724).
- Fix subscriptions to # incorrectly matching against topics beginning with /
0.13 - 20110920
===============
- Implement bridge state notification messages.
- Save client last used mid in persistent database (DB version number bumped).
- Expose message id in Python MosquittoMessage.
- It is now possible to set the topic QoS level for bridges.
- Python MosquittoMessage payload parameter is now a Python string, not a
ctypes object which makes it much easier to use.
- Fix queueing of messages for disconnected clients. The max_queued_messages
option is now obeyed.
- C++ library is now in its own namespace, mosquittopp.
- Add support for adding log message timestamps in the broker.
- Fix missing mosquitto_username_pw_set() python binding.
- Fix keepalive timeout for reconnecting non clean-session clients. Prevents
immediate disconnection on reconnection.
- Fix subscription wildcard matching - a subscription of +/+ will now match
against /foo
- Fix subscription wildcard matching - a subscription of foo/# will now match
against foo
- When restoring persistent database, clients should be set to non
clean-session or their subscriptions will be immediately removed.
- Fix SUBACK payload for multiple topic subscriptions.
- Don't send retained messages when a client subscribes to a topic it is
already subscribed to.
0.12 - 20110725
===============
- Reload (most) configuration on SIGHUP.
- Memory tracking is no longer compiled in the client library.
- Add --help option to mosquitto to display usage.
- Add --id-prefix option to clients to allow easier use with brokers that are
using the clientid_prefix option.
- Fix compilation on QNX.
- Add -P as a synonym argument for --pw in the clients.
- Fix python MosquittoMessage payload parameter. This is now returned as a
pointer to an array of c_uint8 values so binary data is handled correctly.
If a string is needed, use msg.payload_str
- Fix memory leaks on client authentication.
- If password_file is not defined then clients can now connect even if they
use a username/password.
- Add mosquitto_reconnect() to the client library.
- Add option for compiling with liberal protocol compliance support (enabled
by default).
- Fix problems with clients reconnecting and old messages remaining in the
message store.
- Display both ip and client id in the log message when a client connects.
Change the socket connection message to make it more obvious that it is just
a socket connection being made (bug #801135).
- Fix retained message delivery where a subscription contains a +.
- Be more lenient when reloading persistent database to reduce errors with
empty retained messages.
0.11.3 - 20110707
=================
- Don't complain and quit if persistence_file option is given (bug #802423).
- Initialise listeners correctly when clients with duplicate client ids
connect. Bug #801678.
- Memory tracking is now disabled for Symbian builds due to lack of malloc.h.
- Fix memory tracking compilation for kFreeBSD.
- Python callbacks can now be used with class member functions.
- Fix persistent database writing of client message chunks which caused
errors when restoring (bug #798164).
0.11.2 - 20110626
=================
- Don't free contexts in mqtt3_context_disconnect() (bug #799688 / #801678).
- Only free will if present when freeing a client context.
0.11.1 - 20110620
=================
- Fix buffer overrun when checking for + and # in topics (bug #799688).
- Pub client now quits if publish fails.
0.11 - 20110619
===============
- Removed all old sqlite code.
- Remove client id limit in clients.
- Implemented $SYS/broker/heap/maximum size
- Implemented $SYS/broker/clients/inactive to show the number of disconnected
non-clean session clients.
- $SYS/broker/heap/current size and maximum size messages now include "bytes"
to match rsmb message format.
- Implemented the retained_persistence config file option - a synonym of the
"persistence" option.
- Added security_external.c to broker source to make it easier for third
parties to add support for their existing username/password and ACL database
for security checks. See external_security_checks.txt.
- $SYS messages are now only republished when their value changes.
- Windows native broker now responds to command line arguments.
- Simplify client disconnecting so wills gets sent in all cases (bug #792468).
- Clients now have a --quiet option.
- The on_disconnect() callback will always be called now, even if the client
has disconnected unexpectedly.
- Always close persistent DB file after restoring.
- Return error code when exiting the clients.
- mosquitto_publish() now returns MOSQ_ERR_INVAL if the topic contains + or #
- mosquitto now silently rejects published messages with + or # in the topic.
- max_connections is now a per-listener setting instead of global.
- Connection count is now reduced when clients disconnect (bug #797983).
0.10.2 - 20110106
=================
- Don't abort when connecting if the first connection fails. This is important
on e.g. Windows 7, where IPV6 is offered as the first choice but may not be
available.
- Deal with long logging messages properly (bug #785882).
- Fix library compilation on Symbian - no pselect() available.
- Don't stop processing subscriptions on received messages after a
subscription with # matches. (bug #791206).
0.10.1 - 20110512
=================
- Fix Windows compilation.
- Fix mosquitto.py on Windows - call lib init/cleanup.
- Don't abort when connecting if given an unknown address type (assuming an
IPv4 or IPv6 address is given).
0.10 - 20110429
===============
- Implement support for the password_file option and accompanying
authentication requirements in the broker.
- Implement topic Access Control Lists.
- mosquitto_will_set() and mosquitto_publish() now return
MOSQ_ERR_PAYLOAD_SIZE if the payload is too large (>268,435,455 bytes).
- Bridge support can now be disabled at compile time.
- Group together network writes for outgoing packets - don't send single byte
writes!
- Add support for clientid_prefixes variable.
- Add support for the clientid config variable for controlling bridge client
ids.
- Remove 32-bit database ID support because htobe64() no longer used.
- Multiple client subscriptions to the same topic result in only a single
subscription. Bug #744077.
0.9.3 - 20110310
================
- Set retained message status for QoS 2 messages (bug #726535).
- Only abort with an error when opening listening sockets if no address family
is available, rather than aborting when any address family is not available.
- Don't clean queued messages when a non clean session client reconnects.
- Make mosquitto.py compatible with Python <2.6.
- Fix mosquitto.h header includes for Windows.
0.9.2 - 20110208
================
- Only send a single DISCONNECT command when using -l in the pub client.
- Set QoS=1 on PUBREL commands to meet protocol spec.
- Don't leak sockets on connection failure in the library.
- Install man pages when building under cmake.
- Fix crash bug on malformed CONNECT message.
- Clients are now rejected if their socket peer name cannot be obtained on
connection.
- Fix a number of potential problems caused when a client with a duplicate id
connects.
- Install mosquitto.conf under cmake.
0.9.1 - 20101203
================
- Add missing code for parsing the "bind_address" configuration option.
- Fix missing include when compiling with tcp-wrappers support.
- Add linker version script for C library to control exported functions.
0.9 - 20101114
==============
- Client and message data is now stored in memory with custom routines rather
than a sqlite database. This removes the dependencies on sqlite, pcre and
sqlite3-pcre. It also means that the persistent database format has had to
be reimplemented in a custom format. Optional support for importing old
sqlite databases is provided.
- Added IPv6 support for mosquitto and the clients.
- Provide username and password support for the clients and client libraries.
This is part of the new MQTT v3.1 spec.
- The broker supports the username and password connection flags, but will not
do anything with the username and password.
- Python callback functions now optionally take an extra argument which will
return the user object passed to the Mosquitto() constructor, or the calling
python object itself if nothing was given to Mosquitto().
- Remove the mosquitto command line option "-i interface".
- Remove the mosquitto.conf "interface" variable.
- Add support for the listener config variable (replaces the interface
variable)
- Add support for the bind_address config variable.
- Change the port config variable behaviour to match that of rsmb (applies to
the default listener only, can be given just once).
- Fix QoS 2 protocol compliance - stop sending duplicate messages and handle
timeouts correctly. Fixes bug #598290.
- Set retain flag correctly for outgoing messages. It should only be set for
messages sent in response to a subscribe command (ie. stale data).
- Fix bug in returning correct CONNACK result to on_connect client callback.
- Don't send client will if it is disconnected for exceeding its keepalive
timer.
- Fix client library unsubscribe function incorrectly sending a SUBSCRIBE
command when it should be UNSUBSCRIBE.
- Fix max_inflight_messages and max_queued_messages operation. These
parameters now apply only to QoS 1 and 2 messages and are used regardless of
the client connection state.
- mosquitto.conf now installed to /etc/mosquitto/mosquitto.conf instead of
/etc/mosquitto.conf. The /etc/mosquitto/ directory will be used for password
and access control files in the future.
- Give the compile time option of using 32-bit integers for the database IDs
instead of 64-bit integers. This is useful where htobe64()/be64toh() are not
available or for embedded systems for example.
- The DUP bit is now set correctly when resending PUBREL messages.
- A port to Windows native has been partially completed. This currently drops a
number of features, including the ability to change configuration parameters
and persistent storage.
0.8.3 - 20101004
================
- Fix QoS 2 protocol compliance - stop sending duplicate messages and handle
timeouts correctly. Fixes bug #598290. (backported from future 0.9 code)
0.8.2 - 20100815
================
- Fix default loop() timeout value in mosquitto.py. Previous value was 0,
causing high cpu load.
- Fix message handling problem in client library when more than one message was
in the client queue.
- Fix the logic used to determine whether a QoS>0 message needs to be retried.
- Fix the Python sub.py example so that it quits on error.
0.8.1 - 20100812
================
- Improve python interface
- Fix incorrect return value from message delete function
- Use logging function to print error messages in clients.
- Fix python installation script DESTDIR.
- Fix library destination path for 64-bit machines.
0.8 - 20100807
==============
- Topics starting with a / are treated as distinct to those not starting with
a /. For example, /topic/path is different to topic/path. This matches the
behaviour of rsmb.
- Correctly calculate the will QoS on a new client connection (bug #597451).
- Add "addresses" configuration file variable as an alias of "address", for
better rsmb compatibility.
- Bridge clean_session setting is now false, to give more sensible behaviour
and be more compatible with rsmb.
- Add cleansession variable for configuring bridges.
- Add keepalive_interval variable for bridges.
- Remove default topic subscription for mosquitto_sub because the old
behaviour was too confusing.
- Added a C client library, which the pub and sub clients now use.
- Added a C++ client library (bound to the C library).
- Added a Python client library (bound to the C library).
- Added CMake build scripts to allow the library and clients (not the broker)
to be compiled natively on Windows.
0.7 - 20100615
==============
- mosquitto_pub can now send null (zero length) messages.
- Don't store QoS=0 messages for disconnected clients with subscriptions of
QoS>0.
- accept() all available sockets when new clients are connecting, rather than
just one.
- Add option to print debug messages in pub and sub clients.
- hg revision is now exported via $SYS/broker/changeset
- Send Will when client exceeds keepalive timer and is disconnected.
- Check to see if a client has a will before sending it.
- Correctly deal with clients connecting with the same id multiple times.
- Add compile time option to disable heap memory tracking.
- Use poll() instead of select() to allow >1024 clients.
- Implement max_connections.
- Run VACUUM on in-memory database on receiving SIGUSR2.
- Fix bridge keepalive timeouts and reconnects.
- Don't attempt to drop root privileges when running on Windows as this isn't
well supported (bug #586231).
0.6.1 - 20100506
================
- Fix DB auto upgrade for messages table.
0.6 - 20100505
==============
- Basic support for connecting multiple MQTT brokers together (bridging).
- mosquitto_sub can now subscribe to multiple topics (limited to a global QoS).
- mosquitto_pub can now send a file as a message.
- mosquitto_pub can now read all of stdin and send it as a message.
- mosquitto_pub can now read stdin and send each line as a message.
- mosquitto will now correctly run VACUUM on the persistent database on exit.
- Implement a more efficient database design, so that only one copy of each
message is held in the database, rather than one per subscribed client.
- Add the store_cleanup_interval config option for dealing with the internal
message store.
- Add support for disabling "clean session" for the sub client.
- Add support for automatic upgrading of the mosquitto DB from v1 to v2.
- Add persistence_file config option to allow changing the filename of the
persistence database. This allows multiple mosquitto DBs to be stored in the
same location whilst keeping persistence_location compatible with rsmb.
- Don't store QoS=0 messages for disconnected clients. Fixes bug #572608. This
wasn't correctly fixed in version 0.5.
- Don't disconnect clients if they send a PUBLISH with zero length payload
(bug #573610).
- If a retained message is received with a zero length payload, the retained
message for that topic is deleted.
- Send through zero length messages.
- Produce a warning on unsupported rsmb options instead of quitting.
- Describe clean session flag in the mqtt man page.
- Implement the max_inflight_messages and max_queued_messages features in the
broker.
0.5.4 - 20100311
================
- Fix memory allocation in mqtt3_fix_sub_topic() (bug #531861).
- Remove accidental limit of 100 client connections.
- Fix mosquitto_pub handling of messages with QoS>0 (bug #537061).
0.5.3 - 20100303
================
- Will messages are now only sent when a client disconnects unexpectedly.
- Fix all incoming topics/subscriptions that start with a / or contain
multiple / in a row (//).
- Do actually disconnect client when it sends an empty subscription/topic string.
- Add missing $SYS/broker/clients/total to man page.
0.5.2 - 20100302
================
- Always update last backup time, so that the backup doesn't run every time
through the main loop once autosave_interval has been reached.
- Report $SYS/broker/uptime in the same format as rsmb.
- Make mandatory options obvious in usage output and man page of mosquitto_pub.
Fixes bug #529990.
- Treat subscriptions with a trailing slash correctly. This should fix bugs
#530369 and #530099.
0.5.1 - 20100227
================
- Must daemonise before pid file is written.
0.5 - 20100227
==============
- No longer store QoS=0 messages for disconnected clients that do not have
clean start set.
- Rename msg_timeout option to retry_interval for better rsmb compatibility.
- Change persistence behaviour. The database is now stored in memory even if
persistence is enabled. It is written to disk when mosquitto exits and also at
periodic intervals as defined by the new autosave_interval option.
- The writing of the persistence database may be forced by sending mosquitto
the SIGUSR1 signal.
- Clients that do not send CONNECT as their first command are now
disconnected.
- Boolean configuration values may now be specified with true/false as well as
1/0.
- Log message on CONNECT with invalid protocol or protocol version.
- Default sqlite3-pcre path on Linux is now /usr/lib/sqlite3/pcre.so to match
future sqlite3-pcre packages.
- Add mosquitto_sub and mosquitto_pub, simple clients for subscribe/publish.
- Add man pages for clients.
- Add general man page on mqtt.
- Root privileges are now dropped only after attempting to write a pid file
(if configured). This means that the pid file can be written to /var/run/
directly and should fix bug #523183.
0.4.2 - 20100203
================
- Fix segfault on client connect with invalid protocol name/version.
0.4.1 - 20100112
===============
- Fix regex used for finding retained messages to send on new subscription.
0.4 - 20100105
==============
- Added support for wildcard subscriptions using + and #.
- All network operations are now non-blocking and can cope with partial
packets, meaning that networking should be a lot more reliable.
- Total messsages/bytes sent/received are now available in $SYS.
- Improved logging information - use client ip address and id instead of
socket number.
- Broker build timestamp is available in $SYS.
- Keepalive==0 is now correctly treated as "never disconnect".
- Fixed manpage installation.
- Fixed incorrect $SYS hierarchy locations in documentation and code.
- Debug type log messages are no longer sent to "topics".
- Default logging destination no longer includes "topics" to prevent possible
error logging to the db before it is initialised.
- Periodic $SYS messages can now be disabled.
- stdout and stderr are flushed when logging to them to give more timely
updates.
- dup is now set correctly when resending messages.
- Database format bumped due to topic column naming fix.
0.3 - 20091217
==============
- The port option in the configuration file and --port command line argument
may now be given any number of times to make mosquitto listen on multiple
sockets.
- Add new config file and command line option "interface" to specify an
interface to listen on, rather than all interfaces.
- Added host access control through tcp-wrappers support.
- Set SO_REUSEADDR on the listening socket so restart is much quicker.
- Added support for tracking current heap memory usage - this is published on
the topic "$SYS/broker/heap/current size"
- Added code for logging to stderr, stdout, syslog and topics.
- Added logging to numerous places - still plenty of scope for more.
0.2 - 20091204
==============
- Replaced the command line option --foreground with --daemon, swapping the
default behaviour.
- Added the command line option --config-file, to specify a config file to
load. If this is not given, no config file is load and the default options
are used.
- Added the command line option --port for specifying the port to listen on.
This overrides values in the config file.
- Don't use persistence by default.
- Default behaviour is now more sane when run by a normal user with no command
line options (combination of above changes).
- Added option user to config file, defaulting to a value of mosquitto. If
this value isn't blank and mosquitto is started by root, then it will drop
privileges by changing to the user and its primary group. This replaces the
current behaviour of refusing to start if run by root.
- Fix non-persistent mode, which would never work in the previous release.
- Added information on default values of msg_timeout and sys_interval to the
mosquitto.conf man page. (closes bug #492045).
mosquitto-0.15/compiling.txt 0000664 0001750 0001750 00000001000 11713444064 015240 0 ustar roger roger Add a very brief blurb on packages needed for compiling
The following packages are required for mosquitto:
tcp-wrappers (optional, package name libwrap0-dev)
To compile, run "make".
tcp-wrappers support can be added by editing config.h to comment out the
appropriate #define lines.
Use cmake to compile on Windows.
If you have any questions, problems or suggestions (particularly related to
installing on a more unusual device like a plug-computer) then please get in
touch using the details in readme.txt.
mosquitto-0.15/service/ 0000775 0001750 0001750 00000000000 11713444064 014167 5 ustar roger roger mosquitto-0.15/service/monit/ 0000775 0001750 0001750 00000000000 11713444064 015315 5 ustar roger roger mosquitto-0.15/service/monit/mosquitto.monit 0000664 0001750 0001750 00000000211 11713444064 020423 0 ustar roger roger check process mosquitto with pidfile /var/run/mosquitto.pid
start = "/etc/init.d/mosquitto start"
stop = "/etc/init.d/mosquitto stop"
mosquitto-0.15/service/svscan/ 0000775 0001750 0001750 00000000000 11713444064 015464 5 ustar roger roger mosquitto-0.15/service/svscan/run 0000775 0001750 0001750 00000000100 11713444064 016205 0 ustar roger roger #!/bin/sh
/usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf
mosquitto-0.15/service/upstart/ 0000775 0001750 0001750 00000000000 11713444064 015671 5 ustar roger roger mosquitto-0.15/service/upstart/mosquitto.conf 0000664 0001750 0001750 00000000254 11713444064 020605 0 ustar roger roger description "Mosquitto MQTTv3.1 broker"
author "Roger Light "
start on net-device-up
respawn
exec /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf
mosquitto-0.15/COPYING 0000664 0001750 0001750 00000002742 11713444064 013567 0 ustar roger roger Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
mosquitto-0.15/mosquitto.conf 0000664 0001750 0001750 00000032366 11713444064 015454 0 ustar roger roger # Config file for mosquitto
#
# See mosquitto.conf(5) for more information.
#
# Default values are shown, uncomment to change.
#
# Use the # character to indicate a comment, but only if it is the
# very first character on the line.
# =================================================================
# General configuration
# =================================================================
# Time in seconds to wait before resending an outgoing QoS=1 or
# QoS=2 message.
#retry_interval 20
# Time in seconds between updates of the $SYS tree.
#sys_interval 10
# Time in seconds between cleaning the internal message store of
# unreferenced messages. Lower values will result in lower memory
# usage but more processor time, higher values will have the
# opposite effect.
# Setting a value of 0 means the unreferenced messages will be
# disposed of as quickly as possible.
#store_clean_interval 10
# Write process id to a file. Default is a blank string which means
# a pid file shouldn't be written.
# This should be set to /var/run/mosquitto.pid if mosquitto is
# being run automatically on boot with an init script and
# start-stop-daemon or similar.
#pid_file
# When run as root, drop privileges to this user and its primary
# group.
# Leave blank to stay as root, but this is not recommended.
# If run as a non-root user, this setting has no effect.
# Note that on Windows this has no effect and so mosquitto should
# be started by the user you wish it to run as.
#user mosquitto
# The maximum number of QoS 1 and 2 messages currently inflight per
# client.
# This includes messages that are partway through handshakes and
# those that are being retried. Defaults to 10. Set to 0 for no
# maximum. Setting to 1 will guarantee in-order delivery of QoS 1
# and 2 messages.
#max_inflight_messages 10
# The maximum number of QoS 1 and 2 messages to hold in a queue
# above those that are currently in-flight. Defaults to 100. Set
# to 0 for no maximum (not recommended).
#max_queued_messages 100
# =================================================================
# Default listener
# =================================================================
# IP address/hostname to bind the default listener to. If not
# given, the default listener will not be bound to a specific
# address and so will be accessible to all network interfaces.
# bind_address ip-address/host name
#bind_address
# Port to use for the default listener.
#port 1883
# The maximum number of client connections to allow. This is
# a per listener setting.
# Default is -1, which means unlimited connections.
# Note that other process limits mean that unlimited connections
# are not really possible. Typically the default maximum number of
# connections possible is around 1024.
#max_connections -1
# =================================================================
# Extra listeners
# =================================================================
# Listen on a port/ip address combination. By using this variable
# multiple times, mosquitto can listen on more than one port. If
# this variable is used and neither bind_address nor port given,
# then the default listener will not be started.
# The port number to listen on must be given. Optionally, an ip
# address or host name may be supplied as a second argument. In
# this case, mosquitto will attempt to bind the listener to that
# address and so restrict access to the associated network and
# interface. By default, mosquitto will listen on all interfaces.
# listener port-number [ip address/host name]
#listener
# The maximum number of client connections to allow. This is
# a per listener setting.
# Default is -1, which means unlimited connections.
# Note that other process limits mean that unlimited connections
# are not really possible. Typically the default maximum number of
# connections possible is around 1024.
#max_connections -1
# The listener can be restricted to operating within a topic hierarchy using
# the mount_point option. This is achieved be prefixing the mount_point string
# to all topics for any clients connected to this listener. This prefixing only
# happens internally to the broker; the client will not see the prefix.
#mount_point
# =================================================================
# Persistence
# =================================================================
# If persistence is enabled, save the in-memory database to disk
# every autosave_interval seconds. If set to 0, the persistence
# database will only be written when mosquitto exits.
# Note that writing of the persistence database can be forced by
# sending mosquitto a SIGUSR1 signal.
#autosave_interval 1800
# Save persistent message data to disk (true/false).
# This saves information about all messages, including
# subscriptions, currently in-flight messages and retained
# messages.
# retained_persistence is a synonym for this option.
#persistence false
# The filename to use for the persistent database, not including
# the path.
#persistence_file mosquitto.db
# Location for persistent database. Must include trailing /
# Default is an empty string (current directory).
# Set to /var/lib/mosquitto/ if running as a proper service.
#persistence_location
# =================================================================
# Logging
# =================================================================
# Places to log to. Use multiple log_dest lines for multiple
# logging destinations.
# Possible destinations are: stdout stderr syslog topic
# stdout and stderr log to the console on the named output.
# syslog uses the userspace syslog facility which usually ends up
# in /var/log/messages or similar.
# topic logs to the broker topic '$SYS/broker/log/',
# where severity is one of D, E, W, N, I which are debug, error,
# warning, notice and information.
# Use "log_dest none" if you wish to disable logging.
#log_dest stderr
# Types of messages to log. Use multiple log_type lines for logging
# multiple types of messages.
# Possible types are: debug, error, warning, notice, information,
# none.
# Note that debug type messages are for decoding the incoming
# network packets.
# They are not logged in syslog.
#log_type error
#log_type warning
#log_type notice
#log_type information
# If set to true, client connection and disconnection messages will be included
# in the log.
#connection_messages true
# If set to true, add a timestamp value to each log message.
#log_timestamp true
# =================================================================
# Security
# =================================================================
# If set, only clients that have a matching prefix on their
# clientid will be allowed to connect to the broker. By default,
# all clients may connect.
# For example, setting "secure-" here would mean a client "secure-
# client" could connect but another with clientid "mqtt" couldn't.
#clientid_prefixes
# Boolean value that determines whether clients that connect
# without providing a username are allowed to connect. If set to
# false then a password file should be created (see the
# password_file option) to control authenticated client access.
# Defaults to true.
#allow_anonymous true
# Control access to the broker using a password file. The file is a
# text file # of lines in the format:
# username:password
# The password (and colon) may be omitted if desired, although this
# offers very little in the way of security.
#password_file
# Control access to topics on the broker using an access control list
# file. If this parameter is defined then only the topics listed will
# have access.
# Topic access is added with lines of the format:
#
# topic [read|write]
#
# The access type is controlled using "read" or "write". This parameter
# is optional - if not given then the access is read/write.
# can contain the + or # wildcards as in subscriptions.
#
# The first set of topics are applied to anonymous clients, assuming
# allow_anonymous is true. User specific topic ACLs are added after a
# user line as follows:
#
# user
#
# The username referred to here is the same as in password_file. It is
# not the clientid.
#
#
# If is also possible to define ACLs based on pattern substitution within the
# topic. The patterns available for substition are:
#
# %c to match the client id of the client
# %u to match the username of the client
#
# The substitution pattern must be the only text for that level of hierarchy.
#
# The form is the same as for the topic keyword, but using pattern as the
# keyword.
# Pattern ACLs apply to all users even if the "user" keyword has previously
# been given.
#
# pattern [read|write]
#
# Example:
#
# pattern write sensor/%u/data
#
#acl_file
# =================================================================
# Bridges
# =================================================================
# Experimental support for connecting multiple MQTT brokers
# together.
# Specify multiple sets of connection, address and topic
# configurations.
# Each connection must have a unique name.
# Only a single address per configuration is currently supported,
# unlike in rsmb.
# The direction that the topic will be shared can be chosen by
# specifying out, in or both, where the default value is out.
# The QoS level of the bridged communication can be specified with the final
# topic option. The default QoS level is 2, to change the QoS the topic
# direction must also be given.
# Multiple topics can be specified per connection, but be careful
# not to create any loops.
#connection
#address [:]
#topic [[out | in | both] qos-level]
# Set the client id for this bridge connection. If not defined,
# this defaults to 'name.hostname' where name is the connection
# name and hostname is the hostname of this computer.
#clientid
# Set the clean session variable for this bridge.
# When set to true, when the bridge disconnects for any reason, all
# messages and subscriptions will be cleaned up on the remote
# broker. Note that with cleansession set to true, there may be a
# significant amount of retained messages sent when the bridge
# reconnects after losing its connection.
# When set to false, the subscriptions and messages are kept on the
# remote broker, and delivered when the bridge reconnects.
#cleansession false
# If set to true, publish notification messages to the local and remote brokers
# giving information about the state of the bridge connection. Retained
# messages are published to the topic $SYS/bridge/connection//state.
# If the message is 1 then the connection is active, or 0 if the connection has
# failed.
#notifications true
# Set the keepalive interval for this bridge connection, in
# seconds.
#keepalive_interval 60
# Set the start type of the bridge. This controls how the bridge starts and
# can be one of three types: automatic, lazy and once. Note that RSMB provides
# a fourth start type "manual" which isn't currently supported by mosquitto.
#
# "automatic" is the default start type and means that the bridge connection
# will be started automatically when the broker starts and also restarted
# after a short delay (30 seconds) if the connection fails.
#
# Bridges using the "lazy" start type will be started automatically when the
# number of queued messages exceeds the number set with the "threshold"
# parameter. It will be stopped automatically after the time set by the
# "idle_timeout" parameter. Use this start type if you wish the connection to
# only be active when it is needed.
#
# A bridge using the "once" start type will be started automatically when the
# broker starts but will not be restarted if the connection fails.
#start_type automatic
# Set the amount of time a bridge using the lazy start type must be idle before
# it will be stopped. Defaults to 60 seconds.
#idle_timeout 60
# Set the number of messages that need to be queued for a bridge with lazy
# start type to be restarted. Defaults to 10 messages.
# Must be less than max_queued_messages.
#threshold 10
# Set the username to use when connecting to an MQTT v3.1 broker
# that requires authentication.
#username
# Set the password to use when connecting to an MQTT v3.1 broker
# that requires authentication. This option is only used if
# username is also set.
#password
# =================================================================
# External security checks
# =================================================================
# This section defines options for potential use with external
# databases.
# They are intended to make it easier to add external security
# checks along with WITH_EXT_SECURITY_CHECKS. If you haven't written
# code to support another database and compiled support in, you are
# unlikely to need to change anything here.
# Database hostname.
#db_host
# Database port.
#db_port
# Database name.
#db_name
# Database username.
#db_username
# Database password.
#db_password
# =================================================================
# Unsupported rsmb options - for the future
# =================================================================
#autosave_on_changes
#addresses
#notification_topic
#round_robin
# =================================================================
# rsmb options - unlikely to ever be supported
# =================================================================
#ffdc_output
#max_log_entries
#trace_level
#trace_output
#try_private
mosquitto-0.15/src/ 0000775 0001750 0001750 00000000000 11713444064 013316 5 ustar roger roger mosquitto-0.15/src/service.c 0000664 0001750 0001750 00000011323 11713444064 015122 0 ustar roger roger /*
Copyright (c) 2011 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#if defined(WIN32) || defined(__CYGWIN__)
#include
#include
extern int run;
static SERVICE_STATUS_HANDLE service_handle;
static SERVICE_STATUS service_status;
int main(int argc, char *argv[]);
/* Service control callback */
void __stdcall service_handler(DWORD fdwControl)
{
switch(fdwControl){
case SERVICE_CONTROL_CONTINUE:
/* Continue from Paused state. */
break;
case SERVICE_CONTROL_PAUSE:
/* Pause service. */
break;
case SERVICE_CONTROL_SHUTDOWN:
/* System is shutting down. */
case SERVICE_CONTROL_STOP:
/* Service should stop. */
service_status.dwCurrentState = SERVICE_STOP_PENDING;
SetServiceStatus(service_handle, &service_status);
run = 0;
break;
}
}
/* Function called when started as a service. */
void __stdcall service_main(DWORD dwArgc, LPTSTR *lpszArgv)
{
char **argv;
int argc = 1;
char conf_path[MAX_PATH + 20];
int rc;
service_handle = RegisterServiceCtrlHandler("mosquitto", service_handler);
if(service_handle){
rc = GetEnvironmentVariable("MOSQUITTO_DIR", conf_path, MAX_PATH);
if(!rc || rc == MAX_PATH){
service_status.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus(service_handle, &service_status);
return;
}
strcat(conf_path, "/mosquitto.conf");
argv = _mosquitto_malloc(sizeof(char *)*3);
argv[0] = "mosquitto";
argv[1] = "-c";
argv[2] = conf_path;
argc = 3;
service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
service_status.dwCurrentState = SERVICE_RUNNING;
service_status.dwControlsAccepted = SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP;
service_status.dwWin32ExitCode = NO_ERROR;
service_status.dwCheckPoint = 0;
SetServiceStatus(service_handle, &service_status);
main(argc, argv);
_mosquitto_free(argv);
service_status.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus(service_handle, &service_status);
}
}
void service_install(void)
{
SC_HANDLE sc_manager, svc_handle;
char exe_path[MAX_PATH + 5];
SERVICE_DESCRIPTION svc_desc;
GetModuleFileName(NULL, exe_path, MAX_PATH);
strcat(exe_path, " run");
sc_manager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
if(sc_manager){
svc_handle = CreateService(sc_manager, "mosquitto", "Mosquitto Broker",
SERVICE_START | SERVICE_STOP | SERVICE_CHANGE_CONFIG,
SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
exe_path, NULL, NULL, NULL, NULL, NULL);
if(svc_handle){
svc_desc.lpDescription = "MQTT v3.1 broker";
ChangeServiceConfig2(svc_handle, SERVICE_CONFIG_DESCRIPTION, &svc_desc);
CloseServiceHandle(svc_handle);
}
CloseServiceHandle(sc_manager);
}
}
void service_uninstall(void)
{
SC_HANDLE sc_manager, svc_handle;
SERVICE_STATUS status;
sc_manager = OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT);
if(sc_manager){
svc_handle = OpenService(sc_manager, "mosquitto", SERVICE_QUERY_STATUS | DELETE);
if(svc_handle){
if(QueryServiceStatus(svc_handle, &status)){
if(status.dwCurrentState == SERVICE_STOPPED){
DeleteService(svc_handle);
}
}
CloseServiceHandle(svc_handle);
}
CloseServiceHandle(sc_manager);
}
}
void service_run(void)
{
SERVICE_TABLE_ENTRY ste[] = {
{ "mosquitto", service_main },
{ NULL, NULL }
};
StartServiceCtrlDispatcher(ste);
}
#endif
mosquitto-0.15/src/CMakeLists.txt 0000664 0001750 0001750 00000004413 11713444064 016060 0 ustar roger roger include_directories(${mosquitto_SOURCE_DIR} ${mosquitto_SOURCE_DIR}/src
${mosquitto_SOURCE_DIR}/lib ${OPENSSL_INCLUDE_DIR}
${STDBOOL_H_PATH} ${STDINT_H_PATH})
set (MOSQ_SRCS
conf.c
context.c
database.c
logging.c
loop.c
../lib/memory_mosq.c ../lib/memory_mosq.h
mosquitto.c
mqtt3.h
net.c
../lib/net_mosq.c ../lib/net_mosq.h
persist.c persist.h
read_handle.c read_handle_client.c read_handle_server.c
../lib/read_handle_shared.c ../lib/read_handle.h
subs.c
security.c security_external.c
../lib/send_client_mosq.c ../lib/send_mosq.h
../lib/send_mosq.c ../lib/send_mosq.h
send_server.c
../lib/util_mosq.c ../lib/util_mosq.h
../lib/will_mosq.c ../lib/will_mosq.h)
set (MOSQ_LIBS ${OPENSSL_LIBRARIES})
option(INC_BRIDGE_SUPPORT
"Include bridge support for connecting to other brokers?" ON)
if (${INC_BRIDGE_SUPPORT} STREQUAL ON)
set (MOSQ_SRCS ${MOSQ_SRCS} bridge.c)
add_definitions("-DWITH_BRIDGE")
endif (${INC_BRIDGE_SUPPORT} STREQUAL ON)
option(USE_LIBWRAP
"Include tcp-wrappers support?" OFF)
if (${USE_LIBWRAP} STREQUAL ON)
set (MOSQ_LIBS ${MOSQ_LIBS} wrap)
add_definitions("-DWITH_WRAP")
endif (${USE_LIBWRAP} STREQUAL ON)
option(INC_DB_UPGRADE
"Include database upgrade support? (recommended)" ON)
option(INC_MEMTRACK
"Include memory tracking support?" ON)
if (${INC_MEMTRACK} STREQUAL ON)
add_definitions("-DWITH_MEMORY_TRACKING")
endif (${INC_MEMTRACK} STREQUAL ON)
option(WITH_PERSISTENCE
"Include persistence support?" ON)
if (${WITH_PERSISTENCE} STREQUAL ON)
add_definitions("-DWITH_PERSISTENCE")
endif (${WITH_PERSISTENCE} STREQUAL ON)
if (WIN32 OR CYGWIN)
set (MOSQ_SRCS ${MOSQ_SRCS} service.c)
endif (WIN32 OR CYGWIN)
option(WITH_EXTERNAL_SECURITY_CHECKS
"Use external security checks (needs additional code)?" OFF)
if (${WITH_EXTERNAL_SECURITY_CHECKS} STREQUAL ON)
add_definitions("-DWITH_EXTERNAL_SECURITY_CHECKS")
endif (${WITH_EXTERNAL_SECURITY_CHECKS} STREQUAL ON)
add_definitions (-DWITH_BROKER)
add_executable(mosquitto ${MOSQ_SRCS})
if (NOT WIN32)
target_link_libraries(mosquitto ${MOSQ_LIBS})
else (NOT WIN32)
target_link_libraries(mosquitto ws2_32 ${MOSQ_LIBS})
endif (NOT WIN32)
install(TARGETS mosquitto RUNTIME DESTINATION ${SBINDIR} LIBRARY DESTINATION ${LIBDIR})
if (UNIX)
install(CODE "EXEC_PROGRAM(/sbin/ldconfig)")
endif (UNIX)
mosquitto-0.15/src/loop.c 0000664 0001750 0001750 00000021614 11713444064 014437 0 ustar roger roger /*
Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#ifndef WIN32
#include
#else
#include
#include
#include
#endif
#include
#include
#include
#include
#include
#include
extern bool flag_reload;
#ifdef WITH_PERSISTENCE
extern bool flag_db_backup;
#endif
extern bool flag_tree_print;
extern int run;
static void loop_handle_errors(mosquitto_db *db, struct pollfd *pollfds);
static void loop_handle_reads_writes(mosquitto_db *db, struct pollfd *pollfds);
int mosquitto_main_loop(mosquitto_db *db, int *listensock, int listensock_count, int listener_max)
{
time_t start_time = time(NULL);
time_t last_backup = time(NULL);
time_t last_store_clean = time(NULL);
time_t now;
int fdcount;
#ifndef WIN32
sigset_t sigblock, origsig;
#endif
int i;
struct pollfd *pollfds = NULL;
unsigned int pollfd_count = 0;
int client_max = 0;
unsigned int sock_max = 0;
#ifndef WIN32
sigemptyset(&sigblock);
sigaddset(&sigblock, SIGINT);
#endif
while(run){
mqtt3_db_sys_update(db, db->config->sys_interval, start_time);
client_max = -1;
for(i=0; icontext_count; i++){
if(db->contexts[i] && db->contexts[i]->sock != INVALID_SOCKET && db->contexts[i]->sock > client_max){
client_max = db->contexts[i]->sock;
}
}
if(client_max > listener_max){
sock_max = client_max;
}else{
sock_max = listener_max;
}
if(sock_max+1 > pollfd_count){
pollfd_count = sock_max+1;
pollfds = _mosquitto_realloc(pollfds, sizeof(struct pollfd)*pollfd_count);
if(!pollfds){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
}
memset(pollfds, -1, sizeof(struct pollfd)*pollfd_count);
for(i=0; icontext_count; i++){
if(db->contexts[i]){
if(db->contexts[i]->sock != INVALID_SOCKET){
if(db->contexts[i]->sock > sock_max){
sock_max = db->contexts[i]->sock;
}
#ifdef WITH_BRIDGE
if(db->contexts[i]->bridge){
_mosquitto_check_keepalive(db->contexts[i]);
}
#endif
/* Local bridges never time out in this fashion. */
if(!(db->contexts[i]->keepalive) || db->contexts[i]->bridge || now - db->contexts[i]->last_msg_in < (time_t)(db->contexts[i]->keepalive)*3/2){
if(mqtt3_db_message_write(db->contexts[i]) == MOSQ_ERR_SUCCESS){
if(db->contexts[i]->sock < pollfd_count){
pollfds[db->contexts[i]->sock].fd = db->contexts[i]->sock;
pollfds[db->contexts[i]->sock].events = POLLIN;
pollfds[db->contexts[i]->sock].revents = 0;
if(db->contexts[i]->out_packet){
pollfds[db->contexts[i]->sock].events |= POLLOUT;
}
}
}else{
mqtt3_context_disconnect(db, i);
}
}else{
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Client %s has exceeded timeout, disconnecting.", db->contexts[i]->id);
}
/* Client has exceeded keepalive*1.5 */
mqtt3_context_disconnect(db, i);
}
}else{
#ifdef WITH_BRIDGE
if(db->contexts[i]->bridge){
/* Want to try to restart the bridge connection */
if(!db->contexts[i]->bridge->restart_t){
db->contexts[i]->bridge->restart_t = time(NULL)+30;
}else{
if(db->contexts[i]->bridge->start_type == bst_automatic && time(NULL) > db->contexts[i]->bridge->restart_t){
db->contexts[i]->bridge->restart_t = 0;
mqtt3_bridge_connect(db, db->contexts[i]);
}
}
}else{
#endif
if(db->contexts[i]->clean_session == true){
mqtt3_context_cleanup(db, db->contexts[i], true);
db->contexts[i] = NULL;
}
#ifdef WITH_BRIDGE
}
#endif
}
}
}
mqtt3_db_message_timeout_check(db, db->config->retry_interval);
#ifndef WIN32
sigprocmask(SIG_SETMASK, &sigblock, &origsig);
fdcount = poll(pollfds, pollfd_count, 1000);
sigprocmask(SIG_SETMASK, &origsig, NULL);
#else
fdcount = WSAPoll(pollfds, pollfd_count, 1000);
#endif
if(fdcount == -1){
loop_handle_errors(db, pollfds);
}else{
loop_handle_reads_writes(db, pollfds);
for(i=0; iconfig->persistence && db->config->autosave_interval){
if(last_backup + db->config->autosave_interval < now){
mqtt3_db_backup(db, false, false);
last_backup = time(NULL);
}
}
#endif
if(!db->config->store_clean_interval || last_store_clean + db->config->store_clean_interval < now){
mqtt3_db_store_clean(db);
last_store_clean = time(NULL);
}
#ifdef WITH_PERSISTENCE
if(flag_db_backup){
mqtt3_db_backup(db, false, false);
flag_db_backup = false;
}
#endif
if(flag_reload){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Reloading config.");
mqtt3_config_read(db->config, true);
mosquitto_security_cleanup(db);
mosquitto_security_init(db);
mosquitto_security_apply(db);
flag_reload = false;
}
if(flag_tree_print){
mqtt3_sub_tree_print(&db->subs, 0);
flag_tree_print = false;
}
}
if(pollfds) _mosquitto_free(pollfds);
return MOSQ_ERR_SUCCESS;
}
/* Error ocurred, probably an fd has been closed.
* Loop through and check them all.
*/
static void loop_handle_errors(mosquitto_db *db, struct pollfd *pollfds)
{
int i;
for(i=0; icontext_count; i++){
if(db->contexts[i] && db->contexts[i]->sock != INVALID_SOCKET){
if(pollfds[db->contexts[i]->sock].revents & POLLHUP){
if(db->config->connection_messages == true){
if(db->contexts[i]->state != mosq_cs_disconnecting){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Socket error on client %s, disconnecting.", db->contexts[i]->id);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Client %s disconnected.", db->contexts[i]->id);
}
}
mqtt3_context_disconnect(db, i);
}
}
}
}
static void loop_handle_reads_writes(mosquitto_db *db, struct pollfd *pollfds)
{
int i;
for(i=0; icontext_count; i++){
if(db->contexts[i] && db->contexts[i]->sock != INVALID_SOCKET){
if(pollfds[db->contexts[i]->sock].revents & POLLOUT){
if(_mosquitto_packet_write(db->contexts[i])){
if(db->config->connection_messages == true){
if(db->contexts[i]->state != mosq_cs_disconnecting){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Socket write error on client %s, disconnecting.", db->contexts[i]->id);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Client %s disconnected.", db->contexts[i]->id);
}
}
/* Write error or other that means we should disconnect */
mqtt3_context_disconnect(db, i);
}
}
}
if(db->contexts[i] && db->contexts[i]->sock != INVALID_SOCKET){
if(pollfds[db->contexts[i]->sock].revents & POLLIN){
if(_mosquitto_packet_read(db, i)){
if(db->config->connection_messages == true){
if(db->contexts[i]->state != mosq_cs_disconnecting){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Socket read error on client %s, disconnecting.", db->contexts[i]->id);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Client %s disconnected.", db->contexts[i]->id);
}
}
/* Read error or other that means we should disconnect */
mqtt3_context_disconnect(db, i);
}
}
}
}
}
mosquitto-0.15/src/net.c 0000664 0001750 0001750 00000016300 11713444064 014250 0 ustar roger roger /*
Copyright (c) 2009-2011 Roger Light
Copyright (c) 2011 Yuvraaj Kelkar
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#ifndef WIN32
#include
#include
#else
#include
#include
#endif
#include
#include
#include
#include
#include
#ifdef WITH_WRAP
#include
#endif
#ifdef __QNX__
#include
#include
#include
#endif
#include
#include
#include
#include
uint64_t bytes_received = 0;
uint64_t bytes_sent = 0;
unsigned long msgs_received = 0;
unsigned long msgs_sent = 0;
int mqtt3_socket_accept(struct _mosquitto_db *db, int listensock)
{
int i;
int j;
int new_sock = -1;
struct mosquitto **tmp_contexts = NULL;
struct mosquitto *new_context;
int opt = 1;
#ifdef WITH_WRAP
struct request_info wrap_req;
#endif
new_sock = accept(listensock, NULL, 0);
if(new_sock == INVALID_SOCKET) return -1;
#ifndef WIN32
/* Set non-blocking */
opt = fcntl(new_sock, F_GETFL, 0);
if(opt == -1 || fcntl(new_sock, F_SETFL, opt | O_NONBLOCK) == -1){
/* If either fcntl fails, don't want to allow this client to connect. */
close(new_sock);
return -1;
}
#else
if(ioctlsocket(new_sock, FIONBIO, &opt)){
closesocket(new_sock);
return INVALID_SOCKET;
}
#endif
#ifdef WITH_WRAP
/* Use tcpd / libwrap to determine whether a connection is allowed. */
request_init(&wrap_req, RQ_FILE, new_sock, RQ_DAEMON, "mosquitto", 0);
fromhost(&wrap_req);
if(!hosts_access(&wrap_req)){
/* Access is denied */
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Client connection denied access by tcpd.");
COMPAT_CLOSE(new_sock);
return -1;
}else{
#endif
new_context = mqtt3_context_init(new_sock);
if(!new_context){
COMPAT_CLOSE(new_sock);
return -1;
}
for(i=0; iconfig->listener_count; i++){
for(j=0; jconfig->listeners[i].sock_count; j++){
if(db->config->listeners[i].socks[j] == listensock){
new_context->listener = &db->config->listeners[i];
break;
}
}
}
if(!new_context->listener){
COMPAT_CLOSE(new_sock);
return -1;
}
if(new_context->listener->max_connections > 0 && new_context->listener->client_count >= new_context->listener->max_connections){
COMPAT_CLOSE(new_sock);
return -1;
}
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "New connection from %s.", new_context->address);
for(i=0; icontext_count; i++){
if(db->contexts[i] == NULL){
db->contexts[i] = new_context;
break;
}
}
if(i==db->context_count){
tmp_contexts = _mosquitto_realloc(db->contexts, sizeof(struct mosquitto*)*(db->context_count+1));
if(tmp_contexts){
db->context_count++;
db->contexts = tmp_contexts;
db->contexts[db->context_count-1] = new_context;
}else{
mqtt3_context_cleanup(NULL, new_context, true);
}
}
new_context->listener->client_count++;
#ifdef WITH_WRAP
}
#endif
return new_sock;
}
/* Creates a socket and listens on port 'port'.
* Returns 1 on failure
* Returns 0 on success.
*/
int mqtt3_socket_listen(struct _mqtt3_listener *listener)
{
int sock = -1;
struct addrinfo hints;
struct addrinfo *ainfo, *rp;
char service[10];
int opt = 1;
#ifndef WIN32
int ss_opt = 1;
#else
char ss_opt = 1;
#endif
if(!listener) return MOSQ_ERR_INVAL;
snprintf(service, 10, "%d", listener->port);
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = PF_UNSPEC;
hints.ai_flags = AI_PASSIVE;
hints.ai_socktype = SOCK_STREAM;
if(getaddrinfo(listener->host, service, &hints, &ainfo)) return INVALID_SOCKET;
listener->sock_count = 0;
listener->socks = NULL;
for(rp = ainfo; rp; rp = rp->ai_next){
if(rp->ai_family == AF_INET){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Opening ipv4 listen socket on port %d.", ntohs(((struct sockaddr_in *)rp->ai_addr)->sin_port));
}else if(rp->ai_family == AF_INET6){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Opening ipv6 listen socket on port %d.", ntohs(((struct sockaddr_in6 *)rp->ai_addr)->sin6_port));
}else{
continue;
}
sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if(sock == -1){
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: %s", strerror(errno));
continue;
}
listener->sock_count++;
listener->socks = _mosquitto_realloc(listener->socks, sizeof(int)*listener->sock_count);
if(!listener->socks){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
listener->socks[listener->sock_count-1] = sock;
#ifndef WIN32
ss_opt = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &ss_opt, sizeof(ss_opt));
#endif
ss_opt = 1;
setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &ss_opt, sizeof(ss_opt));
#ifndef WIN32
/* Set non-blocking */
opt = fcntl(sock, F_GETFL, 0);
if(opt == -1 || fcntl(sock, F_SETFL, opt | O_NONBLOCK) == -1){
/* If either fcntl fails, don't want to allow this client to connect. */
COMPAT_CLOSE(sock);
return 1;
}
#else
if(ioctlsocket(sock, FIONBIO, &opt)){
COMPAT_CLOSE(sock);
return 1;
}
#endif
if(bind(sock, rp->ai_addr, rp->ai_addrlen) == -1){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s", strerror(errno));
COMPAT_CLOSE(sock);
return 1;
}
if(listen(sock, 100) == -1){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s", strerror(errno));
COMPAT_CLOSE(sock);
return 1;
}
}
freeaddrinfo(ainfo);
/* We need to have at least one working socket. */
if(listener->sock_count > 0){
return 0;
}else{
return 1;
}
}
uint64_t mqtt3_net_bytes_total_received(void)
{
return bytes_received;
}
uint64_t mqtt3_net_bytes_total_sent(void)
{
return bytes_sent;
}
unsigned long mqtt3_net_msgs_total_received(void)
{
return msgs_received;
}
unsigned long mqtt3_net_msgs_total_sent(void)
{
return msgs_sent;
}
mosquitto-0.15/src/send_server.c 0000664 0001750 0001750 00000006003 11713444064 016000 0 ustar roger roger /*
Copyright (c) 2009-2011 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
int _mosquitto_send_connack(struct mosquitto *context, uint8_t result)
{
struct _mosquitto_packet *packet = NULL;
int rc;
if(context){
if(context->id){
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Sending CONNACK to %s (%d)", context->id, result);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Sending CONNACK to %s (%d)", context->address, result);
}
}
packet = _mosquitto_calloc(1, sizeof(struct _mosquitto_packet));
if(!packet) return MOSQ_ERR_NOMEM;
packet->command = CONNACK;
packet->remaining_length = 2;
rc = _mosquitto_packet_alloc(packet);
if(rc){
_mosquitto_free(packet);
return rc;
}
packet->payload[packet->pos+0] = 0;
packet->payload[packet->pos+1] = result;
return _mosquitto_packet_queue(context, packet);
}
int _mosquitto_send_suback(struct mosquitto *context, uint16_t mid, uint32_t payloadlen, const uint8_t *payload)
{
struct _mosquitto_packet *packet = NULL;
int rc;
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Sending SUBACK to %s", context->id);
packet = _mosquitto_calloc(1, sizeof(struct _mosquitto_packet));
if(!packet) return MOSQ_ERR_NOMEM;
packet->command = SUBACK;
packet->remaining_length = 2+payloadlen;
rc = _mosquitto_packet_alloc(packet);
if(rc){
_mosquitto_free(packet);
return rc;
}
_mosquitto_write_uint16(packet, mid);
if(payloadlen){
_mosquitto_write_bytes(packet, payload, payloadlen);
}
return _mosquitto_packet_queue(context, packet);
}
mosquitto-0.15/src/context.c 0000664 0001750 0001750 00000012647 11713444064 015160 0 ustar roger roger /*
Copyright (c) 2009-2011 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#ifndef WIN32
#include
#include
#else
#include
#endif
#include
#include
#include
struct mosquitto *mqtt3_context_init(int sock)
{
struct mosquitto *context;
struct sockaddr_storage addr;
socklen_t addrlen;
char address[1024];
context = _mosquitto_malloc(sizeof(struct mosquitto));
if(!context) return NULL;
context->state = mosq_cs_new;
context->sock = sock;
context->last_msg_in = time(NULL);
context->last_msg_out = time(NULL);
context->keepalive = 60; /* Default to 60s */
context->clean_session = true;
context->id = NULL;
context->last_mid = 0;
context->will = NULL;
context->username = NULL;
context->password = NULL;
context->listener = NULL;
context->acl_list = NULL;
context->in_packet.payload = NULL;
_mosquitto_packet_cleanup(&context->in_packet);
context->out_packet = NULL;
addrlen = sizeof(addr);
context->address = NULL;
if(!getpeername(sock, (struct sockaddr *)&addr, &addrlen)){
if(addr.ss_family == AF_INET){
if(inet_ntop(AF_INET, &((struct sockaddr_in *)&addr)->sin_addr.s_addr, address, 1024)){
context->address = _mosquitto_strdup(address);
}
}else if(addr.ss_family == AF_INET6){
if(inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&addr)->sin6_addr.s6_addr, address, 1024)){
context->address = _mosquitto_strdup(address);
}
}
}
if(!context->address && sock != -1){
/* getpeername and inet_ntop failed and not a bridge */
_mosquitto_free(context);
return NULL;
}
context->bridge = NULL;
context->msgs = NULL;
#ifdef WITH_SSL
context->ssl = NULL;
#endif
return context;
}
/*
* This will result in any outgoing packets going unsent. If we're disconnected
* forcefully then it is usually an error condition and shouldn't be a problem,
* but it will mean that CONNACK messages will never get sent for bad protocol
* versions for example.
*/
void mqtt3_context_cleanup(mosquitto_db *db, struct mosquitto *context, bool do_free)
{
struct _mosquitto_packet *packet;
mosquitto_client_msg *msg, *next;
if(!context) return;
if(context->username){
_mosquitto_free(context->username);
context->username = NULL;
}
if(context->password){
_mosquitto_free(context->password);
context->password = NULL;
}
if(context->sock != -1){
if(context->listener){
context->listener->client_count--;
assert(context->listener->client_count >= 0);
}
_mosquitto_socket_close(context);
context->listener = NULL;
}
if(context->clean_session && db){
mqtt3_subs_clean_session(context, &db->subs);
mqtt3_db_messages_delete(context);
}
if(context->address){
_mosquitto_free(context->address);
context->address = NULL;
}
if(context->id){
_mosquitto_free(context->id);
context->id = NULL;
}
_mosquitto_packet_cleanup(&(context->in_packet));
while(context->out_packet){
_mosquitto_packet_cleanup(context->out_packet);
packet = context->out_packet;
context->out_packet = context->out_packet->next;
_mosquitto_free(packet);
}
if(context->will){
if(context->will->topic) _mosquitto_free(context->will->topic);
if(context->will->payload) _mosquitto_free(context->will->payload);
_mosquitto_free(context->will);
}
if(do_free || context->clean_session){
msg = context->msgs;
while(msg){
next = msg->next;
msg->store->ref_count--;
_mosquitto_free(msg);
msg = next;
}
context->msgs = NULL;
}
if(do_free){
_mosquitto_free(context);
}
}
void mqtt3_context_disconnect(mosquitto_db *db, int context_index)
{
struct mosquitto *ctxt;
ctxt = db->contexts[context_index];
if(ctxt->state != mosq_cs_disconnecting && ctxt->will){
/* Unexpected disconnect, queue the client will. */
mqtt3_db_messages_easy_queue(db, ctxt, ctxt->will->topic, ctxt->will->qos, ctxt->will->payloadlen, ctxt->will->payload, ctxt->will->retain);
}
if(ctxt->listener){
ctxt->listener->client_count--;
assert(ctxt->listener->client_count >= 0);
ctxt->listener = NULL;
}
_mosquitto_socket_close(ctxt);
}
mosquitto-0.15/src/read_handle_server.c 0000664 0001750 0001750 00000032165 11713444064 017305 0 ustar roger roger /*
Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
#include
#include
int mqtt3_handle_connect(mosquitto_db *db, int context_index)
{
char *protocol_name;
uint8_t protocol_version;
uint8_t connect_flags;
char *client_id;
char *will_message = NULL, *will_topic = NULL;
struct mosquitto_message *will_struct = NULL;
uint8_t will, will_retain, will_qos, clean_session;
uint8_t username_flag, password_flag;
char *username, *password = NULL;
int i;
int rc;
struct _mosquitto_acl_user *acl_tail;
struct mosquitto *context;
context = db->contexts[context_index];
/* Don't accept multiple CONNECT commands. */
if(context->state != mosq_cs_new){
mqtt3_context_disconnect(db, context_index);
return MOSQ_ERR_PROTOCOL;
}
if(_mosquitto_read_string(&context->in_packet, &protocol_name)){
mqtt3_context_disconnect(db, context_index);
return 1;
}
if(!protocol_name){
mqtt3_context_disconnect(db, context_index);
return 3;
}
if(strcmp(protocol_name, PROTOCOL_NAME)){
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Invalid protocol \"%s\" in CONNECT from %s.",
protocol_name, context->address);
}
_mosquitto_free(protocol_name);
mqtt3_context_disconnect(db, context_index);
return MOSQ_ERR_PROTOCOL;
}
_mosquitto_free(protocol_name);
if(_mosquitto_read_byte(&context->in_packet, &protocol_version)){
mqtt3_context_disconnect(db, context_index);
return 1;
}
if(protocol_version != PROTOCOL_VERSION){
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Invalid protocol version %d in CONNECT from %s.",
protocol_version, context->address);
}
_mosquitto_free(protocol_name);
_mosquitto_send_connack(context, 1);
mqtt3_context_disconnect(db, context_index);
return MOSQ_ERR_PROTOCOL;
}
if(_mosquitto_read_byte(&context->in_packet, &connect_flags)){
mqtt3_context_disconnect(db, context_index);
return 1;
}
clean_session = connect_flags & 0x02;
will = connect_flags & 0x04;
will_qos = (connect_flags & 0x18) >> 3;
will_retain = connect_flags & 0x20;
password_flag = connect_flags & 0x40;
username_flag = connect_flags & 0x80;
if(_mosquitto_read_uint16(&context->in_packet, &(context->keepalive))){
mqtt3_context_disconnect(db, context_index);
return 1;
}
if(_mosquitto_read_string(&context->in_packet, &client_id)){
mqtt3_context_disconnect(db, context_index);
return 1;
}
/* clientid_prefixes check */
if(db->config->clientid_prefixes){
if(strncmp(db->config->clientid_prefixes, client_id, strlen(db->config->clientid_prefixes))){
_mosquitto_free(client_id);
_mosquitto_send_connack(context, 2);
mqtt3_context_disconnect(db, context_index);
return MOSQ_ERR_SUCCESS;
}
}
if(will){
will_struct = _mosquitto_calloc(1, sizeof(struct mosquitto_message));
if(!will_struct){
_mosquitto_free(client_id);
mqtt3_context_disconnect(db, context_index);
return MOSQ_ERR_NOMEM;
}
if(_mosquitto_read_string(&context->in_packet, &will_topic)){
_mosquitto_free(client_id);
mqtt3_context_disconnect(db, context_index);
return 1;
}
if(_mosquitto_read_string(&context->in_packet, &will_message)){
_mosquitto_free(client_id);
mqtt3_context_disconnect(db, context_index);
return 1;
}
}
if(username_flag){
rc = _mosquitto_read_string(&context->in_packet, &username);
if(rc == MOSQ_ERR_SUCCESS){
if(password_flag){
rc = _mosquitto_read_string(&context->in_packet, &password);
if(rc == MOSQ_ERR_NOMEM){
_mosquitto_free(username);
_mosquitto_free(client_id);
return MOSQ_ERR_NOMEM;
}else if(rc == MOSQ_ERR_PROTOCOL){
/* Password flag given, but no password. Ignore. */
password_flag = 0;
}
}
rc = mosquitto_unpwd_check(db, username, password);
context->username = username;
context->password = password;
if(rc == MOSQ_ERR_AUTH){
_mosquitto_send_connack(context, 2);
mqtt3_context_disconnect(db, context_index);
_mosquitto_free(client_id);
return MOSQ_ERR_SUCCESS;
}else if(rc == MOSQ_ERR_INVAL){
_mosquitto_free(client_id);
return MOSQ_ERR_INVAL;
}
}else if(rc == MOSQ_ERR_NOMEM){
_mosquitto_free(client_id);
return MOSQ_ERR_NOMEM;
}else{
/* Username flag given, but no username. Ignore. */
username_flag = 0;
}
}
if(!username_flag && db->config->allow_anonymous == false){
_mosquitto_send_connack(context, 2);
mqtt3_context_disconnect(db, context_index);
_mosquitto_free(client_id);
return MOSQ_ERR_SUCCESS;
}
/* Find if this client already has an entry. This must be done *after* any security checks. */
for(i=0; icontext_count; i++){
if(db->contexts[i] && db->contexts[i]->id && !strcmp(db->contexts[i]->id, client_id)){
/* Client does match. */
if(db->contexts[i]->sock == -1){
/* Client is reconnecting after a disconnect */
/* FIXME - does anything else need to be done here? */
}else{
/* Client is already connected, disconnect old version */
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Client %s already connected, closing old connection.", client_id);
}
}
db->contexts[i]->clean_session = clean_session;
mqtt3_context_cleanup(db, db->contexts[i], false);
db->contexts[i]->state = mosq_cs_connected;
db->contexts[i]->address = _mosquitto_strdup(context->address);
db->contexts[i]->sock = context->sock;
db->contexts[i]->listener = context->listener;
db->contexts[i]->last_msg_in = time(NULL);
db->contexts[i]->last_msg_out = time(NULL);
db->contexts[i]->keepalive = context->keepalive;
context->sock = -1;
context->state = mosq_cs_disconnecting;
context = db->contexts[i];
if(context->msgs){
/* Messages received when the client was disconnected are put
* in the ms_queued state. If we don't change them to the
* appropriate "publish" state, then the queued messages won't
* get sent until the client next receives a message - and they
* will be sent out of order.
* This only sets a single message up to be published, but once
* it is sent the full max_inflight amount of messages will be
* queued up for sending.
*/
if(context->msgs->state == ms_queued && context->msgs->direction == mosq_md_out){
switch(context->msgs->qos){
case 0:
context->msgs->state = ms_publish;
break;
case 1:
context->msgs->state = ms_publish_puback;
break;
case 2:
context->msgs->state = ms_publish_pubrec;
break;
}
}
}
break;
}
}
context->id = client_id;
context->clean_session = clean_session;
context->will = will_struct;
if(context->will){
context->will->topic = will_topic;
if(will_message){
context->will->payload = (uint8_t *)will_message;
context->will->payloadlen = strlen(will_message);
}else{
context->will->payload = NULL;
context->will->payloadlen = 0;
}
context->will->qos = will_qos;
context->will->retain = will_retain;
}
/* Associate user with its ACL, assuming we have ACLs loaded. */
if(db->acl_list){
acl_tail = db->acl_list;
while(acl_tail){
if(context->username){
if(acl_tail->username && !strcmp(context->username, acl_tail->username)){
context->acl_list = acl_tail;
break;
}
}else{
if(acl_tail->username == NULL){
context->acl_list = acl_tail;
break;
}
}
acl_tail = acl_tail->next;
}
}else{
context->acl_list = NULL;
}
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "New client connected from %s as %s.", context->address, client_id);
}
context->state = mosq_cs_connected;
return _mosquitto_send_connack(context, 0);
}
int mqtt3_handle_disconnect(mosquitto_db *db, int context_index)
{
struct mosquitto *context;
context = db->contexts[context_index];
if(!context){
return MOSQ_ERR_INVAL;
}
if(context->in_packet.remaining_length != 0){
return MOSQ_ERR_PROTOCOL;
}
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Received DISCONNECT from %s", context->id);
context->state = mosq_cs_disconnecting;
mqtt3_context_disconnect(db, context_index);
return MOSQ_ERR_SUCCESS;
}
int mqtt3_handle_subscribe(mosquitto_db *db, struct mosquitto *context)
{
int rc = 0;
int rc2;
uint16_t mid;
char *sub;
uint8_t qos;
uint8_t *payload = NULL, *tmp_payload;
uint32_t payloadlen = 0;
int len;
char *sub_mount;
if(!context) return MOSQ_ERR_INVAL;
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Received SUBSCRIBE from %s", context->id);
/* FIXME - plenty of potential for memory leaks here */
if(_mosquitto_read_uint16(&context->in_packet, &mid)) return 1;
while(context->in_packet.pos < context->in_packet.remaining_length){
sub = NULL;
if(_mosquitto_read_string(&context->in_packet, &sub)){
if(payload) _mosquitto_free(payload);
return 1;
}
if(sub){
if(_mosquitto_read_byte(&context->in_packet, &qos)){
_mosquitto_free(sub);
if(payload) _mosquitto_free(payload);
return 1;
}
if(qos > 2){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Invalid QoS in subscription command from %s, disconnecting.",
context->address);
_mosquitto_free(sub);
if(payload) _mosquitto_free(payload);
return 1;
}
if(_mosquitto_fix_sub_topic(&sub)){
_mosquitto_free(sub);
if(payload) _mosquitto_free(payload);
return 1;
}
if(!strlen(sub)){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Empty subscription string from %s, disconnecting.",
context->address);
_mosquitto_free(sub);
if(payload) _mosquitto_free(payload);
return 1;
}
if(context->listener && context->listener->mount_point){
len = strlen(context->listener->mount_point) + strlen(sub) + 1;
sub_mount = _mosquitto_calloc(len, sizeof(char));
if(!sub_mount){
_mosquitto_free(sub);
if(payload) _mosquitto_free(payload);
return MOSQ_ERR_NOMEM;
}
snprintf(sub_mount, len, "%s%s", context->listener->mount_point, sub);
_mosquitto_free(sub);
sub = sub_mount;
}
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "\t%s (QoS %d)", sub, qos);
/* FIXME - need to deny access to retained messages. */
#if 0
/* Check for topic access */
rc2 = mqtt3_acl_check(db, context, sub, MOSQ_ACL_READ);
if(rc2 == MOSQ_ERR_SUCCESS){
mqtt3_sub_add(context, sub, qos, &db->subs);
if(mqtt3_retain_queue(db, context, sub, qos)) rc = 1;
}else if(rc2 != MOSQ_ERR_ACL_DENIED){
rc = 1;
}
#else
rc2 = mqtt3_sub_add(context, sub, qos, &db->subs);
if(rc2 == MOSQ_ERR_SUCCESS){
if(mqtt3_retain_queue(db, context, sub, qos)) rc = 1;
}else if(rc2 != -1){
rc = rc2;
}
#endif
_mosquitto_free(sub);
tmp_payload = _mosquitto_realloc(payload, payloadlen + 1);
if(tmp_payload){
payload = tmp_payload;
payload[payloadlen] = qos;
payloadlen++;
}else{
if(payload) _mosquitto_free(payload);
return MOSQ_ERR_NOMEM;
}
}
}
if(_mosquitto_send_suback(context, mid, payloadlen, payload)) rc = 1;
_mosquitto_free(payload);
return rc;
}
int mqtt3_handle_unsubscribe(mosquitto_db *db, struct mosquitto *context)
{
uint16_t mid;
char *sub;
if(!context) return MOSQ_ERR_INVAL;
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Received UNSUBSCRIBE from %s", context->id);
if(_mosquitto_read_uint16(&context->in_packet, &mid)) return 1;
while(context->in_packet.pos < context->in_packet.remaining_length){
sub = NULL;
if(_mosquitto_read_string(&context->in_packet, &sub)){
return 1;
}
if(sub){
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "\t%s", sub);
mqtt3_sub_remove(context, sub, &db->subs);
_mosquitto_free(sub);
}
}
return _mosquitto_send_command_with_mid(context, UNSUBACK, mid, false);
}
mosquitto-0.15/src/read_handle_client.c 0000664 0001750 0001750 00000007446 11713444064 017261 0 ustar roger roger /*
Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
#include
int mqtt3_handle_connack(mosquitto_db *db, struct mosquitto *context)
{
uint8_t byte;
uint8_t rc;
int i;
char *notification_topic;
int notification_topic_len;
uint8_t notification_payload[2];
if(!context){
return MOSQ_ERR_INVAL;
}
#ifdef WITH_STRICT_PROTOCOL
if(context->in_packet.remaining_length != 2){
return MOSQ_ERR_PROTOCOL;
}
#endif
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Received CONNACK on connection %s.", context->id);
if(_mosquitto_read_byte(&context->in_packet, &byte)) return 1; // Reserved byte, not used
if(_mosquitto_read_byte(&context->in_packet, &rc)) return 1;
switch(rc){
case 0:
if(context->bridge){
if(context->bridge->notifications){
notification_topic_len = strlen(context->id)+strlen("$SYS/broker/connection//state");
notification_topic = _mosquitto_malloc(sizeof(char)*(notification_topic_len+1));
if(!notification_topic) return MOSQ_ERR_NOMEM;
snprintf(notification_topic, notification_topic_len+1, "$SYS/broker/connection/%s/state", context->id);
notification_payload[0] = '1';
notification_payload[1] = '\0';
if(_mosquitto_send_real_publish(context, _mosquitto_mid_generate(context),
notification_topic, 2, (uint8_t *)¬ification_payload, 1, true, 0)){
_mosquitto_free(notification_topic);
return 1;
}
mqtt3_db_messages_easy_queue(db, context, notification_topic, 1, 2, (uint8_t *)¬ification_payload, 1);
_mosquitto_free(notification_topic);
}
for(i=0; ibridge->topic_count; i++){
if(context->bridge->topics[i].direction == bd_in || context->bridge->topics[i].direction == bd_both){
if(_mosquitto_send_subscribe(context, NULL, false, context->bridge->topics[i].topic, 2)){
return 1;
}
}
}
}
context->state = mosq_cs_connected;
return MOSQ_ERR_SUCCESS;
case 1:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Connection Refused: unacceptable protocol version");
return 1;
case 2:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Connection Refused: identifier rejected");
return 1;
case 3:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Connection Refused: broker unavailable");
return 1;
}
return 1;
}
mosquitto-0.15/src/security.c 0000664 0001750 0001750 00000044477 11713444064 015351 0 ustar roger roger /*
Copyright (c) 2011,2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
int mosquitto_security_init(mosquitto_db *db)
{
int rc;
#ifdef WITH_EXTERNAL_SECURITY_CHECKS
rc = mosquitto_unpwd_init(db);
if(rc){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error initialising passwords.");
return rc;
}
rc = mosquitto_acl_init(db);
if(rc){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error initialising ACLs.");
return rc;
}
#else
/* Load username/password data if required. */
if(db->config->password_file){
rc = mqtt3_pwfile_parse(db);
if(rc){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error opening password file.");
return rc;
}
}
/* Load acl data if required. */
if(db->config->acl_file){
rc = mqtt3_aclfile_parse(db);
if(rc){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error opening acl file.");
return rc;
}
}
#endif
return MOSQ_ERR_SUCCESS;
}
void mosquitto_security_cleanup(mosquitto_db *db)
{
mosquitto_acl_cleanup(db);
mosquitto_unpwd_cleanup(db);
}
#ifndef WITH_EXTERNAL_SECURITY_CHECKS
int _add_acl(struct _mosquitto_db *db, const char *user, const char *topic, int access)
{
struct _mosquitto_acl_user *acl_user=NULL, *user_tail;
struct _mosquitto_acl *acl, *acl_root=NULL, *acl_tail=NULL;
char *local_topic;
char *token = NULL;
bool new_user = false;
if(!db || !topic) return MOSQ_ERR_INVAL;
local_topic = _mosquitto_strdup(topic);
if(!local_topic){
return MOSQ_ERR_NOMEM;
}
if(db->acl_list){
user_tail = db->acl_list;
while(user_tail){
if(user == NULL){
if(user_tail->username == NULL){
acl_user = user_tail;
break;
}
}else if(user_tail->username && !strcmp(user_tail->username, user)){
acl_user = user_tail;
break;
}
user_tail = user_tail->next;
}
}
if(!acl_user){
acl_user = _mosquitto_malloc(sizeof(struct _mosquitto_acl_user));
if(!acl_user){
_mosquitto_free(local_topic);
return MOSQ_ERR_NOMEM;
}
new_user = true;
if(user){
acl_user->username = _mosquitto_strdup(user);
if(!acl_user->username){
_mosquitto_free(local_topic);
_mosquitto_free(acl_user);
return MOSQ_ERR_NOMEM;
}
}else{
acl_user->username = NULL;
}
acl_user->next = NULL;
acl_user->acl = NULL;
}
/* Tokenise topic */
if(local_topic[0] == '/'){
acl_root = _mosquitto_malloc(sizeof(struct _mosquitto_acl));
if(!acl_root) return MOSQ_ERR_NOMEM;
acl_tail = acl_root;
acl_root->child = NULL;
acl_root->next = NULL;
acl_root->access = MOSQ_ACL_NONE;
acl_root->topic = _mosquitto_strdup("/");
if(!acl_root->topic) return MOSQ_ERR_NOMEM;
token = strtok(local_topic+1, "/");
}else{
token = strtok(local_topic, "/");
}
while(token){
acl = _mosquitto_malloc(sizeof(struct _mosquitto_acl));
if(!acl) return MOSQ_ERR_NOMEM;
acl->child = NULL;
acl->next = NULL;
acl->access = MOSQ_ACL_NONE;
acl->topic = _mosquitto_strdup(token);
if(!acl->topic) return MOSQ_ERR_NOMEM;
if(acl_root){
acl_tail->child = acl;
acl_tail = acl;
}else{
acl_root = acl;
acl_tail = acl;
}
token = strtok(NULL, "/");
}
if(acl_root){
acl_tail = acl_root;
while(acl_tail->child){
acl_tail = acl_tail->child;
}
acl_tail->access = access;
}else{
return MOSQ_ERR_INVAL;
}
/* Add acl to user acl list */
if(acl_user->acl){
acl_tail = acl_user->acl;
while(acl_tail->next){
acl_tail = acl_tail->next;
}
acl_tail->next = acl_root;
}else{
acl_user->acl = acl_root;
}
if(new_user){
/* Add to end of list */
if(db->acl_list){
user_tail = db->acl_list;
while(user_tail->next){
user_tail = user_tail->next;
}
user_tail->next = acl_user;
}else{
db->acl_list = acl_user;
}
}
_mosquitto_free(local_topic);
return MOSQ_ERR_SUCCESS;
}
int _add_acl_pattern(struct _mosquitto_db *db, const char *topic, int access)
{
struct _mosquitto_acl *acl, *acl_root=NULL, *acl_tail=NULL;
char *local_topic;
char *token = NULL;
if(!db || !topic) return MOSQ_ERR_INVAL;
local_topic = _mosquitto_strdup(topic);
if(!local_topic){
return MOSQ_ERR_NOMEM;
}
/* Tokenise topic */
if(local_topic[0] == '/'){
acl_root = _mosquitto_malloc(sizeof(struct _mosquitto_acl));
if(!acl_root) return MOSQ_ERR_NOMEM;
acl_tail = acl_root;
acl_root->child = NULL;
acl_root->next = NULL;
acl_root->access = MOSQ_ACL_NONE;
acl_root->topic = _mosquitto_strdup("/");
if(!acl_root->topic) return MOSQ_ERR_NOMEM;
token = strtok(local_topic+1, "/");
}else{
token = strtok(local_topic, "/");
}
while(token){
acl = _mosquitto_malloc(sizeof(struct _mosquitto_acl));
if(!acl) return MOSQ_ERR_NOMEM;
acl->child = NULL;
acl->next = NULL;
acl->access = MOSQ_ACL_NONE;
acl->topic = _mosquitto_strdup(token);
if(!acl->topic) return MOSQ_ERR_NOMEM;
if(acl_root){
acl_tail->child = acl;
acl_tail = acl;
}else{
acl_root = acl;
acl_tail = acl;
}
token = strtok(NULL, "/");
}
if(acl_root){
acl_tail = acl_root;
while(acl_tail->child){
acl_tail = acl_tail->child;
}
acl_tail->access = access;
if(db->acl_patterns){
acl_tail = db->acl_patterns;
while(acl_tail->next){
acl_tail = acl_tail->next;
}
acl_tail->next = acl_root;
}else{
db->acl_patterns = acl_root;
}
}else{
return MOSQ_ERR_INVAL;
}
_mosquitto_free(local_topic);
return MOSQ_ERR_SUCCESS;
}
int mosquitto_acl_check(struct _mosquitto_db *db, struct mosquitto *context, const char *topic, int access)
{
char *local_topic;
char *token;
struct _mosquitto_acl *acl_root, *acl_tail;
if(!db || !context || !topic) return MOSQ_ERR_INVAL;
if(!db->acl_list) return MOSQ_ERR_SUCCESS;
if(!context->acl_list && !db->acl_patterns) return MOSQ_ERR_ACL_DENIED;
if(context->acl_list){
acl_root = context->acl_list->acl;
}else{
acl_root = NULL;
}
/* Loop through all ACLs for this client. */
while(acl_root){
local_topic = _mosquitto_strdup(topic);
if(!local_topic) return MOSQ_ERR_NOMEM;
acl_tail = acl_root;
if(local_topic[0] == '/'){
if(strcmp(acl_tail->topic, "/")){
acl_root = acl_root->next;
continue;
}
acl_tail = acl_tail->child;
}
token = strtok(local_topic, "/");
/* Loop through the topic looking for matches to this ACL. */
while(token){
if(acl_tail){
if(!strcmp(acl_tail->topic, "#") && acl_tail->child == NULL){
/* We have a match */
if(access & acl_tail->access){
/* And access is allowed. */
_mosquitto_free(local_topic);
return MOSQ_ERR_SUCCESS;
}else{
break;
}
}else if(!strcmp(acl_tail->topic, token) || !strcmp(acl_tail->topic, "+")){
token = strtok(NULL, "/");
if(!token && acl_tail->child == NULL){
/* We have a match */
if(access & acl_tail->access){
/* And access is allowed. */
_mosquitto_free(local_topic);
return MOSQ_ERR_SUCCESS;
}else{
break;
}
}
}else{
break;
}
acl_tail = acl_tail->child;
}else{
break;
}
}
_mosquitto_free(local_topic);
acl_root = acl_root->next;
}
acl_root = db->acl_patterns;
/* Loop through all pattern ACLs. */
while(acl_root){
local_topic = _mosquitto_strdup(topic);
if(!local_topic) return MOSQ_ERR_NOMEM;
acl_tail = acl_root;
if(local_topic[0] == '/'){
if(strcmp(acl_tail->topic, "/")){
acl_root = acl_root->next;
continue;
}
acl_tail = acl_tail->child;
}
token = strtok(local_topic, "/");
/* Loop through the topic looking for matches to this ACL. */
while(token){
if(acl_tail){
if(!strcmp(acl_tail->topic, "#") && acl_tail->child == NULL){
/* We have a match */
if(access & acl_tail->access){
/* And access is allowed. */
_mosquitto_free(local_topic);
return MOSQ_ERR_SUCCESS;
}else{
break;
}
}else if(!strcmp(acl_tail->topic, "%c")){
if(!context->id || strcmp(token, context->id)){
/* No access */
break;
}
token = strtok(NULL, "/");
if(!token && acl_tail->child == NULL){
/* We have a match */
if(access & acl_tail->access){
/* And access is allowed. */
_mosquitto_free(local_topic);
return MOSQ_ERR_SUCCESS;
}else{
break;
}
}
}else if(!strcmp(acl_tail->topic, "%u")){
if(!context->username || strcmp(token, context->username)){
/* No access */
break;
}
token = strtok(NULL, "/");
if(!token && acl_tail->child == NULL){
/* We have a match */
if(access & acl_tail->access){
/* And access is allowed. */
_mosquitto_free(local_topic);
return MOSQ_ERR_SUCCESS;
}else{
break;
}
}
}else if(!strcmp(acl_tail->topic, token) || !strcmp(acl_tail->topic, "+")){
token = strtok(NULL, "/");
if(!token && acl_tail->child == NULL){
/* We have a match */
if(access & acl_tail->access){
/* And access is allowed. */
_mosquitto_free(local_topic);
return MOSQ_ERR_SUCCESS;
}else{
break;
}
}
}else{
break;
}
acl_tail = acl_tail->child;
}else{
break;
}
}
_mosquitto_free(local_topic);
acl_root = acl_root->next;
}
return MOSQ_ERR_ACL_DENIED;
}
int mqtt3_aclfile_parse(struct _mosquitto_db *db)
{
FILE *aclfile;
char buf[1024];
char *token;
char *user = NULL;
char *topic;
char *access_s;
int access;
int rc;
int slen;
int topic_pattern;
if(!db || !db->config) return MOSQ_ERR_INVAL;
if(!db->config->acl_file) return MOSQ_ERR_SUCCESS;
aclfile = fopen(db->config->acl_file, "rt");
if(!aclfile) return 1;
// topic [read|write]
// user
while(fgets(buf, 1024, aclfile)){
slen = strlen(buf);
while(slen > 0 && (buf[slen-1] == 10 || buf[slen-1] == 13)){
buf[slen-1] = '\0';
slen = strlen(buf);
}
token = strtok(buf, " ");
if(token){
if(!strcmp(token, "topic") || !strcmp(token, "pattern")){
if(!strcmp(token, "topic")){
topic_pattern = 0;
}else{
topic_pattern = 1;
}
access_s = strtok(NULL, " ");
if(!access_s){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty topic in acl_file.");
if(user) _mosquitto_free(user);
fclose(aclfile);
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
topic = token;
}else{
topic = access_s;
access_s = NULL;
}
if(access_s){
if(!strcmp(access_s, "read")){
access = MOSQ_ACL_READ;
}else if(!strcmp(access_s, "write")){
access = MOSQ_ACL_WRITE;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty invalid topic access type in acl_file.");
if(user) _mosquitto_free(user);
fclose(aclfile);
return MOSQ_ERR_INVAL;
}
}else{
access = MOSQ_ACL_READ | MOSQ_ACL_WRITE;
}
if(topic_pattern == 0){
rc = _add_acl(db, user, topic, access);
}else{
rc = _add_acl_pattern(db, topic, access);
}
if(rc) return rc;
}else if(!strcmp(token, "user")){
token = strtok(NULL, " ");
if(token){
if(user) _mosquitto_free(user);
user = _mosquitto_strdup(token);
if(!user){
fclose(aclfile);
return MOSQ_ERR_NOMEM;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Missing username in acl_file.");
if(user) _mosquitto_free(user);
fclose(aclfile);
return 1;
}
}
}
}
if(user) _mosquitto_free(user);
fclose(aclfile);
return MOSQ_ERR_SUCCESS;
}
static void _free_acl(struct _mosquitto_acl *acl)
{
if(!acl) return;
if(acl->child){
_free_acl(acl->child);
}
if(acl->next){
_free_acl(acl->next);
}
if(acl->topic){
_mosquitto_free(acl->topic);
}
_mosquitto_free(acl);
}
void mosquitto_acl_cleanup(struct _mosquitto_db *db)
{
int i;
struct _mosquitto_acl_user *user_tail;
if(!db || !db->acl_list) return;
/* As we're freeing ACLs, we must clear context->acl_list to ensure no
* invalid memory accesses take place later.
* This *requires* the ACLs to be reapplied after mosquitto_acl_cleanup()
* is called if we are reloading the config. If this is not done, all
* access will be denied to currently connected clients.
*/
if(db->contexts){
for(i=0; icontext_count; i++){
if(db->contexts[i] && db->contexts[i]->acl_list){
db->contexts[i]->acl_list = NULL;
}
}
}
while(db->acl_list){
user_tail = db->acl_list->next;
_free_acl(db->acl_list->acl);
if(db->acl_list->username){
_mosquitto_free(db->acl_list->username);
}
_mosquitto_free(db->acl_list);
db->acl_list = user_tail;
}
if(db->acl_patterns){
_free_acl(db->acl_patterns);
}
}
int mqtt3_pwfile_parse(struct _mosquitto_db *db)
{
FILE *pwfile;
struct _mosquitto_unpwd *unpwd;
char buf[256];
char *username, *password;
int len;
if(!db || !db->config) return MOSQ_ERR_INVAL;
if(!db->config->password_file) return MOSQ_ERR_SUCCESS;
pwfile = fopen(db->config->password_file, "rt");
if(!pwfile) return 1;
while(!feof(pwfile)){
if(fgets(buf, 256, pwfile)){
username = strtok(buf, ":");
if(username){
unpwd = _mosquitto_calloc(1, sizeof(struct _mosquitto_unpwd));
if(!unpwd) return MOSQ_ERR_NOMEM;
unpwd->username = _mosquitto_strdup(username);
if(!unpwd->username) return MOSQ_ERR_NOMEM;
len = strlen(unpwd->username);
while(unpwd->username[len-1] == 10 || unpwd->username[len-1] == 13){
unpwd->username[len-1] = '\0';
len = strlen(unpwd->username);
}
password = strtok(NULL, ":");
if(password){
unpwd->password = _mosquitto_strdup(password);
if(!unpwd->password) return MOSQ_ERR_NOMEM;
len = strlen(unpwd->password);
while(unpwd->password[len-1] == 10 || unpwd->password[len-1] == 13){
unpwd->password[len-1] = '\0';
len = strlen(unpwd->password);
}
}
unpwd->next = db->unpwd;
db->unpwd = unpwd;
}
}
}
fclose(pwfile);
return MOSQ_ERR_SUCCESS;
}
int mosquitto_unpwd_check(struct _mosquitto_db *db, const char *username, const char *password)
{
struct _mosquitto_unpwd *tail;
if(!db || !username) return MOSQ_ERR_INVAL;
if(!db->unpwd) return MOSQ_ERR_SUCCESS;
tail = db->unpwd;
while(tail){
if(!strcmp(tail->username, username)){
if(tail->password){
if(password){
if(!strcmp(tail->password, password)){
return MOSQ_ERR_SUCCESS;
}
}else{
return MOSQ_ERR_AUTH;
}
}else{
return MOSQ_ERR_SUCCESS;
}
}
tail = tail->next;
}
return MOSQ_ERR_AUTH;
}
int mosquitto_unpwd_cleanup(struct _mosquitto_db *db)
{
struct _mosquitto_unpwd *tail;
if(!db) return MOSQ_ERR_INVAL;
while(db->unpwd){
tail = db->unpwd->next;
if(db->unpwd->password) _mosquitto_free(db->unpwd->password);
if(db->unpwd->username) _mosquitto_free(db->unpwd->username);
_mosquitto_free(db->unpwd);
db->unpwd = tail;
}
return MOSQ_ERR_SUCCESS;
}
/* Apply security settings after a reload.
* Includes:
* - Disconnecting anonymous users if appropriate
* - Disconnecting users with invalid passwords
* - Reapplying ACLs
*/
int mosquitto_security_apply(struct _mosquitto_db *db)
{
struct _mosquitto_acl_user *acl_user_tail;
struct _mosquitto_unpwd *unpwd_tail;
bool allow_anonymous;
int i;
bool unpwd_ok;
if(!db) return MOSQ_ERR_INVAL;
allow_anonymous = db->config->allow_anonymous;
if(db->contexts){
for(i=0; icontext_count; i++){
if(db->contexts[i]){
/* Check for anonymous clients when allow_anonymous is false */
if(!allow_anonymous && !db->contexts[i]->username){
db->contexts[i]->state = mosq_cs_disconnecting;
_mosquitto_socket_close(db->contexts[i]);
continue;
}
/* Check for connected clients that are no longer authorised */
if(db->unpwd && db->contexts[i]->username){
unpwd_ok = false;
unpwd_tail = db->unpwd;
while(unpwd_tail){
if(!strcmp(db->contexts[i]->username, unpwd_tail->username)){
if(unpwd_tail->password){
if(!db->contexts[i]->password
|| strcmp(db->contexts[i]->password, unpwd_tail->password)){
/* Non matching password to username. */
db->contexts[i]->state = mosq_cs_disconnecting;
_mosquitto_socket_close(db->contexts[i]);
continue;
}else{
/* Username matches, password matches. */
unpwd_ok = true;
}
}else{
/* Username matches, password not in password file. */
unpwd_ok = true;
}
}
unpwd_tail = unpwd_tail->next;
}
if(!unpwd_ok){
db->contexts[i]->state = mosq_cs_disconnecting;
_mosquitto_socket_close(db->contexts[i]);
continue;
}
}
/* Check for ACLs and apply to user. */
if(db->acl_list){
acl_user_tail = db->acl_list;
while(acl_user_tail){
if(acl_user_tail->username){
if(db->contexts[i]->username){
if(!strcmp(acl_user_tail->username, db->contexts[i]->username)){
db->contexts[i]->acl_list = acl_user_tail;
break;
}
}
}else{
if(!db->contexts[i]->username){
db->contexts[i]->acl_list = acl_user_tail;
break;
}
}
acl_user_tail = acl_user_tail->next;
}
}
}
}
}
return MOSQ_ERR_SUCCESS;
}
#endif
mosquitto-0.15/src/mqtt3.h 0000664 0001750 0001750 00000031447 11713444064 014550 0 ustar roger roger /*
Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef MQTT3_H
#define MQTT3_H
#include
#include
#include
#include
#ifndef __GNUC__
#define __attribute__(attrib)
#endif
/* Database macros */
#define MOSQ_DB_VERSION 2
/* Log destinations */
#define MQTT3_LOG_NONE 0x00
#define MQTT3_LOG_SYSLOG 0x01
#define MQTT3_LOG_FILE 0x02
#define MQTT3_LOG_STDOUT 0x04
#define MQTT3_LOG_STDERR 0x08
#define MQTT3_LOG_TOPIC 0x10
#define MQTT3_LOG_ALL 0xFF
#define MOSQ_ACL_NONE 0x00
#define MOSQ_ACL_READ 0x01
#define MOSQ_ACL_WRITE 0x02
typedef uint64_t dbid_t;
enum mqtt3_msg_state {
ms_invalid = 0,
ms_publish = 1,
ms_publish_puback = 2,
ms_wait_puback = 3,
ms_publish_pubrec = 4,
ms_wait_pubrec = 5,
ms_resend_pubrel = 6,
ms_wait_pubrel = 7,
ms_resend_pubcomp = 8,
ms_wait_pubcomp = 9,
ms_resend_pubrec = 10,
ms_queued = 11
};
struct _mqtt3_listener {
int fd;
char *host;
uint16_t port;
int max_connections;
char *mount_point;
int *socks;
int sock_count;
int client_count;
};
typedef struct {
char *config_file;
char *acl_file;
bool allow_anonymous;
int autosave_interval;
char *clientid_prefixes;
bool connection_messages;
bool daemon;
struct _mqtt3_listener default_listener;
struct _mqtt3_listener *listeners;
int listener_count;
int log_dest;
int log_type;
bool log_timestamp;
char *password_file;
bool persistence;
char *persistence_location;
char *persistence_file;
char *persistence_filepath;
int retry_interval;
int store_clean_interval;
int sys_interval;
char *pid_file;
char *user;
#ifdef WITH_BRIDGE
struct _mqtt3_bridge *bridges;
int bridge_count;
#endif
#ifdef WITH_EXTERNAL_SECURITY_CHECKS
char *db_host;
int db_port;
char *db_name;
char *db_username;
char *db_password;
#endif
} mqtt3_config;
struct _mosquitto_subleaf {
struct _mosquitto_subleaf *prev;
struct _mosquitto_subleaf *next;
struct mosquitto *context;
int qos;
};
struct _mosquitto_subhier {
struct _mosquitto_subhier *children;
struct _mosquitto_subhier *next;
struct _mosquitto_subleaf *subs;
char *topic;
struct mosquitto_msg_store *retained;
};
struct mosquitto_msg_store{
struct mosquitto_msg_store *next;
dbid_t db_id;
int ref_count;
char *source_id;
uint16_t source_mid;
struct mosquitto_message msg;
};
typedef struct _mosquitto_client_msg{
struct _mosquitto_client_msg *next;
struct mosquitto_msg_store *store;
uint16_t mid;
int qos;
bool retain;
time_t timestamp;
enum mosquitto_msg_direction direction;
enum mqtt3_msg_state state;
bool dup;
} mosquitto_client_msg;
struct _mosquitto_unpwd{
struct _mosquitto_unpwd *next;
char *username;
char *password;
};
struct _mosquitto_acl{
struct _mosquitto_acl *child;
struct _mosquitto_acl *next;
char *topic;
int access;
};
struct _mosquitto_acl_user{
struct _mosquitto_acl_user *next;
char *username;
struct _mosquitto_acl *acl;
};
typedef struct _mosquitto_db{
dbid_t last_db_id;
struct _mosquitto_subhier subs;
struct _mosquitto_unpwd *unpwd;
struct _mosquitto_acl_user *acl_list;
struct _mosquitto_acl *acl_patterns;
struct mosquitto **contexts;
int context_count;
struct mosquitto_msg_store *msg_store;
int msg_store_count;
mqtt3_config *config;
} mosquitto_db;
enum mqtt3_bridge_direction{
bd_out = 0,
bd_in = 1,
bd_both = 2
};
enum mosquitto_bridge_start_type{
bst_automatic = 0,
bst_lazy = 1,
bst_manual = 2,
bst_once = 3
};
struct _mqtt3_bridge_topic{
char *topic;
int qos;
enum mqtt3_bridge_direction direction;
};
struct _mqtt3_bridge{
char *name;
char *address;
char *clientid;
uint16_t port;
int keepalive;
bool clean_session;
struct _mqtt3_bridge_topic *topics;
int topic_count;
time_t restart_t;
char *username;
char *password;
bool notifications;
enum mosquitto_bridge_start_type start_type;
int idle_timeout;
int threshold;
};
#include
/* ============================================================
* Main functions
* ============================================================ */
int mosquitto_main_loop(mosquitto_db *db, int *listensock, int listensock_count, int listener_max);
/* ============================================================
* Config functions
* ============================================================ */
/* Initialise config struct to default values. */
void mqtt3_config_init(mqtt3_config *config);
/* Parse command line options into config. */
int mqtt3_config_parse_args(mqtt3_config *config, int argc, char *argv[]);
/* Read configuration data from config->config_file into config.
* If reload is true, don't process config options that shouldn't be reloaded (listeners etc)
* Returns 0 on success, 1 if there is a configuration error or if a file cannot be opened.
*/
int mqtt3_config_read(mqtt3_config *config, bool reload);
/* Free all config data. */
void mqtt3_config_cleanup(mqtt3_config *config);
/* ============================================================
* Server send functions
* ============================================================ */
int _mosquitto_send_connack(struct mosquitto *context, uint8_t result);
int _mosquitto_send_suback(struct mosquitto *context, uint16_t mid, uint32_t payloadlen, const uint8_t *payload);
/* ============================================================
* Network functions
* ============================================================ */
int mqtt3_socket_accept(struct _mosquitto_db *db, int listensock);
int mqtt3_socket_listen(struct _mqtt3_listener *listener);
uint64_t mqtt3_net_bytes_total_received(void);
uint64_t mqtt3_net_bytes_total_sent(void);
unsigned long mqtt3_net_msgs_total_received(void);
unsigned long mqtt3_net_msgs_total_sent(void);
/* ============================================================
* Read handling functions
* ============================================================ */
int mqtt3_packet_handle(mosquitto_db *db, int context_index);
int mqtt3_handle_connack(mosquitto_db *db, struct mosquitto *context);
int mqtt3_handle_connect(mosquitto_db *db, int context_index);
int mqtt3_handle_disconnect(mosquitto_db *db, int context_index);
int mqtt3_handle_publish(mosquitto_db *db, struct mosquitto *context);
int mqtt3_handle_subscribe(mosquitto_db *db, struct mosquitto *context);
int mqtt3_handle_unsubscribe(mosquitto_db *db, struct mosquitto *context);
/* ============================================================
* Database handling
* ============================================================ */
int mqtt3_db_open(mqtt3_config *config, mosquitto_db *db);
int mqtt3_db_close(mosquitto_db *db);
#ifdef WITH_PERSISTENCE
int mqtt3_db_backup(mosquitto_db *db, bool cleanup, bool shutdown);
int mqtt3_db_restore(mosquitto_db *db);
#endif
int mqtt3_db_client_count(mosquitto_db *db, int *count, int *inactive_count);
void mqtt3_db_limits_set(int inflight, int queued);
/* Return the number of in-flight messages in count. */
int mqtt3_db_message_count(int *count);
int mqtt3_db_message_delete(struct mosquitto *context, uint16_t mid, enum mosquitto_msg_direction dir);
int mqtt3_db_message_insert(mosquitto_db *db, struct mosquitto *context, uint16_t mid, enum mosquitto_msg_direction dir, int qos, bool retain, struct mosquitto_msg_store *stored);
int mqtt3_db_message_release(mosquitto_db *db, struct mosquitto *context, uint16_t mid, enum mosquitto_msg_direction dir);
int mqtt3_db_message_update(struct mosquitto *context, uint16_t mid, enum mosquitto_msg_direction dir, enum mqtt3_msg_state state);
int mqtt3_db_message_write(struct mosquitto *context);
int mqtt3_db_messages_delete(struct mosquitto *context);
int mqtt3_db_messages_easy_queue(mosquitto_db *db, struct mosquitto *context, const char *topic, int qos, uint32_t payloadlen, const uint8_t *payload, int retain);
int mqtt3_db_messages_queue(mosquitto_db *db, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store *stored);
int mqtt3_db_message_store(mosquitto_db *db, const char *source, uint16_t source_mid, const char *topic, int qos, uint32_t payloadlen, const uint8_t *payload, int retain, struct mosquitto_msg_store **stored, dbid_t store_id);
int mqtt3_db_message_store_find(struct mosquitto *context, uint16_t mid, struct mosquitto_msg_store **stored);
/* Check all messages waiting on a client reply and resend if timeout has been exceeded. */
int mqtt3_db_message_timeout_check(mosquitto_db *db, unsigned int timeout);
int mqtt3_retain_queue(mosquitto_db *db, struct mosquitto *context, const char *sub, int sub_qos);
void mqtt3_db_store_clean(mosquitto_db *db);
void mqtt3_db_sys_update(mosquitto_db *db, int interval, time_t start_time);
void mqtt3_db_vacuum(void);
/* ============================================================
* Subscription functions
* ============================================================ */
int mqtt3_sub_add(struct mosquitto *context, const char *sub, int qos, struct _mosquitto_subhier *root);
int mqtt3_sub_remove(struct mosquitto *context, const char *sub, struct _mosquitto_subhier *root);
int mqtt3_sub_search(struct _mosquitto_db *db, struct _mosquitto_subhier *root, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store *stored);
void mqtt3_sub_tree_print(struct _mosquitto_subhier *root, int level);
int mqtt3_subs_clean_session(struct mosquitto *context, struct _mosquitto_subhier *root);
/* ============================================================
* Context functions
* ============================================================ */
struct mosquitto *mqtt3_context_init(int sock);
void mqtt3_context_cleanup(mosquitto_db *db, struct mosquitto *context, bool do_free);
void mqtt3_context_disconnect(mosquitto_db *db, int context_index);
/* ============================================================
* Logging functions
* ============================================================ */
int mqtt3_log_init(int level, int destinations);
int mqtt3_log_close(void);
int _mosquitto_log_printf(struct mosquitto *mosq, int level, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
/* ============================================================
* Bridge functions
* ============================================================ */
#ifdef WITH_BRIDGE
int mqtt3_bridge_new(mosquitto_db *db, struct _mqtt3_bridge *bridge);
int mqtt3_bridge_connect(mosquitto_db *db, struct mosquitto *context);
void mqtt3_bridge_packet_cleanup(struct mosquitto *context);
#endif
/* ============================================================
* Security related functions
* ============================================================ */
int mosquitto_security_init(mosquitto_db *db);
void mosquitto_security_cleanup(mosquitto_db *db);
#ifdef WITH_EXTERNAL_SECURITY_CHECKS
int mosquitto_unpwd_init(struct _mosquitto_db *db);
int mosquitto_acl_init(struct _mosquitto_db *db);
#else
int mqtt3_aclfile_parse(struct _mosquitto_db *db);
int mqtt3_pwfile_parse(struct _mosquitto_db *db);
int mosquitto_security_apply(struct _mosquitto_db *db);
#endif
int mosquitto_acl_check(struct _mosquitto_db *db, struct mosquitto *context, const char *topic, int access);
void mosquitto_acl_cleanup(struct _mosquitto_db *db);
int mosquitto_unpwd_check(struct _mosquitto_db *db, const char *username, const char *password);
int mosquitto_unpwd_cleanup(struct _mosquitto_db *db);
/* ============================================================
* Window service related functions
* ============================================================ */
#ifdef WIN32
void service_install(void);
void service_uninstall(void);
void service_run(void);
#endif
#endif
mosquitto-0.15/src/logging.c 0000664 0001750 0001750 00000012442 11713444064 015113 0 ustar roger roger /*
Copyright (c) 2009-2011 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#ifndef WIN32
#include
#endif
#ifndef CMAKE
#include
#endif
#include
#include
extern mosquitto_db int_db;
#ifdef WIN32
HANDLE syslog_h;
#endif
/* Options for logging should be:
*
* A combination of:
* Via syslog
* To a file
* To stdout/stderr
* To topics
*/
/* Give option of logging timestamp.
* Logging pid.
*/
static int log_destinations = MQTT3_LOG_STDERR;
static int log_priorities = MOSQ_LOG_ERR | MOSQ_LOG_WARNING | MOSQ_LOG_NOTICE | MOSQ_LOG_INFO;
int mqtt3_log_init(int priorities, int destinations)
{
int rc = 0;
log_priorities = priorities;
log_destinations = destinations;
if(log_destinations & MQTT3_LOG_SYSLOG){
#ifndef WIN32
openlog("mosquitto", LOG_PID, LOG_DAEMON);
#else
syslog_h = OpenEventLog(NULL, "mosquitto");
#endif
}
return rc;
}
int mqtt3_log_close(void)
{
if(log_destinations & MQTT3_LOG_SYSLOG){
#ifndef WIN32
closelog();
#else
CloseEventLog(syslog_h);
#endif
}
/* FIXME - do something for all destinations! */
return MOSQ_ERR_SUCCESS;
}
int _mosquitto_log_printf(struct mosquitto *mosq, int priority, const char *fmt, ...)
{
va_list va;
char *s;
char *st;
int len;
#ifdef WIN32
char *sp;
#endif
const char *topic;
int syslog_priority;
time_t now = time(NULL);
if((log_priorities & priority) && log_destinations != MQTT3_LOG_NONE){
switch(priority){
case MOSQ_LOG_DEBUG:
topic = "$SYS/broker/log/D";
#ifndef WIN32
syslog_priority = LOG_DEBUG;
#else
syslog_priority = EVENTLOG_INFORMATION_TYPE;
#endif
break;
case MOSQ_LOG_ERR:
topic = "$SYS/broker/log/E";
#ifndef WIN32
syslog_priority = LOG_ERR;
#else
syslog_priority = EVENTLOG_ERROR_TYPE;
#endif
break;
case MOSQ_LOG_WARNING:
topic = "$SYS/broker/log/W";
#ifndef WIN32
syslog_priority = LOG_WARNING;
#else
syslog_priority = EVENTLOG_WARNING_TYPE;
#endif
break;
case MOSQ_LOG_NOTICE:
topic = "$SYS/broker/log/N";
#ifndef WIN32
syslog_priority = LOG_NOTICE;
#else
syslog_priority = EVENTLOG_INFORMATION_TYPE;
#endif
break;
case MOSQ_LOG_INFO:
topic = "$SYS/broker/log/I";
#ifndef WIN32
syslog_priority = LOG_INFO;
#else
syslog_priority = EVENTLOG_INFORMATION_TYPE;
#endif
break;
default:
topic = "$SYS/broker/log/E";
#ifndef WIN32
syslog_priority = LOG_ERR;
#else
syslog_priority = EVENTLOG_ERROR_TYPE;
#endif
}
len = strlen(fmt) + 500;
s = _mosquitto_malloc(len*sizeof(char));
if(!s) return MOSQ_ERR_NOMEM;
va_start(va, fmt);
vsnprintf(s, len, fmt, va);
va_end(va);
s[len-1] = '\0'; /* Ensure string is null terminated. */
if(log_destinations & MQTT3_LOG_STDOUT){
if(int_db.config && int_db.config->log_timestamp){
fprintf(stdout, "%d: %s\n", (int)now, s);
}else{
fprintf(stdout, "%s\n", s);
}
fflush(stdout);
}
if(log_destinations & MQTT3_LOG_STDERR){
if(int_db.config && int_db.config->log_timestamp){
fprintf(stderr, "%d: %s\n", (int)now, s);
}else{
fprintf(stderr, "%s\n", s);
}
fflush(stderr);
}
if(log_destinations & MQTT3_LOG_SYSLOG){
#ifndef WIN32
syslog(syslog_priority, "%s", s);
#else
sp = (char *)s;
ReportEvent(syslog_h, syslog_priority, 0, 0, NULL, 1, 0, &sp, NULL);
#endif
}
if(log_destinations & MQTT3_LOG_TOPIC && priority != MOSQ_LOG_DEBUG){
if(int_db.config && int_db.config->log_timestamp){
len += 30;
st = _mosquitto_malloc(len*sizeof(char));
if(!st){
_mosquitto_free(s);
return MOSQ_ERR_NOMEM;
}
snprintf(st, len, "%d: %s", (int)now, s);
mqtt3_db_messages_easy_queue(&int_db, NULL, topic, 2, strlen(st), (uint8_t *)st, 0);
_mosquitto_free(st);
}else{
mqtt3_db_messages_easy_queue(&int_db, NULL, topic, 2, strlen(s), (uint8_t *)s, 0);
}
}
_mosquitto_free(s);
}
return MOSQ_ERR_SUCCESS;
}
mosquitto-0.15/src/read_handle.c 0000664 0001750 0001750 00000013617 11713444064 015720 0 ustar roger roger /*
Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
int mqtt3_packet_handle(mosquitto_db *db, int context_index)
{
struct mosquitto *context;
if(context_index < 0 || context_index >= db->context_count) return MOSQ_ERR_INVAL;
context = db->contexts[context_index];
if(!context) return MOSQ_ERR_INVAL;
switch((context->in_packet.command)&0xF0){
case PINGREQ:
return _mosquitto_handle_pingreq(context);
case PINGRESP:
return _mosquitto_handle_pingresp(context);
case PUBACK:
return _mosquitto_handle_pubackcomp(context, "PUBACK");
case PUBCOMP:
return _mosquitto_handle_pubackcomp(context, "PUBCOMP");
case PUBLISH:
return mqtt3_handle_publish(db, context);
case PUBREC:
return _mosquitto_handle_pubrec(context);
case PUBREL:
return _mosquitto_handle_pubrel(db, context);
case CONNECT:
return mqtt3_handle_connect(db, context_index);
case DISCONNECT:
return mqtt3_handle_disconnect(db, context_index);
case SUBSCRIBE:
return mqtt3_handle_subscribe(db, context);
case UNSUBSCRIBE:
return mqtt3_handle_unsubscribe(db, context);
#ifdef WITH_BRIDGE
case CONNACK:
return mqtt3_handle_connack(db, context);
case SUBACK:
return _mosquitto_handle_suback(context);
case UNSUBACK:
return _mosquitto_handle_unsuback(context);
#endif
default:
/* If we don't recognise the command, return an error straight away. */
return MOSQ_ERR_PROTOCOL;
}
}
int mqtt3_handle_publish(mosquitto_db *db, struct mosquitto *context)
{
char *topic;
uint8_t *payload = NULL;
uint32_t payloadlen;
uint8_t dup, qos, retain;
uint16_t mid = 0;
int rc = 0;
uint8_t header = context->in_packet.command;
int res = 0;
struct mosquitto_msg_store *stored = NULL;
int len;
char *topic_mount;
dup = (header & 0x08)>>3;
qos = (header & 0x06)>>1;
retain = (header & 0x01);
if(_mosquitto_read_string(&context->in_packet, &topic)) return 1;
if(_mosquitto_fix_sub_topic(&topic)) return 1;
if(!strlen(topic)){
return 1;
}
if(_mosquitto_topic_wildcard_len_check(topic) != MOSQ_ERR_SUCCESS){
/* Invalid publish topic, just swallow it. */
_mosquitto_free(topic);
return MOSQ_ERR_SUCCESS;
}
if(qos > 0){
if(_mosquitto_read_uint16(&context->in_packet, &mid)){
_mosquitto_free(topic);
return 1;
}
}
payloadlen = context->in_packet.remaining_length - context->in_packet.pos;
if(context->listener && context->listener->mount_point){
len = strlen(context->listener->mount_point) + strlen(topic) + 1;
topic_mount = _mosquitto_calloc(len, sizeof(char));
if(!topic_mount){
_mosquitto_free(topic);
return MOSQ_ERR_NOMEM;
}
snprintf(topic_mount, len, "%s%s", context->listener->mount_point, topic);
_mosquitto_free(topic);
topic = topic_mount;
}
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Received PUBLISH from %s (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", context->id, dup, qos, retain, mid, topic, (long)payloadlen);
if(payloadlen){
payload = _mosquitto_calloc(payloadlen+1, sizeof(uint8_t));
if(_mosquitto_read_bytes(&context->in_packet, payload, payloadlen)){
_mosquitto_free(topic);
return 1;
}
}
/* Check for topic access */
rc = mosquitto_acl_check(db, context, topic, MOSQ_ACL_WRITE);
if(rc == MOSQ_ERR_ACL_DENIED){
_mosquitto_free(topic);
if(payload) _mosquitto_free(payload);
return MOSQ_ERR_SUCCESS;
}else if(rc != MOSQ_ERR_SUCCESS){
_mosquitto_free(topic);
if(payload) _mosquitto_free(payload);
return rc;
}
if(qos > 0){
mqtt3_db_message_store_find(context, mid, &stored);
}
if(!stored){
dup = 0;
if(mqtt3_db_message_store(db, context->id, mid, topic, qos, payloadlen, payload, retain, &stored, 0)){
_mosquitto_free(topic);
if(payload) _mosquitto_free(payload);
return 1;
}
}else{
dup = 1;
}
switch(qos){
case 0:
if(mqtt3_db_messages_queue(db, context->id, topic, qos, retain, stored)) rc = 1;
break;
case 1:
if(mqtt3_db_messages_queue(db, context->id, topic, qos, retain, stored)) rc = 1;
if(_mosquitto_send_puback(context, mid)) rc = 1;
break;
case 2:
if(!dup){
res = mqtt3_db_message_insert(db, context, mid, mosq_md_in, qos, retain, stored);
}else{
res = 0;
}
if(!res){
if(_mosquitto_send_pubrec(context, mid)) rc = 1;
}else if(res == 1){
rc = 1;
}
break;
}
_mosquitto_free(topic);
if(payload) _mosquitto_free(payload);
return rc;
}
mosquitto-0.15/src/database.c 0000664 0001750 0001750 00000057103 11713444064 015234 0 ustar roger roger /*
Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
/* A note on matching topic subscriptions.
*
* Topics can be up to 32767 characters in length. The / character is used as a
* hierarchy delimiter. Messages are published to a particular topic.
* Clients may subscribe to particular topics directly, but may also use
* wildcards in subscriptions. The + and # characters are used as wildcards.
* The # wildcard can be used at the end of a subscription only, and is a
* wildcard for the level of hierarchy at which it is placed and all subsequent
* levels.
* The + wildcard may be used at any point within the subscription and is a
* wildcard for only the level of hierarchy at which it is placed.
* Neither wildcard may be used as part of a substring.
* Valid:
* a/b/+
* a/+/c
* a/#
* a/b/#
* #
* +/b/c
* +/+/+
* Invalid:
* a/#/c
* a+/b/c
* Valid but non-matching:
* a/b
* a/+
* +/b
* b/c/a
* a/b/d
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
static int max_inflight = 20;
static int max_queued = 100;
static int _mqtt3_db_cleanup(mosquitto_db *db);
int mqtt3_db_open(mqtt3_config *config, mosquitto_db *db)
{
int rc = 0;
struct _mosquitto_subhier *child;
if(!config || !db) return MOSQ_ERR_INVAL;
db->last_db_id = 0;
db->context_count = 1;
db->contexts = _mosquitto_malloc(sizeof(struct mosquitto*)*db->context_count);
if(!db->contexts) return MOSQ_ERR_NOMEM;
db->contexts[0] = NULL;
db->subs.next = NULL;
db->subs.subs = NULL;
db->subs.topic = "";
child = _mosquitto_malloc(sizeof(struct _mosquitto_subhier));
if(!child){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
child->next = NULL;
child->topic = _mosquitto_strdup("");
if(!child->topic){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
child->subs = NULL;
child->children = NULL;
child->retained = NULL;
db->subs.children = child;
child = _mosquitto_malloc(sizeof(struct _mosquitto_subhier));
if(!child){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
child->next = NULL;
child->topic = _mosquitto_strdup("$SYS");
if(!child->topic){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
child->subs = NULL;
child->children = NULL;
child->retained = NULL;
db->subs.children->next = child;
db->unpwd = NULL;
#ifdef WITH_PERSISTENCE
if(config->persistence && config->persistence_filepath){
if(mqtt3_db_restore(db)) return 1;
}
#endif
if(_mqtt3_db_cleanup(db)) return 1;
return rc;
}
static void subhier_clean(struct _mosquitto_subhier *subhier)
{
struct _mosquitto_subhier *next;
struct _mosquitto_subleaf *leaf, *nextleaf;
while(subhier){
next = subhier->next;
leaf = subhier->subs;
while(leaf){
nextleaf = leaf->next;
_mosquitto_free(leaf);
leaf = nextleaf;
}
if(subhier->retained){
subhier->retained->ref_count--;
}
subhier_clean(subhier->children);
if(subhier->topic) _mosquitto_free(subhier->topic);
_mosquitto_free(subhier);
subhier = next;
}
}
int mqtt3_db_close(mosquitto_db *db)
{
subhier_clean(db->subs.children);
mqtt3_db_store_clean(db);
return MOSQ_ERR_SUCCESS;
}
/* Returns the number of client currently in the database.
* This includes inactive clients.
* Returns 1 on failure (count is NULL)
* Returns 0 on success.
*/
int mqtt3_db_client_count(mosquitto_db *db, int *count, int *inactive_count)
{
int i;
if(!db || !count || !inactive_count) return MOSQ_ERR_INVAL;
*count = 0;
*inactive_count = 0;
for(i=0; icontext_count; i++){
if(db->contexts[i]){
(*count)++;
if(db->contexts[i]->sock == INVALID_SOCKET){
(*inactive_count)++;
}
}
}
return MOSQ_ERR_SUCCESS;
}
/* Internal function.
* Set all stored sockets to -1 (invalid) when starting mosquitto.
* Also removes any stray clients and subcriptions that may be around from a prior crash.
* Returns 1 on failure (db is NULL)
* Returns 0 on success.
*/
static int _mqtt3_db_cleanup(mosquitto_db *db)
{
int rc = 0;
if(!db) return MOSQ_ERR_INVAL;
// FIXME - reimplement for new db
#if 0
query = sqlite3_mprintf("UPDATE clients SET sock=-1");
/* Remove any stray clients that have clean session set. */
query = sqlite3_mprintf("DELETE FROM clients WHERE sock=-1 AND clean_session=1");
/* Remove any subs with no client. */
query = sqlite3_mprintf("DELETE FROM subs WHERE client_id NOT IN (SELECT id FROM clients)");
/* Remove any messages with no client. */
query = sqlite3_mprintf("DELETE FROM messages WHERE client_id NOT IN (SELECT id FROM clients)");
#endif
return rc;
}
int mqtt3_db_message_delete(struct mosquitto *context, uint16_t mid, enum mosquitto_msg_direction dir)
{
mosquitto_client_msg *tail, *last = NULL;
int msg_index = 0;
bool deleted = false;
if(!context) return MOSQ_ERR_INVAL;
tail = context->msgs;
while(tail){
msg_index++;
if(tail->state == ms_queued && msg_index <= max_inflight){
tail->timestamp = time(NULL);
if(tail->direction == mosq_md_out){
switch(tail->qos){
case 0:
tail->state = ms_publish;
break;
case 1:
tail->state = ms_publish_puback;
break;
case 2:
tail->state = ms_publish_pubrec;
break;
}
}else{
if(tail->qos == 2){
tail->state = ms_wait_pubrec;
}
}
}
if(tail->mid == mid && tail->direction == dir){
msg_index--;
/* FIXME - it would be nice to be able to remove the stored message here if ref_count==0 */
tail->store->ref_count--;
if(last){
last->next = tail->next;
}else{
context->msgs = tail->next;
}
_mosquitto_free(tail);
if(last){
tail = last->next;
}else{
tail = context->msgs;
}
deleted = true;
}else{
last = tail;
tail = tail->next;
}
if(msg_index > max_inflight && deleted){
return MOSQ_ERR_SUCCESS;
}
}
return MOSQ_ERR_SUCCESS;
}
int mqtt3_db_message_insert(mosquitto_db *db, struct mosquitto *context, uint16_t mid, enum mosquitto_msg_direction dir, int qos, bool retain, struct mosquitto_msg_store *stored)
{
mosquitto_client_msg *msg, *tail = NULL;
enum mqtt3_msg_state state = ms_invalid;
int msg_count = 0;
int rc = 0;
assert(stored);
if(!context) return MOSQ_ERR_INVAL;
if(context->sock == INVALID_SOCKET){
/* Client is not connected only queue messages with QoS>0. */
if(qos == 0){
if(!context->bridge){
return 2;
}else{
if(context->bridge->start_type != bst_lazy){
return 2;
}
}
}
}
if(context->msgs){
tail = context->msgs;
msg_count = 1;
while(tail && tail->next){
if(tail->qos > 0){
msg_count++;
}
tail = tail->next;
}
}
if(context->sock != INVALID_SOCKET){
if(qos == 0 || max_inflight == 0 || msg_count < max_inflight){
if(dir == mosq_md_out){
switch(qos){
case 0:
state = ms_publish;
break;
case 1:
state = ms_publish_puback;
break;
case 2:
state = ms_publish_pubrec;
break;
}
}else{
if(qos == 2){
state = ms_wait_pubrec;
}else{
return 1;
}
}
}else if(max_queued == 0 || msg_count-max_inflight < max_queued){
state = ms_queued;
rc = 2;
}else{
/* Dropping message due to full queue.
* FIXME - should this be logged? */
return 2;
}
}else{
if(msg_count >= max_queued){
return 2;
}else{
state = ms_queued;
}
}
assert(state != ms_invalid);
msg = _mosquitto_malloc(sizeof(mosquitto_client_msg));
if(!msg) return MOSQ_ERR_NOMEM;
msg->next = NULL;
msg->store = stored;
msg->store->ref_count++;
msg->mid = mid;
msg->timestamp = time(NULL);
msg->direction = dir;
msg->state = state;
msg->dup = false;
msg->qos = qos;
msg->retain = retain;
if(tail){
tail->next = msg;
}else{
context->msgs = msg;
}
#ifdef WITH_BRIDGE
msg_count++; /* We've just added a message to the list */
if(context->bridge && context->bridge->start_type == bst_lazy
&& context->sock == INVALID_SOCKET
&& msg_count >= context->bridge->threshold){
context->state = mosq_cs_new;
mqtt3_bridge_connect(db, context);
}
#endif
return rc;
}
int mqtt3_db_message_update(struct mosquitto *context, uint16_t mid, enum mosquitto_msg_direction dir, enum mqtt3_msg_state state)
{
mosquitto_client_msg *tail;
tail = context->msgs;
while(tail){
if(tail->mid == mid && tail->direction == dir){
tail->state = state;
tail->timestamp = time(NULL);
return MOSQ_ERR_SUCCESS;
}
tail = tail->next;
}
return 1;
}
int mqtt3_db_messages_delete(struct mosquitto *context)
{
mosquitto_client_msg *tail, *next;
if(!context) return MOSQ_ERR_INVAL;
tail = context->msgs;
while(tail){
/* FIXME - it would be nice to be able to remove the stored message here if rec_count==0 */
tail->store->ref_count--;
next = tail->next;
_mosquitto_free(tail);
tail = next;
}
context->msgs = NULL;
return MOSQ_ERR_SUCCESS;
}
int mqtt3_db_messages_easy_queue(mosquitto_db *db, struct mosquitto *context, const char *topic, int qos, uint32_t payloadlen, const uint8_t *payload, int retain)
{
struct mosquitto_msg_store *stored;
char *source_id;
assert(db);
if(!topic) return MOSQ_ERR_INVAL;
if(context){
source_id = context->id;
}else{
source_id = "";
}
if(mqtt3_db_message_store(db, source_id, 0, topic, qos, payloadlen, payload, retain, &stored, 0)) return 1;
return mqtt3_db_messages_queue(db, source_id, topic, qos, retain, stored);
}
int mqtt3_db_message_store(mosquitto_db *db, const char *source, uint16_t source_mid, const char *topic, int qos, uint32_t payloadlen, const uint8_t *payload, int retain, struct mosquitto_msg_store **stored, dbid_t store_id)
{
struct mosquitto_msg_store *temp;
assert(db);
assert(stored);
if(!topic) return MOSQ_ERR_INVAL;
temp = _mosquitto_malloc(sizeof(struct mosquitto_msg_store));
if(!temp) return MOSQ_ERR_NOMEM;
temp->next = db->msg_store;
temp->ref_count = 0;
if(source){
temp->source_id = _mosquitto_strdup(source);
}else{
temp->source_id = _mosquitto_strdup("");
}
if(!temp->source_id){
_mosquitto_free(temp);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
temp->source_mid = source_mid;
temp->msg.mid = 0;
temp->msg.qos = qos;
temp->msg.retain = retain;
temp->msg.topic = _mosquitto_strdup(topic);
if(!temp->msg.topic){
_mosquitto_free(temp);
_mosquitto_free(temp->source_id);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
temp->msg.payloadlen = payloadlen;
if(payloadlen){
temp->msg.payload = _mosquitto_malloc(sizeof(uint8_t)*payloadlen);
if(!temp->msg.payload){
if(temp->source_id) _mosquitto_free(temp->source_id);
if(temp->msg.topic) _mosquitto_free(temp->msg.topic);
if(temp->msg.payload) _mosquitto_free(temp->msg.payload);
_mosquitto_free(temp);
return MOSQ_ERR_NOMEM;
}
memcpy(temp->msg.payload, payload, sizeof(uint8_t)*payloadlen);
}else{
temp->msg.payload = NULL;
}
if(!temp->source_id || !temp->msg.topic || (payloadlen && !temp->msg.payload)){
if(temp->source_id) _mosquitto_free(temp->source_id);
if(temp->msg.topic) _mosquitto_free(temp->msg.topic);
if(temp->msg.payload) _mosquitto_free(temp->msg.payload);
_mosquitto_free(temp);
return 1;
}
db->msg_store_count++;
db->msg_store = temp;
(*stored) = temp;
if(!store_id){
temp->db_id = ++db->last_db_id;
}else{
temp->db_id = store_id;
}
return MOSQ_ERR_SUCCESS;
}
int mqtt3_db_message_store_find(struct mosquitto *context, uint16_t mid, struct mosquitto_msg_store **stored)
{
mosquitto_client_msg *tail;
if(!context) return MOSQ_ERR_INVAL;
*stored = NULL;
tail = context->msgs;
while(tail){
if(tail->store->source_mid == mid && tail->direction == mosq_md_in){
*stored = tail->store;
return MOSQ_ERR_SUCCESS;
}
tail = tail->next;
}
return 1;
}
int mqtt3_db_message_timeout_check(mosquitto_db *db, unsigned int timeout)
{
int i;
time_t threshold = time(NULL) - timeout;
enum mqtt3_msg_state new_state = ms_invalid;
struct mosquitto *context;
mosquitto_client_msg *msg;
for(i=0; icontext_count; i++){
context = db->contexts[i];
if(!context) continue;
msg = context->msgs;
while(msg){
if(msg->timestamp < threshold && msg->state != ms_queued){
switch(msg->state){
case ms_wait_puback:
new_state = ms_publish_puback;
break;
case ms_wait_pubrec:
new_state = ms_publish_pubrec;
break;
case ms_wait_pubrel:
new_state = ms_resend_pubrec;
break;
case ms_wait_pubcomp:
new_state = ms_resend_pubrel;
break;
default:
break;
}
if(new_state != ms_invalid){
msg->timestamp = time(NULL);
msg->state = new_state;
msg->dup = true;
}
}
msg = msg->next;
}
}
return MOSQ_ERR_SUCCESS;
}
int mqtt3_db_message_release(mosquitto_db *db, struct mosquitto *context, uint16_t mid, enum mosquitto_msg_direction dir)
{
mosquitto_client_msg *tail, *last = NULL;
int qos;
int retain;
char *topic;
char *source_id;
if(!context) return MOSQ_ERR_INVAL;
tail = context->msgs;
while(tail){
if(tail->mid == mid && tail->direction == dir){
qos = tail->store->msg.qos;
topic = tail->store->msg.topic;
retain = tail->retain;
source_id = tail->store->source_id;
if(!mqtt3_db_messages_queue(db, source_id, topic, qos, retain, tail->store)){
tail->store->ref_count--;
if(last){
last->next = tail->next;
}else{
context->msgs = tail->next;
}
_mosquitto_free(tail);
return MOSQ_ERR_SUCCESS;
}else{
return 1;
}
}
last = tail;
tail = tail->next;
}
return 1;
}
int mqtt3_db_message_write(struct mosquitto *context)
{
int rc;
mosquitto_client_msg *tail, *last = NULL;
uint16_t mid;
int retries;
int retain;
const char *topic;
int qos;
uint32_t payloadlen;
const uint8_t *payload;
if(!context || context->sock == -1
|| (context->state == mosq_cs_connected && !context->id)){
return MOSQ_ERR_INVAL;
}
tail = context->msgs;
while(tail){
if(tail->direction == mosq_md_out && tail->state != ms_queued){
mid = tail->mid;
retries = tail->dup;
retain = tail->retain;
topic = tail->store->msg.topic;
qos = tail->qos;
payloadlen = tail->store->msg.payloadlen;
payload = tail->store->msg.payload;
switch(tail->state){
case ms_publish:
rc = _mosquitto_send_publish(context, mid, topic, payloadlen, payload, qos, retain, retries);
if(!rc){
if(last){
last->next = tail->next;
tail->store->ref_count--;
_mosquitto_free(tail);
tail = last->next;
}else{
context->msgs = tail->next;
tail->store->ref_count--;
_mosquitto_free(tail);
tail = context->msgs;
}
}else{
return rc;
}
break;
case ms_publish_puback:
rc = _mosquitto_send_publish(context, mid, topic, payloadlen, payload, qos, retain, retries);
if(!rc){
tail->state = ms_wait_puback;
}else{
return rc;
}
last = tail;
tail = tail->next;
break;
case ms_publish_pubrec:
rc = _mosquitto_send_publish(context, mid, topic, payloadlen, payload, qos, retain, retries);
if(!rc){
tail->state = ms_wait_pubrec;
}else{
return rc;
}
last = tail;
tail = tail->next;
break;
case ms_resend_pubrec:
rc = _mosquitto_send_pubrec(context, mid);
if(!rc){
tail->state = ms_wait_pubrel;
}else{
return rc;
}
last = tail;
tail = tail->next;
break;
case ms_resend_pubrel:
rc = _mosquitto_send_pubrel(context, mid, true);
if(!rc){
tail->state = ms_wait_pubcomp;
}else{
return rc;
}
last = tail;
tail = tail->next;
break;
case ms_resend_pubcomp:
rc = _mosquitto_send_pubcomp(context, mid);
if(!rc){
tail->state = ms_wait_pubrel;
}else{
return rc;
}
last = tail;
tail = tail->next;
break;
default:
last = tail;
tail = tail->next;
break;
}
}else{
last = tail;
tail = tail->next;
}
}
return MOSQ_ERR_SUCCESS;
}
void mqtt3_db_store_clean(mosquitto_db *db)
{
/* FIXME - this may not be necessary if checks are made when messages are removed. */
struct mosquitto_msg_store *tail, *last = NULL;
assert(db);
tail = db->msg_store;
while(tail){
if(tail->ref_count == 0){
if(tail->source_id) _mosquitto_free(tail->source_id);
if(tail->msg.topic) _mosquitto_free(tail->msg.topic);
if(tail->msg.payload) _mosquitto_free(tail->msg.payload);
if(last){
last->next = tail->next;
_mosquitto_free(tail);
tail = last->next;
}else{
db->msg_store = tail->next;
_mosquitto_free(tail);
tail = db->msg_store;
}
db->msg_store_count--;
}else{
last = tail;
tail = tail->next;
}
}
}
/* Send messages for the $SYS hierarchy if the last update is longer than
* 'interval' seconds ago.
* 'interval' is the amount of seconds between updates. If 0, then no periodic
* messages are sent for the $SYS hierarchy.
* 'start_time' is the result of time() that the broker was started at.
*/
void mqtt3_db_sys_update(mosquitto_db *db, int interval, time_t start_time)
{
static time_t last_update = 0;
time_t now = time(NULL);
time_t uptime;
char buf[100];
int value;
int inactive;
int active;
unsigned long value_ul;
unsigned long long value_ull;
static int msg_store_count = -1;
static int client_count = -1;
static int client_max = -1;
static int inactive_count = -1;
static int active_count = -1;
#ifdef REAL_WITH_MEMORY_TRACKING
static unsigned long current_heap = -1;
static unsigned long max_heap = -1;
#endif
static unsigned long msgs_received = -1;
static unsigned long msgs_sent = -1;
static unsigned int msgsps_received = -1;
static unsigned int msgsps_sent = -1;
static unsigned long long bytes_received = -1;
static unsigned long long bytes_sent = -1;
static unsigned int bytesps_received = -1;
static unsigned int bytesps_sent = -1;
if(interval && now - interval > last_update){
uptime = now - start_time;
snprintf(buf, 100, "%d seconds", (int)uptime);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/uptime", 2, strlen(buf), (uint8_t *)buf, 1);
if(db->msg_store_count != msg_store_count){
msg_store_count = db->msg_store_count;
snprintf(buf, 100, "%d", msg_store_count);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/messages/stored", 2, strlen(buf), (uint8_t *)buf, 1);
}
if(!mqtt3_db_client_count(db, &value, &inactive)){
if(client_count != value){
client_count = value;
snprintf(buf, 100, "%d", client_count);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/clients/total", 2, strlen(buf), (uint8_t *)buf, 1);
}
if(inactive_count != inactive){
inactive_count = inactive;
snprintf(buf, 100, "%d", inactive_count);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/clients/inactive", 2, strlen(buf), (uint8_t *)buf, 1);
}
active = client_count - inactive;
if(active_count != active){
active_count = active;
snprintf(buf, 100, "%d", active_count);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/clients/active", 2, strlen(buf), (uint8_t *)buf, 1);
}
if(value > client_max){
client_max = value;
snprintf(buf, 100, "%d", client_max);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/clients/maximum", 2, strlen(buf), (uint8_t *)buf, 1);
}
}
#ifdef REAL_WITH_MEMORY_TRACKING
value_ul = _mosquitto_memory_used();
if(current_heap != value_ul){
current_heap = value_ul;
snprintf(buf, 100, "%lu bytes", current_heap);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/heap/current size", 2, strlen(buf), (uint8_t *)buf, 1);
}
value_ul =_mosquitto_max_memory_used();
if(max_heap != value_ul){
max_heap = value_ul;
snprintf(buf, 100, "%lu bytes", max_heap);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/heap/maximum size", 2, strlen(buf), (uint8_t *)buf, 1);
}
#endif
value_ul = mqtt3_net_msgs_total_received();
if(msgs_received != value_ul){
msgs_received = value_ul;
snprintf(buf, 100, "%lu", msgs_received);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/messages/received", 2, strlen(buf), (uint8_t *)buf, 1);
}
value_ul = mqtt3_net_msgs_total_sent();
if(msgs_sent != value_ul){
msgs_sent = value_ul;
snprintf(buf, 100, "%lu", msgs_sent);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/messages/sent", 2, strlen(buf), (uint8_t *)buf, 1);
}
value_ull = (unsigned long long)mqtt3_net_bytes_total_received();
if(bytes_received != value_ull){
bytes_received = value_ull;
snprintf(buf, 100, "%llu", bytes_received);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/bytes/received", 2, strlen(buf), (uint8_t *)buf, 1);
}
value_ull = (unsigned long long)mqtt3_net_bytes_total_sent();
if(bytes_sent != value_ull){
bytes_sent = value_ull;
snprintf(buf, 100, "%llu", bytes_sent);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/bytes/sent", 2, strlen(buf), (uint8_t *)buf, 1);
}
if(uptime){
value = msgs_received/uptime;
if(msgsps_received != value){
msgsps_received = value;
snprintf(buf, 100, "%u", msgsps_received);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/messages/per second/received", 2, strlen(buf), (uint8_t *)buf, 1);
}
value = msgs_sent/uptime;
if(msgsps_sent != value){
msgsps_sent = value;
snprintf(buf, 100, "%u", msgsps_sent);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/messages/per second/sent", 2, strlen(buf), (uint8_t *)buf, 1);
}
value = bytes_received/uptime;
if(bytesps_received != value){
bytesps_received = value;
snprintf(buf, 100, "%u", bytesps_received);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/bytes/per second/received", 2, strlen(buf), (uint8_t *)buf, 1);
}
value = bytes_sent/uptime;
if(bytesps_sent != value){
bytesps_sent = value;
snprintf(buf, 100, "%u", bytesps_sent);
mqtt3_db_messages_easy_queue(db, NULL, "$SYS/broker/bytes/per second/sent", 2, strlen(buf), (uint8_t *)buf, 1);
}
}
last_update = time(NULL);
}
}
void mqtt3_db_limits_set(int inflight, int queued)
{
max_inflight = inflight;
max_queued = queued;
}
void mqtt3_db_vacuum(void)
{
/* FIXME - reimplement? */
}
mosquitto-0.15/src/persist.c 0000664 0001750 0001750 00000052047 11713444064 015163 0 ustar roger roger /*
Copyright (c) 2010,2011 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#ifdef WITH_PERSISTENCE
#ifndef WIN32
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
static int _db_restore_sub(mosquitto_db *db, const char *client_id, const char *sub, int qos);
static struct mosquitto *_db_find_or_add_context(mosquitto_db *db, const char *client_id, uint16_t last_mid)
{
struct mosquitto *context;
struct mosquitto **tmp_contexts;
int i;
context = NULL;
for(i=0; icontext_count; i++){
if(db->contexts[i] && !strcmp(db->contexts[i]->id, client_id)){
context = db->contexts[i];
break;
}
}
if(!context){
context = mqtt3_context_init(-1);
context->clean_session = false;
for(i=0; icontext_count; i++){
if(!db->contexts[i]){
db->contexts[i] = context;
break;
}
}
if(i==db->context_count){
db->context_count++;
tmp_contexts = _mosquitto_realloc(db->contexts, sizeof(struct mosquitto*)*db->context_count);
if(tmp_contexts){
db->contexts = tmp_contexts;
db->contexts[db->context_count-1] = context;
}else{
return NULL;
}
}
context->id = _mosquitto_strdup(client_id);
}
if(last_mid){
context->last_mid = last_mid;
}
return context;
}
static int mqtt3_db_client_messages_write(mosquitto_db *db, FILE *db_fptr, struct mosquitto *context)
{
uint32_t length;
dbid_t i64temp;
uint16_t i16temp, slen;
uint8_t i8temp;
mosquitto_client_msg *cmsg;
assert(db);
assert(db_fptr);
assert(context);
cmsg = context->msgs;
while(cmsg){
slen = strlen(context->id);
length = htonl(sizeof(dbid_t) + sizeof(uint16_t) + sizeof(uint8_t) +
sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint8_t) +
sizeof(uint8_t) + 2+slen);
i16temp = htons(DB_CHUNK_CLIENT_MSG);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, context->id, slen);
i64temp = cmsg->store->db_id;
write_e(db_fptr, &i64temp, sizeof(dbid_t));
i16temp = htons(cmsg->mid);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
i8temp = (uint8_t )cmsg->qos;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )cmsg->retain;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )cmsg->direction;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )cmsg->state;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )cmsg->dup;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
cmsg = cmsg->next;
}
return MOSQ_ERR_SUCCESS;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
static int mqtt3_db_message_store_write(mosquitto_db *db, FILE *db_fptr)
{
uint32_t length;
dbid_t i64temp;
uint32_t i32temp;
uint16_t i16temp, slen;
uint8_t i8temp;
struct mosquitto_msg_store *stored;
assert(db);
assert(db_fptr);
stored = db->msg_store;
while(stored){
length = htonl(sizeof(dbid_t) + 2+strlen(stored->source_id) +
sizeof(uint16_t) + sizeof(uint16_t) +
2+strlen(stored->msg.topic) + sizeof(uint32_t) +
stored->msg.payloadlen + sizeof(uint8_t) + sizeof(uint8_t));
i16temp = htons(DB_CHUNK_MSG_STORE);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
i64temp = stored->db_id;
write_e(db_fptr, &i64temp, sizeof(dbid_t));
slen = strlen(stored->source_id);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
if(slen){
write_e(db_fptr, stored->source_id, slen);
}
i16temp = htons(stored->source_mid);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
i16temp = htons(stored->msg.mid);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
slen = strlen(stored->msg.topic);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, stored->msg.topic, slen);
i8temp = (uint8_t )stored->msg.qos;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )stored->msg.retain;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i32temp = htonl(stored->msg.payloadlen);
write_e(db_fptr, &i32temp, sizeof(uint32_t));
if(stored->msg.payloadlen){
write_e(db_fptr, stored->msg.payload, stored->msg.payloadlen);
}
stored = stored->next;
}
return MOSQ_ERR_SUCCESS;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
static int mqtt3_db_client_write(mosquitto_db *db, FILE *db_fptr)
{
int i;
struct mosquitto *context;
uint16_t i16temp, slen;
uint32_t length;
assert(db);
assert(db_fptr);
for(i=0; icontext_count; i++){
context = db->contexts[i];
if(context && context->clean_session == false){
length = htonl(2+strlen(context->id) + sizeof(uint16_t));
i16temp = htons(DB_CHUNK_CLIENT);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
slen = strlen(context->id);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, context->id, slen);
i16temp = htons(context->last_mid);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
if(mqtt3_db_client_messages_write(db, db_fptr, context)) return 1;
}
}
return MOSQ_ERR_SUCCESS;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
static int _db_subs_retain_write(mosquitto_db *db, FILE *db_fptr, struct _mosquitto_subhier *node, const char *topic)
{
struct _mosquitto_subhier *subhier;
struct _mosquitto_subleaf *sub;
char *thistopic;
uint32_t length;
uint16_t i16temp;
dbid_t i64temp;
int slen;
slen = strlen(topic) + strlen(node->topic) + 2;
thistopic = _mosquitto_malloc(sizeof(char)*slen);
if(!thistopic) return MOSQ_ERR_NOMEM;
if(strlen(topic)){
snprintf(thistopic, slen, "%s/%s", topic, node->topic);
}else{
snprintf(thistopic, slen, "%s", node->topic);
}
sub = node->subs;
while(sub){
if(sub->context->clean_session == false){
length = htonl(2+strlen(sub->context->id) + 2+strlen(thistopic) + sizeof(uint8_t));
i16temp = htons(DB_CHUNK_SUB);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
slen = strlen(sub->context->id);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, sub->context->id, slen);
slen = strlen(thistopic);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, thistopic, slen);
write_e(db_fptr, &sub->qos, sizeof(uint8_t));
}
sub = sub->next;
}
if(node->retained){
length = htonl(sizeof(dbid_t));
i16temp = htons(DB_CHUNK_RETAIN);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
i64temp = node->retained->db_id;
write_e(db_fptr, &i64temp, sizeof(dbid_t));
}
subhier = node->children;
while(subhier){
_db_subs_retain_write(db, db_fptr, subhier, thistopic);
subhier = subhier->next;
}
_mosquitto_free(thistopic);
return MOSQ_ERR_SUCCESS;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
static int mqtt3_db_subs_retain_write(mosquitto_db *db, FILE *db_fptr)
{
struct _mosquitto_subhier *subhier;
subhier = db->subs.children;
while(subhier){
_db_subs_retain_write(db, db_fptr, subhier, "");
subhier = subhier->next;
}
return MOSQ_ERR_SUCCESS;
}
int mqtt3_db_backup(mosquitto_db *db, bool cleanup, bool shutdown)
{
int rc = 0;
FILE *db_fptr = NULL;
uint32_t db_version = htonl(MOSQ_DB_VERSION);
uint32_t crc = htonl(0);
dbid_t i64temp;
uint32_t i32temp;
uint16_t i16temp;
uint8_t i8temp;
if(!db || !db->config || !db->config->persistence_filepath) return MOSQ_ERR_INVAL;
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Saving in-memory database to %s.", db->config->persistence_filepath);
if(cleanup){
mqtt3_db_store_clean(db);
}
db_fptr = fopen(db->config->persistence_filepath, "wb");
if(db_fptr == NULL){
goto error;
}
/* Header */
write_e(db_fptr, magic, 15);
write_e(db_fptr, &crc, sizeof(uint32_t));
write_e(db_fptr, &db_version, sizeof(uint32_t));
/* DB config */
i16temp = htons(DB_CHUNK_CFG);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
/* chunk length */
i32temp = htonl(sizeof(dbid_t) + sizeof(uint8_t) + sizeof(uint8_t));
write_e(db_fptr, &i32temp, sizeof(uint32_t));
/* db written at broker shutdown or not */
i8temp = shutdown;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = sizeof(dbid_t);
write_e(db_fptr, &i8temp, sizeof(uint8_t));
/* last db mid */
i64temp = db->last_db_id;
write_e(db_fptr, &i64temp, sizeof(dbid_t));
if(mqtt3_db_message_store_write(db, db_fptr)){
goto error;
}
mqtt3_db_client_write(db, db_fptr);
mqtt3_db_subs_retain_write(db, db_fptr);
fclose(db_fptr);
return rc;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
if(db_fptr) fclose(db_fptr);
return 1;
}
static int _db_client_msg_restore(mosquitto_db *db, const char *client_id, uint16_t mid, uint8_t qos, uint8_t retain, uint8_t direction, uint8_t state, uint8_t dup, uint64_t store_id)
{
mosquitto_client_msg *cmsg, *tail;
struct mosquitto_msg_store *store;
struct mosquitto *context;
cmsg = _mosquitto_calloc(1, sizeof(mosquitto_client_msg));
if(!cmsg){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
cmsg->store = NULL;
cmsg->mid = mid;
cmsg->qos = qos;
cmsg->retain = retain;
cmsg->direction = direction;
cmsg->state = state;
cmsg->dup = dup;
store = db->msg_store;
while(store){
if(store->db_id == store_id){
cmsg->store = store;
cmsg->store->ref_count++;
break;
}
store = store->next;
}
if(!cmsg->store){
_mosquitto_free(cmsg);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error restoring persistent database, message store corrupt.");
return 1;
}
context = _db_find_or_add_context(db, client_id, 0);
if(!context){
_mosquitto_free(cmsg);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error restoring persistent database, message store corrupt.");
return 1;
}
if(context->msgs){
tail = context->msgs;
while(tail->next){
tail = tail->next;
}
tail->next = cmsg;
}else{
context->msgs = cmsg;
}
cmsg->next = NULL;
return MOSQ_ERR_SUCCESS;
}
static int _db_client_chunk_restore(mosquitto_db *db, FILE *db_fptr)
{
uint16_t i16temp, slen, last_mid;
char *client_id = NULL;
int rc = 0;
struct mosquitto *context;
read_e(db_fptr, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
if(!slen){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Corrupt persistent database.");
fclose(db_fptr);
return 1;
}
client_id = _mosquitto_calloc(slen+1, sizeof(char));
if(!client_id){
fclose(db_fptr);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
read_e(db_fptr, client_id, slen);
read_e(db_fptr, &i16temp, sizeof(uint16_t));
last_mid = ntohs(i16temp);
context = _db_find_or_add_context(db, client_id, last_mid);
if(!context) rc = 1;
_mosquitto_free(client_id);
return rc;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
if(db_fptr) fclose(db_fptr);
if(client_id) _mosquitto_free(client_id);
return 1;
}
static int _db_client_msg_chunk_restore(mosquitto_db *db, FILE *db_fptr)
{
dbid_t i64temp, store_id;
uint16_t i16temp, slen, mid;
uint8_t qos, retain, direction, state, dup;
char *client_id = NULL;
int rc;
read_e(db_fptr, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
if(!slen){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Corrupt persistent database.");
fclose(db_fptr);
return 1;
}
client_id = _mosquitto_calloc(slen+1, sizeof(char));
if(!client_id){
fclose(db_fptr);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
read_e(db_fptr, client_id, slen);
read_e(db_fptr, &i64temp, sizeof(dbid_t));
store_id = i64temp;
read_e(db_fptr, &i16temp, sizeof(uint16_t));
mid = ntohs(i16temp);
read_e(db_fptr, &qos, sizeof(uint8_t));
read_e(db_fptr, &retain, sizeof(uint8_t));
read_e(db_fptr, &direction, sizeof(uint8_t));
read_e(db_fptr, &state, sizeof(uint8_t));
read_e(db_fptr, &dup, sizeof(uint8_t));
rc = _db_client_msg_restore(db, client_id, mid, qos, retain, direction, state, dup, store_id);
_mosquitto_free(client_id);
return rc;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
if(db_fptr) fclose(db_fptr);
if(client_id) _mosquitto_free(client_id);
return 1;
}
static int _db_msg_store_chunk_restore(mosquitto_db *db, FILE *db_fptr)
{
dbid_t i64temp, store_id;
uint32_t i32temp, payloadlen;
uint16_t i16temp, slen, source_mid, mid;
uint8_t qos, retain, *payload = NULL;
char *source_id = NULL;
char *topic = NULL;
int rc = 0;
struct mosquitto_msg_store *stored = NULL;
read_e(db_fptr, &i64temp, sizeof(dbid_t));
store_id = i64temp;
read_e(db_fptr, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
if(slen){
source_id = _mosquitto_calloc(slen+1, sizeof(char));
if(!source_id){
fclose(db_fptr);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
if(fread(source_id, 1, slen, db_fptr) != slen){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
fclose(db_fptr);
_mosquitto_free(source_id);
return 1;
}
}
read_e(db_fptr, &i16temp, sizeof(uint16_t));
source_mid = ntohs(i16temp);
read_e(db_fptr, &i16temp, sizeof(uint16_t));
mid = ntohs(i16temp);
read_e(db_fptr, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
if(slen){
topic = _mosquitto_calloc(slen+1, sizeof(char));
if(!topic){
fclose(db_fptr);
_mosquitto_free(source_id);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
if(fread(topic, 1, slen, db_fptr) != slen){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
fclose(db_fptr);
_mosquitto_free(source_id);
_mosquitto_free(topic);
return 1;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid msg_store chunk when restoring persistent database.");
fclose(db_fptr);
_mosquitto_free(source_id);
return 1;
}
read_e(db_fptr, &qos, sizeof(uint8_t));
read_e(db_fptr, &retain, sizeof(uint8_t));
read_e(db_fptr, &i32temp, sizeof(uint32_t));
payloadlen = ntohl(i32temp);
if(payloadlen){
payload = _mosquitto_malloc(payloadlen);
if(!payload){
fclose(db_fptr);
_mosquitto_free(source_id);
_mosquitto_free(topic);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
if(fread(payload, 1, payloadlen, db_fptr) != payloadlen){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
fclose(db_fptr);
_mosquitto_free(source_id);
_mosquitto_free(topic);
_mosquitto_free(payload);
return 1;
}
}
rc = mqtt3_db_message_store(db, source_id, source_mid, topic, qos, payloadlen, payload, retain, &stored, store_id);
_mosquitto_free(source_id);
_mosquitto_free(topic);
_mosquitto_free(payload);
return rc;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
if(db_fptr) fclose(db_fptr);
if(source_id) _mosquitto_free(source_id);
if(topic) _mosquitto_free(topic);
return 1;
}
static int _db_retain_chunk_restore(mosquitto_db *db, FILE *db_fptr)
{
dbid_t i64temp, store_id;
struct mosquitto_msg_store *store;
if(fread(&i64temp, 1, sizeof(dbid_t), db_fptr) != sizeof(dbid_t)){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
fclose(db_fptr);
return 1;
}
store_id = i64temp;
store = db->msg_store;
while(store){
if(store->db_id == store_id){
mqtt3_db_messages_queue(db, NULL, store->msg.topic, store->msg.qos, store->msg.retain, store);
break;
}
store = store->next;
}
return MOSQ_ERR_SUCCESS;
}
static int _db_sub_chunk_restore(mosquitto_db *db, FILE *db_fptr)
{
uint16_t i16temp, slen;
uint8_t qos;
char *client_id;
char *topic;
int rc = 0;
read_e(db_fptr, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
client_id = _mosquitto_calloc(slen+1, sizeof(char));
if(!client_id){
fclose(db_fptr);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
read_e(db_fptr, client_id, slen);
read_e(db_fptr, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
topic = _mosquitto_calloc(slen+1, sizeof(char));
if(!topic){
fclose(db_fptr);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
_mosquitto_free(client_id);
return MOSQ_ERR_NOMEM;
}
read_e(db_fptr, topic, slen);
read_e(db_fptr, &qos, sizeof(uint8_t));
if(_db_restore_sub(db, client_id, topic, qos)){
rc = 1;
}
_mosquitto_free(client_id);
_mosquitto_free(topic);
return rc;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
if(db_fptr) fclose(db_fptr);
return 1;
}
int mqtt3_db_restore(mosquitto_db *db)
{
FILE *fptr;
char header[15];
int rc = 0;
uint32_t crc, db_version;
dbid_t i64temp;
uint32_t i32temp, length;
uint16_t i16temp, chunk;
uint8_t i8temp;
ssize_t rlen;
assert(db);
assert(db->config);
assert(db->config->persistence_filepath);
fptr = fopen(db->config->persistence_filepath, "rb");
if(fptr == NULL) return MOSQ_ERR_SUCCESS;
read_e(fptr, &header, 15);
if(!memcmp(header, magic, 15)){
// Restore DB as normal
read_e(fptr, &crc, sizeof(uint32_t));
read_e(fptr, &i32temp, sizeof(uint32_t));
db_version = ntohl(i32temp);
/* IMPORTANT - this is where compatibility checks are made.
* Is your DB change still compatible with previous versions?
*/
if(db_version > MOSQ_DB_VERSION && db_version != 0){
fclose(fptr);
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unsupported persistent database format version %d (need version %d).", db_version, MOSQ_DB_VERSION);
return 1;
}
while(rlen = fread(&i16temp, 1, sizeof(uint16_t), fptr), rlen == sizeof(uint16_t)){
chunk = ntohs(i16temp);
read_e(fptr, &i32temp, sizeof(uint32_t));
length = ntohl(i32temp);
switch(chunk){
case DB_CHUNK_CFG:
read_e(fptr, &i8temp, sizeof(uint8_t)); // shutdown
read_e(fptr, &i8temp, sizeof(uint8_t)); // sizeof(dbid_t)
if(i8temp != sizeof(dbid_t)){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Incompatible database configuration (dbid size is %d bytes, expected %d)",
i8temp, sizeof(dbid_t));
fclose(fptr);
return 1;
}
read_e(fptr, &i64temp, sizeof(dbid_t));
db->last_db_id = i64temp;
break;
case DB_CHUNK_MSG_STORE:
if(_db_msg_store_chunk_restore(db, fptr)) return 1;
break;
case DB_CHUNK_CLIENT_MSG:
if(_db_client_msg_chunk_restore(db, fptr)) return 1;
break;
case DB_CHUNK_RETAIN:
if(_db_retain_chunk_restore(db, fptr)) return 1;
break;
case DB_CHUNK_SUB:
if(_db_sub_chunk_restore(db, fptr)) return 1;
break;
case DB_CHUNK_CLIENT:
if(_db_client_chunk_restore(db, fptr)) return 1;
break;
default:
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Unsupported chunk \"%d\" in persistent database file. Ignoring.", chunk);
fseek(fptr, length, SEEK_CUR);
break;
}
}
if(rlen < 0) goto error;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to restore persistent database. Unrecognised file format.");
rc = 1;
}
fclose(fptr);
return rc;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
if(fptr) fclose(fptr);
return 1;
}
static int _db_restore_sub(mosquitto_db *db, const char *client_id, const char *sub, int qos)
{
struct mosquitto *context;
assert(db);
assert(client_id);
assert(sub);
context = _db_find_or_add_context(db, client_id, 0);
if(!context) return 1;
return mqtt3_sub_add(context, sub, qos, &db->subs);
}
#endif
mosquitto-0.15/src/subs.c 0000664 0001750 0001750 00000037044 11713444064 014446 0 ustar roger roger /*
Copyright (c) 2010-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
#include
struct _sub_token {
struct _sub_token *next;
char *topic;
};
static int _subs_process(struct _mosquitto_db *db, struct _mosquitto_subhier *hier, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store *stored)
{
int rc = 0;
int rc2;
int client_qos, msg_qos;
uint16_t mid;
struct _mosquitto_subleaf *leaf;
leaf = hier->subs;
if(retain){
if(hier->retained){
hier->retained->ref_count--;
/* FIXME - it would be nice to be able to remove the message from the store at this point if ref_count == 0 */
}
if(stored->msg.payloadlen){
hier->retained = stored;
hier->retained->ref_count++;
}else{
hier->retained = NULL;
}
}
while(source_id && leaf){
if(leaf->context->bridge && !strcmp(leaf->context->id, source_id)){
leaf = leaf->next;
continue;
}
/* Check for ACL topic access. */
rc2 = mosquitto_acl_check(db, leaf->context, topic, MOSQ_ACL_READ);
if(rc2 == MOSQ_ERR_ACL_DENIED){
leaf = leaf->next;
continue;
}else if(rc2 == MOSQ_ERR_SUCCESS){
client_qos = leaf->qos;
if(qos > client_qos){
msg_qos = client_qos;
}else{
msg_qos = qos;
}
if(msg_qos){
mid = _mosquitto_mid_generate(leaf->context);
}else{
mid = 0;
}
if(mqtt3_db_message_insert(db, leaf->context, mid, mosq_md_out, msg_qos, false, stored) == 1) rc = 1;
}else{
rc = 1;
}
leaf = leaf->next;
}
return rc;
}
static int _sub_topic_tokenise(const char *subtopic, struct _sub_token **topics)
{
struct _sub_token *new_topic, *tail = NULL;
char *token;
char *local_subtopic = NULL;
char *real_subtopic;
assert(subtopic);
assert(topics);
local_subtopic = _mosquitto_strdup(subtopic);
if(!local_subtopic) return MOSQ_ERR_NOMEM;
real_subtopic = local_subtopic;
if(local_subtopic[0] == '/'){
new_topic = _mosquitto_malloc(sizeof(struct _sub_token));
if(!new_topic) goto cleanup;
new_topic->next = NULL;
new_topic->topic = _mosquitto_strdup("/");
if(!new_topic->topic) goto cleanup;
*topics = new_topic;
tail = new_topic;
local_subtopic++;
}
token = strtok(local_subtopic, "/");
while(token){
new_topic = _mosquitto_malloc(sizeof(struct _sub_token));
if(!new_topic) goto cleanup;
new_topic->next = NULL;
new_topic->topic = _mosquitto_strdup(token);
if(!new_topic->topic) goto cleanup;
if(tail){
tail->next = new_topic;
tail = tail->next;
}else{
tail = new_topic;
*topics = tail;
}
token = strtok(NULL, "/");
}
_mosquitto_free(real_subtopic);
return MOSQ_ERR_SUCCESS;
cleanup:
_mosquitto_free(real_subtopic);
tail = *topics;
*topics = NULL;
while(tail){
if(tail->topic) _mosquitto_free(tail->topic);
new_topic = tail->next;
_mosquitto_free(tail);
tail = new_topic;
}
return 1;
}
static int _sub_add(struct mosquitto *context, int qos, struct _mosquitto_subhier *subhier, struct _sub_token *tokens)
{
struct _mosquitto_subhier *branch, *last = NULL;
struct _mosquitto_subleaf *leaf, *last_leaf;
if(!tokens){
if(context){
leaf = subhier->subs;
last_leaf = NULL;
while(leaf){
if(!strcmp(leaf->context->id, context->id)){
/* Client making a second subscription to same topic. Only
* need to update QoS. Return -1 to indicate this to the
* calling function. */
leaf->qos = qos;
return -1;
}
last_leaf = leaf;
leaf = leaf->next;
}
leaf = _mosquitto_malloc(sizeof(struct _mosquitto_subleaf));
if(!leaf) return MOSQ_ERR_NOMEM;
leaf->next = NULL;
leaf->context = context;
leaf->qos = qos;
if(last_leaf){
last_leaf->next = leaf;
leaf->prev = last_leaf;
}else{
subhier->subs = leaf;
leaf->prev = NULL;
}
}
return MOSQ_ERR_SUCCESS;
}
branch = subhier->children;
while(branch){
if(!strcmp(branch->topic, tokens->topic)){
return _sub_add(context, qos, branch, tokens->next);
}
last = branch;
branch = branch->next;
}
/* Not found */
branch = _mosquitto_calloc(1, sizeof(struct _mosquitto_subhier));
if(!branch) return MOSQ_ERR_NOMEM;
branch->topic = _mosquitto_strdup(tokens->topic);
if(!branch->topic) return MOSQ_ERR_NOMEM;
if(!last){
subhier->children = branch;
}else{
last->next = branch;
}
return _sub_add(context, qos, branch, tokens->next);
}
static int _sub_remove(struct mosquitto *context, struct _mosquitto_subhier *subhier, struct _sub_token *tokens)
{
struct _mosquitto_subhier *branch, *last = NULL;
struct _mosquitto_subleaf *leaf;
if(!tokens){
leaf = subhier->subs;
while(leaf){
if(leaf->context==context){
if(leaf->prev){
leaf->prev->next = leaf->next;
}else{
subhier->subs = leaf->next;
}
if(leaf->next){
leaf->next->prev = leaf->prev;
}
_mosquitto_free(leaf);
return MOSQ_ERR_SUCCESS;
}
leaf = leaf->next;
}
return MOSQ_ERR_SUCCESS;
}
branch = subhier->children;
while(branch){
if(!strcmp(branch->topic, tokens->topic)){
_sub_remove(context, branch, tokens->next);
if(!branch->children && !branch->subs && !branch->retained){
if(last){
last->next = branch->next;
}else{
subhier->children = branch->next;
}
_mosquitto_free(branch->topic);
_mosquitto_free(branch);
}
return MOSQ_ERR_SUCCESS;
}
last = branch;
branch = branch->next;
}
return MOSQ_ERR_SUCCESS;
}
static int _sub_search(struct _mosquitto_db *db, struct _mosquitto_subhier *subhier, struct _sub_token *tokens, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store *stored)
{
/* FIXME - need to take into account source_id if the client is a bridge */
struct _mosquitto_subhier *branch;
int flag = 0;
branch = subhier->children;
while(branch){
if(tokens && tokens->topic && (!strcmp(branch->topic, tokens->topic) || !strcmp(branch->topic, "+"))){
/* The topic matches this subscription.
* Doesn't include # wildcards */
_sub_search(db, branch, tokens->next, source_id, topic, qos, retain, stored);
if(!tokens->next){
_subs_process(db, branch, source_id, topic, qos, retain, stored);
}
}else if(!strcmp(branch->topic, "#") && !branch->children && (!tokens || strcmp(tokens->topic, "/"))){
/* The topic matches due to a # wildcard - process the
* subscriptions but *don't* return. Although this branch has ended
* there may still be other subscriptions to deal with.
*/
_subs_process(db, branch, source_id, topic, qos, retain, stored);
flag = -1;
}
branch = branch->next;
}
return flag;
}
int mqtt3_sub_add(struct mosquitto *context, const char *sub, int qos, struct _mosquitto_subhier *root)
{
int tree;
int rc = 0;
struct _mosquitto_subhier *subhier;
struct _sub_token *tokens = NULL, *tail;
assert(root);
assert(sub);
if(!strncmp(sub, "$SYS/", 5)){
tree = 2;
if(strlen(sub+5) == 0) return MOSQ_ERR_SUCCESS;
if(_sub_topic_tokenise(sub+5, &tokens)) return 1;
}else{
tree = 0;
if(strlen(sub) == 0) return MOSQ_ERR_SUCCESS;
if(_sub_topic_tokenise(sub, &tokens)) return 1;
}
subhier = root->children;
while(subhier){
if(!strcmp(subhier->topic, "") && tree == 0){
rc = _sub_add(context, qos, subhier, tokens);
break;
}else if(!strcmp(subhier->topic, "$SYS") && tree == 2){
rc = _sub_add(context, qos, subhier, tokens);
break;
}
subhier = subhier->next;
}
while(tokens){
tail = tokens->next;
_mosquitto_free(tokens->topic);
_mosquitto_free(tokens);
tokens = tail;
}
/* We aren't worried about -1 (already subscribed) return codes. */
if(rc == -1) rc = MOSQ_ERR_SUCCESS;
return rc;
}
int mqtt3_sub_remove(struct mosquitto *context, const char *sub, struct _mosquitto_subhier *root)
{
int rc = 0;
int tree;
struct _mosquitto_subhier *subhier;
struct _sub_token *tokens = NULL, *tail;
assert(root);
assert(sub);
if(!strncmp(sub, "$SYS/", 5)){
tree = 2;
if(_sub_topic_tokenise(sub+5, &tokens)) return 1;
}else{
tree = 0;
if(_sub_topic_tokenise(sub, &tokens)) return 1;
}
subhier = root->children;
while(subhier){
if(!strcmp(subhier->topic, "") && tree == 0){
rc = _sub_remove(context, subhier, tokens);
break;
}else if(!strcmp(subhier->topic, "$SYS") && tree == 2){
rc = _sub_remove(context, subhier, tokens);
break;
}
subhier = subhier->next;
}
while(tokens){
tail = tokens->next;
_mosquitto_free(tokens->topic);
_mosquitto_free(tokens);
tokens = tail;
}
return rc;
}
int mqtt3_db_messages_queue(struct _mosquitto_db *db, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store *stored)
{
int rc = 0;
int tree;
struct _mosquitto_subhier *subhier;
struct _sub_token *tokens = NULL, *tail;
assert(db);
assert(topic);
if(!strncmp(topic, "$SYS/", 5)){
tree = 2;
if(_sub_topic_tokenise(topic+5, &tokens)) return 1;
}else{
tree = 0;
if(_sub_topic_tokenise(topic, &tokens)) return 1;
}
subhier = db->subs.children;
while(subhier){
if(!strcmp(subhier->topic, "") && tree == 0){
if(retain){
/* We have a message that needs to be retained, so ensure that the subscription
* tree for its topic exists.
*/
_sub_add(NULL, 0, subhier, tokens);
}
rc = _sub_search(db, subhier, tokens, source_id, topic, qos, retain, stored);
if(rc == -1){
_subs_process(db, subhier, source_id, topic, qos, retain, stored);
rc = 0;
}
}else if(!strcmp(subhier->topic, "$SYS") && tree == 2){
if(retain){
/* We have a message that needs to be retained, so ensure that the subscription
* tree for its topic exists.
*/
_sub_add(NULL, 0, subhier, tokens);
}
rc = _sub_search(db, subhier, tokens, source_id, topic, qos, retain, stored);
if(rc == -1){
_subs_process(db, subhier, source_id, topic, qos, retain, stored);
rc = 0;
}
}
subhier = subhier->next;
}
while(tokens){
tail = tokens->next;
_mosquitto_free(tokens->topic);
_mosquitto_free(tokens);
tokens = tail;
}
return rc;
}
static int _subs_clean_session(struct mosquitto *context, struct _mosquitto_subhier *root)
{
int rc = 0;
struct _mosquitto_subhier *child, *last = NULL;
struct _mosquitto_subleaf *leaf, *next;
if(!root) return MOSQ_ERR_SUCCESS;
leaf = root->subs;
while(leaf){
if(leaf->context == context){
if(leaf->prev){
leaf->prev->next = leaf->next;
}else{
root->subs = leaf->next;
}
if(leaf->next){
leaf->next->prev = leaf->prev;
}
next = leaf->next;
_mosquitto_free(leaf);
leaf = next;
}else{
leaf = leaf->next;
}
}
child = root->children;
while(child){
_subs_clean_session(context, child);
if(!child->children && !child->subs && !child->retained){
if(last){
last->next = child->next;
}else{
root->children = child->next;
}
_mosquitto_free(child->topic);
_mosquitto_free(child);
if(last){
child = last->next;
}else{
child = root->children;
}
}else{
last = child;
child = child->next;
}
}
return rc;
}
/* Remove all subscriptions for a client.
*/
int mqtt3_subs_clean_session(struct mosquitto *context, struct _mosquitto_subhier *root)
{
struct _mosquitto_subhier *child;
child = root->children;
while(child){
_subs_clean_session(context, child);
child = child->next;
}
return MOSQ_ERR_SUCCESS;
}
void mqtt3_sub_tree_print(struct _mosquitto_subhier *root, int level)
{
int i;
struct _mosquitto_subhier *branch;
struct _mosquitto_subleaf *leaf;
for(i=0; itopic);
leaf = root->subs;
while(leaf){
printf(" (%s, %d)", "", leaf->qos);
leaf = leaf->next;
}
if(root->retained){
printf(" (r)");
}
printf("\n");
branch = root->children;
while(branch){
mqtt3_sub_tree_print(branch, level+1);
branch = branch->next;
}
}
static int _retain_process(struct _mosquitto_db *db, struct mosquitto_msg_store *retained, struct mosquitto *context, const char *sub, int sub_qos)
{
int rc = 0;
int qos;
uint16_t mid;
rc = mosquitto_acl_check(db, context, retained->msg.topic, MOSQ_ACL_READ);
if(rc == MOSQ_ERR_ACL_DENIED){
return MOSQ_ERR_SUCCESS;
}else if(rc != MOSQ_ERR_SUCCESS){
return rc;
}
qos = retained->msg.qos;
if(qos > sub_qos) qos = sub_qos;
if(qos > 0){
mid = _mosquitto_mid_generate(context);
}else{
mid = 0;
}
return mqtt3_db_message_insert(db, context, mid, mosq_md_out, qos, true, retained);
}
static int _retain_search(struct _mosquitto_db *db, struct _mosquitto_subhier *subhier, struct _sub_token *tokens, struct mosquitto *context, const char *sub, int sub_qos)
{
struct _mosquitto_subhier *branch;
branch = subhier->children;
while(branch){
/* Subscriptions with wildcards in aren't really valid topics to publish to
* so they can't have retained messages.
*/
if(_mosquitto_topic_wildcard_len_check(branch->topic) == MOSQ_ERR_SUCCESS){
if(!strcmp(tokens->topic, "#") && !tokens->next){
if(branch->retained){
_retain_process(db, branch->retained, context, sub, sub_qos);
}
_retain_search(db, branch, tokens, context, sub, sub_qos);
}else if(!strcmp(branch->topic, tokens->topic) || !strcmp(tokens->topic, "+")){
if(tokens->next){
_retain_search(db, branch, tokens->next, context, sub, sub_qos);
}else{
if(branch->retained){
_retain_process(db, branch->retained, context, sub, sub_qos);
}
}
}
}
branch = branch->next;
}
return MOSQ_ERR_SUCCESS;
}
int mqtt3_retain_queue(mosquitto_db *db, struct mosquitto *context, const char *sub, int sub_qos)
{
int rc = 0;
int tree;
struct _mosquitto_subhier *subhier;
struct _sub_token *tokens = NULL, *tail;
assert(db);
assert(context);
assert(sub);
if(!strncmp(sub, "$SYS/", 5)){
tree = 2;
if(_sub_topic_tokenise(sub+5, &tokens)) return 1;
}else{
tree = 0;
if(_sub_topic_tokenise(sub, &tokens)) return 1;
}
subhier = db->subs.children;
while(subhier){
if(!strcmp(subhier->topic, "") && tree == 0){
rc = _retain_search(db, subhier, tokens, context, sub, sub_qos);
break;
}else if(!strcmp(subhier->topic, "$SYS") && tree == 2){
rc = _retain_search(db, subhier, tokens, context, sub, sub_qos);
break;
}
subhier = subhier->next;
}
while(tokens){
tail = tokens->next;
_mosquitto_free(tokens->topic);
_mosquitto_free(tokens);
tokens = tail;
}
return rc;
}
mosquitto-0.15/src/mosquitto.c 0000664 0001750 0001750 00000022047 11713444064 015533 0 ustar roger roger /*
Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#ifndef WIN32
#include
#else
#include
#include
#include
#endif
#include
#include
#include
#include
#ifdef WITH_WRAP
#include
#endif
#include
#include
mosquitto_db int_db;
bool flag_reload = false;
#ifdef WITH_PERSISTENCE
bool flag_db_backup = false;
#endif
bool flag_tree_print = false;
int run;
#ifdef WITH_WRAP
#include
int allow_severity = LOG_INFO;
int deny_severity = LOG_INFO;
#endif
int drop_privileges(mqtt3_config *config);
void handle_sigint(int signal);
void handle_sigusr1(int signal);
void handle_sigusr2(int signal);
/* mosquitto shouldn't run as root.
* This function will attempt to change to an unprivileged user and group if
* running as root. The user is given in config->user.
* Returns 1 on failure (unknown user, setuid/setgid failure)
* Returns 0 on success.
* Note that setting config->user to "root" does not produce an error, but it
* strongly discouraged.
*/
int drop_privileges(mqtt3_config *config)
{
#if !defined(__CYGWIN__) && !defined(WIN32)
struct passwd *pwd;
if(geteuid() == 0){
if(config->user){
pwd = getpwnam(config->user);
if(!pwd){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid user '%s'.", config->user);
return 1;
}
if(setgid(pwd->pw_gid) == -1){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
if(setuid(pwd->pw_uid) == -1){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
}
if(geteuid() == 0 || getegid() == 0){
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Mosquitto should not be run as root/administrator.");
}
}
#endif
return MOSQ_ERR_SUCCESS;
}
#ifdef SIGHUP
/* Signal handler for SIGHUP - flag a config reload. */
void handle_sighup(int signal)
{
flag_reload = true;
}
#endif
/* Signal handler for SIGINT and SIGTERM - just stop gracefully. */
void handle_sigint(int signal)
{
run = 0;
}
/* Signal handler for SIGUSR1 - backup the db. */
void handle_sigusr1(int signal)
{
#ifdef WITH_PERSISTENCE
flag_db_backup = true;
#endif
}
/* Signal handler for SIGUSR2 - vacuum the db. */
void handle_sigusr2(int signal)
{
flag_tree_print = true;
}
int main(int argc, char *argv[])
{
int *listensock = NULL;
int listensock_count = 0;
int listensock_index = 0;
mqtt3_config config;
char buf[1024];
int i, j;
FILE *pid;
int listener_max;
int rc;
#if defined(WIN32) || defined(__CYGWIN__)
if(argc == 2){
if(!strcmp(argv[1], "run")){
service_run();
return 0;
}else if(!strcmp(argv[1], "install")){
service_install();
return 0;
}else if(!strcmp(argv[1], "uninstall")){
service_uninstall();
return 0;
}
}
#endif
memset(&int_db, 0, sizeof(mosquitto_db));
_mosquitto_net_init();
mqtt3_config_init(&config);
rc = mqtt3_config_parse_args(&config, argc, argv);
if(rc != MOSQ_ERR_SUCCESS) return rc;
int_db.config = &config;
if(config.daemon){
#ifndef WIN32
switch(fork()){
case 0:
break;
case -1:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error in fork: %s", strerror(errno));
return 1;
default:
return MOSQ_ERR_SUCCESS;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Can't start in daemon mode in Windows.");
#endif
}
if(config.daemon && config.pid_file){
pid = fopen(config.pid_file, "wt");
if(pid){
fprintf(pid, "%d", getpid());
fclose(pid);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to write pid file.");
return 1;
}
}
rc = drop_privileges(&config);
if(rc != MOSQ_ERR_SUCCESS) return rc;
rc = mqtt3_db_open(&config, &int_db);
if(rc != MOSQ_ERR_SUCCESS){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Couldn't open database.");
return rc;
}
/* Initialise logging only after initialising the database in case we're
* logging to topics */
mqtt3_log_init(config.log_type, config.log_dest);
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "mosquitto version %s (build date %s) starting", VERSION, TIMESTAMP);
rc = mosquitto_security_init(&int_db);
if(rc) return rc;
/* Set static $SYS messages */
snprintf(buf, 1024, "mosquitto version %s", VERSION);
mqtt3_db_messages_easy_queue(&int_db, NULL, "$SYS/broker/version", 2, strlen(buf), (uint8_t *)buf, 1);
snprintf(buf, 1024, "%s", TIMESTAMP);
mqtt3_db_messages_easy_queue(&int_db, NULL, "$SYS/broker/timestamp", 2, strlen(buf), (uint8_t *)buf, 1);
snprintf(buf, 1024, "%s", "$Revision: e745e1ab5007 $"); // Requires hg keyword extension.
mqtt3_db_messages_easy_queue(&int_db, NULL, "$SYS/broker/changeset", 2, strlen(buf), (uint8_t *)buf, 1);
listener_max = -1;
listensock_index = 0;
for(i=0; i listener_max){
listener_max = listensock[listensock_index];
}
listensock_index++;
}
}
signal(SIGINT, handle_sigint);
signal(SIGTERM, handle_sigint);
#ifdef SIGHUP
signal(SIGHUP, handle_sighup);
#endif
#ifndef WIN32
signal(SIGUSR1, handle_sigusr1);
signal(SIGUSR2, handle_sigusr2);
signal(SIGPIPE, SIG_IGN);
#endif
#ifdef WITH_BRIDGE
for(i=0; i
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef WITH_BRIDGE
int mqtt3_bridge_new(mosquitto_db *db, struct _mqtt3_bridge *bridge)
{
int i;
struct mosquitto *new_context = NULL;
struct mosquitto **tmp_contexts;
char hostname[256];
int len;
assert(db);
assert(bridge);
new_context = mqtt3_context_init(-1);
if(!new_context){
return MOSQ_ERR_NOMEM;
}
new_context->bridge = bridge;
for(i=0; icontext_count; i++){
if(db->contexts[i] == NULL){
db->contexts[i] = new_context;
break;
}
}
if(i==db->context_count){
db->context_count++;
tmp_contexts = _mosquitto_realloc(db->contexts, sizeof(struct mosquitto*)*db->context_count);
if(tmp_contexts){
db->contexts = tmp_contexts;
db->contexts[db->context_count-1] = new_context;
}else{
_mosquitto_free(new_context);
return MOSQ_ERR_NOMEM;
}
}
/* FIXME - need to check that this name isn't already in use. */
if(bridge->clientid){
new_context->id = _mosquitto_strdup(bridge->clientid);
}else{
if(!gethostname(hostname, 256)){
len = strlen(hostname) + strlen(bridge->name) + 2;
new_context->id = _mosquitto_malloc(len);
if(!new_context->id){
return MOSQ_ERR_NOMEM;
}
snprintf(new_context->id, len, "%s.%s", hostname, bridge->name);
}else{
return 1;
}
}
if(!new_context->id){
_mosquitto_free(new_context);
return MOSQ_ERR_NOMEM;
}
new_context->username = new_context->bridge->username;
new_context->password = new_context->bridge->password;
return mqtt3_bridge_connect(db, new_context);
}
int mqtt3_bridge_connect(mosquitto_db *db, struct mosquitto *context)
{
int rc;
int i;
char *notification_topic;
int notification_topic_len;
uint8_t notification_payload[2];
if(!context || !context->bridge) return MOSQ_ERR_INVAL;
context->state = mosq_cs_new;
context->sock = -1;
context->last_msg_in = time(NULL);
context->last_msg_out = time(NULL);
context->keepalive = context->bridge->keepalive;
context->clean_session = context->bridge->clean_session;
context->in_packet.payload = NULL;
mqtt3_bridge_packet_cleanup(context);
for(i=0; ibridge->topic_count; i++){
if(context->bridge->topics[i].direction == bd_out || context->bridge->topics[i].direction == bd_both){
if(mqtt3_sub_add(context, context->bridge->topics[i].topic, context->bridge->topics[i].qos, &db->subs)) return 1;
}
}
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "Connecting bridge %s", context->bridge->name);
rc = _mosquitto_socket_connect(context, context->bridge->address, context->bridge->port);
if(rc != MOSQ_ERR_SUCCESS){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error creating bridge.");
return rc;
}
if(context->bridge->notifications){
notification_topic_len = strlen(context->id)+strlen("$SYS/broker/connection//state");
notification_topic = _mosquitto_malloc(sizeof(char)*(notification_topic_len+1));
if(!notification_topic) return MOSQ_ERR_NOMEM;
snprintf(notification_topic, notification_topic_len+1, "$SYS/broker/connection/%s/state", context->id);
notification_payload[0] = '0';
notification_payload[1] = '\0';
mqtt3_db_messages_easy_queue(db, context, notification_topic, 1, 2, (uint8_t *)¬ification_payload, 1);
rc = _mosquitto_will_set(context, true, notification_topic, 2, (uint8_t *)¬ification_payload, 1, true);
if(rc != MOSQ_ERR_SUCCESS){
_mosquitto_free(notification_topic);
return rc;
}
_mosquitto_free(notification_topic);
}
return _mosquitto_send_connect(context, context->keepalive, context->clean_session);
}
void mqtt3_bridge_packet_cleanup(struct mosquitto *context)
{
struct _mosquitto_packet *packet;
if(!context) return;
while(context->out_packet){
_mosquitto_packet_cleanup(context->out_packet);
packet = context->out_packet;
context->out_packet = context->out_packet->next;
_mosquitto_free(packet);
}
_mosquitto_packet_cleanup(&(context->in_packet));
}
#endif
mosquitto-0.15/src/db_dump/ 0000775 0001750 0001750 00000000000 11713444064 014730 5 ustar roger roger mosquitto-0.15/src/db_dump/db_dump.c 0000664 0001750 0001750 00000024510 11713444064 016510 0 ustar roger roger /*
Copyright (c) 2010-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
static int _db_client_chunk_restore(mosquitto_db *db, FILE *db_fd)
{
uint16_t i16temp, slen, last_mid;
char *client_id = NULL;
int rc = 0;
read_e(db_fd, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
if(!slen){
fprintf(stderr, "Error: Corrupt persistent database.");
fclose(db_fd);
return 1;
}
client_id = calloc(slen+1, sizeof(char));
if(!client_id){
fclose(db_fd);
fprintf(stderr, "Error: Out of memory.");
return 1;
}
read_e(db_fd, client_id, slen);
printf("\tClient ID: %s\n", client_id);
read_e(db_fd, &i16temp, sizeof(uint16_t));
last_mid = ntohs(i16temp);
printf("\tLast MID: %d\n", last_mid);
free(client_id);
return rc;
error:
fprintf(stderr, "Error: %s.", strerror(errno));
if(db_fd >= 0) fclose(db_fd);
if(client_id) free(client_id);
return 1;
}
static int _db_client_msg_chunk_restore(mosquitto_db *db, FILE *db_fd)
{
dbid_t i64temp, store_id;
uint16_t i16temp, slen, mid;
uint8_t qos, retain, direction, state, dup;
char *client_id = NULL;
read_e(db_fd, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
if(!slen){
fprintf(stderr, "Error: Corrupt persistent database.");
fclose(db_fd);
return 1;
}
client_id = calloc(slen+1, sizeof(char));
if(!client_id){
fclose(db_fd);
fprintf(stderr, "Error: Out of memory.");
return 1;
}
read_e(db_fd, client_id, slen);
printf("\tClient ID: %s\n", client_id);
read_e(db_fd, &i64temp, sizeof(dbid_t));
store_id = i64temp;
printf("\tStore ID: %ld\n", (long )store_id);
read_e(db_fd, &i16temp, sizeof(uint16_t));
mid = ntohs(i16temp);
printf("\tMID: %d\n", mid);
read_e(db_fd, &qos, sizeof(uint8_t));
printf("\tQoS: %d\n", mid);
read_e(db_fd, &retain, sizeof(uint8_t));
printf("\tRetain: %d\n", mid);
read_e(db_fd, &direction, sizeof(uint8_t));
printf("\tDirection: %d\n", mid);
read_e(db_fd, &state, sizeof(uint8_t));
printf("\tState: %d\n", mid);
read_e(db_fd, &dup, sizeof(uint8_t));
printf("\tDup: %d\n", mid);
free(client_id);
return 0;
error:
fprintf(stderr, "Error: %s.", strerror(errno));
if(db_fd >= 0) fclose(db_fd);
if(client_id) free(client_id);
return 1;
}
static int _db_msg_store_chunk_restore(mosquitto_db *db, FILE *db_fd)
{
dbid_t i64temp, store_id;
uint32_t i32temp, payloadlen;
uint16_t i16temp, slen, source_mid, mid;
uint8_t qos, retain, *payload = NULL;
char *source_id = NULL;
char *topic = NULL;
int rc = 0;
bool binary;
int i;
read_e(db_fd, &i64temp, sizeof(dbid_t));
store_id = i64temp;
printf("\tStore ID: %ld\n", (long)store_id);
read_e(db_fd, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
if(slen){
source_id = calloc(slen+1, sizeof(char));
if(!source_id){
fclose(db_fd);
fprintf(stderr, "Error: Out of memory.");
return 1;
}
if(fread(source_id, 1, slen, db_fd) != slen){
fprintf(stderr, "Error: %s.", strerror(errno));
fclose(db_fd);
free(source_id);
return 1;
}
printf("\tSource ID: %s\n", source_id);
free(source_id);
}
read_e(db_fd, &i16temp, sizeof(uint16_t));
source_mid = ntohs(i16temp);
printf("\tSource MID: %d\n", source_mid);
read_e(db_fd, &i16temp, sizeof(uint16_t));
mid = ntohs(i16temp);
printf("\tMID: %d\n", source_mid);
read_e(db_fd, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
if(slen){
topic = calloc(slen+1, sizeof(char));
if(!topic){
fclose(db_fd);
free(source_id);
fprintf(stderr, "Error: Out of memory.");
return 1;
}
if(fread(topic, 1, slen, db_fd) != slen){
fprintf(stderr, "Error: %s.", strerror(errno));
fclose(db_fd);
free(source_id);
free(topic);
return 1;
}
printf("\tTopic: %s\n", topic);
free(topic);
}else{
fprintf(stderr, "Error: Invalid msg_store chunk when restoring persistent database.");
fclose(db_fd);
free(source_id);
return 1;
}
read_e(db_fd, &qos, sizeof(uint8_t));
printf("\tQoS: %d\n", qos);
read_e(db_fd, &retain, sizeof(uint8_t));
printf("\tRetain: %d\n", retain);
read_e(db_fd, &i32temp, sizeof(uint32_t));
payloadlen = ntohl(i32temp);
printf("\tPayload Length: %d\n", payloadlen);
if(payloadlen){
payload = malloc(payloadlen+1);
if(!payload){
fclose(db_fd);
free(source_id);
free(topic);
fprintf(stderr, "Error: Out of memory.");
return 1;
}
memset(payload, 0, payloadlen+1);
if(fread(payload, 1, payloadlen, db_fd) != payloadlen){
fprintf(stderr, "Error: %s.", strerror(errno));
fclose(db_fd);
free(source_id);
free(topic);
free(payload);
return 1;
}
binary = false;
for(i=0; i= 0) fclose(db_fd);
if(source_id) free(source_id);
if(topic) free(topic);
return 1;
}
static int _db_retain_chunk_restore(mosquitto_db *db, FILE *db_fd)
{
dbid_t i64temp, store_id;
if(fread(&i64temp, sizeof(dbid_t), 1, db_fd) != sizeof(dbid_t)){
fprintf(stderr, "Error: %s.", strerror(errno));
fclose(db_fd);
return 1;
}
store_id = i64temp;
printf("\tStore ID: %ld\n", (long int)store_id);
return 0;
}
static int _db_sub_chunk_restore(mosquitto_db *db, FILE *db_fd)
{
uint16_t i16temp, slen;
uint8_t qos;
char *client_id;
char *topic;
int rc = 0;
read_e(db_fd, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
client_id = calloc(slen+1, sizeof(char));
if(!client_id){
fclose(db_fd);
fprintf(stderr, "Error: Out of memory.");
return 1;
}
read_e(db_fd, client_id, slen);
printf("\tClient ID: %s\n", client_id);
read_e(db_fd, &i16temp, sizeof(uint16_t));
slen = ntohs(i16temp);
topic = calloc(slen+1, sizeof(char));
if(!topic){
fclose(db_fd);
fprintf(stderr, "Error: Out of memory.");
free(client_id);
return 1;
}
read_e(db_fd, topic, slen);
printf("\tTopic: %s\n", client_id);
read_e(db_fd, &qos, sizeof(uint8_t));
printf("\tQoS: %d\n", qos);
free(client_id);
free(topic);
return rc;
error:
fprintf(stderr, "Error: %s.", strerror(errno));
if(db_fd >= 0) fclose(db_fd);
return 1;
}
int main(int argc, char *argv[])
{
FILE *fd;
char header[15];
int rc = 0;
uint32_t crc, db_version;
dbid_t i64temp;
uint32_t i32temp, length;
uint16_t i16temp, chunk;
uint8_t i8temp;
ssize_t rlen;
mosquitto_db db;
if(argc != 2){
fprintf(stderr, "Usage: db_dump \n");
return 1;
}
memset(&db, 0, sizeof(mosquitto_db));
fd = fopen(argv[1], "rb");
if(!fd) return 0;
read_e(fd, &header, 15);
if(!memcmp(header, magic, 15)){
printf("Mosquitto DB dump\n");
// Restore DB as normal
read_e(fd, &crc, sizeof(uint32_t));
printf("CRC: %d\n", crc);
read_e(fd, &i32temp, sizeof(uint32_t));
db_version = ntohl(i32temp);
printf("DB version: %d\n", db_version);
while(rlen = fread(&i16temp, sizeof(uint16_t), 1, fd), rlen == 1){
chunk = ntohs(i16temp);
read_e(fd, &i32temp, sizeof(uint32_t));
length = ntohl(i32temp);
switch(chunk){
case DB_CHUNK_CFG:
printf("DB_CHUNK_CFG:\n");
printf("\tLength: %d\n", length);
read_e(fd, &i8temp, sizeof(uint8_t)); // shutdown
printf("\tShutdown: %d\n", i8temp);
read_e(fd, &i8temp, sizeof(uint8_t)); // sizeof(dbid_t)
printf("\tDB ID size: %d\n", i8temp);
if(i8temp != sizeof(dbid_t)){
fprintf(stderr, "Error: Incompatible database configuration (dbid size is %d bytes, expected %d)",
i8temp, sizeof(dbid_t));
fclose(fd);
return 1;
}
read_e(fd, &i64temp, sizeof(dbid_t));
printf("\tLast DB ID: %ld\n", (long)i64temp);
break;
case DB_CHUNK_MSG_STORE:
printf("DB_CHUNK_MSG_STORE:\n");
printf("\tLength: %d\n", length);
if(_db_msg_store_chunk_restore(&db, fd)) return 1;
break;
case DB_CHUNK_CLIENT_MSG:
printf("DB_CHUNK_CLIENT_MSG:\n");
printf("\tLength: %d\n", length);
if(_db_client_msg_chunk_restore(&db, fd)) return 1;
break;
case DB_CHUNK_RETAIN:
printf("DB_CHUNK_RETAIN:\n");
printf("\tLength: %d\n", length);
if(_db_retain_chunk_restore(&db, fd)) return 1;
break;
case DB_CHUNK_SUB:
printf("DB_CHUNK_SUB:\n");
printf("\tLength: %d\n", length);
if(_db_sub_chunk_restore(&db, fd)) return 1;
break;
case DB_CHUNK_CLIENT:
printf("DB_CHUNK_CLIENT:\n");
printf("\tLength: %d\n", length);
if(_db_client_chunk_restore(&db, fd)) return 1;
break;
default:
fprintf(stderr, "Warning: Unsupported chunk \"%d\" in persistent database file. Ignoring.", chunk);
fseek(fd, length, SEEK_CUR);
break;
}
}
if(rlen < 0) goto error;
}else{
fprintf(stderr, "Error: Unrecognised file format.");
rc = 1;
}
fclose(fd);
return rc;
error:
fprintf(stderr, "Error: %s.", strerror(errno));
if(fd >= 0) fclose(fd);
return 1;
}
mosquitto-0.15/src/db_dump/Makefile 0000664 0001750 0001750 00000000462 11713444064 016372 0 ustar roger roger include ../../config.mk
CFLAGS_FINAL=${CFLAGS} -I.. -I../../lib -I../..
.PHONY: all clean reallyclean
all : mosquitto_db_dump
mosquitto_db_dump : db_dump.o
${CC} $^ -o $@ ${LDFLAGS} ${LIBS}
db_dump.o : db_dump.c ../persist.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
clean :
-rm -f *.o mosquitto_db_dump
mosquitto-0.15/src/conf.c 0000664 0001750 0001750 00000106273 11713444064 014420 0 ustar roger roger /*
Copyright (c) 2009-2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
static int _conf_parse_bool(char **token, const char *name, bool *value);
static int _conf_parse_int(char **token, const char *name, int *value);
static int _conf_parse_string(char **token, const char *name, char **value);
static void _config_init_reload(mqtt3_config *config)
{
/* Set defaults */
if(config->acl_file) _mosquitto_free(config->acl_file);
config->acl_file = NULL;
config->allow_anonymous = true;
config->autosave_interval = 1800;
if(config->clientid_prefixes) _mosquitto_free(config->clientid_prefixes);
config->connection_messages = true;
config->clientid_prefixes = NULL;
#ifndef WIN32
config->log_dest = MQTT3_LOG_STDERR;
config->log_type = MOSQ_LOG_ERR | MOSQ_LOG_WARNING | MOSQ_LOG_NOTICE | MOSQ_LOG_INFO;
#else
config->log_dest = MQTT3_LOG_SYSLOG;
config->log_type = MOSQ_LOG_ERR | MOSQ_LOG_WARNING;
#endif
config->log_timestamp = true;
if(config->password_file) _mosquitto_free(config->password_file);
config->password_file = NULL;
config->persistence = false;
if(config->persistence_location) _mosquitto_free(config->persistence_location);
config->persistence_location = NULL;
if(config->persistence_file) _mosquitto_free(config->persistence_file);
config->persistence_file = NULL;
config->retry_interval = 20;
config->store_clean_interval = 10;
config->sys_interval = 10;
#ifdef WITH_EXTERNAL_SECURITY_CHECKS
if(config->db_host) _mosquitto_free(config->db_host);
config->db_host = NULL;
config->db_port = 0;
if(config->db_name) _mosquitto_free(config->db_name);
config->db_name = NULL;
if(config->db_username) _mosquitto_free(config->db_username);
config->db_username = NULL;
if(config->db_password) _mosquitto_free(config->db_password);
config->db_password = NULL;
#endif
}
void mqtt3_config_init(mqtt3_config *config)
{
memset(config, 0, sizeof(mqtt3_config));
_config_init_reload(config);
config->config_file = NULL;
config->daemon = false;
config->default_listener.host = NULL;
config->default_listener.port = 0;
config->default_listener.max_connections = -1;
config->default_listener.mount_point = NULL;
config->default_listener.socks = NULL;
config->default_listener.sock_count = 0;
config->default_listener.client_count = 0;
config->listeners = NULL;
config->listener_count = 0;
config->pid_file = NULL;
config->user = NULL;
#ifdef WITH_BRIDGE
config->bridges = NULL;
config->bridge_count = 0;
#endif
}
void mqtt3_config_cleanup(mqtt3_config *config)
{
int i, j;
if(config->acl_file) _mosquitto_free(config->acl_file);
if(config->clientid_prefixes) _mosquitto_free(config->clientid_prefixes);
if(config->config_file) _mosquitto_free(config->config_file);
if(config->password_file) _mosquitto_free(config->password_file);
if(config->persistence_location) _mosquitto_free(config->persistence_location);
if(config->persistence_file) _mosquitto_free(config->persistence_file);
if(config->persistence_filepath) _mosquitto_free(config->persistence_filepath);
if(config->listeners){
for(i=0; ilistener_count; i++){
if(config->listeners[i].host) _mosquitto_free(config->listeners[i].host);
if(config->listeners[i].mount_point) _mosquitto_free(config->listeners[i].mount_point);
if(config->listeners[i].socks) _mosquitto_free(config->listeners[i].socks);
}
_mosquitto_free(config->listeners);
}
#ifdef WITH_BRIDGE
if(config->bridges){
for(i=0; ibridge_count; i++){
if(config->bridges[i].name) _mosquitto_free(config->bridges[i].name);
if(config->bridges[i].address) _mosquitto_free(config->bridges[i].address);
if(config->bridges[i].clientid) _mosquitto_free(config->bridges[i].clientid);
if(config->bridges[i].username) _mosquitto_free(config->bridges[i].username);
if(config->bridges[i].password) _mosquitto_free(config->bridges[i].password);
if(config->bridges[i].topics){
for(j=0; jbridges[i].topic_count; j++){
if(config->bridges[i].topics[j].topic) _mosquitto_free(config->bridges[i].topics[j].topic);
}
_mosquitto_free(config->bridges[i].topics);
}
}
_mosquitto_free(config->bridges);
}
#endif
#ifdef WITH_EXTERNAL_SECURITY_CHECKS
if(config->db_host) _mosquitto_free(config->db_host);
if(config->db_name) _mosquitto_free(config->db_name);
if(config->db_username) _mosquitto_free(config->db_username);
if(config->db_password) _mosquitto_free(config->db_password);
#endif
}
static void print_usage(void)
{
printf("mosquitto is an MQTT v3.1 broker.\n\n");
printf("Usage: mosquitto [-c config_file] [-d] [-h] [-p port]\n\n");
printf(" -c : specify the broker config file.\n");
printf(" -d : put the broker into the background after starting.\n");
printf(" -h : display this help.\n");
printf(" -p : start the broker listening on the specified port.\n");
printf(" Not recommended in conjunction with the -c option.\n");
printf("\nSee http://mosquitto.org/ for more information.\n\n");
}
int mqtt3_config_parse_args(mqtt3_config *config, int argc, char *argv[])
{
int i;
int port_tmp;
for(i=1; iconfig_file = _mosquitto_strdup(argv[i+1]);
if(!config->config_file){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
if(mqtt3_config_read(config, false)){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to open configuration file.");
return MOSQ_ERR_INVAL;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: -c argument given, but no config file specified.");
return MOSQ_ERR_INVAL;
}
i++;
}else if(!strcmp(argv[i], "-d") || !strcmp(argv[i], "--daemon")){
config->daemon = true;
}else if(!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")){
print_usage();
return MOSQ_ERR_INVAL;
}else if(!strcmp(argv[i], "-p") || !strcmp(argv[i], "--port")){
if(i65535){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid port specified (%d).", port_tmp);
return MOSQ_ERR_INVAL;
}else{
if(config->default_listener.port){
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Default listener port specified multiple times. Only the latest will be used.");
}
config->default_listener.port = port_tmp;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: -p argument given, but no port specified.");
return MOSQ_ERR_INVAL;
}
i++;
}else{
fprintf(stderr, "Error: Unknown option '%s'.\n",argv[i]);
print_usage();
return MOSQ_ERR_INVAL;
}
}
if(config->listener_count == 0 || config->default_listener.host || config->default_listener.port){
config->listener_count++;
config->listeners = _mosquitto_realloc(config->listeners, sizeof(struct _mqtt3_listener)*config->listener_count);
if(!config->listeners){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
if(config->default_listener.port){
config->listeners[config->listener_count-1].port = config->default_listener.port;
}else{
config->listeners[config->listener_count-1].port = 1883;
}
if(config->default_listener.host){
config->listeners[config->listener_count-1].host = config->default_listener.host;
}else{
config->listeners[config->listener_count-1].host = NULL;
}
if(config->default_listener.mount_point){
config->listeners[config->listener_count-1].mount_point = config->default_listener.host;
}else{
config->listeners[config->listener_count-1].mount_point = NULL;
}
config->listeners[config->listener_count-1].max_connections = config->default_listener.max_connections;
config->listeners[config->listener_count-1].client_count = 0;
config->listeners[config->listener_count-1].socks = NULL;
config->listeners[config->listener_count-1].sock_count = 0;
config->listeners[config->listener_count-1].client_count = 0;
}
return MOSQ_ERR_SUCCESS;
}
int mqtt3_config_read(mqtt3_config *config, bool reload)
{
int rc = MOSQ_ERR_SUCCESS;
FILE *fptr = NULL;
char buf[1024];
char *token;
int port_tmp;
int log_dest = MQTT3_LOG_NONE;
int log_dest_set = 0;
int log_type = MOSQ_LOG_NONE;
int log_type_set = 0;
int i;
#ifdef WITH_BRIDGE
struct _mqtt3_bridge *cur_bridge = NULL;
#endif
int max_inflight_messages = 20;
int max_queued_messages = 100;
if(!config->config_file) return 0;
if(reload){
/* Re-initialise appropriate config vars to default for reload. */
_config_init_reload(config);
}
fptr = fopen(config->config_file, "rt");
if(!fptr) return 1;
while(fgets(buf, 1024, fptr)){
if(buf[0] != '#' && buf[0] != 10 && buf[0] != 13){
while(buf[strlen(buf)-1] == 10 || buf[strlen(buf)-1] == 13){
buf[strlen(buf)-1] = 0;
}
token = strtok(buf, " ");
if(token){
if(!strcmp(token, "acl_file")){
if(reload){
if(config->acl_file){
_mosquitto_free(config->acl_file);
config->acl_file = NULL;
}
}
if(_conf_parse_string(&token, "acl_file", &config->acl_file)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "address") || !strcmp(token, "addresses")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge || cur_bridge->address){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
token = strtok(token, ":");
if(token){
cur_bridge->address = _mosquitto_strdup(token);
if(!cur_bridge->address){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
token = strtok(NULL, ":");
if(token){
port_tmp = atoi(token);
if(port_tmp < 1 || port_tmp > 65535){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid port value (%d).", port_tmp);
return MOSQ_ERR_INVAL;
}
cur_bridge->port = port_tmp;
}else{
cur_bridge->port = 1883;
}
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty address value in configuration.");
return MOSQ_ERR_INVAL;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "allow_anonymous")){
if(_conf_parse_bool(&token, "allow_anonymous", &config->allow_anonymous)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "autosave_interval")){
if(_conf_parse_int(&token, "autosave_interval", &config->autosave_interval)) return MOSQ_ERR_INVAL;
if(config->autosave_interval < 0) config->autosave_interval = 0;
}else if(!strcmp(token, "bind_address")){
if(reload) continue; // Listener not valid for reloading.
if(_conf_parse_string(&token, "default listener bind_address", &config->default_listener.host)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "clientid")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
if(cur_bridge->clientid){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Duplicate clientid value in bridge configuration.");
return MOSQ_ERR_INVAL;
}
cur_bridge->clientid = _mosquitto_strdup(token);
if(!cur_bridge->clientid){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory");
return MOSQ_ERR_NOMEM;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty clientid value in configuration.");
return MOSQ_ERR_INVAL;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "cleansession")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
if(_conf_parse_bool(&token, "cleansession", &cur_bridge->clean_session)) return MOSQ_ERR_INVAL;
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "clientid_prefixes")){
if(reload){
if(config->clientid_prefixes){
_mosquitto_free(config->clientid_prefixes);
config->clientid_prefixes = NULL;
}
}
if(_conf_parse_string(&token, "clientid_prefixes", &config->clientid_prefixes)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "connection")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
token = strtok(NULL, " ");
if(token){
config->bridge_count++;
config->bridges = _mosquitto_realloc(config->bridges, config->bridge_count*sizeof(struct _mqtt3_bridge));
if(!config->bridges){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
cur_bridge = &(config->bridges[config->bridge_count-1]);
cur_bridge->name = _mosquitto_strdup(token);
cur_bridge->address = NULL;
cur_bridge->keepalive = 60;
cur_bridge->clean_session = false;
cur_bridge->clientid = NULL;
cur_bridge->port = 0;
cur_bridge->topics = NULL;
cur_bridge->topic_count = 0;
cur_bridge->restart_t = 0;
cur_bridge->username = NULL;
cur_bridge->password = NULL;
cur_bridge->notifications = true;
cur_bridge->start_type = bst_automatic;
cur_bridge->idle_timeout = 60;
cur_bridge->threshold = 10;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty connection value in configuration.");
return MOSQ_ERR_INVAL;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "connection_messages")){
if(_conf_parse_bool(&token, token, &config->connection_messages)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "idle_timeout")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
if(_conf_parse_int(&token, "idle_timeout", &cur_bridge->idle_timeout)) return MOSQ_ERR_INVAL;
if(cur_bridge->idle_timeout < 1){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "idle_timeout interval too low, using 1 second.");
cur_bridge->idle_timeout = 1;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "keepalive_interval")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
if(_conf_parse_int(&token, "keepalive_interval", &cur_bridge->keepalive)) return MOSQ_ERR_INVAL;
if(cur_bridge->keepalive < 5){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "keepalive interval too low, using 5 seconds.");
cur_bridge->keepalive = 5;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "listener")){
if(reload) continue; // Listeners not valid for reloading.
token = strtok(NULL, " ");
if(token){
config->listener_count++;
config->listeners = _mosquitto_realloc(config->listeners, sizeof(struct _mqtt3_listener)*config->listener_count);
if(!config->listeners){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory.");
return MOSQ_ERR_NOMEM;
}
port_tmp = atoi(token);
if(port_tmp < 1 || port_tmp > 65535){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid port value (%d).", port_tmp);
return MOSQ_ERR_INVAL;
}
config->listeners[config->listener_count-1].mount_point = NULL;
config->listeners[config->listener_count-1].port = port_tmp;
config->listeners[config->listener_count-1].socks = NULL;
config->listeners[config->listener_count-1].sock_count = 0;
config->listeners[config->listener_count-1].client_count = 0;
token = strtok(NULL, " ");
if(token){
config->listeners[config->listener_count-1].host = _mosquitto_strdup(token);
}else{
config->listeners[config->listener_count-1].host = NULL;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty listener value in configuration.");
return MOSQ_ERR_INVAL;
}
}else if(!strcmp(token, "log_dest")){
token = strtok(NULL, " ");
if(token){
log_dest_set = 1;
if(!strcmp(token, "none")){
log_dest = MQTT3_LOG_NONE;
}else if(!strcmp(token, "syslog")){
log_dest |= MQTT3_LOG_SYSLOG;
}else if(!strcmp(token, "stdout")){
log_dest |= MQTT3_LOG_STDOUT;
}else if(!strcmp(token, "stderr")){
log_dest |= MQTT3_LOG_STDERR;
}else if(!strcmp(token, "topic")){
log_dest |= MQTT3_LOG_TOPIC;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid log_dest value (%s).", token);
return MOSQ_ERR_INVAL;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty log_dest value in configuration.");
return MOSQ_ERR_INVAL;
}
}else if(!strcmp(token, "log_timestamp")){
if(_conf_parse_bool(&token, token, &config->log_timestamp)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "log_type")){
token = strtok(NULL, " ");
if(token){
log_type_set = 1;
if(!strcmp(token, "none")){
log_type = MOSQ_LOG_NONE;
}else if(!strcmp(token, "information")){
log_type |= MOSQ_LOG_INFO;
}else if(!strcmp(token, "notice")){
log_type |= MOSQ_LOG_NOTICE;
}else if(!strcmp(token, "warning")){
log_type |= MOSQ_LOG_WARNING;
}else if(!strcmp(token, "error")){
log_type |= MOSQ_LOG_ERR;
}else if(!strcmp(token, "debug")){
log_type |= MOSQ_LOG_DEBUG;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid log_type value (%s).", token);
return MOSQ_ERR_INVAL;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty log_type value in configuration.");
}
}else if(!strcmp(token, "max_connections")){
if(reload) continue; // Listeners not valid for reloading.
token = strtok(NULL, " ");
if(token){
if(config->listener_count > 0){
config->listeners[config->listener_count-1].max_connections = atoi(token);
if(config->listeners[config->listener_count-1].max_connections < 0) config->listeners[config->listener_count-1].max_connections = -1;
}else{
config->default_listener.max_connections = atoi(token);
if(config->default_listener.max_connections < 0) config->default_listener.max_connections = -1;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty max_connections value in configuration.");
}
}else if(!strcmp(token, "max_inflight_messages")){
token = strtok(NULL, " ");
if(token){
max_inflight_messages = atoi(token);
if(max_inflight_messages < 0) max_inflight_messages = 0;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty max_inflight_messages value in configuration.");
}
}else if(!strcmp(token, "max_queued_messages")){
token = strtok(NULL, " ");
if(token){
max_queued_messages = atoi(token);
if(max_queued_messages < 0) max_queued_messages = 0;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty max_queued_messages value in configuration.");
}
}else if(!strcmp(token, "mount_point")){
if(reload) continue; // Listeners not valid for reloading.
if(config->listener_count == 0){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: You must use create a listener before using the mount_point option in the configuration file.");
return MOSQ_ERR_INVAL;
}
if(_conf_parse_string(&token, "mount_point", &config->listeners[config->listener_count-1].mount_point)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "notifications")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
if(_conf_parse_bool(&token, "notifications", &cur_bridge->notifications)) return MOSQ_ERR_INVAL;
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "password")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
if(cur_bridge->password){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Duplicate password value in bridge configuration.");
return MOSQ_ERR_INVAL;
}
cur_bridge->password = _mosquitto_strdup(token);
if(!cur_bridge->password){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory");
return MOSQ_ERR_NOMEM;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty password value in configuration.");
return MOSQ_ERR_INVAL;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "password_file")){
if(reload){
if(config->password_file){
_mosquitto_free(config->password_file);
config->password_file = NULL;
}
}
if(_conf_parse_string(&token, "password_file", &config->password_file)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "persistence") || !strcmp(token, "retained_persistence")){
if(_conf_parse_bool(&token, token, &config->persistence)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "persistence_file")){
if(reload) continue; // FIXME
if(_conf_parse_string(&token, "persistence_file", &config->persistence_file)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "persistence_location")){
if(reload) continue; // FIXME
if(_conf_parse_string(&token, "persistence_location", &config->persistence_location)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "pid_file")){
if(reload) continue; // pid file not valid for reloading.
if(_conf_parse_string(&token, "pid_file", &config->pid_file)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "port")){
if(reload) continue; // Listener not valid for reloading.
if(config->default_listener.port){
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Default listener port specified multiple times. Only the latest will be used.");
}
if(_conf_parse_int(&token, "port", &port_tmp)) return MOSQ_ERR_INVAL;
if(port_tmp < 1 || port_tmp > 65535){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid port value (%d).", port_tmp);
return MOSQ_ERR_INVAL;
}
config->default_listener.port = port_tmp;
}else if(!strcmp(token, "retry_interval")){
if(_conf_parse_int(&token, "retry_interval", &config->retry_interval)) return MOSQ_ERR_INVAL;
if(config->retry_interval < 1 || config->retry_interval > 3600){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid retry_interval value (%d).", config->retry_interval);
return MOSQ_ERR_INVAL;
}
}else if(!strcmp(token, "start_type")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
if(!strcmp(token, "automatic")){
cur_bridge->start_type = bst_automatic;
}else if(!strcmp(token, "lazy")){
cur_bridge->start_type = bst_lazy;
}else if(!strcmp(token, "manual")){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Manual start_type not supported.");
return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "once")){
cur_bridge->start_type = bst_once;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid start_type value in configuration (%s).", token);
return MOSQ_ERR_INVAL;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty start_type value in configuration.");
return MOSQ_ERR_INVAL;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "store_clean_interval")){
if(_conf_parse_int(&token, "store_clean_interval", &config->store_clean_interval)) return MOSQ_ERR_INVAL;
if(config->store_clean_interval < 0 || config->store_clean_interval > 65535){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid store_clean_interval value (%d).", config->store_clean_interval);
return MOSQ_ERR_INVAL;
}
}else if(!strcmp(token, "sys_interval")){
if(_conf_parse_int(&token, "sys_interval", &config->sys_interval)) return MOSQ_ERR_INVAL;
if(config->sys_interval < 1 || config->sys_interval > 65535){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid sys_interval value (%d).", config->sys_interval);
return MOSQ_ERR_INVAL;
}
}else if(!strcmp(token, "threshold")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
if(_conf_parse_int(&token, "threshold", &cur_bridge->threshold)) return MOSQ_ERR_INVAL;
if(cur_bridge->threshold < 1){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "threshold too low, using 1 message.");
cur_bridge->threshold = 1;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "topic")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
cur_bridge->topic_count++;
cur_bridge->topics = _mosquitto_realloc(cur_bridge->topics,
sizeof(struct _mqtt3_bridge_topic)*cur_bridge->topic_count);
if(!cur_bridge->topics){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory");
return MOSQ_ERR_NOMEM;
}
cur_bridge->topics[cur_bridge->topic_count-1].topic = _mosquitto_strdup(token);
if(!cur_bridge->topics[cur_bridge->topic_count-1].topic){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory");
return MOSQ_ERR_NOMEM;
}
cur_bridge->topics[cur_bridge->topic_count-1].direction = bd_out;
cur_bridge->topics[cur_bridge->topic_count-1].qos = 2;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty topic value in configuration.");
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
if(!strcasecmp(token, "out")){
cur_bridge->topics[cur_bridge->topic_count-1].direction = bd_out;
}else if(!strcasecmp(token, "in")){
cur_bridge->topics[cur_bridge->topic_count-1].direction = bd_in;
}else if(!strcasecmp(token, "both")){
cur_bridge->topics[cur_bridge->topic_count-1].direction = bd_both;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge topic direction '%s'.", token);
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
cur_bridge->topics[cur_bridge->topic_count-1].qos = atoi(token);
if(cur_bridge->topics[cur_bridge->topic_count-1].qos < 0 || cur_bridge->topics[cur_bridge->topic_count-1].qos > 2){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge QoS level '%s'.", token);
return MOSQ_ERR_INVAL;
}
}
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
}else if(!strcmp(token, "user")){
if(reload) continue; // Drop privileges user not valid for reloading.
if(_conf_parse_string(&token, "user", &config->user)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "username")){
#ifdef WITH_BRIDGE
if(reload) continue; // FIXME
if(!cur_bridge){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
token = strtok(NULL, " ");
if(token){
if(cur_bridge->username){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Duplicate username value in bridge configuration.");
return MOSQ_ERR_INVAL;
}
cur_bridge->username = _mosquitto_strdup(token);
if(!cur_bridge->username){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory");
return MOSQ_ERR_NOMEM;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty username value in configuration.");
return MOSQ_ERR_INVAL;
}
#else
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge support not available.");
#endif
#ifdef WITH_EXTERNAL_SECURITY_CHECKS
}else if(!strcmp(token, "db_host")){
if(reload){
if(config->db_host){
_mosquitto_free(config->db_host);
config->db_host = NULL;
}
}
if(_conf_parse_string(&token, "db_host", &config->db_host)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "db_name")){
if(reload){
if(config->db_name){
_mosquitto_free(config->db_name);
config->db_name = NULL;
}
}
if(_conf_parse_string(&token, "db_name", &config->db_name)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "db_username")){
if(reload){
if(config->db_username){
_mosquitto_free(config->db_username);
config->db_username = NULL;
}
}
if(_conf_parse_string(&token, "db_username", &config->db_username)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "db_password")){
if(reload){
if(config->db_password){
_mosquitto_free(config->db_password);
config->db_password = NULL;
}
}
if(_conf_parse_string(&token, "db_password", &config->db_password)) return MOSQ_ERR_INVAL;
}else if(!strcmp(token, "db_port")){
if(_conf_parse_int(&token, "db_port", &config->db_port)) return MOSQ_ERR_INVAL;
#endif
}else if(!strcmp(token, "autosave_on_changes")
|| !strcmp(token, "connection_messages")
|| !strcmp(token, "trace_level")
|| !strcmp(token, "addresses")
|| !strcmp(token, "idle_timeout")
|| !strcmp(token, "notification_topic")
|| !strcmp(token, "round_robin")
|| !strcmp(token, "threshold")
|| !strcmp(token, "try_private")
|| !strcmp(token, "ffdc_output")
|| !strcmp(token, "max_log_entries")
|| !strcmp(token, "trace_output")){
_mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: Unsupported rsmb configuration option \"%s\".", token);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unknown configuration variable \"%s\".", token);
return MOSQ_ERR_INVAL;
}
}
}
}
fclose(fptr);
#ifdef WITH_PERSISTENCE
if(config->persistence){
if(!config->persistence_file){
config->persistence_file = _mosquitto_strdup("mosquitto.db");
if(!config->persistence_file) return MOSQ_ERR_NOMEM;
}
if(config->persistence_filepath){
_mosquitto_free(config->persistence_filepath);
}
if(config->persistence_location && strlen(config->persistence_location)){
config->persistence_filepath = _mosquitto_malloc(strlen(config->persistence_location) + strlen(config->persistence_file) + 1);
if(!config->persistence_filepath) return MOSQ_ERR_NOMEM;
sprintf(config->persistence_filepath, "%s%s", config->persistence_location, config->persistence_file);
}else{
config->persistence_filepath = _mosquitto_strdup(config->persistence_file);
if(!config->persistence_filepath) return MOSQ_ERR_NOMEM;
}
}
#endif
if(!config->user){
config->user = "mosquitto";
}
mqtt3_db_limits_set(max_inflight_messages, max_queued_messages);
#ifdef WITH_BRIDGE
for(i=0; ibridge_count; i++){
if(!config->bridges[i].name || !config->bridges[i].address || !config->bridges[i].port || !config->bridges[i].topic_count){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid bridge configuration.");
return MOSQ_ERR_INVAL;
}
}
#endif
if(log_dest_set){
config->log_dest = log_dest;
}
if(log_type_set){
config->log_type = log_type;
}
return rc;
}
static int _conf_parse_bool(char **token, const char *name, bool *value)
{
*token = strtok(NULL, " ");
if(*token){
if(!strcmp(*token, "false") || !strcmp(*token, "0")){
*value = false;
}else if(!strcmp(*token, "true") || !strcmp(*token, "1")){
*value = true;
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Invalid %s value (%s).", name, *token);
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty %s value in configuration.", name);
return MOSQ_ERR_INVAL;
}
return MOSQ_ERR_SUCCESS;
}
static int _conf_parse_int(char **token, const char *name, int *value)
{
*token = strtok(NULL, " ");
if(*token){
*value = atoi(*token);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty %s value in configuration.", name);
return MOSQ_ERR_INVAL;
}
return MOSQ_ERR_SUCCESS;
}
static int _conf_parse_string(char **token, const char *name, char **value)
{
*token = strtok(NULL, " ");
if(*token){
if(*value){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Duplicate %s value in configuration.", name);
return MOSQ_ERR_INVAL;
}
*value = _mosquitto_strdup(*token);
if(!*value){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory");
return MOSQ_ERR_NOMEM;
}
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Empty %s value in configuration.", name);
return MOSQ_ERR_INVAL;
}
return MOSQ_ERR_SUCCESS;
}
mosquitto-0.15/src/Makefile 0000664 0001750 0001750 00000005106 11713444064 014760 0 ustar roger roger include ../config.mk
CFLAGS_FINAL=${CFLAGS} -I. -DVERSION="\"${VERSION}\"" -DTIMESTAMP="\"${TIMESTAMP}\"" -DWITH_BROKER
.PHONY: all install uninstall clean reallyclean
all : mosquitto
mosquitto : mosquitto.o bridge.o conf.o context.o database.o logging.o loop.o memory_mosq.o persist.o net.o net_mosq.o read_handle.o read_handle_client.o read_handle_server.o read_handle_shared.o security.o security_external.o send_client_mosq.o send_mosq.o send_server.o service.o subs.o util_mosq.o will_mosq.o
${CC} $^ -o $@ ${LDFLAGS} ${LIBS}
mosquitto.o : mosquitto.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
bridge.o : bridge.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
conf.o : conf.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
context.o : context.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
database.o : database.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
logging.o : logging.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
loop.o : loop.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
memory_mosq.o : ../lib/memory_mosq.c ../lib/memory_mosq.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
net.o : net.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
net_mosq.o : ../lib/net_mosq.c ../lib/net_mosq.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
persist.o : persist.c persist.h mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
read_handle.o : read_handle.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
read_handle_client.o : read_handle_client.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
read_handle_server.o : read_handle_server.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
read_handle_shared.o : ../lib/read_handle_shared.c ../lib/read_handle.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
security.o : security.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
security_external.o : security_external.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
send_client_mosq.o : ../lib/send_client_mosq.c ../lib/send_mosq.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
send_mosq.o : ../lib/send_mosq.c ../lib/send_mosq.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
send_server.o : send_server.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
service.o : service.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
subs.o : subs.c mqtt3.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
util_mosq.o : ../lib/util_mosq.c ../lib/util_mosq.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
will_mosq.o : ../lib/will_mosq.c ../lib/will_mosq.h
${CC} $(CFLAGS_FINAL) -c $< -o $@
install : all
$(INSTALL) -d ${DESTDIR}$(prefix)/sbin
$(INSTALL) -s mosquitto ${DESTDIR}${prefix}/sbin/mosquitto
uninstall :
-rm -f ${DESTDIR}${prefix}/sbin/mosquitto
clean :
-rm -f *.o mosquitto
reallyclean : clean
-rm -rf *.orig *.db
mosquitto-0.15/src/security_external.c 0000664 0001750 0001750 00000004320 11713444064 017232 0 ustar roger roger /*
Copyright (c) 2011,2012 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CMAKE
#include
#endif
#include
#include
#include
#include
#ifdef WITH_EXTERNAL_SECURITY_CHECKS
int mosquitto_acl_init(struct _mosquitto_db *db)
{
return MOSQ_ERR_SUCCESS;
}
int mosquitto_acl_check(struct _mosquitto_db *db, struct mosquitto *context, const char *topic, int access)
{
return MOSQ_ERR_ACL_DENIED;
}
void mosquitto_acl_cleanup(struct _mosquitto_db *db)
{
}
int mosquitto_unpwd_init(struct _mosquitto_db *db)
{
return MOSQ_ERR_SUCCESS;
}
int mosquitto_unpwd_check(struct _mosquitto_db *db, const char *username, const char *password)
{
return MOSQ_ERR_AUTH;
}
int mosquitto_unpwd_cleanup(struct _mosquitto_db *db)
{
return MOSQ_ERR_SUCCESS;
}
#endif
mosquitto-0.15/src/persist.h 0000664 0001750 0001750 00000003713 11713444064 015164 0 ustar roger roger /*
Copyright (c) 2010,2011 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef PERSIST_H
#define PERSIST_H
/* DB read/write */
const unsigned char magic[15] = {0x00, 0xB5, 0x00, 'm','o','s','q','u','i','t','t','o',' ','d','b'};
#define DB_CHUNK_CFG 1
#define DB_CHUNK_MSG_STORE 2
#define DB_CHUNK_CLIENT_MSG 3
#define DB_CHUNK_RETAIN 4
#define DB_CHUNK_SUB 5
#define DB_CHUNK_CLIENT 6
/* End DB read/write */
#define read_e(f, b, c) if(fread(b, 1, c, f) != c){ goto error; }
#define write_e(f, b, c) if(fwrite(b, 1, c, f) != c){ goto error; }
#endif
mosquitto-0.15/misc/ 0000775 0001750 0001750 00000000000 11713444064 013462 5 ustar roger roger mosquitto-0.15/misc/currentcost/ 0000775 0001750 0001750 00000000000 11713444064 016035 5 ustar roger roger mosquitto-0.15/misc/currentcost/cc128_read.py 0000775 0001750 0001750 00000000677 11713444064 020237 0 ustar roger roger #!/usr/bin/python -u
import serial
import shlex
import subprocess
pub_cmd = "mosquitto_pub -t cc128/raw -l -q 2"
pub_args = shlex.split(pub_cmd)
pub = subprocess.Popen(pub_args, stdin=subprocess.PIPE)
usb = serial.Serial(port='/dev/ttyUSB0', baudrate=57600)
running = True
try:
while running:
line = usb.readline()
pub.stdin.write(line)
pub.stdin.flush()
except usb.SerialException, e:
running = False
pub.stdin.close()
pub.wait()
mosquitto-0.15/misc/currentcost/cc128_read.pl 0000775 0001750 0001750 00000000717 11713444064 020215 0 ustar roger roger #!/usr/bin/perl -w
# Reads data from a Current Cost device via serial port.
# Spawns
use strict;
use Device::SerialPort qw( :PARAM :STAT 0.07 );
my $pubclient = "mosquitto_pub -t sensors/cc128/raw -q 2 -l";
my $PORT = "/dev/ttyUSB0";
local $| = 1;
my $ob = Device::SerialPort->new($PORT);
$ob->baudrate(57600);
$ob->write_settings;
open(SERIAL, "+<$PORT");
open(MQTT, "|$pubclient");
while (my $line = ) {
print(MQTT "$line");
}
close(MQTT);
mosquitto-0.15/misc/currentcost/cc128_log_mysql.pl 0000775 0001750 0001750 00000002670 11713444064 021310 0 ustar roger roger #!/usr/bin/perl
# Log CurrentCost power meter data to a mysql database.
# Assumes data is coming in on MQTT topic sensors/cc128
# and in format timestamp,temperature,ch1_data
# e.g. 1276605752,12.7,86
# To create database, table and user:
#
# CREATE DATABASE powermeter;
# USE 'powermeter';
# CREATE TABLE powermeter (
# `id` INT NOT NULL auto_increment,
# `timestamp` INT NOT NULL,
# `temperature` FLOAT NOT NULL DEFAULT 0.0,
# `ch1` INT NOT NULL DEFAULT 0,
# PRIMARY KEY (`id`),
# UNIQUE KEY `timestamp` (`timestamp`)
# ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
#
# CREATE USER 'powermeter'@'localhost' IDENTIFIED BY '';
# GRANT ALL ON powermeter.* to 'powermeter'@'localhost';
use strict;
use DBI();
use FileHandle;
local $| = 1;
my $dbname = "powermeter";
my $dbhost = "localhost";
my $dbusername = "powermeter";
my $dbpassword = "password";
my $dbtable = "powermeter";
my $subclient = "/usr/bin/mosquitto_sub -t sensors/cc128";
open(SUB, "$subclient|");
SUB->autoflush(1);
my $dbh = DBI->connect("DBI:mysql:database=$dbname;host=$dbhost",
"$dbusername", "$dbpassword", {'RaiseError' => 1});
my $query = "INSERT INTO powermeter (timestamp, temperature, ch1) VALUES (?,?,?)";
my @vals;
my ($timestamp, $temperature, $ch1);
while (my $line = ) {
@vals = split(/,/, $line);
$timestamp = @vals[0];
$temperature = @vals[1];
$ch1 = @vals[2];
$dbh->do($query, undef, $timestamp, $temperature, $ch1);
}
$dbh->disconnect();
mosquitto-0.15/misc/currentcost/cc128_parse.pl 0000775 0001750 0001750 00000002500 11713444064 020404 0 ustar roger roger #!/usr/bin/perl -w
# Read raw cc128 data and republish without xml.
# Probably only works if you have a single channel.
use strict;
use HTTP::Date "str2time";
use FileHandle;
local $| = 1;
my $subclient = "/usr/bin/mosquitto_sub -t sensors/cc128/raw -q 2";
my $pubclient = "/usr/bin/mosquitto_pub -t sensors/cc128 -q 2 -l";
my $pubclient_ch1 = "/usr/bin/mosquitto_pub -t sensors/cc128/ch1 -q 2 -l";
open(SUB, "$subclient|");
open(PUB, "|$pubclient");
open(PUB_CH1, "|$pubclient_ch1");
SUB->autoflush(1);
PUB->autoflush(1);
PUB_CH1->autoflush(1);
while (my $line = ) {
#CC128-v0.120000215.7003112100108
if ($line =~ m# *([\-\d.]+)0[0-9]*10*(\d+) $now){
$r_stamp -= 86400;
}
print PUB "$r_stamp,$temp,$watts\n";
print PUB_CH1 "$r_stamp $watts\n";
}
}
mosquitto-0.15/misc/currentcost/gnome-panel/ 0000775 0001750 0001750 00000000000 11713444064 020237 5 ustar roger roger mosquitto-0.15/misc/currentcost/gnome-panel/currentcost.png 0000664 0001750 0001750 00000012304 11713444064 023320 0 ustar roger roger PNG
IHDR 0 0 W sRGB bKGD pHYs
f tIME m, tEXtComment Created with GIMPW IDAThޭk$uz{z ;;"wK.IEG l
LcH,0A r DKb
`ǰ2 7AEe>fv=ﮪ{ɇ]1<
(TssFxiVNcr v-SՕA.z^ !<霻+@ bEv(VFdDx^7Z^nF%֣kOMx̙v%
B#,^'d2P AdxE hP1VRj^,};I?Y<ųÉYiT{:p:ܘLǽ_L&{8 F#
+J{g2`D *jQk?M;] t0F 6ky0I^= j8ջ PζAy$1F$!c+@%Mi[+nk:RVY/7G3wl ` w?}t|\GQ X9D֖<B@s,ϘfyNARUI8mnm_?o|<j=ywN'r]UQ3oux웍I*;O Gƫb UCpbU1:1LVj8ZÓO>/: G'@INpZxڱUm}Ν;cm4&Iypzh93<<~؇+ޣjqLףsZM=GV*daLͿ\[VUED
'Da-[{.~h[RȳdV]Z͖ 'h6A 4=-T *"xʊ ;9!6aooϤi\A"'o IRL8K)z7ݴF)FC`gy&+7]4$Ϧ"B`n *G3 aJ<N#L&M&VmUzeFb3'Zƙv TJِ2ɊReՔZu !3 !W(PUEAfIb8 d6Som8< @=P3e`^ t$">E^}j`ueRݏVU1 tc v(O&5.GGGNck5Qܯ E^V%ix<&2 1ưBZ)qxL 1Ȼ93~ (Q
@ 6"ɳ\888n5$˦X1+&ςh4Tk ,XɊ `I!3^ $!
Zk++gi[2qn5 ;T*)>ƕK1w
ZƗ@imm8d!Ld;'J,^0c(p͓b TR3M9>d: kkkji>t@Ze9VVɳ cM |ys~ ܡޮc,]`6899;7R}cȋe($8d фh\r$jG* BP<ˉίR#\rJ\1rwNseϳzRyW\\ B) ce3E#X
9.l [ۻg9KV8>:PUiƀDxXW9z?6έr~c7߾CT~1]k^bX_Y%#;s$Ke̼!:viѐmjCEt 5@Ygփ#DZfcE:-ȲIN_{|Ρl3NԈ-z)ZP,G1Q s҅~dݭTVOOy.,gOdc1
O\RZsrpp@$[_ ڵLjr=X[.Pc 4x,(t>k$T]{Oei7h5 f6A X1~~lc-8&ZʹՎ^v#1%xp}{}B1B~V;F,JjMⓓSvvwKb-W"OCvVhpZԳ`xL$8 x{qw7x\(kA
T\i(K (^TU1jİO|QD_wMg
+p~V>rۈEޕVJ*q=a0`ELm0J|G<ua:ɸ,^Z"" xSGk DB]B\๛?="`<^"jA5Kj1N
x2xѯ3a8b#KN?G3D,'8+\)j.:>̫"e/\ SO
i0o>uO?''=ob
z&fKhe;歧{[ Fc$lO*Ad.vPpyfW;ܳ^oR"B%1j`Z\⹕O{&Grm1zeZv)CDNx&b>,c7I xң"5x2a%Ix,+m{߽OdeIVJ\^x+ ~Mݮ^p
lVv\R# w^? V*xP ΈHyQ@8Q~<rɳO?+ /_訫 XG̥֛_[bl_
zL&u2*\N%w3fJ-+r5& b}
1"jQ
̲}gϾܫ [^m}ORL\>v[}uwgr8bmm-lllH 2 :f(5jZs4(zfŸ*˝|,lΓO=E=[җoX_wwÃse{f3<JY,T4#DQk
,ԫK Ϸj |Sq^zyp0O+?ճK ?9=]ZQIH̚2o8 J} ERINKzsy.+wyxpt*:_7?: > ?=̈
(zG,)d^QrIY_~鿊ޛo37{+z/u։Wf/*ս^ _WIgDg`9GvjO*ieV1Oo~wG}U[?xn*SOK:4/_/RowkvtyN^sO\/wg?Dd q}?Pb} }aQӾZh IENDB` mosquitto-0.15/misc/currentcost/gnome-panel/CurrentCostMQTT.py 0000775 0001750 0001750 00000004163 11713444064 023601 0 ustar roger roger #!/usr/bin/env python
import gnomeapplet
import gobject
import gtk
import mosquitto
import os
import platform
import pygtk
import sys
class CurrentCostMQTT(gnomeapplet.Applet):
def loop(self):
self.mosq.loop(1)
return True
def on_message(self, msg):
# Message format is "power"
self.label.set_text(msg.payload+"W")
def set_label(self, val):
self.label.set_text(val)
def on_change_background(self, applet, type, color, pixmap):
applet.set_style(None)
applet.modify_style(gtk.RcStyle())
if type == gnomeapplet.COLOR_BACKGROUND:
applet.modify_bg(gtk.STATE_NORMAL, color)
elif type == gnomeapplet.PIXMAP_BACKGROUND:
style = applet.get_style().copy()
style.bg_pixmap[gtk.STATE_NORMAL] = pixmap
applet.set_style(style)
def show_menu(self, widget, event):
print "menu"
def __init__(self, applet, iid):
self.applet = applet
self.label = gtk.Label("0W")
self.event_box = gtk.EventBox()
self.event_box.add(self.label)
self.event_box.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self.event_box.connect("button_press_event", self.show_menu)
self.applet.add(self.event_box)
self.applet.set_background_widget(applet)
self.applet.show_all()
self.mosq = mosquitto.Mosquitto("ccpanel-"+platform.node()+"-"+str(os.getpid()))
self.mosq.on_message = self.on_message
self.mosq.connect("10.90.100.4", 1883, 60, True)
self.mosq.subscribe("sensors/cc128/ch1", 0)
self.applet.connect('change-background', self.on_change_background)
gobject.timeout_add(100, self.loop)
def CurrentCostMQTT_factory(applet, iid):
CurrentCostMQTT(applet, iid)
return gtk.TRUE
if len(sys.argv) == 2:
if sys.argv[1] == "-d": #Debug mode
main_window = gtk.Window(gtk.WINDOW_TOPLEVEL)
main_window.set_title("Python Applet")
main_window.connect("destroy", gtk.main_quit)
app = gnomeapplet.Applet()
CurrentCostMQTT_factory(app,None)
app.reparent(main_window)
main_window.show_all()
gtk.main()
sys.exit()
if __name__ == '__main__':
gnomeapplet.bonobo_factory("OAFIID:CurrentCostMQTT_Factory", gnomeapplet.Applet.__gtype__, "MQTT", "0", CurrentCostMQTT_factory)
mosquitto-0.15/misc/currentcost/gnome-panel/CurrentCostMQTT.server 0000664 0001750 0001750 00000002176 11713444064 024456 0 ustar roger roger
mosquitto-0.15/misc/pachube_update.pl 0000775 0001750 0001750 00000001335 11713444064 016775 0 ustar roger roger #!/usr/bin/perl
use strict;
use Net::Pachube;
# Update a pachube feed.
# Run as "pachube_update.pl ", where is the id of your feed,
# e.g. xxxx from http://www.pachube.com/api/feeds/xxxx.xml
# Your pachube api key should be set in the environment variable
# PACHUBE_API_KEY
#
# Use with mosquitto_sub like:
#
# mosquitto_sub -h -i -t | pachube_update.pl
#
# Needs Net::Pachube installing from CPAN.
if($#ARGV != 0){
print "Usage: pachube_update.pl \n";
exit
}
my $feed_id = $ARGV[0];
my $pachube = Net::Pachube->new();
my $feed = $pachube->feed($feed_id);
#print $feed->title, " ", $feed->status, "\n";
while(){
chomp;
$_ += 0;
$feed->update(data => $_);
}
mosquitto-0.15/config.mk 0000664 0001750 0001750 00000001071 11713444064 014324 0 ustar roger roger # Also bump lib/mosquitto.h, lib/python/setup.py, CMakeLists.txt,
# installer/mosquitto.nsi, installer/mosquitto-cygwin.nsi
VERSION=0.15
TIMESTAMP:=$(shell date "+%F %T%z")
#MANCOUNTRIES=en_GB
CFLAGS=-I. -I.. -ggdb -Wall -O2 -I../lib
UNAME:=$(shell uname -s)
ifeq ($(UNAME),QNX)
LIBS=-lsocket
else
LIBS=
endif
LDFLAGS=
# Add -lwrap to LDFLAGS if compiling with tcp wrappers support.
CC=gcc
INSTALL=install
XGETTEXT=xgettext
MSGMERGE=msgmerge
MSGFMT=msgfmt
DOCBOOK2MAN=docbook2man.pl
prefix=/usr/local
mandir=${prefix}/share/man
localedir=${prefix}/share/locale
mosquitto-0.15/pwfile.example 0000664 0001750 0001750 00000000063 11713444064 015371 0 ustar roger roger roger:password
sub_client:reader
pub_client:writer
mosquitto-0.15/readme.txt 0000664 0001750 0001750 00000001304 11713444064 014523 0 ustar roger roger Mosquitto
=========
Mosquitto is an open source implementation of a server for version 3.1 of the
mqtt protocol. IBM have a closed source version of this server, known as
Really Small Message Broker (rsmb). The plan is to make this a more or less
drop in replacement.
See the following links for more information on mqtt:
http://mqtt.org/
http://www.ibm.com/developerworks/webservices/library/ws-mqtt/index.html
Mosquitto project information is available at the following locations:
http://mosquitto.org/ (main homepage)
http://launchpad.net/mosquitto (bug tracking, translations)
http://bitbucket.org/oojah/mosquitto (hg source code repository)
Mosquitto was written by Roger Light
mosquitto-0.15/security/ 0000775 0001750 0001750 00000000000 11713444064 014376 5 ustar roger roger mosquitto-0.15/security/mosquitto.apparmor 0000664 0001750 0001750 00000000746 11713444064 020214 0 ustar roger roger /usr/sbin/mosquitto {
#include
#include
/usr/sbin/mosquitto r,
/etc/mosquitto/mosquitto.conf r,
/var/lib/mosquitto/ r,
/var/lib/mosquitto/mosquitto.db rwk,
/var/run/mosquitto.pid rw,
network inet stream,
network inet6 stream,
network inet dgram,
network inet6 dgram,
# For drop privileges
capability setgid,
capability setuid,
# For tcp-wrappers
/lib{,32,64}/libwrap.so* rm,
/etc/hosts.allow r,
/etc/hosts.deny r,
}
mosquitto-0.15/external_security_checks.txt 0000664 0001750 0001750 00000006047 11713444064 020370 0 ustar roger roger Mosquitto is now easier to integrate with existing username/password
databases. It doesn't do any of this for you, but it does provide access
points to help.
At the moment mosquitto doesn't support encrypted network connections so you
should be wary of exposing your existing username/passwords.
If you wish to do this, uncomment the WITH_EXTERNAL_SECURITY_CHECKS line in
config.h, or enable the option when configuring the build options with cmake.
You should now edit src/security_external.c to fit your system. If you need to
link extra libraries, add them to src/Makefile or src/CMakeLists.txt.
All functions below have access to the additional config variables db_host,
db_port, db_name, db_username and db_password. They can be accessed via
db->config->db_*.
The functions you need to implement are:
int mosquitto_unpwd_init(struct _mosquitto_db *db)
* Called at mosquitto startup. This is used to open database connections/files
* or anything else that needs to be done once and is related to username and
* password checks.
* Should return MOSQ_ERR_SUCCESS on success, or anything else on error. See
* lib/mosquitto.h for currently defined errors, or use MOSQ_ERR_UNKNOWN.
int mosquitto_unpwd_cleanup(struct _mosquitto_db *db)
* Called when the broker is shutting down. This is used to close database
* connections/files or anything else that needs to be done onc and is related
* to username and password checks.
* Should return MOSQ_ERR_SUCCESS on success, or anything else on error. See
* lib/mosquitto.h for currently defined errors, or use MOSQ_ERR_UNKNOWN.
int mosquitto_unpwd_check(struct _mosquitto_db *db, const char *username, const char *password)
* Called each time a username and/or password needs to be checked.
* Should return MOSQ_ERR_SUCCESS on success, MOSQ_ERR_AUTH for authentication
* errors (username/password invalid) or anything else for other errors. See
* lib/mosquitto.h for currently defined errors, or use MOSQ_ERR_UNKNOWN.
int mosquitto_acl_init(struct _mosquitto_db *db)
* Called at mosquitto startup. This is used to open database connections/files
* or anything else that needs to be done once and is related to access control
* list checks.
* Should return MOSQ_ERR_SUCCESS on success, or anything else on error. See
* lib/mosquitto.h for currently defined errors, or use MOSQ_ERR_UNKNOWN.
void mosquitto_acl_cleanup(struct _mosquitto_db *db)
* Called when the broker is shutting down. This is used to close database
* connections/files or anything else that needs to be done onc and is related
* to username and password checks.
* Should return MOSQ_ERR_SUCCESS on success, or anything else on error. See
* lib/mosquitto.h for currently defined errors, or use MOSQ_ERR_UNKNOWN.
int mosquitto_acl_check(struct _mosquitto_db *db, mqtt3_context *context, const char *topic, int access)
* Called each time a topic access control list should be checked.
* Should return MOSQ_ERR_SUCCESS on success, MOSQ_ERR_ACL_DENIED for ACL
* denials or anything else for other errors. See lib/mosquitto.h for currently
* defined errors, or use MOSQ_ERR_UNKNOWN.
mosquitto-0.15/lib/ 0000775 0001750 0001750 00000000000 11713444064 013275 5 ustar roger roger mosquitto-0.15/lib/CMakeLists.txt 0000664 0001750 0001750 00000002030 11713444064 016030 0 ustar roger roger add_subdirectory(cpp)
include_directories(${mosquitto_SOURCE_DIR} ${mosquitto_SOURCE_DIR}/lib
${STDBOOL_H_PATH} ${STDINT_H_PATH}
${OPENSSL_INCLUDE_DIR})
link_directories(${mosquitto_SOURCE_DIR}/lib)
add_library(libmosquitto SHARED
logging_mosq.c logging_mosq.h
memory_mosq.c memory_mosq.h
messages_mosq.c messages_mosq.h
mosquitto.c mosquitto.h
mqtt3_protocol.h
net_mosq.c net_mosq.h
read_handle.c read_handle.h
read_handle_client.c
read_handle_shared.c
send_client_mosq.c
send_mosq.c send_mosq.h
util_mosq.c util_mosq.h
will_mosq.c will_mosq.h)
if (WIN32)
target_link_libraries(libmosquitto ws2_32 ${OPENSSL_LIBRARIES})
else (WIN32)
target_link_libraries(libmosquitto ${OPENSSL_LIBRARIES})
endif (WIN32)
set_target_properties(libmosquitto PROPERTIES
OUTPUT_NAME mosquitto
VERSION ${VERSION}
SOVERSION 0
)
install(TARGETS libmosquitto RUNTIME DESTINATION ${BINDIR} LIBRARY DESTINATION ${LIBDIR})
install(FILES mosquitto.h DESTINATION ${INCLUDEDIR})
if (UNIX)
install(CODE "EXEC_PROGRAM(/sbin/ldconfig)")
endif (UNIX)
mosquitto-0.15/lib/net_mosq.h 0000664 0001750 0001750 00000006677 11713444064 015313 0 ustar roger roger /*
Copyright (c) 2010,2011 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _NET_MOSQ_H_
#define _NET_MOSQ_H_
#ifndef WIN32
#include
#else
#include
typedef int ssize_t;
#endif
#include
#include
#ifdef WITH_BROKER
struct _mosquitto_db;
#endif
#ifdef WIN32
# define COMPAT_CLOSE(a) closesocket(a)
#else
# define COMPAT_CLOSE(a) close(a)
#endif
/* For when not using winsock libraries. */
#ifndef INVALID_SOCKET
#define INVALID_SOCKET -1
#endif
/* Macros for accessing the MSB and LSB of a uint16_t */
#define MOSQ_MSB(A) (uint8_t)((A & 0xFF00) >> 8)
#define MOSQ_LSB(A) (uint8_t)(A & 0x00FF)
void _mosquitto_net_init(void);
void _mosquitto_net_cleanup(void);
void _mosquitto_packet_cleanup(struct _mosquitto_packet *packet);
int _mosquitto_packet_queue(struct mosquitto *mosq, struct _mosquitto_packet *packet);
int _mosquitto_socket_connect(struct mosquitto *mosq, const char *host, uint16_t port);
int _mosquitto_socket_close(struct mosquitto *mosq);
int _mosquitto_read_byte(struct _mosquitto_packet *packet, uint8_t *byte);
int _mosquitto_read_bytes(struct _mosquitto_packet *packet, uint8_t *bytes, uint32_t count);
int _mosquitto_read_string(struct _mosquitto_packet *packet, char **str);
int _mosquitto_read_uint16(struct _mosquitto_packet *packet, uint16_t *word);
void _mosquitto_write_byte(struct _mosquitto_packet *packet, uint8_t byte);
void _mosquitto_write_bytes(struct _mosquitto_packet *packet, const uint8_t *bytes, uint32_t count);
void _mosquitto_write_string(struct _mosquitto_packet *packet, const char *str, uint16_t length);
void _mosquitto_write_uint16(struct _mosquitto_packet *packet, uint16_t word);
ssize_t _mosquitto_net_read(struct mosquitto *mosq, void *buf, size_t count);
ssize_t _mosquitto_net_write(struct mosquitto *mosq, void *buf, size_t count);
int _mosquitto_packet_write(struct mosquitto *mosq);
#ifdef WITH_BROKER
int _mosquitto_packet_read(struct _mosquitto_db *db, int context_index);
#else
int _mosquitto_packet_read(struct mosquitto *mosq);
#endif
#endif
mosquitto-0.15/lib/will_mosq.c 0000664 0001750 0001750 00000006544 11713444064 015460 0 ustar roger roger /*
Copyright (c) 2010,2011 Roger Light
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of mosquitto nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include