1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24 #include "server_setup.h"
25 #include <stdlib.h>
26 #include <string.h>
27 #include "util.h"
28
29 /* Function
30 *
31 * Accepts a TCP connection on a custom port (IPv4 or IPv6). Speaks MQTT.
32 *
33 * Read commands from FILE (set with --config). The commands control how to
34 * act and is reset to defaults each client TCP connect.
35 *
36 * Config file keywords:
37 *
38 * TODO
39 */
40
41 /* based on sockfilt.c */
42
43 #include <signal.h>
44 #ifdef HAVE_NETINET_IN_H
45 #include <netinet/in.h>
46 #endif
47 #ifdef HAVE_NETINET_IN6_H
48 #include <netinet/in6.h>
49 #endif
50 #ifdef HAVE_ARPA_INET_H
51 #include <arpa/inet.h>
52 #endif
53 #ifdef HAVE_NETDB_H
54 #include <netdb.h>
55 #endif
56
57 #include "curlx.h" /* from the private lib dir */
58 #include "getpart.h"
59 #include "inet_pton.h"
60 #include "server_sockaddr.h"
61 #include "warnless.h"
62
63 /* include memdebug.h last */
64 #include "memdebug.h"
65
66 #ifdef USE_WINSOCK
67 #undef EINTR
68 #define EINTR 4 /* errno.h value */
69 #undef EAGAIN
70 #define EAGAIN 11 /* errno.h value */
71 #undef ENOMEM
72 #define ENOMEM 12 /* errno.h value */
73 #undef EINVAL
74 #define EINVAL 22 /* errno.h value */
75 #endif
76
77 #define DEFAULT_PORT 1883 /* MQTT default port */
78
79 #ifndef DEFAULT_LOGFILE
80 #define DEFAULT_LOGFILE "log/mqttd.log"
81 #endif
82
83 #ifndef DEFAULT_CONFIG
84 #define DEFAULT_CONFIG "mqttd.config"
85 #endif
86
87 #define MQTT_MSG_CONNECT 0x10
88 #define MQTT_MSG_CONNACK 0x20
89 #define MQTT_MSG_PUBLISH 0x30
90 #define MQTT_MSG_PUBACK 0x40
91 #define MQTT_MSG_SUBSCRIBE 0x82
92 #define MQTT_MSG_SUBACK 0x90
93 #define MQTT_MSG_DISCONNECT 0xe0
94
95 #define MQTT_CONNACK_LEN 4
96 #define MQTT_SUBACK_LEN 5
97 #define MQTT_CLIENTID_LEN 12 /* "curl0123abcd" */
98
99 struct configurable {
100 unsigned char version; /* initial version byte in the request must match
101 this */
102 bool publish_before_suback;
103 bool short_publish;
104 bool excessive_remaining;
105 unsigned char error_connack;
106 int testnum;
107 };
108
109 #define REQUEST_DUMP "server.input"
110 #define CONFIG_VERSION 5
111
112 static struct configurable config;
113
114 const char *serverlogfile = DEFAULT_LOGFILE;
115 static const char *configfile = DEFAULT_CONFIG;
116 static const char *logdir = "log";
117 static char loglockfile[256];
118
119 #ifdef USE_IPV6
120 static bool use_ipv6 = FALSE;
121 #endif
122 static const char *ipv_inuse = "IPv4";
123 static unsigned short port = DEFAULT_PORT;
124
resetdefaults(void)125 static void resetdefaults(void)
126 {
127 logmsg("Reset to defaults");
128 config.version = CONFIG_VERSION;
129 config.publish_before_suback = FALSE;
130 config.short_publish = FALSE;
131 config.excessive_remaining = FALSE;
132 config.error_connack = 0;
133 config.testnum = 0;
134 }
135
byteval(char * value)136 static unsigned char byteval(char *value)
137 {
138 unsigned long num = strtoul(value, NULL, 10);
139 return num & 0xff;
140 }
141
getconfig(void)142 static void getconfig(void)
143 {
144 FILE *fp = fopen(configfile, FOPEN_READTEXT);
145 resetdefaults();
146 if(fp) {
147 char buffer[512];
148 logmsg("parse config file");
149 while(fgets(buffer, sizeof(buffer), fp)) {
150 char key[32];
151 char value[32];
152 if(2 == sscanf(buffer, "%31s %31s", key, value)) {
153 if(!strcmp(key, "version")) {
154 config.version = byteval(value);
155 logmsg("version [%d] set", config.version);
156 }
157 else if(!strcmp(key, "PUBLISH-before-SUBACK")) {
158 logmsg("PUBLISH-before-SUBACK set");
159 config.publish_before_suback = TRUE;
160 }
161 else if(!strcmp(key, "short-PUBLISH")) {
162 logmsg("short-PUBLISH set");
163 config.short_publish = TRUE;
164 }
165 else if(!strcmp(key, "error-CONNACK")) {
166 config.error_connack = byteval(value);
167 logmsg("error-CONNACK = %d", config.error_connack);
168 }
169 else if(!strcmp(key, "Testnum")) {
170 config.testnum = atoi(value);
171 logmsg("testnum = %d", config.testnum);
172 }
173 else if(!strcmp(key, "excessive-remaining")) {
174 logmsg("excessive-remaining set");
175 config.excessive_remaining = TRUE;
176 }
177 }
178 }
179 fclose(fp);
180 }
181 else {
182 logmsg("No config file '%s' to read", configfile);
183 }
184 }
185
loghex(unsigned char * buffer,ssize_t len)186 static void loghex(unsigned char *buffer, ssize_t len)
187 {
188 char data[12000];
189 ssize_t i;
190 unsigned char *ptr = buffer;
191 char *optr = data;
192 ssize_t width = 0;
193 int left = sizeof(data);
194
195 for(i = 0; i < len && (left >= 0); i++) {
196 msnprintf(optr, left, "%02x", ptr[i]);
197 width += 2;
198 optr += 2;
199 left -= 2;
200 }
201 if(width)
202 logmsg("'%s'", data);
203 }
204
205 typedef enum {
206 FROM_CLIENT,
207 FROM_SERVER
208 } mqttdir;
209
logprotocol(mqttdir dir,const char * prefix,size_t remlen,FILE * output,unsigned char * buffer,ssize_t len)210 static void logprotocol(mqttdir dir,
211 const char *prefix, size_t remlen,
212 FILE *output,
213 unsigned char *buffer, ssize_t len)
214 {
215 char data[12000] = "";
216 ssize_t i;
217 unsigned char *ptr = buffer;
218 char *optr = data;
219 int left = sizeof(data);
220
221 for(i = 0; i < len && (left >= 0); i++) {
222 msnprintf(optr, left, "%02x", ptr[i]);
223 optr += 2;
224 left -= 2;
225 }
226 fprintf(output, "%s %s %zx %s\n",
227 dir == FROM_CLIENT ? "client" : "server",
228 prefix, remlen, data);
229 }
230
231
232 /* return 0 on success */
connack(FILE * dump,curl_socket_t fd)233 static int connack(FILE *dump, curl_socket_t fd)
234 {
235 unsigned char packet[]={
236 MQTT_MSG_CONNACK, 0x02,
237 0x00, 0x00
238 };
239 ssize_t rc;
240
241 packet[3] = config.error_connack;
242
243 rc = swrite(fd, (char *)packet, sizeof(packet));
244 if(rc > 0) {
245 logmsg("WROTE %zd bytes [CONNACK]", rc);
246 loghex(packet, rc);
247 logprotocol(FROM_SERVER, "CONNACK", 2, dump, packet, sizeof(packet));
248 }
249 if(rc == sizeof(packet)) {
250 return 0;
251 }
252 return 1;
253 }
254
255 /* return 0 on success */
suback(FILE * dump,curl_socket_t fd,unsigned short packetid)256 static int suback(FILE *dump, curl_socket_t fd, unsigned short packetid)
257 {
258 unsigned char packet[]={
259 MQTT_MSG_SUBACK, 0x03,
260 0, 0, /* filled in below */
261 0x00
262 };
263 ssize_t rc;
264 packet[2] = (unsigned char)(packetid >> 8);
265 packet[3] = (unsigned char)(packetid & 0xff);
266
267 rc = swrite(fd, (char *)packet, sizeof(packet));
268 if(rc == sizeof(packet)) {
269 logmsg("WROTE %zd bytes [SUBACK]", rc);
270 loghex(packet, rc);
271 logprotocol(FROM_SERVER, "SUBACK", 3, dump, packet, rc);
272 return 0;
273 }
274 return 1;
275 }
276
277 #ifdef QOS
278 /* return 0 on success */
puback(FILE * dump,curl_socket_t fd,unsigned short packetid)279 static int puback(FILE *dump, curl_socket_t fd, unsigned short packetid)
280 {
281 unsigned char packet[]={
282 MQTT_MSG_PUBACK, 0x00,
283 0, 0 /* filled in below */
284 };
285 ssize_t rc;
286 packet[2] = (unsigned char)(packetid >> 8);
287 packet[3] = (unsigned char)(packetid & 0xff);
288
289 rc = swrite(fd, (char *)packet, sizeof(packet));
290 if(rc == sizeof(packet)) {
291 logmsg("WROTE %zd bytes [PUBACK]", rc);
292 loghex(packet, rc);
293 logprotocol(FROM_SERVER, dump, packet, rc);
294 return 0;
295 }
296 logmsg("Failed sending [PUBACK]");
297 return 1;
298 }
299 #endif
300
301 /* return 0 on success */
disconnect(FILE * dump,curl_socket_t fd)302 static int disconnect(FILE *dump, curl_socket_t fd)
303 {
304 unsigned char packet[]={
305 MQTT_MSG_DISCONNECT, 0x00,
306 };
307 ssize_t rc = swrite(fd, (char *)packet, sizeof(packet));
308 if(rc == sizeof(packet)) {
309 logmsg("WROTE %zd bytes [DISCONNECT]", rc);
310 loghex(packet, rc);
311 logprotocol(FROM_SERVER, "DISCONNECT", 0, dump, packet, rc);
312 return 0;
313 }
314 logmsg("Failed sending [DISCONNECT]");
315 return 1;
316 }
317
318
319
320 /*
321 do
322
323 encodedByte = X MOD 128
324
325 X = X DIV 128
326
327 // if there are more data to encode, set the top bit of this byte
328
329 if ( X > 0 )
330
331 encodedByte = encodedByte OR 128
332
333 endif
334
335 'output' encodedByte
336
337 while ( X > 0 )
338
339 */
340
341 /* return number of bytes used */
encode_length(size_t packetlen,unsigned char * remlength)342 static size_t encode_length(size_t packetlen,
343 unsigned char *remlength) /* 4 bytes */
344 {
345 size_t bytes = 0;
346 unsigned char encode;
347
348 do {
349 encode = packetlen % 0x80;
350 packetlen /= 0x80;
351 if(packetlen)
352 encode |= 0x80;
353
354 remlength[bytes++] = encode;
355
356 if(bytes > 3) {
357 logmsg("too large packet!");
358 return 0;
359 }
360 } while(packetlen);
361
362 return bytes;
363 }
364
365
decode_length(unsigned char * buf,size_t buflen,size_t * lenbytes)366 static size_t decode_length(unsigned char *buf,
367 size_t buflen, size_t *lenbytes)
368 {
369 size_t len = 0;
370 size_t mult = 1;
371 size_t i;
372 unsigned char encoded = 0x80;
373
374 for(i = 0; (i < buflen) && (encoded & 0x80); i++) {
375 encoded = buf[i];
376 len += (encoded & 0x7f) * mult;
377 mult *= 0x80;
378 }
379
380 if(lenbytes)
381 *lenbytes = i;
382
383 return len;
384 }
385
386
387 /* return 0 on success */
publish(FILE * dump,curl_socket_t fd,unsigned short packetid,char * topic,char * payload,size_t payloadlen)388 static int publish(FILE *dump,
389 curl_socket_t fd, unsigned short packetid,
390 char *topic, char *payload, size_t payloadlen)
391 {
392 size_t topiclen = strlen(topic);
393 unsigned char *packet;
394 size_t payloadindex;
395 size_t remaininglength = topiclen + 2 + payloadlen;
396 size_t packetlen;
397 size_t sendamount;
398 ssize_t rc;
399 unsigned char rembuffer[4];
400 size_t encodedlen;
401
402 if(config.excessive_remaining) {
403 /* manually set illegal remaining length */
404 rembuffer[0] = 0xff;
405 rembuffer[1] = 0xff;
406 rembuffer[2] = 0xff;
407 rembuffer[3] = 0x80; /* maximum allowed here by spec is 0x7f */
408 encodedlen = 4;
409 }
410 else
411 encodedlen = encode_length(remaininglength, rembuffer);
412
413 /* one packet type byte (possibly two more for packetid) */
414 packetlen = remaininglength + encodedlen + 1;
415 packet = malloc(packetlen);
416 if(!packet)
417 return 1;
418
419 packet[0] = MQTT_MSG_PUBLISH; /* TODO: set QoS? */
420 memcpy(&packet[1], rembuffer, encodedlen);
421
422 (void)packetid;
423 /* packet_id if QoS is set */
424
425 packet[1 + encodedlen] = (unsigned char)(topiclen >> 8);
426 packet[2 + encodedlen] = (unsigned char)(topiclen & 0xff);
427 memcpy(&packet[3 + encodedlen], topic, topiclen);
428
429 payloadindex = 3 + topiclen + encodedlen;
430 memcpy(&packet[payloadindex], payload, payloadlen);
431
432 sendamount = packetlen;
433 if(config.short_publish)
434 sendamount -= 2;
435
436 rc = swrite(fd, (char *)packet, sendamount);
437 if(rc > 0) {
438 logmsg("WROTE %zd bytes [PUBLISH]", rc);
439 loghex(packet, rc);
440 logprotocol(FROM_SERVER, "PUBLISH", remaininglength, dump, packet, rc);
441 }
442 if((size_t)rc == packetlen)
443 return 0;
444 return 1;
445 }
446
447 #define MAX_TOPIC_LENGTH 65535
448 #define MAX_CLIENT_ID_LENGTH 32
449
450 static char topic[MAX_TOPIC_LENGTH + 1];
451
fixedheader(curl_socket_t fd,unsigned char * bytep,size_t * remaining_lengthp,size_t * remaining_length_bytesp)452 static int fixedheader(curl_socket_t fd,
453 unsigned char *bytep,
454 size_t *remaining_lengthp,
455 size_t *remaining_length_bytesp)
456 {
457 /* get the fixed header */
458 unsigned char buffer[10];
459
460 /* get the first two bytes */
461 ssize_t rc = sread(fd, (char *)buffer, 2);
462 size_t i;
463 if(rc < 2) {
464 logmsg("READ %zd bytes [SHORT!]", rc);
465 return 1; /* fail */
466 }
467 logmsg("READ %zd bytes", rc);
468 loghex(buffer, rc);
469 *bytep = buffer[0];
470
471 /* if the length byte has the top bit set, get the next one too */
472 i = 1;
473 while(buffer[i] & 0x80) {
474 i++;
475 rc = sread(fd, (char *)&buffer[i], 1);
476 if(rc != 1) {
477 logmsg("Remaining Length broken");
478 return 1;
479 }
480 }
481 *remaining_lengthp = decode_length(&buffer[1], i, remaining_length_bytesp);
482 logmsg("Remaining Length: %zu [%zu bytes]", *remaining_lengthp,
483 *remaining_length_bytesp);
484 return 0;
485 }
486
mqttit(curl_socket_t fd)487 static curl_socket_t mqttit(curl_socket_t fd)
488 {
489 size_t buff_size = 10*1024;
490 unsigned char *buffer = NULL;
491 ssize_t rc;
492 unsigned char byte;
493 unsigned short packet_id;
494 size_t payload_len;
495 size_t client_id_length;
496 size_t topic_len;
497 size_t remaining_length = 0;
498 size_t bytes = 0; /* remaining length field size in bytes */
499 char client_id[MAX_CLIENT_ID_LENGTH];
500 long testno;
501 FILE *stream = NULL;
502 FILE *dump;
503 char dumpfile[256];
504
505 static const char protocol[7] = {
506 0x00, 0x04, /* protocol length */
507 'M','Q','T','T', /* protocol name */
508 0x04 /* protocol level */
509 };
510 msnprintf(dumpfile, sizeof(dumpfile), "%s/%s", logdir, REQUEST_DUMP);
511 dump = fopen(dumpfile, "ab");
512 if(!dump)
513 goto end;
514
515 getconfig();
516
517 testno = config.testnum;
518
519 if(testno)
520 logmsg("Found test number %ld", testno);
521
522 buffer = malloc(buff_size);
523 if(!buffer) {
524 logmsg("Out of memory, unable to allocate buffer");
525 goto end;
526 }
527
528 do {
529 unsigned char usr_flag = 0x80;
530 unsigned char passwd_flag = 0x40;
531 unsigned char conn_flags;
532 const size_t client_id_offset = 12;
533 size_t start_usr;
534 size_t start_passwd;
535
536 /* get the fixed header */
537 rc = fixedheader(fd, &byte, &remaining_length, &bytes);
538 if(rc)
539 break;
540
541 if(remaining_length >= buff_size) {
542 buff_size = remaining_length;
543 buffer = realloc(buffer, buff_size);
544 if(!buffer) {
545 logmsg("Failed realloc of size %zu", buff_size);
546 goto end;
547 }
548 }
549
550 if(remaining_length) {
551 /* reading variable header and payload into buffer */
552 rc = sread(fd, (char *)buffer, remaining_length);
553 if(rc > 0) {
554 logmsg("READ %zd bytes", rc);
555 loghex(buffer, rc);
556 }
557 }
558
559 if(byte == MQTT_MSG_CONNECT) {
560 logprotocol(FROM_CLIENT, "CONNECT", remaining_length,
561 dump, buffer, rc);
562
563 if(memcmp(protocol, buffer, sizeof(protocol))) {
564 logmsg("Protocol preamble mismatch");
565 goto end;
566 }
567 /* ignore the connect flag byte and two keepalive bytes */
568 payload_len = (size_t)(buffer[10] << 8) | buffer[11];
569 /* first part of the payload is the client ID */
570 client_id_length = payload_len;
571
572 /* checking if user and password flags were set */
573 conn_flags = buffer[7];
574
575 start_usr = client_id_offset + payload_len;
576 if(usr_flag == (unsigned char)(conn_flags & usr_flag)) {
577 logmsg("User flag is present in CONN flag");
578 payload_len += (size_t)(buffer[start_usr] << 8) |
579 buffer[start_usr + 1];
580 payload_len += 2; /* MSB and LSB for user length */
581 }
582
583 start_passwd = client_id_offset + payload_len;
584 if(passwd_flag == (char)(conn_flags & passwd_flag)) {
585 logmsg("Password flag is present in CONN flags");
586 payload_len += (size_t)(buffer[start_passwd] << 8) |
587 buffer[start_passwd + 1];
588 payload_len += 2; /* MSB and LSB for password length */
589 }
590
591 /* check the length of the payload */
592 if((ssize_t)payload_len != (rc - 12)) {
593 logmsg("Payload length mismatch, expected %zx got %zx",
594 rc - 12, payload_len);
595 goto end;
596 }
597 /* check the length of the client ID */
598 else if((client_id_length + 1) > MAX_CLIENT_ID_LENGTH) {
599 logmsg("Too large client id");
600 goto end;
601 }
602 memcpy(client_id, &buffer[12], client_id_length);
603 client_id[client_id_length] = 0;
604
605 logmsg("MQTT client connect accepted: %s", client_id);
606
607 /* The first packet sent from the Server to the Client MUST be a
608 CONNACK Packet */
609
610 if(connack(dump, fd)) {
611 logmsg("failed sending CONNACK");
612 goto end;
613 }
614 }
615 else if(byte == MQTT_MSG_SUBSCRIBE) {
616 int error;
617 char *data;
618 size_t datalen;
619 logprotocol(FROM_CLIENT, "SUBSCRIBE", remaining_length,
620 dump, buffer, rc);
621 logmsg("Incoming SUBSCRIBE");
622
623 if(rc < 6) {
624 logmsg("Too small SUBSCRIBE");
625 goto end;
626 }
627
628 /* two bytes packet id */
629 packet_id = (unsigned short)((buffer[0] << 8) | buffer[1]);
630
631 /* two bytes topic length */
632 topic_len = (size_t)(buffer[2] << 8) | buffer[3];
633 if(topic_len != (remaining_length - 5)) {
634 logmsg("Wrong topic length, got %zu expected %zu",
635 topic_len, remaining_length - 5);
636 goto end;
637 }
638 memcpy(topic, &buffer[4], topic_len);
639 topic[topic_len] = 0;
640
641 /* there's a QoS byte (two bits) after the topic */
642
643 logmsg("SUBSCRIBE to '%s' [%d]", topic, packet_id);
644 stream = test2fopen(testno, logdir);
645 error = getpart(&data, &datalen, "reply", "data", stream);
646 if(!error) {
647 if(!config.publish_before_suback) {
648 if(suback(dump, fd, packet_id)) {
649 logmsg("failed sending SUBACK");
650 goto end;
651 }
652 }
653 if(publish(dump, fd, packet_id, topic, data, datalen)) {
654 logmsg("PUBLISH failed");
655 goto end;
656 }
657 if(config.publish_before_suback) {
658 if(suback(dump, fd, packet_id)) {
659 logmsg("failed sending SUBACK");
660 goto end;
661 }
662 }
663 }
664 else {
665 char *def = (char *)"this is random payload yes yes it is";
666 publish(dump, fd, packet_id, topic, def, strlen(def));
667 }
668 disconnect(dump, fd);
669 }
670 else if((byte & 0xf0) == (MQTT_MSG_PUBLISH & 0xf0)) {
671 size_t topiclen;
672
673 logmsg("Incoming PUBLISH");
674 logprotocol(FROM_CLIENT, "PUBLISH", remaining_length,
675 dump, buffer, rc);
676
677 topiclen = (size_t)(buffer[1 + bytes] << 8) | buffer[2 + bytes];
678 logmsg("Got %zu bytes topic", topiclen);
679 /* TODO: verify topiclen */
680
681 #ifdef QOS
682 /* TODO: handle packetid if there is one. Send puback if QoS > 0 */
683 puback(dump, fd, 0);
684 #endif
685 /* expect a disconnect here */
686 /* get the request */
687 rc = sread(fd, (char *)&buffer[0], 2);
688
689 logmsg("READ %zd bytes [DISCONNECT]", rc);
690 loghex(buffer, rc);
691 logprotocol(FROM_CLIENT, "DISCONNECT", 0, dump, buffer, rc);
692 goto end;
693 }
694 else {
695 /* not supported (yet) */
696 goto end;
697 }
698 } while(1);
699
700 end:
701 if(buffer)
702 free(buffer);
703 if(dump)
704 fclose(dump);
705 if(stream)
706 fclose(stream);
707 return CURL_SOCKET_BAD;
708 }
709
710 /*
711 sockfdp is a pointer to an established stream or CURL_SOCKET_BAD
712
713 if sockfd is CURL_SOCKET_BAD, listendfd is a listening socket we must
714 accept()
715 */
incoming(curl_socket_t listenfd)716 static bool incoming(curl_socket_t listenfd)
717 {
718 fd_set fds_read;
719 fd_set fds_write;
720 fd_set fds_err;
721 int clients = 0; /* connected clients */
722
723 if(got_exit_signal) {
724 logmsg("signalled to die, exiting...");
725 return FALSE;
726 }
727
728 #ifdef HAVE_GETPPID
729 /* As a last resort, quit if socks5 process becomes orphan. */
730 if(getppid() <= 1) {
731 logmsg("process becomes orphan, exiting");
732 return FALSE;
733 }
734 #endif
735
736 do {
737 ssize_t rc;
738 int error = 0;
739 curl_socket_t sockfd = listenfd;
740 int maxfd = (int)sockfd;
741
742 FD_ZERO(&fds_read);
743 FD_ZERO(&fds_write);
744 FD_ZERO(&fds_err);
745
746 /* there's always a socket to wait for */
747 FD_SET(sockfd, &fds_read);
748
749 do {
750 /* select() blocking behavior call on blocking descriptors please */
751 rc = select(maxfd + 1, &fds_read, &fds_write, &fds_err, NULL);
752 if(got_exit_signal) {
753 logmsg("signalled to die, exiting...");
754 return FALSE;
755 }
756 } while((rc == -1) && ((error = SOCKERRNO) == EINTR));
757
758 if(rc < 0) {
759 logmsg("select() failed with error: (%d) %s",
760 error, strerror(error));
761 return FALSE;
762 }
763
764 if(FD_ISSET(sockfd, &fds_read)) {
765 curl_socket_t newfd = accept(sockfd, NULL, NULL);
766 if(CURL_SOCKET_BAD == newfd) {
767 error = SOCKERRNO;
768 logmsg("accept(%" FMT_SOCKET_T ", NULL, NULL) "
769 "failed with error: (%d) %s", sockfd, error, sstrerror(error));
770 }
771 else {
772 logmsg("====> Client connect, fd %" FMT_SOCKET_T ". "
773 "Read config from %s", newfd, configfile);
774 set_advisor_read_lock(loglockfile);
775 (void)mqttit(newfd); /* until done */
776 clear_advisor_read_lock(loglockfile);
777
778 logmsg("====> Client disconnect");
779 sclose(newfd);
780 }
781 }
782 } while(clients);
783
784 return TRUE;
785 }
786
sockdaemon(curl_socket_t sock,unsigned short * listenport)787 static curl_socket_t sockdaemon(curl_socket_t sock,
788 unsigned short *listenport)
789 {
790 /* passive daemon style */
791 srvr_sockaddr_union_t listener;
792 int flag;
793 int rc;
794 int totdelay = 0;
795 int maxretr = 10;
796 int delay = 20;
797 int attempt = 0;
798 int error = 0;
799
800 do {
801 attempt++;
802 flag = 1;
803 rc = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
804 (void *)&flag, sizeof(flag));
805 if(rc) {
806 error = SOCKERRNO;
807 logmsg("setsockopt(SO_REUSEADDR) failed with error: (%d) %s",
808 error, sstrerror(error));
809 if(maxretr) {
810 rc = wait_ms(delay);
811 if(rc) {
812 /* should not happen */
813 logmsg("wait_ms() failed with error: %d", rc);
814 sclose(sock);
815 return CURL_SOCKET_BAD;
816 }
817 if(got_exit_signal) {
818 logmsg("signalled to die, exiting...");
819 sclose(sock);
820 return CURL_SOCKET_BAD;
821 }
822 totdelay += delay;
823 delay *= 2; /* double the sleep for next attempt */
824 }
825 }
826 } while(rc && maxretr--);
827
828 if(rc) {
829 logmsg("setsockopt(SO_REUSEADDR) failed %d times in %d ms. Error: (%d) %s",
830 attempt, totdelay, error, strerror(error));
831 logmsg("Continuing anyway...");
832 }
833
834 /* When the specified listener port is zero, it is actually a
835 request to let the system choose a non-zero available port. */
836
837 #ifdef USE_IPV6
838 if(!use_ipv6) {
839 #endif
840 memset(&listener.sa4, 0, sizeof(listener.sa4));
841 listener.sa4.sin_family = AF_INET;
842 listener.sa4.sin_addr.s_addr = INADDR_ANY;
843 listener.sa4.sin_port = htons(*listenport);
844 rc = bind(sock, &listener.sa, sizeof(listener.sa4));
845 #ifdef USE_IPV6
846 }
847 else {
848 memset(&listener.sa6, 0, sizeof(listener.sa6));
849 listener.sa6.sin6_family = AF_INET6;
850 listener.sa6.sin6_addr = in6addr_any;
851 listener.sa6.sin6_port = htons(*listenport);
852 rc = bind(sock, &listener.sa, sizeof(listener.sa6));
853 }
854 #endif /* USE_IPV6 */
855 if(rc) {
856 error = SOCKERRNO;
857 logmsg("Error binding socket on port %hu: (%d) %s",
858 *listenport, error, sstrerror(error));
859 sclose(sock);
860 return CURL_SOCKET_BAD;
861 }
862
863 if(!*listenport) {
864 /* The system was supposed to choose a port number, figure out which
865 port we actually got and update the listener port value with it. */
866 curl_socklen_t la_size;
867 srvr_sockaddr_union_t localaddr;
868 #ifdef USE_IPV6
869 if(!use_ipv6)
870 #endif
871 la_size = sizeof(localaddr.sa4);
872 #ifdef USE_IPV6
873 else
874 la_size = sizeof(localaddr.sa6);
875 #endif
876 memset(&localaddr.sa, 0, (size_t)la_size);
877 if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
878 error = SOCKERRNO;
879 logmsg("getsockname() failed with error: (%d) %s",
880 error, sstrerror(error));
881 sclose(sock);
882 return CURL_SOCKET_BAD;
883 }
884 switch(localaddr.sa.sa_family) {
885 case AF_INET:
886 *listenport = ntohs(localaddr.sa4.sin_port);
887 break;
888 #ifdef USE_IPV6
889 case AF_INET6:
890 *listenport = ntohs(localaddr.sa6.sin6_port);
891 break;
892 #endif
893 default:
894 break;
895 }
896 if(!*listenport) {
897 /* Real failure, listener port shall not be zero beyond this point. */
898 logmsg("Apparently getsockname() succeeded, with listener port zero.");
899 logmsg("A valid reason for this failure is a binary built without");
900 logmsg("proper network library linkage. This might not be the only");
901 logmsg("reason, but double check it before anything else.");
902 sclose(sock);
903 return CURL_SOCKET_BAD;
904 }
905 }
906
907 /* start accepting connections */
908 rc = listen(sock, 5);
909 if(0 != rc) {
910 error = SOCKERRNO;
911 logmsg("listen(%" FMT_SOCKET_T ", 5) failed with error: (%d) %s",
912 sock, error, sstrerror(error));
913 sclose(sock);
914 return CURL_SOCKET_BAD;
915 }
916
917 return sock;
918 }
919
920
main(int argc,char * argv[])921 int main(int argc, char *argv[])
922 {
923 curl_socket_t sock = CURL_SOCKET_BAD;
924 curl_socket_t msgsock = CURL_SOCKET_BAD;
925 int wrotepidfile = 0;
926 int wroteportfile = 0;
927 const char *pidname = ".mqttd.pid";
928 const char *portname = ".mqttd.port";
929 bool juggle_again;
930 int error;
931 int arg = 1;
932
933 while(argc > arg) {
934 if(!strcmp("--version", argv[arg])) {
935 printf("mqttd IPv4%s\n",
936 #ifdef USE_IPV6
937 "/IPv6"
938 #else
939 ""
940 #endif
941 );
942 return 0;
943 }
944 else if(!strcmp("--pidfile", argv[arg])) {
945 arg++;
946 if(argc > arg)
947 pidname = argv[arg++];
948 }
949 else if(!strcmp("--portfile", argv[arg])) {
950 arg++;
951 if(argc > arg)
952 portname = argv[arg++];
953 }
954 else if(!strcmp("--config", argv[arg])) {
955 arg++;
956 if(argc > arg)
957 configfile = argv[arg++];
958 }
959 else if(!strcmp("--logfile", argv[arg])) {
960 arg++;
961 if(argc > arg)
962 serverlogfile = argv[arg++];
963 }
964 else if(!strcmp("--logdir", argv[arg])) {
965 arg++;
966 if(argc > arg)
967 logdir = argv[arg++];
968 }
969 else if(!strcmp("--ipv6", argv[arg])) {
970 #ifdef USE_IPV6
971 ipv_inuse = "IPv6";
972 use_ipv6 = TRUE;
973 #endif
974 arg++;
975 }
976 else if(!strcmp("--ipv4", argv[arg])) {
977 /* for completeness, we support this option as well */
978 #ifdef USE_IPV6
979 ipv_inuse = "IPv4";
980 use_ipv6 = FALSE;
981 #endif
982 arg++;
983 }
984 else if(!strcmp("--port", argv[arg])) {
985 arg++;
986 if(argc > arg) {
987 char *endptr;
988 unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
989 if((endptr != argv[arg] + strlen(argv[arg])) ||
990 ((ulnum != 0UL) && ((ulnum < 1025UL) || (ulnum > 65535UL)))) {
991 fprintf(stderr, "mqttd: invalid --port argument (%s)\n",
992 argv[arg]);
993 return 0;
994 }
995 port = curlx_ultous(ulnum);
996 arg++;
997 }
998 }
999 else {
1000 puts("Usage: mqttd [option]\n"
1001 " --config [file]\n"
1002 " --version\n"
1003 " --logfile [file]\n"
1004 " --logdir [directory]\n"
1005 " --pidfile [file]\n"
1006 " --portfile [file]\n"
1007 " --ipv4\n"
1008 " --ipv6\n"
1009 " --port [port]\n");
1010 return 0;
1011 }
1012 }
1013
1014 msnprintf(loglockfile, sizeof(loglockfile), "%s/%s/mqtt-%s.lock",
1015 logdir, SERVERLOGS_LOCKDIR, ipv_inuse);
1016
1017 #ifdef _WIN32
1018 win32_init();
1019 atexit(win32_cleanup);
1020
1021 setmode(fileno(stdin), O_BINARY);
1022 setmode(fileno(stdout), O_BINARY);
1023 setmode(fileno(stderr), O_BINARY);
1024 #endif
1025
1026 install_signal_handlers(FALSE);
1027
1028 #ifdef USE_IPV6
1029 if(!use_ipv6)
1030 #endif
1031 sock = socket(AF_INET, SOCK_STREAM, 0);
1032 #ifdef USE_IPV6
1033 else
1034 sock = socket(AF_INET6, SOCK_STREAM, 0);
1035 #endif
1036
1037 if(CURL_SOCKET_BAD == sock) {
1038 error = SOCKERRNO;
1039 logmsg("Error creating socket: (%d) %s", error, sstrerror(error));
1040 goto mqttd_cleanup;
1041 }
1042
1043 {
1044 /* passive daemon style */
1045 sock = sockdaemon(sock, &port);
1046 if(CURL_SOCKET_BAD == sock) {
1047 goto mqttd_cleanup;
1048 }
1049 msgsock = CURL_SOCKET_BAD; /* no stream socket yet */
1050 }
1051
1052 logmsg("Running %s version", ipv_inuse);
1053 logmsg("Listening on port %hu", port);
1054
1055 wrotepidfile = write_pidfile(pidname);
1056 if(!wrotepidfile) {
1057 goto mqttd_cleanup;
1058 }
1059
1060 wroteportfile = write_portfile(portname, port);
1061 if(!wroteportfile) {
1062 goto mqttd_cleanup;
1063 }
1064
1065 do {
1066 juggle_again = incoming(sock);
1067 } while(juggle_again);
1068
1069 mqttd_cleanup:
1070
1071 if((msgsock != sock) && (msgsock != CURL_SOCKET_BAD))
1072 sclose(msgsock);
1073
1074 if(sock != CURL_SOCKET_BAD)
1075 sclose(sock);
1076
1077 if(wrotepidfile)
1078 unlink(pidname);
1079 if(wroteportfile)
1080 unlink(portname);
1081
1082 restore_signal_handlers(FALSE);
1083
1084 if(got_exit_signal) {
1085 logmsg("============> mqttd exits with signal (%d)", exit_signal);
1086 /*
1087 * To properly set the return status of the process we
1088 * must raise the same signal SIGINT or SIGTERM that we
1089 * caught and let the old handler take care of it.
1090 */
1091 raise(exit_signal);
1092 }
1093
1094 logmsg("============> mqttd quits");
1095 return 0;
1096 }
1097
