Changeset 31170


Ignore:
Timestamp:
Jan 20, 2017, 11:20:56 PM (2 months ago)
Author:
brainslayer
Message:

update mactelnet

Location:
src/router/mactelnet
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed
  • src/router/mactelnet/README.markdown

    r23406 r31170  
    1 MAC-Telnet for Linux
    2 ====================
     1MAC-Telnet for Posix systems
     2============================
    33
    44Console tools for connecting to, and serving, devices using MikroTik RouterOS MAC-Telnet protocol.
     
    77------------
    88
    9 Then download source tarball, extract, compile and install:
     9### Linux / kfreebsd ###
     10
     11Download source tarball, extract, compile and install:
    1012
    1113    wget http://github.com/haakonnessjoen/MAC-Telnet/tarball/master
    1214    tar zxvf haakonness*.tar.gz
    1315    cd haakonness*/
     16    ./autogen.sh
     17    ./configure
    1418    make all install
    1519
    1620Now you're ready.
    1721
    18 TIP: You can use the well known "expect" tool to automate/script dialogues via mactelnet!
     22### Mac OS X ###
     23
     24Install dependencies, download source tarball, extract, compile and install:
     25
     26    wget http://github.com/haakonnessjoen/MAC-Telnet/tarball/master
     27    tar zxvf haakonness*.tar.gz
     28    cd haakonness*/
     29   
     30    # Install dependencies
     31    brew install gettext
     32   
     33    # Check what paths it tells you to use, for a standard install, the following should suffice:
     34    export PATH=/usr/local/opt/gettext/bin:$PATH
     35   
     36    ./autogen.sh
     37    ./configure
     38    make all install
     39
     40And you are ready..
    1941
    2042Usage
     
    5981     [admin@HMG] >
    6082
     83### Tips
     84
     85You can use the well known "expect" tool to automate/script dialogues via mactelnet!
     86
     87### List available hosts ###
     88
     89    # mactelnet -l
     90
    6191MAC-Ping usage
    6292--------------
  • src/router/mactelnet/autologin.c

    r23406 r31170  
    2323#include <errno.h>
    2424#include <unistd.h>
     25#include "config.h"
    2526#include "autologin.h"
    26 #include "config.h"
    2727
    2828#define _(String) String
     
    5252                static char newpath[256];
    5353                memset(newpath, 0, sizeof(newpath));
    54                 strncpy(newpath, homepath, 255);
    55                 strncat(newpath, path+1, 255);
     54                strncpy(newpath, homepath, sizeof(newpath) - 1);
     55                /* strncat is confusing, try not to overflow */
     56                strncat(newpath, path+1, sizeof(newpath) - strlen(newpath) - 1);
    5657                return newpath;
    5758        }
     
    6364        char c;
    6465        int i = -1;
    65         char *p = NULL;
    6666        char *file_to_read;
    6767        char key[AUTOLOGIN_MAXSTR];
     68        char *p=key;
    6869        char value[AUTOLOGIN_MAXSTR];
    6970        int line_counter=1;
     
    7677
    7778        fp = fopen(file_to_read, "r");
    78         if (fp <= 0) {
     79        if (!fp) {
    7980                if (strcmp(configfile, AUTOLOGIN_PATH) == 0) {
    8081                        /* Silent ignore? */
  • src/router/mactelnet/config.h

    r23406 r31170  
    2121
    2222#define DEBUG 0
     23
     24#define PACKAGE_VERSION "0.4.4"
    2325
    2426#define PROGRAM_VERSION "0.4.1"
  • src/router/mactelnet/interfaces.c

    r29333 r31170  
    2929#include <sys/types.h>
    3030#include <ifaddrs.h>
    31 #if defined(__FreeBSD__)
     31#if defined(__FreeBSD__) || defined(__APPLE__)
    3232#include <netinet/in.h>
    3333#endif
    3434#include <netinet/ip.h>
    3535#include <netinet/udp.h>
    36 #if defined(__FreeBSD__)
     36#if defined(__FreeBSD__) || defined(__APPLE__)
    3737#include <net/ethernet.h>
    3838#define ETH_FRAME_LEN (ETHER_MAX_LEN - ETHER_CRC_LEN)
     
    298298        static unsigned char stackbuf[ETH_FRAME_LEN];
    299299        void* buffer = (void*)&stackbuf;
    300 #if defined(__FreeBSD__)
     300#if defined(__FreeBSD__) || defined(__APPLE__)
    301301        struct ether_header *eh = (struct ether_header *)buffer;
    302302        struct ip *ip = (struct ip *)(buffer + 14);
     
    309309          (unsigned char *)(buffer + 20 + 14 + sizeof(struct udphdr));
    310310
    311         if (((void *)rest - (void*)buffer) + datalen  > ETH_FRAME_LEN) {
     311        /* Avoid integer overflow in check */
     312        if (datalen > ETH_FRAME_LEN - ((void *)rest - (void*)buffer)) {
    312313                fprintf(stderr, _("packet size too large\n"));
    313314                return 0;
     
    324325
    325326        /* Init ethernet header */
    326 #if defined(__FreeBSD__)
     327#if defined(__FreeBSD__) || defined(__APPLE__)
    327328        memcpy(eh->ether_shost, sourcemac, ETH_ALEN);
    328329        memcpy(eh->ether_dhost, destmac, ETH_ALEN);
     
    349350
    350351        /* Init IP Header */
    351 #if defined(__FreeBSD__)
     352#if defined(__FreeBSD__) || defined(__APPLE__)
    352353        ip->ip_v = 4;
    353354        ip->ip_hl = 5;
     
    376377
    377378        /* Calculate checksum for IP header */
    378 #if defined(__FreeBSD__)
     379#if defined(__FreeBSD__) || defined(__APPLE__)
    379380        ip->ip_sum = in_cksum((unsigned short *)ip, sizeof(struct ip));
    380381#else
     
    383384
    384385        /* Init UDP Header */
    385 #if defined(__FreeBSD__)
     386#if defined(__FreeBSD__) || defined(__APPLE__)
    386387        udp->uh_sport = htons(sourceport);
    387388        udp->uh_dport = htons(destport);
     
    399400
    400401        /* Add UDP checksum */
    401 #if defined(__FreeBSD__)
     402#if defined(__FreeBSD__) || defined(__APPLE__)
    402403        udp->uh_sum = udp_sum_calc((unsigned char *)&(ip->ip_src.s_addr),
    403404          (unsigned char *)&(ip->ip_dst.s_addr),
  • src/router/mactelnet/macping.c

    r29335 r31170  
    2222#include <stdio.h>
    2323#include <arpa/inet.h>
    24 #if defined(__FreeBSD__)
     24#if defined(__FreeBSD__) || defined(__APPLE__)
    2525#include <sys/types.h>
    2626#include <sys/socket.h>
     
    3838#include <stdio.h>
    3939#include <float.h>
     40#include "config.h"
    4041#include "protocol.h"
    4142#include "interfaces.h"
    42 #include "config.h"
    4343#include "utlist.h"
    4444
     
    4848#define PROGRAM_NAME "MAC-Ping"
    4949
    50 #define _(String) (String)
     50#define _(String) String
    5151
    5252static int sockfd, insockfd;
     
    7070
    7171static void print_version() {
    72         fprintf(stderr, PROGRAM_NAME " " PROGRAM_VERSION "\n");
     72        fprintf(stderr, PROGRAM_NAME " " PACKAGE_VERSION "\n");
    7373}
    7474
     
    118118
    119119        setlocale(LC_ALL, "");
    120 //      bindtextdomain("mactelnet","/usr/share/locale");
    121 //      textdomain("mactelnet");
    122120
    123121        while (1) {
     
    155153
    156154        /* We don't want people to use this for the wrong reasons */
    157         if (fastmode && (send_packets == 0 || send_packets > 100)) {
    158                 fprintf(stderr, _("Number of packets to send must be more than 0 and less than 100 in fast mode.\n"));
     155        if (fastmode && (send_packets <= 0 || send_packets > 100)) {
     156                fprintf(stderr, _("Number of packets to send must be more than 0 and up to 100 in fast mode.\n"));
    159157                return 1;
    160158        }
     
    235233        signal(SIGINT, display_results);
    236234
    237         for (i = 0; i < send_packets || send_packets == 0; ++i) {
     235        for (i = 0; i < send_packets || send_packets <= 0; ++i) {
    238236                fd_set read_fds;
    239237                static struct timeval lasttimestamp;
     
    244242                int waitforpacket;
    245243                struct timeval timestamp;
    246                 unsigned char pingdata[1500];
     244                unsigned char pingdata[MT_PACKET_LEN];
    247245                struct net_interface *interface;
    248246
     
    290288                        }
    291289
    292                         unsigned char buff[1500];
     290                        unsigned char buff[MT_PACKET_LEN];
    293291                        struct sockaddr_in saddress;
    294292                        unsigned int slen = sizeof(saddress);
    295293                        struct mt_mactelnet_hdr pkthdr;
    296294
    297                         result = recvfrom(insockfd, buff, 1500, 0, (struct sockaddr *)&saddress, &slen);
     295                        result = recvfrom(insockfd, buff, sizeof(buff), 0, (struct sockaddr *)&saddress, &slen);
     296                        /* Check for exact size */
     297                        if (result != 18 + ping_size) {
     298                                continue;
     299                        }
    298300                        parse_packet(buff, &pkthdr);
    299301
  • src/router/mactelnet/mactelnet.c

    r29338 r31170  
    2626#include <fcntl.h>
    2727#include <signal.h>
    28 #if defined(__FreeBSD__)
     28#if defined(__APPLE__)
     29# include <libkern/OSByteOrder.h>
     30# define htole16 OSSwapHostToLittleInt16
     31#elif defined(__FreeBSD__)
    2932#include <sys/endian.h>
     33#else
     34#include <endian.h>
     35#endif
     36#if defined(__FreeBSD__) || defined(__APPLE__)
    3037#include <sys/types.h>
    3138#include <net/ethernet.h>
    3239#else
    33 #include <endian.h>
    3440#include <netinet/ether.h>
    3541#endif
     
    4248#include <string.h>
    4349#ifdef __linux__
    44 //#include <linux/if_ether.h>
    4550#include <sys/mman.h>
    4651#endif
     52#include "config.h"
    4753#include "md5.h"
    4854#include "protocol.h"
    4955#include "console.h"
    5056#include "interfaces.h"
    51 #include "config.h"
    5257#include "mactelnet.h"
    5358#include "mndp.h"
     
    9095static int keepalive_counter = 0;
    9196
    92 static unsigned char encryptionkey[128];
    93 static char username[255];
    94 static char password[255];
    95 static char nonpriv_username[255];
     97static unsigned char pass_salt[16];
     98static char username[MT_MNDP_MAX_STRING_SIZE];
     99static char password[MT_MNDP_MAX_STRING_SIZE];
     100static char nonpriv_username[MT_MNDP_MAX_STRING_SIZE];
    96101
    97102struct net_interface *interfaces=NULL;
     
    106111
    107112static void print_version() {
    108         fprintf(stderr, PROGRAM_NAME " " PROGRAM_VERSION "\n");
     113        fprintf(stderr, PROGRAM_NAME " " PACKAGE_VERSION "\n");
    109114}
    110115
     
    173178                        reads = select(insockfd + 1, &read_fds, NULL, NULL, &timeout);
    174179                        if (reads && FD_ISSET(insockfd, &read_fds)) {
    175                                 unsigned char buff[1500];
     180                                unsigned char buff[MT_PACKET_LEN];
    176181                                int result;
    177182
    178                                 bzero(buff, 1500);
    179                                 result = recvfrom(insockfd, buff, 1500, 0, 0, 0);
     183                                bzero(buff, sizeof(buff));
     184                                result = recvfrom(insockfd, buff, sizeof(buff), 0, 0, 0);
    180185
    181186                                /* Handle incoming packets, waiting for an ack */
     
    206211        char md5data[100];
    207212        unsigned char md5sum[17];
    208         int plen;
     213        int plen, act_pass_len;
    209214        md5_state_t state;
    210215
     
    214219#endif
    215220
    216         /* Concat string of 0 + password + encryptionkey */
     221        /* calculate the actual password's length */
     222        act_pass_len = strnlen(password, 82);
     223
     224        /* Concat string of 0 + password + pass_salt */
    217225        md5data[0] = 0;
    218         strncpy(md5data + 1, password, 82);
    219         md5data[83] = '\0';
    220         memcpy(md5data + 1 + strlen(password), encryptionkey, 16);
     226        memcpy(md5data + 1, password, act_pass_len);
     227        /* in case that password is long, calculate only using the used-up parts */
     228        memcpy(md5data + 1 + act_pass_len, pass_salt, 16);
    221229
    222230        /* Generate md5 sum of md5data with a leading 0 */
    223231        md5_init(&state);
    224         md5_append(&state, (const md5_byte_t *)md5data, strlen(password) + 17);
     232        md5_append(&state, (const md5_byte_t *)md5data, 1 + act_pass_len + 16);
    225233        md5_finish(&state, (md5_byte_t *)md5sum + 1);
    226234        md5sum[0] = 0;
     
    268276static int handle_packet(unsigned char *data, int data_len) {
    269277        struct mt_mactelnet_hdr pkthdr;
     278
     279        /* Minimal size checks (pings are not supported here) */
     280        if (data_len < MT_HEADER_LEN){
     281                return -1;
     282        }
    270283        parse_packet(data, &pkthdr);
    271284
     
    299312                while (success) {
    300313
    301                         /* If we receive encryptionkey, transmit auth data back */
    302                         if (cpkt.cptype == MT_CPTYPE_ENCRYPTIONKEY) {
    303                                 memcpy(encryptionkey, cpkt.data, cpkt.length);
     314                        /* If we receive pass_salt, transmit auth data back */
     315                        if (cpkt.cptype == MT_CPTYPE_PASSSALT) {
     316                                /* check validity, server sends exactly 16 bytes */
     317                                if (cpkt.length != 16) {
     318                                        fprintf(stderr, _("Invalid salt length: %d (instead of 16) received from server %s\n"), cpkt.length, ether_ntoa((struct ether_addr *)dstmac));
     319                                }
     320                                memcpy(pass_salt, cpkt.data, 16);
    304321                                send_auth(username, password);
    305322                        }
     
    308325                           the data is raw terminal data to be outputted to the terminal. */
    309326                        else if (cpkt.cptype == MT_CPTYPE_PLAINDATA) {
    310                                 cpkt.data[cpkt.length] = 0;
    311                                 fputs((const char *)cpkt.data, stdout);
     327                                fwrite((const void *)cpkt.data, 1, cpkt.length, stdout);
    312328                        }
    313329
     
    444460        struct autologin_profile *login_profile;
    445461        struct net_interface *interface, *tmp;
    446         unsigned char buff[1500];
     462        unsigned char buff[MT_PACKET_LEN];
    447463        unsigned char print_help = 0, have_username = 0, have_password = 0;
    448464        unsigned char drop_priv = 0;
     
    450466        int optval = 1;
    451467
    452         strncpy(autologin_path, AUTOLOGIN_PATH, 254);
     468        strncpy(autologin_path, AUTOLOGIN_PATH, sizeof(autologin_path));
    453469
    454470        setlocale(LC_ALL, "");
    455 //      bindtextdomain("mactelnet","/usr/share/locale");
    456 //      textdomain("mactelnet");
    457471
    458472        while (1) {
     
    520534
    521535                        case 'a':
    522                                 strncpy(autologin_path, optarg, 254);
     536                                strncpy(autologin_path, optarg, sizeof(autologin_path) - 1);
     537                                autologin_path[sizeof(autologin_path) - 1] = '\0';
    523538                                break;
    524539
     
    547562                        "  -n             Do not use broadcast packets. Less insecure but requires\n"
    548563                        "                 root privileges.\n"
    549                         "  -a <path>      Use specified path instead of the default: " AUTOLOGIN_PATH " for autologin config file.\n"
     564                        "  -a <path>      Use specified path instead of the default: %s for autologin config file.\n"
    550565                        "  -A             Disable autologin feature.\n"
    551566                        "  -t <timeout>   Amount of seconds to wait for a response on each interface.\n"
     
    556571                        "  -q             Quiet mode.\n"
    557572                        "  -h             This help.\n"
    558                         "\n"));
     573                        "\n"), AUTOLOGIN_PATH);
    559574                }
    560575                return 1;
     
    637652                        fflush(stdout);
    638653                }
    639                 scanf("%254s", username);
     654                scanf("%127s", username);
    640655        }
    641656
     
    684699        }
    685700
    686         if (!find_interface() || (result = recvfrom(insockfd, buff, 1400, 0, 0, 0)) < 1) {
     701        if (!find_interface() || (result = recvfrom(insockfd, buff, sizeof(buff), 0, 0, 0)) < 1) {
    687702                fprintf(stderr, _("Connection failed.\n"));
    688703                return 1;
     
    696711
    697712        init_packet(&data, MT_PTYPE_DATA, srcmac, dstmac, sessionkey, 0);
    698         outcounter +=  add_control_packet(&data, MT_CPTYPE_BEGINAUTH, NULL, 0);
     713        outcounter += add_control_packet(&data, MT_CPTYPE_BEGINAUTH, NULL, 0);
    699714
    700715        /* TODO: handle result of send_udp */
     
    722737                        /* Handle data from server */
    723738                        if (FD_ISSET(insockfd, &read_fds)) {
    724                                 bzero(buff, 1500);
    725                                 result = recvfrom(insockfd, buff, 1500, 0, 0, 0);
     739                                bzero(buff, sizeof(buff));
     740                                result = recvfrom(insockfd, buff, sizeof(buff), 0, 0, 0);
    726741                                handle_packet(buff, result);
    727742                        }
     
    731746                                int datalen;
    732747
    733                                 datalen = read(STDIN_FILENO, &keydata, 512);
     748                                datalen = read(STDIN_FILENO, &keydata, sizeof(keydata));
    734749
    735750                                if (datalen > 0) {
  • src/router/mactelnet/mactelnetd.c

    r29338 r31170  
    2020#define _XOPEN_SOURCE 600
    2121#define _BSD_SOURCE
     22#define _DARWIN_C_SOURCE
    2223#include <locale.h>
    2324#include <stdlib.h>
     
    2829#include <signal.h>
    2930#include <paths.h>
    30 #if defined(__FreeBSD__)
     31#if defined(__APPLE__)
     32# include <sys/sysctl.h>
     33# include <libkern/OSByteOrder.h>
     34# define le16toh OSSwapLittleToHostInt16
     35# define htole32 OSSwapHostToLittleInt32
     36#elif defined(__FreeBSD__)
    3137#include <sys/endian.h>
    3238#else
    3339#include <endian.h>
    3440#endif
     41#if defined(__FreeBSD__) || defined(__APPLE__)
     42#include <paths.h>
     43#endif
    3544#include <time.h>
    3645#include <arpa/inet.h>
    3746#include <sys/types.h>
    38 //#include <net/ethernet.h>
    3947#include <netinet/in.h>
    40 #if !defined(__FreeBSD__)
     48#if !defined(__FreeBSD__) && !defined(__APPLE__)
    4149#include <netinet/ether.h>
    4250#endif
     
    4654#include <string.h>
    4755#ifdef __linux__
    48 //#include <linux/if_ether.h>
    4956#include <sys/mman.h>
    5057#else
     
    5764#endif
    5865#include <pwd.h>
    59 #if defined(__FreeBSD__)
     66#if defined(__FreeBSD__) || defined(__APPLE__)
    6067#include <sys/time.h>
    6168/* This is the really Posix interface the Linux code should have used !!*/
     
    6673#include <syslog.h>
    6774#include <sys/utsname.h>
     75#include "config.h"
    6876#include "md5.h"
    6977#include "protocol.h"
     
    7179#include "interfaces.h"
    7280#include "users.h"
    73 #include "config.h"
    7481#include "utlist.h"
    7582
     
    132139        int pid;
    133140        int wait_for_ack;
    134         int have_enckey;
    135 
    136         char username[30];
     141        int have_pass_salt;
     142
     143        char username[MT_MNDP_MAX_STRING_SIZE];
    137144        unsigned char trypassword[17];
    138145        unsigned char srcip[IPV4_ALEN];
     
    140147        unsigned short srcport;
    141148        unsigned char dstmac[ETH_ALEN];
    142         unsigned char enckey[16];
     149        unsigned char pass_salt[16];
    143150        unsigned short terminal_width;
    144151        unsigned short terminal_height;
     
    297304
    298305static void uwtmp_login(struct mt_connection *conn) {
    299 #if defined(__FreeBSD__)
     306#if defined(__FreeBSD__) || defined(__APPLE__)
    300307        struct utmpx utent;
    301308#else
     
    321328                ether_ntoa((const struct ether_addr *)conn->srcmac),
    322329                sizeof(utent.ut_host));
    323 #if defined(__FreeBSD__)
     330#if defined(__FreeBSD__) || defined(__APPLE__)
    324331        gettimeofday(&utent.ut_tv, NULL);
    325332#else
     
    328335
    329336        /* Update utmp and/or wtmp */
    330 #if defined(__FreeBSD__)
     337#if defined(__FreeBSD__) || defined(__APPLE__)
    331338        setutxent();
    332339        pututxline(&utent);
     
    342349static void uwtmp_logout(struct mt_connection *conn) {
    343350        if (conn->pid > 0) {
    344 #if defined(__FreeBSD__)
     351#if defined(__FreeBSD__) || defined(__APPLE__)
    345352                struct utmpx *utentp;
    346353                struct utmpx utent;
     
    352359#endif
    353360
    354 #if defined(__FreeBSD__)
     361#if defined(__FreeBSD__) || defined(__APPLE__)
    355362                while ((utentp = getutxent()) != NULL) {
    356363#else
    357364                while ((utentp = getutent()) != NULL) {
    358365#endif
    359                         if (utentp->ut_pid == conn->pid && utentp->ut_id) {
     366                        if (utentp->ut_pid == conn->pid && utentp->ut_id[0]) {
    360367                                break;
    361368                        }
     
    368375                        utent.ut_tv.tv_sec = time(NULL);
    369376
    370 #if defined(__FreeBSD__)
     377#if defined(__FreeBSD__) || defined(__APPLE__)
    371378                        pututxline(&utent);
    372379                        endutxent();
     
    399406        struct mt_credentials *user;
    400407        char *slavename;
     408        int act_pass_len;
    401409
    402410        /* Reparse user file before each login */
     
    413421#endif
    414422
    415                 /* Concat string of 0 + password + encryptionkey */
     423                /* calculate the password's actual length */
     424                act_pass_len = strlen(user->password);
     425                act_pass_len = act_pass_len <= 82 ? act_pass_len : 82;
     426
     427                /* Concat string of 0 + password + pass_salt */
    416428                md5data[0] = 0;
    417                 strncpy(md5data + 1, user->password, 82);
    418                 memcpy(md5data + 1 + strlen(user->password), curconn->enckey, 16);
     429                memcpy(md5data + 1, user->password, act_pass_len);
     430                memcpy(md5data + 1 + act_pass_len, curconn->pass_salt, 16);
    419431
    420432                /* Generate md5 sum of md5data with a leading 0 */
    421433                md5_init(&state);
    422                 md5_append(&state, (const md5_byte_t *)md5data, strlen(user->password) + 17);
     434                md5_append(&state, (const md5_byte_t *)md5data, 1 + act_pass_len + 16);
    423435                md5_finish(&state, (md5_byte_t *)md5sum + 1);
    424436                md5sum[0] = 0;
     
    465477                struct passwd *user = (struct passwd *)malloc(sizeof(struct passwd));
    466478                struct passwd *tmpuser=user;
    467                 char *buffer = malloc(1024);
    468 
    469                 if (user == NULL || buffer == NULL) {
     479                char *buffer;
     480
     481                if (user == NULL) {
     482                        syslog(LOG_CRIT, _("(%d) Error allocating memory."), curconn->seskey);
     483                        /*_ Please include both \r and \n in translation, this is needed for the terminal emulator. */
     484                        abort_connection(curconn, pkthdr, _("System error, out of memory\r\n"));
     485                        return;
     486                }
     487
     488                buffer = (char *)malloc(1024);
     489                if (buffer == NULL) {
    470490                        syslog(LOG_CRIT, _("(%d) Error allocating memory."), curconn->seskey);
    471491                        /*_ Please include both \r and \n in translation, this is needed for the terminal emulator. */
     
    575595        struct mt_packet pdata;
    576596        unsigned char *data = pkthdr->data;
     597        unsigned int act_size = 0;
    577598        int got_user_packet = 0;
    578599        int got_pass_packet = 0;
     
    587608                if (cpkt.cptype == MT_CPTYPE_BEGINAUTH) {
    588609                        int plen,i;
    589                         if (!curconn->have_enckey) {
     610                        if (!curconn->have_pass_salt) {
    590611                                for (i = 0; i < 16; ++i) {
    591                                         curconn->enckey[i] = rand() % 256;
     612                                        curconn->pass_salt[i] = rand() % 256;
    592613                                }
    593                                 curconn->have_enckey = 1;
     614                                curconn->have_pass_salt = 1;
    594615
    595616                                memset(curconn->trypassword, 0, sizeof(curconn->trypassword));
    596617                        }
    597618                        init_packet(&pdata, MT_PTYPE_DATA, pkthdr->dstaddr, pkthdr->srcaddr, pkthdr->seskey, curconn->outcounter);
    598                         plen = add_control_packet(&pdata, MT_CPTYPE_ENCRYPTIONKEY, (curconn->enckey), 16);
     619                        plen = add_control_packet(&pdata, MT_CPTYPE_PASSSALT, (curconn->pass_salt), 16);
    599620                        curconn->outcounter += plen;
    600621
    601622                        send_udp(curconn, &pdata);
    602 
    603                 } else if (cpkt.cptype == MT_CPTYPE_USERNAME) {
    604 
    605                         memcpy(curconn->username, cpkt.data, cpkt.length > 29 ? 29 : cpkt.length);
    606                         curconn->username[cpkt.length > 29 ? 29 : cpkt.length] = 0;
     623               
     624                /* Don't change the username after the state is active */
     625                } else if (cpkt.cptype == MT_CPTYPE_USERNAME && curconn->state != STATE_ACTIVE) {
     626                        memcpy(curconn->username, cpkt.data, act_size = (cpkt.length > MT_MNDP_MAX_STRING_SIZE - 1 ? MT_MNDP_MAX_STRING_SIZE - 1 : cpkt.length));
     627                        curconn->username[act_size] = 0;
    607628                        got_user_packet = 1;
    608629
    609                 } else if (cpkt.cptype == MT_CPTYPE_TERM_WIDTH) {
     630                } else if (cpkt.cptype == MT_CPTYPE_TERM_WIDTH && cpkt.length >= 2) {
    610631                        unsigned short width;
    611632
     
    614635                        got_width_packet = 1;
    615636
    616                 } else if (cpkt.cptype == MT_CPTYPE_TERM_HEIGHT) {
     637                } else if (cpkt.cptype == MT_CPTYPE_TERM_HEIGHT && cpkt.length >= 2) {
    617638                        unsigned short height;
    618639
     
    623644                } else if (cpkt.cptype == MT_CPTYPE_TERM_TYPE) {
    624645
    625                         memcpy(curconn->terminal_type, cpkt.data, cpkt.length > 29 ? 29 : cpkt.length);
    626                         curconn->terminal_type[cpkt.length > 29 ? 29 : cpkt.length] = 0;
    627 
    628                 } else if (cpkt.cptype == MT_CPTYPE_PASSWORD) {
     646                        memcpy(curconn->terminal_type, cpkt.data, act_size = (cpkt.length > 30 - 1 ? 30 - 1 : cpkt.length));
     647                        curconn->terminal_type[act_size] = 0;
     648
     649                } else if (cpkt.cptype == MT_CPTYPE_PASSWORD && cpkt.length == 17) {
    629650
    630651#if defined(__linux__) && defined(_POSIX_MEMLOCK_RANGE)
     
    642663
    643664                } else {
    644                         syslog(LOG_WARNING, _("(%d) Unhandeled control packet type: %d"), curconn->seskey, cpkt.cptype);
     665                        syslog(LOG_WARNING, _("(%d) Unhandeled control packet type: %d, length: %d"), curconn->seskey, cpkt.cptype, cpkt.length);
    645666                }
    646667
     
    665686        struct net_interface *interface;
    666687
     688        /* Check for minimal size */
     689        if (data_len < MT_HEADER_LEN - 4) {
     690                return;
     691        }
    667692        parse_packet(data, &pkthdr);
    668693
     
    676701                case MT_PTYPE_PING:
    677702                        if (pings++ > MT_MAXPPS) {
     703                                /* Don't want it to wrap around back to the valid range */
     704                                pings--;
    678705                                break;
    679706                        }
     
    751778                        curconn->lastdata = time(NULL);
    752779
     780                        /* now check the right size */
     781                        if (data_len < MT_HEADER_LEN) {
     782                                /* Ignore illegal packet */
     783                                return;
     784                        }
     785
    753786                        /* ack the data packet */
    754787                        init_packet(&pdata, MT_PTYPE_ACK, pkthdr.dstaddr, pkthdr.srcaddr, pkthdr.seskey, pkthdr.counter + (data_len - MT_HEADER_LEN));
     
    779812
    780813static void print_version() {
    781         fprintf(stderr, PROGRAM_NAME " " PROGRAM_VERSION "\n");
     814        fprintf(stderr, PROGRAM_NAME " " PACKAGE_VERSION "\n");
    782815}
    783816
     
    787820        struct net_interface *interface;
    788821        unsigned int uptime;
    789 #ifdef __linux__
     822#if defined(__APPLE__)
     823        int mib[] = {CTL_KERN, KERN_BOOTTIME};
     824        struct timeval boottime;
     825        size_t tv_size = sizeof(boottime);
     826        if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), &boottime, &tv_size, NULL, 0) == -1) {
     827          return;
     828        }
     829        uptime = htole32(boottime.tv_sec);
     830#elif defined(__linux__)
    790831        struct sysinfo s_sysinfo;
    791832
     
    891932        /* Reassign outgoing interfaces to connections again, since they may have changed */
    892933        DL_FOREACH(connections_head, p) {
    893                 if (p->interface_name != NULL) {
     934                if (p->interface_name[0] != 0) {
    894935                        struct net_interface *interface = net_get_interface_ptr(&interfaces, p->interface_name, 0);
    895936                        if (interface != NULL) {
     
    923964
    924965        setlocale(LC_ALL, "");
    925 //      bindtextdomain("mactelnet","/usr/share/locale");
    926 //      textdomain("mactelnet");
    927966
    928967        while ((c = getopt(argc, argv, "fnvh?")) != -1) {
     
    10931132                         */
    10941133                        if (FD_ISSET(insockfd, &read_fds)) {
    1095                                 unsigned char buff[1500];
     1134                                unsigned char buff[MT_PACKET_LEN];
    10961135                                struct sockaddr_in saddress;
    10971136                                unsigned int slen = sizeof(saddress);
    1098                                 result = recvfrom(insockfd, buff, 1500, 0, (struct sockaddr *)&saddress, &slen);
     1137                                bzero(buff, MT_HEADER_LEN);
     1138
     1139                                result = recvfrom(insockfd, buff, sizeof(buff), 0, (struct sockaddr *)&saddress, &slen);
    10991140                                handle_packet(buff, result, &saddress);
    11001141                        }
    11011142                        if (FD_ISSET(mndpsockfd, &read_fds)) {
    1102                                 unsigned char buff[1500];
     1143                                unsigned char buff[MT_PACKET_LEN];
    11031144                                struct sockaddr_in saddress;
    11041145                                unsigned int slen = sizeof(saddress);
    1105                                 result = recvfrom(mndpsockfd, buff, 1500, 0, (struct sockaddr *)&saddress, &slen);
     1146                                result = recvfrom(mndpsockfd, buff, sizeof(buff), 0, (struct sockaddr *)&saddress, &slen);
    11061147
    11071148                                /* Handle MNDP broadcast request, max 1 rps */
     
    11191160
    11201161                                        /* Read it */
    1121                                         datalen = read(p->ptsfd, &keydata, 1024);
     1162                                        datalen = read(p->ptsfd, &keydata, sizeof(keydata));
    11221163                                        if (datalen > 0) {
    11231164                                                /* Send it */
     
    11321173                                                init_packet(&pdata, MT_PTYPE_END, p->dstmac, p->srcmac, p->seskey, p->outcounter);
    11331174                                                send_udp(p, &pdata);
    1134                                                 if (p->username != NULL) {
     1175                                                if (p->username[0] != 0) {
    11351176                                                        syslog(LOG_INFO, _("(%d) Connection to user %s closed."), p->seskey, p->username);
    11361177                                                } else {
  • src/router/mactelnet/mndp.c

    r29335 r31170  
    2323#include <unistd.h>
    2424#include <errno.h>
    25 #if defined(__FreeBSD__)
     25#if defined(__FreeBSD__) || defined(__APPLE__)
    2626#include <net/ethernet.h>
    2727#include <netinet/in.h>
     
    3232#include <arpa/inet.h>
    3333#include <string.h>
     34#include "config.h"
    3435#include "protocol.h"
    35 #include "config.h"
    3636
    3737#define _(String) String
     
    6666
    6767        setlocale(LC_ALL, "");
    68 //      bindtextdomain("mactelnet","/usr/share/locale");
    69 //      textdomain("mactelnet");
    7068
    7169        /* Open a UDP socket handle */
     
    106104
    107105        if (batch_mode) {
    108                 printf("%s\n", _("MAC-Address,Identity,Platform,Version,Hardware,Uptime,Softid,Ifname,IP"));
     106                printf("%s\n", "MAC-Address,Identity,Platform,Version,Hardware,Uptime,Softid,Ifname,IP");
    109107        } else {
    110108                printf("\n\E[1m%-15s %-17s %s\E[m\n", _("IP"), _("MAC-Address"), _("Identity (platform version hardware) uptime"));
     
    125123
    126124                /* Wait for a UDP packet */
    127                 result = recvfrom(sock, buff, MT_PACKET_LEN, 0, (struct sockaddr *)&addr, &addrlen);
     125                result = recvfrom(sock, buff, sizeof(buff), 0, (struct sockaddr *)&addr, &addrlen);
    128126                if (result < 0) {
    129                         fprintf(stderr, _("An error occured. aborting\n"));
     127                        fprintf(stderr, _("An error occurred. aborting\n"));
    130128                        exit(1);
    131129                }
     
    139137                        printf("%-15s ", inet_ntop(addr.sin_family, &addr.sin_addr, ipstr, sizeof ipstr));
    140138                        printf("%-17s %s", ether_ntoa((struct ether_addr *)packet->address), packet->identity);
    141                         if (packet->platform != NULL) {
     139                        if (packet->platform[0] != 0) {
    142140                                printf(" (%s %s %s)", packet->platform, packet->version, packet->hardware);
    143141                        }
     
    145143                                printf(_("  up %d days %d hours"), packet->uptime / 86400, packet->uptime % 86400 / 3600);
    146144                        }
    147                         if (packet->softid != NULL) {
     145                        if (packet->softid[0] != 0) {
    148146                                printf("  %s", packet->softid);
    149147                        }
    150                         if (packet->ifname != NULL) {
     148                        if (packet->ifname[0] != 0) {
    151149                                printf(" %s", packet->ifname);
    152150                        }
  • src/router/mactelnet/protocol.c

    r29333 r31170  
    2828#include <arpa/inet.h>
    2929#include <netinet/in.h>
    30 #if defined(__FreeBSD__)
     30#if defined(__FreeBSD__) || defined(__APPLE__)
    3131#include <net/ethernet.h>
    3232#include <sys/types.h>
     
    3636#endif
    3737#include <time.h>
    38 #if defined(__FreeBSD__)
     38#if defined(__APPLE__)
     39# include <libkern/OSByteOrder.h>
     40# define le32toh OSSwapLittleToHostInt32
     41#elif defined(__FreeBSD__)
    3942#include <sys/endian.h>
    4043#else
    4144#include <endian.h>
    4245#endif
     46#include "config.h"
    4347#include "protocol.h"
    44 #include "config.h"
    4548
    4649#define _(String) String
     
    6164        memcpy(data + 8, dstmac, ETH_ALEN);
    6265
    63         if (mt_direction_fromserver) {
    64                 /* Session key */
    65                 sessionkey = htons(sessionkey);
    66                 memcpy(data + 16, &sessionkey, sizeof(sessionkey));
    67 
    68                 /* Client type: Mac Telnet */
    69                 memcpy(data + 14, &mt_mactelnet_clienttype, sizeof(mt_mactelnet_clienttype));
    70         } else {
    71                 /* Session key */
    72                 sessionkey = htons(sessionkey);
    73                 memcpy(data + 14, &sessionkey, sizeof(sessionkey));
    74 
    75                 /* Client type: Mac Telnet */
    76                 memcpy(data + 16, &mt_mactelnet_clienttype, sizeof(mt_mactelnet_clienttype));
    77         }
     66        /* Session key */
     67        sessionkey = htons(sessionkey);
     68        memcpy(data + (mt_direction_fromserver ? 16 : 14), &sessionkey, sizeof(sessionkey));
     69
     70        /* Client type: Mac Telnet */
     71        memcpy(data + (mt_direction_fromserver ? 14 : 16), &mt_mactelnet_clienttype, sizeof(mt_mactelnet_clienttype));
    7872
    7973        /* Received/sent data counter */
     
    8680}
    8781
    88 int add_control_packet(struct mt_packet *packet, enum mt_cptype cptype, void *cpdata, int data_len) {
     82int add_control_packet(struct mt_packet *packet, enum mt_cptype cptype, void *cpdata, unsigned short data_len) {
    8983        unsigned char *data = packet->data + packet->size;
    90 
    91         /* Something is really wrong. Packets should never become over 1500 bytes */
    92         if (packet->size + MT_CPHEADER_LEN + data_len > MT_PACKET_LEN) {
     84        unsigned int act_size = data_len + (cptype == MT_CPTYPE_PLAINDATA ? 0 : MT_CPHEADER_LEN);
     85
     86        /* Something is really wrong. Packets should never become over 1500 bytes,
     87       perform an Integer-Overflow safe check */
     88        if (act_size > MT_PACKET_LEN - packet->size) {
    9389                fprintf(stderr, _("add_control_packet: ERROR, too large packet. Exceeds %d bytes\n"), MT_PACKET_LEN);
    9490                return -1;
     
    105101
    106102        /* Control Packet Magic id */
    107         memcpy(data,  mt_mactelnet_cpmagic, sizeof(mt_mactelnet_cpmagic));
     103        memcpy(data, mt_mactelnet_cpmagic, sizeof(mt_mactelnet_cpmagic));
    108104
    109105        /* Control packet type */
     
    126122        }
    127123
    128         packet->size += MT_CPHEADER_LEN + data_len;
     124        packet->size += act_size;
    129125        /* Control packet header length + data length */
    130         return MT_CPHEADER_LEN + data_len;
     126        return act_size;
    131127}
    132128
     
    154150
    155151int add_packetdata(struct mt_packet *packet, unsigned char *data, unsigned short length) {
    156         if (packet->size + length > MT_PACKET_LEN) {
     152        /* Integer-Overflow safe check */
     153        if (length > MT_PACKET_LEN - packet->size) {
    157154                fprintf(stderr, _("add_control_packet: ERROR, too large packet. Exceeds %d bytes\n"), MT_PACKET_LEN);
    158155                return -1;
     
    178175        memcpy(pkthdr->dstaddr, data + 8, ETH_ALEN);
    179176
    180         if (mt_direction_fromserver) {
    181                 /* Session key */
    182                 memcpy(&(pkthdr->seskey), data + 14, sizeof(pkthdr->seskey));
    183                 pkthdr->seskey = ntohs(pkthdr->seskey);
    184 
    185                 /* server type */
    186                 memcpy(&(pkthdr->clienttype), data + 16, 2);
    187         } else {
    188                 /* server type */
    189                 memcpy(&(pkthdr->clienttype), data + 14, 2);
    190 
    191                 /* Session key */
    192                 memcpy(&(pkthdr->seskey), data + 16, sizeof(pkthdr->seskey));
    193                 pkthdr->seskey = ntohs(pkthdr->seskey);
    194         }
     177        /* Session key */
     178        memcpy(&(pkthdr->seskey), data + (mt_direction_fromserver ? 14 : 16), sizeof(pkthdr->seskey));
     179        pkthdr->seskey = ntohs(pkthdr->seskey);
     180
     181        /* server type */
     182        memcpy(&(pkthdr->clienttype), data + (mt_direction_fromserver ? 16 : 14), 2);
    195183
    196184        /* Received/sent data counter */
     
    203191
    204192
    205 int parse_control_packet(unsigned char *packetdata, int data_len, struct mt_mactelnet_control_hdr *cpkthdr) {
     193int parse_control_packet(unsigned char *packetdata, unsigned short data_len, struct mt_mactelnet_control_hdr *cpkthdr) {
    206194        static unsigned char *int_data;
    207195        static unsigned int int_data_len;
     
    213201           control the data position. */
    214202        if (packetdata != NULL) {
    215                 if (data_len <= 0) {
     203                if (data_len == 0) {
    216204                        return 0;
    217205                }
     
    231219
    232220        /* Check for valid minimum packet length & magic header */
    233         if (int_data_len >= 9 && memcmp(data, &mt_mactelnet_cpmagic, 4) == 0) {
     221        if ((int_data_len - int_pos) >= MT_CPHEADER_LEN && memcmp(data, &mt_mactelnet_cpmagic, 4) == 0) {
    234222
    235223                /* Control packet type */
     
    241229
    242230                /* We want no buffer overflows */
    243                 if (cpkthdr->length >= MT_PACKET_LEN - 22 - int_pos) {
    244                         cpkthdr->length = MT_PACKET_LEN - 1 - 22 - int_pos;
     231                if (cpkthdr->length > int_data_len - MT_CPHEADER_LEN - int_pos) {
     232                        cpkthdr->length = int_data_len - MT_CPHEADER_LEN - int_pos;
    245233                }
    246234
    247235                /* Set pointer to actual data */
    248                 cpkthdr->data = data + 9;
     236                cpkthdr->data = data + MT_CPHEADER_LEN;
    249237
    250238                /* Remember old position, for next call */
    251                 int_pos += cpkthdr->length + 9;
     239                int_pos += cpkthdr->length + MT_CPHEADER_LEN;
    252240
    253241                /* Read data successfully */
     
    286274
    287275        /* Something is really wrong. Packets should never become over 1500 bytes */
    288         if (packet->size + 4 + data_len > MT_PACKET_LEN) {
     276        if (data_len > MT_PACKET_LEN - 4 - packet->size) {
    289277                fprintf(stderr, _("mndp_add_attribute: ERROR, too large packet. Exceeds %d bytes\n"), MT_PACKET_LEN);
    290278                return -1;
     
    324312        p = data + sizeof(struct mt_mndp_hdr);
    325313
    326         while(p < data + packet_len) {
     314        while(p + 4 < data + packet_len) {
    327315                unsigned short type, len;
    328316
     
    351339
    352340                        case MT_MNDPTYPE_IDENTITY:
    353                                 if (len > MT_MNDP_MAX_STRING_LENGTH) {
    354                                         len = MT_MNDP_MAX_STRING_LENGTH;
     341                                if (len >= MT_MNDP_MAX_STRING_SIZE) {
     342                                        len = MT_MNDP_MAX_STRING_SIZE - 1;
    355343                                }
    356344
     
    360348
    361349                        case MT_MNDPTYPE_PLATFORM:
    362                                 if (len > MT_MNDP_MAX_STRING_LENGTH) {
    363                                         len = MT_MNDP_MAX_STRING_LENGTH;
     350                                if (len >= MT_MNDP_MAX_STRING_SIZE) {
     351                                        len = MT_MNDP_MAX_STRING_SIZE - 1;
    364352                                }
    365353
     
    369357
    370358                        case MT_MNDPTYPE_VERSION:
    371                                 if (len > MT_MNDP_MAX_STRING_LENGTH) {
    372                                         len = MT_MNDP_MAX_STRING_LENGTH;
     359                                if (len >= MT_MNDP_MAX_STRING_SIZE) {
     360                                        len = MT_MNDP_MAX_STRING_SIZE - 1;
    373361                                }
    374362
     
    378366
    379367                        case MT_MNDPTYPE_TIMESTAMP:
    380                                 memcpy(&packetp->uptime, p, 4);
    381                                 /* Seems like ping uptime is transmitted as little endian? */
    382                                 packetp->uptime = le32toh(packetp->uptime);
     368                                if (len >= 4) {
     369                                        memcpy(&packetp->uptime, p, 4);
     370                                        /* Seems like ping uptime is transmitted as little endian? */
     371                                        packetp->uptime = le32toh(packetp->uptime);
     372                                }
    383373                                break;
    384374
    385375                        case MT_MNDPTYPE_HARDWARE:
    386                                 if (len > MT_MNDP_MAX_STRING_LENGTH) {
    387                                         len = MT_MNDP_MAX_STRING_LENGTH;
     376                                if (len >= MT_MNDP_MAX_STRING_SIZE) {
     377                                        len = MT_MNDP_MAX_STRING_SIZE - 1;
    388378                                }
    389379
     
    393383
    394384                        case MT_MNDPTYPE_SOFTID:
    395                                 if (len > MT_MNDP_MAX_STRING_LENGTH) {
    396                                         len = MT_MNDP_MAX_STRING_LENGTH;
     385                                if (len >= MT_MNDP_MAX_STRING_SIZE) {
     386                                        len = MT_MNDP_MAX_STRING_SIZE - 1;
    397387                                }
    398388
     
    402392
    403393                        case MT_MNDPTYPE_IFNAME:
    404                                 if (len > MT_MNDP_MAX_STRING_LENGTH) {
    405                                         len = MT_MNDP_MAX_STRING_LENGTH;
     394                                if (len >= MT_MNDP_MAX_STRING_SIZE) {
     395                                        len = MT_MNDP_MAX_STRING_SIZE - 1;
    406396                                }
    407397
     
    488478
    489479                /* Read UDP packet */
    490                 length = recvfrom(sock, buff, MT_PACKET_LEN, 0, 0, 0);
     480                length = recvfrom(sock, buff, sizeof(buff), 0, 0, 0);
    491481                if (length < 0) {
    492482                        goto done;
     
    562552        } else {
    563553                /* Convert mac address string to ether_addr struct */
     554#if defined(__APPLE__)
     555                struct ether_addr* dstmac_buf = ether_aton(address);
     556                memcpy(dstmac, dstmac_buf, sizeof(struct ether_addr));
     557#else
    564558                ether_aton_r(address, (struct ether_addr *)dstmac);
     559#endif
    565560        }
    566561
  • src/router/mactelnet/protocol.h

    r29333 r31170  
    2828
    2929#define MT_MNDP_PORT 5678
    30 #define MT_MNDP_MAX_STRING_LENGTH 128
     30#define MT_MNDP_MAX_STRING_SIZE 128
    3131#define MT_MNDP_BROADCAST_INTERVAL 30
    3232
     
    5656enum mt_cptype {
    5757        MT_CPTYPE_BEGINAUTH,
    58         MT_CPTYPE_ENCRYPTIONKEY,
     58        MT_CPTYPE_PASSSALT,
    5959        MT_CPTYPE_PASSWORD,
    6060        MT_CPTYPE_USERNAME,
     
    108108        struct mt_mndp_hdr header;
    109109        unsigned char address[ETH_ALEN];
    110         char identity[MT_MNDP_MAX_STRING_LENGTH];
    111         char version[MT_MNDP_MAX_STRING_LENGTH];
    112         char platform[MT_MNDP_MAX_STRING_LENGTH];
    113         char hardware[MT_MNDP_MAX_STRING_LENGTH];
    114         char softid[MT_MNDP_MAX_STRING_LENGTH];
    115         char ifname[MT_MNDP_MAX_STRING_LENGTH];
     110        char identity[MT_MNDP_MAX_STRING_SIZE];
     111        char version[MT_MNDP_MAX_STRING_SIZE];
     112        char platform[MT_MNDP_MAX_STRING_SIZE];
     113        char hardware[MT_MNDP_MAX_STRING_SIZE];
     114        char softid[MT_MNDP_MAX_STRING_SIZE];
     115        char ifname[MT_MNDP_MAX_STRING_SIZE];
    116116        unsigned int uptime;
    117117};
     
    124124/* MacTelnet/Winbox packets */
    125125extern int init_packet(struct mt_packet *packet, enum mt_ptype ptype, unsigned char *srcmac, unsigned char *dstmac, unsigned short sessionkey, unsigned int counter);
    126 extern int add_control_packet(struct mt_packet *packet, enum mt_cptype cptype, void *cpdata, int data_len);
     126extern int add_control_packet(struct mt_packet *packet, enum mt_cptype cptype, void *cpdata, unsigned short data_len);
    127127extern void parse_packet(unsigned char *data, struct mt_mactelnet_hdr *pkthdr);
    128 extern int parse_control_packet(unsigned char *data, int data_len, struct mt_mactelnet_control_hdr *cpkthdr);
     128extern int parse_control_packet(unsigned char *data, unsigned short data_len, struct mt_mactelnet_control_hdr *cpkthdr);
    129129
    130130/* MAC-Ping packets */
     
    155155#if defined(DEBUG_PROTO)
    156156#ifndef hexdump_defined
    157 void hexdump(const char *title, const void *buf, int len)
     157void hexdump(const char *title, const void *buf, unsigned short len)
    158158{
    159159    int i;
  • src/router/mactelnet/users.c

    r29333 r31170  
    2020#include <stdlib.h>
    2121#include <string.h>
     22#include "config.h"
    2223#include "users.h"
    23 #include "config.h"
    2424#include "utlist.h"
    2525
    26 #define _(String) (String)
     26#define _(String) String
    2727
    2828struct mt_credentials *mt_users = NULL;
     
    4646                char *user;
    4747                char *password;
     48                size_t size;
    4849
    4950                user = strtok(line, ":");
     
    6061                }
    6162
    62                 memcpy(cred->username, user, strlen(user) < MT_CRED_LEN - 1? strlen(user) : MT_CRED_LEN);
    63                 memcpy(cred->password, password, strlen(password)  < MT_CRED_LEN - 1? strlen(password)  : MT_CRED_LEN);
     63                /* verify that the username & password will be '\0' terminated */
     64                memcpy(cred->username, user, size = (strlen(user) < MT_CRED_LEN ? strlen(user) : MT_CRED_LEN - 1));
     65                cred->username[size] = '\0';
     66                memcpy(cred->password, password, size = (strlen(password) < MT_CRED_LEN ? strlen(password) : MT_CRED_LEN - 1));
     67                cred->password[size] = '\0';
    6468                DL_APPEND(mt_users, cred);
    6569        }
Note: See TracChangeset for help on using the changeset viewer.