// dump1090, a Mode S messages decoder for RTLSDR devices. // // Copyright (C) 2012 by Salvatore Sanfilippo // // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // // * 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. // // 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 // HOLDER 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 "dump1090.h" // // ============================= Networking ============================= // // Note: here we disregard any kind of good coding practice in favor of // extreme simplicity, that is: // // 1) We only rely on the kernel buffers for our I/O without any kind of // user space buffering. // 2) We don't register any kind of event handler, from time to time a // function gets called and we accept new connections. All the rest is // handled via non-blocking I/O and manually polling clients to see if // they have something new to share with us when reading is needed. // //========================================================================= // // Networking "stack" initialization // struct service { char *descr; int *socket; int port; int enabled; }; struct service services[MODES_NET_SERVICES_NUM]; // //========================================================================= // // On error free the client, collect the structure, adjust maxfd if needed. // void modesFreeClient(Modes * modes, struct client *c) { // Unhook this client from the linked list of clients struct client *p = modes->clients; if (p) { if (p == c) { modes->clients = c->next; } else { while ((p) && (p->next != c)) { p = p->next; } if (p) { p->next = c->next; } } } free(c); } // //========================================================================= // // Close the client connection and mark it as closed // void modesCloseClient(Modes *modes, struct client *c) { close(c->fd); if (c->service == modes->sbsos) { if (modes->stat_sbs_connections) modes->stat_sbs_connections--; } else if (c->service == modes->ros) { if (modes->stat_raw_connections) modes->stat_raw_connections--; } else if (c->service == modes->bos) { if (modes->stat_beast_connections) modes->stat_beast_connections--; } if (modes->debug & MODES_DEBUG_NET) printf("Closing client %d\n", c->fd); c->fd = -1; } //========================================================================= // // This function decodes a Beast binary format message // // The message is passed to the higher level layers, so it feeds // the selected screen output, the network output and so forth. // // If the message looks invalid it is silently discarded. // // The function always returns 0 (success) to the caller as there is no // case where we want broken messages here to close the client connection. // int decodeBinMessage(Modes *modes, struct client *c, char *p) { int msgLen = 0; int j; char ch; char * ptr; unsigned char msg[MODES_LONG_MSG_BYTES]; struct modesMessage mm; MODES_NOTUSED(c); memset(&mm, 0, sizeof(mm)); ch = *p++; /// Get the message type if (0x1A == ch) {p++;} if ((ch == '1') && (modes->mode_ac)) { // skip ModeA/C unless user enables --modes-ac msgLen = MODEAC_MSG_BYTES; } else if (ch == '2') { msgLen = MODES_SHORT_MSG_BYTES; } else if (ch == '3') { msgLen = MODES_LONG_MSG_BYTES; } if (msgLen) { // Mark messages received over the internet as remote so that we don't try to // pass them off as being received by this instance when forwarding them mm.remote = 1; ptr = (char*) &mm.timestampMsg; for (j = 0; j < 6; j++) { // Grab the timestamp (big endian format) ptr[5-j] = ch = *p++; if (0x1A == ch) {p++;} } mm.signalLevel = ch = *p++; // Grab the signal level if (0x1A == ch) {p++;} for (j = 0; j < msgLen; j++) { // and the data msg[j] = ch = *p++; if (0x1A == ch) {p++;} } // if (msgLen == MODEAC_MSG_BYTES) { // ModeA or ModeC // decodeModeAMessage(modes, &mm, ((msg[0] << 8) | msg[1])); // } else { decodeModesMessage(modes, &mm, msg); //} useModesMessage(modes, &mm); } return (0); } // //========================================================================= // // Turn an hex digit into its 4 bit decimal value. // Returns -1 if the digit is not in the 0-F range. // int hexDigitVal(int c) { c = tolower(c); if (c >= '0' && c <= '9') return c-'0'; else if (c >= 'a' && c <= 'f') return c-'a'+10; else return -1; } // // //========================================================================= // // This function polls the clients using read() in order to receive new // messages from the net. // // The message is supposed to be separated from the next message by the // separator 'sep', which is a null-terminated C string. // // Every full message received is decoded and passed to the higher layers // calling the function's 'handler'. // // The handler returns 0 on success, or 1 to signal this function we should // close the connection with the client in case of non-recoverable errors. // void modesReadFromClient(Modes *modes, struct client *c, char *sep, int(*handler)(Modes *modes, struct client *, char *)) { int left; int nread; int fullmsg; int bContinue = 1; char *s, *e, *p; while(bContinue) { fullmsg = 0; left = MODES_CLIENT_BUF_SIZE - c->buflen; // If our buffer is full discard it, this is some badly formatted shit if (left <= 0) { c->buflen = 0; left = MODES_CLIENT_BUF_SIZE; // If there is garbage, read more to discard it ASAP } #ifndef _WIN32 nread = read(c->fd, c->buf+c->buflen, left); #else nread = recv(c->fd, c->buf+c->buflen, left, 0); if (nread < 0) {errno = WSAGetLastError();} #endif if (nread == 0) { modesCloseClient(modes, c); return; } // If we didn't get all the data we asked for, then return once we've processed what we did get. if (nread != left) { bContinue = 0; } #ifndef _WIN32 if ( (nread < 0 && errno != EAGAIN && errno != EWOULDBLOCK) || nread == 0 ) { // Error, or end of file #else if ( (nread < 0) && (errno != EWOULDBLOCK)) { // Error, or end of file #endif modesCloseClient(modes, c); return; } if (nread <= 0) { break; // Serve next client } c->buflen += nread; // Always null-term so we are free to use strstr() (it won't affect binary case) c->buf[c->buflen] = '\0'; e = s = c->buf; // Start with the start of buffer, first message if (c->service == modes->bis) { // This is the Beast Binary scanning case. // If there is a complete message still in the buffer, there must be the separator 'sep' // in the buffer, note that we full-scan the buffer at every read for simplicity. left = c->buflen; // Length of valid search for memchr() while (left && ((s = (char*)memchr(e, (char) 0x1a, left)) != NULL)) { // The first byte of buffer 'should' be 0x1a s++; // skip the 0x1a if (*s == '1') { e = s + MODEAC_MSG_BYTES + 8; // point past remainder of message } else if (*s == '2') { e = s + MODES_SHORT_MSG_BYTES + 8; } else if (*s == '3') { e = s + MODES_LONG_MSG_BYTES + 8; } else { e = s; // Not a valid beast message, skip left = &(c->buf[c->buflen]) - e; continue; } // we need to be careful of double escape characters in the message body for (p = s; p < e; p++) { if (0x1A == *p) { p++; e++; if (e > &(c->buf[c->buflen])) { break; } } } left = &(c->buf[c->buflen]) - e; if (left < 0) { // Incomplete message in buffer e = s - 1; // point back at last found 0x1a. break; } // Have a 0x1a followed by 1, 2 or 3 - pass message less 0x1a to handler. if (handler(modes, c, s)) { modesCloseClient(modes, c); return; } fullmsg = 1; } s = e; // For the buffer remainder below } else { // // This is the ASCII scanning case, AVR RAW or HTTP at present // If there is a complete message still in the buffer, there must be the separator 'sep' // in the buffer, note that we full-scan the buffer at every read for simplicity. // while ((e = strstr(s, sep)) != NULL) { // end of first message if found *e = '\0'; // The handler expects null terminated strings if (handler(modes, c, s)) { // Pass message to handler. modesCloseClient(modes, c); // Handler returns 1 on error to signal we . return; // should close the client connection } s = e + strlen(sep); // Move to start of next message fullmsg = 1; } } if (fullmsg) { // We processed something - so c->buflen = &(c->buf[c->buflen]) - s; // Update the unprocessed buffer length memmove(c->buf, s, c->buflen); // Move what's remaining to the start of the buffer } else { // If no message was decoded process the next client break; } } }