src/iodined.c

   1 /*
   2  * Copyright (c) 2006-2009 Bjorn Andersson <flex@kryo.se>, Erik Ekman <yarrick@kryo.se>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdint.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <signal.h>
  22 #include <unistd.h>
  23 #include <sys/types.h>
  24 #include <sys/param.h>
  25 #include <sys/time.h>
  26 #include <fcntl.h>
  27 #include <time.h>
  28 #include <zlib.h>
  29
  30 #ifdef WINDOWS32
  31 #include "windows.h"
  32 #include <winsock2.h>
  33 #else
  34 #include <arpa/nameser.h>
  35 #ifdef DARWIN
  36 #include <arpa/nameser8_compat.h>
  37 #endif
  38 #define _XPG4_2
  39 #include <sys/socket.h>
  40 #include <err.h>
  41 #include <arpa/inet.h>
  42 #include <netinet/in.h>
  43 #include <netinet/in_systm.h>
  44 #include <netinet/ip.h>
  45 #include <grp.h>
  46 #include <sys/uio.h>
  47 #include <pwd.h>
  48 #include <netdb.h>
  49 #include <syslog.h>
  50 #endif
  51
  52 #include "common.h"
  53 #include "dns.h"
  54 #include "encoding.h"
  55 #include "base32.h"
  56 #include "base64.h"
  57 #include "user.h"
  58 #include "login.h"
  59 #include "tun.h"
  60 #include "fw_query.h"
  61 #include "version.h"
  62
  63 #ifdef WINDOWS32
  64 WORD req_version = MAKEWORD(2, 2);
  65 WSADATA wsa_data;
  66 #endif
  67
  68 static int running = 1;
  69 static char *topdomain;
  70 static char password[33];
  71 static struct encoder *b32;
  72 static int created_users;
  73
  74 static int check_ip;
  75 static int my_mtu;
  76 static in_addr_t my_ip;
  77 static int netmask;
  78
  79 static in_addr_t ns_ip;
  80
  81 static int bind_port;
  82 static int debug;
  83
  84 #if !defined(BSD) && !defined(__GLIBC__)
  85 static char *__progname;
  86 #endif
  87
  88 static int read_dns(int, struct query *);
  89 static void write_dns(int, struct query *, char *, int);
  90
  91 static void
  92 sigint(int sig)
  93 {
  94         running = 0;
  95 }
  96
  97 #ifdef WINDOWS32
  98 #define LOG_EMERG       0
  99 #define LOG_ALERT       1
 100 #define LOG_CRIT        2
 101 #define LOG_ERR         3
 102 #define LOG_WARNING     4
 103 #define LOG_NOTICE      5
 104 #define LOG_INFO        6
 105 #define LOG_DEBUG       7
 106 static void
 107 syslog(int a, const char *str, ...)
 108 {
 109         /* TODO: implement (add to event log), move to common.c */
 110         ;
 111 }
 112 #endif
 113
 114 static int
 115 check_user_and_ip(int userid, struct query *q)
 116 {
 117         struct sockaddr_in *tempin;
 118
 119         if (userid < 0 || userid >= created_users ) {
 120                 return 1;
 121         }
 122         if (!users[userid].active) {
 123                 return 1;
 124         }
 125
 126         /* return early if IP checking is disabled */
 127         if (!check_ip) {
 128                 return 0;
 129         }
 130
 131         tempin = (struct sockaddr_in *) &(q->from);
 132         return memcmp(&(users[userid].host), &(tempin->sin_addr), sizeof(struct in_addr));
 133 }
 134
 135 static int
 136 tunnel_tun(int tun_fd, int dns_fd)
 137 {
 138         unsigned long outlen;
 139         struct ip *header;
 140         char out[64*1024];
 141         char in[64*1024];
 142         int userid;
 143         int read;
 144
 145         if ((read = read_tun(tun_fd, in, sizeof(in))) <= 0)
 146                 return 0;
 147
 148         /* find target ip in packet, in is padded with 4 bytes TUN header */
 149         header = (struct ip*) (in + 4);
 150         userid = find_user_by_ip(header->ip_dst.s_addr);
 151         if (userid < 0)
 152                 return 0;
 153
 154         outlen = sizeof(out);
 155         compress2((uint8_t*)out, &outlen, (uint8_t*)in, read, 9);
 156
 157         /* if another packet is queued, throw away this one. TODO build queue */
 158         if (users[userid].outpacket.len == 0) {
 159                 memcpy(users[userid].outpacket.data, out, outlen);
 160                 users[userid].outpacket.len = outlen;
 161                 users[userid].outpacket.offset = 0;
 162                 users[userid].outpacket.sentlen = 0;
 163                 users[userid].outpacket.seqno = (++users[userid].outpacket.seqno & 7);
 164                 users[userid].outpacket.fragment = 0;
 165                 return outlen;
 166         } else {
 167                 return 0;
 168         }
 169 }
 170
 171 typedef enum {
 172         VERSION_ACK,
 173         VERSION_NACK,
 174         VERSION_FULL
 175 } version_ack_t;
 176
 177 static void
 178 send_version_response(int fd, version_ack_t ack, uint32_t payload, int userid, struct query *q)
 179 {
 180         char out[9];
 181
 182         switch (ack) {
 183         case VERSION_ACK:
 184                 strncpy(out, "VACK", sizeof(out));
 185                 break;
 186         case VERSION_NACK:
 187                 strncpy(out, "VNAK", sizeof(out));
 188                 break;
 189         case VERSION_FULL:
 190                 strncpy(out, "VFUL", sizeof(out));
 191                 break;
 192         }
 193
 194         out[4] = ((payload >> 24) & 0xff);
 195         out[5] = ((payload >> 16) & 0xff);
 196         out[6] = ((payload >> 8) & 0xff);
 197         out[7] = ((payload) & 0xff);
 198         out[8] = userid & 0xff;
 199
 200         write_dns(fd, q, out, sizeof(out));
 201 }
 202
 203 static void
 204 send_chunk(int dns_fd, int userid) {
 205         char pkt[4096];
 206         int datalen;
 207         int last;
 208
 209         datalen = MIN(users[userid].fragsize, users[userid].outpacket.len - users[userid].outpacket.offset);
 210
 211         if (datalen && users[userid].outpacket.sentlen > 0 &&
 212                         (
 213                         users[userid].outpacket.seqno != users[userid].out_acked_seqno ||
 214                         users[userid].outpacket.fragment != users[userid].out_acked_fragment
 215                         )
 216                 ) {
 217
 218                 /* Still waiting on latest ack, send nothing */
 219                 datalen = 0;
 220                 last = 0;
 221                 /* TODO : count down and discard packet if no acks arrive within X queries */
 222         } else {
 223                 memcpy(&pkt[2], &users[userid].outpacket.data[users[userid].outpacket.offset], datalen);
 224                 users[userid].outpacket.sentlen = datalen;
 225                 last = (users[userid].outpacket.len == users[userid].outpacket.offset + users[userid].outpacket.sentlen);
 226
 227                 /* Increase fragment# when sending data with offset */
 228                 if (users[userid].outpacket.offset && datalen)
 229                         users[userid].outpacket.fragment++;
 230         }
 231
 232         /* Build downstream data header (see doc/proto_xxxxxxxx.txt) */
 233
 234         /* First byte is 1 bit compression flag, 3 bits upstream seqno, 4 bits upstream fragment */
 235         pkt[0] = (1<<7) | ((users[userid].inpacket.seqno & 7) << 4) | (users[userid].inpacket.fragment & 15);
 236         /* Second byte is 3 bits downstream seqno, 4 bits downstream fragment, 1 bit last flag */
 237         pkt[1] = ((users[userid].outpacket.seqno & 7) << 5) |
 238                 ((users[userid].outpacket.fragment & 15) << 1) | (last & 1);
 239
 240         if (debug >= 1) {
 241                 fprintf(stderr, "OUT  pkt seq# %d, frag %d (last=%d), offset %d, fragsize %d, total %d, to user %d\n",
 242                         users[userid].outpacket.seqno & 7, users[userid].outpacket.fragment & 15,
 243                         last, users[userid].outpacket.offset, datalen, users[userid].outpacket.len, userid);
 244         }
 245         write_dns(dns_fd, &users[userid].q, pkt, datalen + 2);
 246         users[userid].q.id = 0;
 247
 248         if (users[userid].outpacket.len > 0 &&
 249                 users[userid].outpacket.len == users[userid].outpacket.sentlen) {
 250
 251                 /* Whole packet was sent in one chunk, dont wait for ack */
 252                 users[userid].outpacket.len = 0;
 253                 users[userid].outpacket.offset = 0;
 254                 users[userid].outpacket.sentlen = 0;
 255         }
 256 }
 257
 258 static void
 259 update_downstream_seqno(int dns_fd, int userid, int down_seq, int down_frag)
 260 {
 261         /* If we just read a new packet from tun we have not sent a fragment of, just send it */
 262         if (users[userid].outpacket.len > 0 && users[userid].outpacket.sentlen == 0) {
 263                 send_chunk(dns_fd, userid);
 264                 return;
 265         }
 266
 267         /* otherwise, check if we received ack on a fragment and can send next */
 268         if (users[userid].outpacket.len > 0 &&
 269                 users[userid].outpacket.seqno == down_seq && users[userid].outpacket.fragment == down_frag) {
 270
 271                 if (down_seq != users[userid].out_acked_seqno || down_frag != users[userid].out_acked_fragment) {
 272                         /* Received ACK on downstream fragment */
 273                         users[userid].outpacket.offset += users[userid].outpacket.sentlen;
 274                         users[userid].outpacket.sentlen = 0;
 275
 276                         /* Is packet done? */
 277                         if (users[userid].outpacket.offset == users[userid].outpacket.len) {
 278                                 users[userid].outpacket.len = 0;
 279                                 users[userid].outpacket.offset = 0;
 280                                 users[userid].outpacket.sentlen = 0;
 281                         }
 282
 283                         users[userid].out_acked_seqno = down_seq;
 284                         users[userid].out_acked_fragment = down_frag;
 285
 286                         /* Send reply if waiting */
 287                         if (users[userid].outpacket.len > 0) {
 288                                 send_chunk(dns_fd, userid);
 289                         }
 290                 }
 291         }
 292 }
 293
 294 static void
 295 handle_null_request(int tun_fd, int dns_fd, struct query *q, int domain_len)
 296 {
 297         struct in_addr tempip;
 298         struct ip *hdr;
 299         unsigned long outlen;
 300         char in[512];
 301         char logindata[16];
 302         char out[64*1024];
 303         char unpacked[64*1024];
 304         char *tmp[2];
 305         int userid;
 306         int touser;
 307         int version;
 308         int code;
 309         int read;
 310
 311         userid = -1;
 312
 313         memcpy(in, q->name, MIN(domain_len, sizeof(in)));
 314
 315         if(in[0] == 'V' || in[0] == 'v') {
 316                 read = unpack_data(unpacked, sizeof(unpacked), &(in[1]), domain_len - 1, b32);
 317                 /* Version greeting, compare and send ack/nak */
 318                 if (read > 4) {
 319                         /* Received V + 32bits version */
 320                         version = (((unpacked[0] & 0xff) << 24) |
 321                                            ((unpacked[1] & 0xff) << 16) |
 322                                            ((unpacked[2] & 0xff) << 8) |
 323                                            ((unpacked[3] & 0xff)));
 324                 }
 325
 326                 if (version == VERSION) {
 327                         userid = find_available_user();
 328                         if (userid >= 0) {
 329                                 struct sockaddr_in *tempin;
 330
 331                                 users[userid].seed = rand();
 332                                 /* Store remote IP number */
 333                                 tempin = (struct sockaddr_in *) &(q->from);
 334                                 memcpy(&(users[userid].host), &(tempin->sin_addr), sizeof(struct in_addr));
 335
 336                                 memcpy(&(users[userid].q), q, sizeof(struct query));
 337                                 users[userid].encoder = get_base32_encoder();
 338                                 send_version_response(dns_fd, VERSION_ACK, users[userid].seed, userid, q);
 339                                 syslog(LOG_INFO, "accepted version for user #%d from %s",
 340                                         userid, inet_ntoa(tempin->sin_addr));
 341                                 users[userid].q.id = 0;
 342                         } else {
 343                                 /* No space for another user */
 344                                 send_version_response(dns_fd, VERSION_FULL, created_users, 0, q);
 345                                 syslog(LOG_INFO, "dropped user from %s, server full",
 346                                         inet_ntoa(((struct sockaddr_in *) &q->from)->sin_addr));
 347                         }
 348                 } else {
 349                         send_version_response(dns_fd, VERSION_NACK, VERSION, 0, q);
 350                         syslog(LOG_INFO, "dropped user from %s, sent bad version %08X",
 351                                 inet_ntoa(((struct sockaddr_in *) &q->from)->sin_addr), version);
 352                 }
 353                 return;
 354         } else if(in[0] == 'L' || in[0] == 'l') {
 355                 read = unpack_data(unpacked, sizeof(unpacked), &(in[1]), domain_len - 1, b32);
 356                 /* Login phase, handle auth */
 357                 userid = unpacked[0];
 358
 359                 if (check_user_and_ip(userid, q) != 0) {
 360                         write_dns(dns_fd, q, "BADIP", 5);
 361                         syslog(LOG_WARNING, "dropped login request from user #%d from unexpected source %s",
 362                                 userid, inet_ntoa(((struct sockaddr_in *) &q->from)->sin_addr));
 363                         return;
 364                 } else {
 365                         users[userid].last_pkt = time(NULL);
 366                         login_calculate(logindata, 16, password, users[userid].seed);
 367
 368                         if (read >= 18 && (memcmp(logindata, unpacked+1, 16) == 0)) {
 369                                 /* Login ok, send ip/mtu/netmask info */
 370
 371                                 tempip.s_addr = my_ip;
 372                                 tmp[0] = strdup(inet_ntoa(tempip));
 373                                 tempip.s_addr = users[userid].tun_ip;
 374                                 tmp[1] = strdup(inet_ntoa(tempip));
 375
 376                                 read = snprintf(out, sizeof(out), "%s-%s-%d-%d",
 377                                                 tmp[0], tmp[1], my_mtu, netmask);
 378
 379                                 write_dns(dns_fd, q, out, read);
 380                                 q->id = 0;
 381                                 syslog(LOG_NOTICE, "accepted password from user #%d, given IP %s", userid, tmp[1]);
 382
 383                                 free(tmp[1]);
 384                                 free(tmp[0]);
 385                         } else {
 386                                 write_dns(dns_fd, q, "LNAK", 4);
 387                                 syslog(LOG_WARNING, "rejected login request from user #%d from %s, bad password",
 388                                         userid, inet_ntoa(((struct sockaddr_in *) &q->from)->sin_addr));
 389                         }
 390                 }
 391                 return;
 392         } else if(in[0] == 'Z' || in[0] == 'z') {
 393                 /* Check for case conservation and chars not allowed according to RFC */
 394
 395                 /* Reply with received hostname as data */
 396                 write_dns(dns_fd, q, in, domain_len);
 397                 return;
 398         } else if(in[0] == 'S' || in[0] == 's') {
 399                 int codec;
 400                 struct encoder *enc;
 401                 if (domain_len != 4) { /* len = 4, example: "S15." */
 402                         write_dns(dns_fd, q, "BADLEN", 6);
 403                         return;
 404                 }
 405
 406                 userid = b32_8to5(in[1]);
 407
 408                 if (check_user_and_ip(userid, q) != 0) {
 409                         write_dns(dns_fd, q, "BADIP", 5);
 410                         return; /* illegal id */
 411                 }
 412
 413                 codec = b32_8to5(in[2]);
 414
 415                 switch (codec) {
 416                 case 5: /* 5 bits per byte = base32 */
 417                         enc = get_base32_encoder();
 418                         user_switch_codec(userid, enc);
 419                         write_dns(dns_fd, q, enc->name, strlen(enc->name));
 420                         break;
 421                 case 6: /* 6 bits per byte = base64 */
 422                         enc = get_base64_encoder();
 423                         user_switch_codec(userid, enc);
 424                         write_dns(dns_fd, q, enc->name, strlen(enc->name));
 425                         break;
 426                 default:
 427                         write_dns(dns_fd, q, "BADCODEC", 8);
 428                         break;
 429                 }
 430                 return;
 431         } else if(in[0] == 'R' || in[0] == 'r') {
 432                 int req_frag_size;
 433
 434                 /* Downstream fragsize probe packet */
 435                 userid = (b32_8to5(in[1]) >> 1) & 15;
 436                 if (check_user_and_ip(userid, q) != 0) {
 437                         write_dns(dns_fd, q, "BADIP", 5);
 438                         return; /* illegal id */
 439                 }
 440
 441                 req_frag_size = ((b32_8to5(in[1]) & 1) << 10) | ((b32_8to5(in[2]) & 31) << 5) | (b32_8to5(in[3]) & 31);
 442                 if (req_frag_size < 2 || req_frag_size > 2047) {
 443                         write_dns(dns_fd, q, "BADFRAG", 7);
 444                 } else {
 445                         char buf[2048];
 446
 447                         memset(buf, 0, sizeof(buf));
 448                         buf[0] = (req_frag_size >> 8) & 0xff;
 449                         buf[1] = req_frag_size & 0xff;
 450                         write_dns(dns_fd, q, buf, req_frag_size);
 451                 }
 452                 return;
 453         } else if(in[0] == 'N' || in[0] == 'n') {
 454                 int max_frag_size;
 455
 456                 read = unpack_data(unpacked, sizeof(unpacked), &(in[1]), domain_len - 1, b32);
 457                 /* Downstream fragsize packet */
 458                 userid = unpacked[0];
 459                 if (check_user_and_ip(userid, q) != 0) {
 460                         write_dns(dns_fd, q, "BADIP", 5);
 461                         return; /* illegal id */
 462                 }
 463
 464                 max_frag_size = ((unpacked[1] & 0xff) << 8) | (unpacked[2] & 0xff);
 465                 if (max_frag_size < 2) {
 466                         write_dns(dns_fd, q, "BADFRAG", 7);
 467                 } else {
 468                         users[userid].fragsize = max_frag_size;
 469                         write_dns(dns_fd, q, &unpacked[1], 2);
 470                 }
 471                 return;
 472         } else if(in[0] == 'P' || in[0] == 'p') {
 473                 int dn_seq;
 474                 int dn_frag;
 475
 476                 read = unpack_data(unpacked, sizeof(unpacked), &(in[1]), domain_len - 1, b32);
 477                 /* Ping packet, store userid */
 478                 userid = unpacked[0];
 479                 if (check_user_and_ip(userid, q) != 0) {
 480                         write_dns(dns_fd, q, "BADIP", 5);
 481                         return; /* illegal id */
 482                 }
 483
 484                 if (debug >= 1) {
 485                         fprintf(stderr, "PING pkt from user %d\n", userid);
 486                 }
 487
 488                 if (users[userid].q.id != 0) {
 489                         /* Send reply on earlier query before overwriting */
 490                         send_chunk(dns_fd, userid);
 491                 }
 492
 493                 dn_seq = unpacked[1] >> 4;
 494                 dn_frag = unpacked[1] & 15;
 495                 memcpy(&(users[userid].q), q, sizeof(struct query));
 496                 users[userid].last_pkt = time(NULL);
 497
 498                 /* Update seqno and maybe send immediate response packet */
 499                 update_downstream_seqno(dns_fd, userid, dn_seq, dn_frag);
 500         } else if((in[0] >= '0' && in[0] <= '9')
 501                         || (in[0] >= 'a' && in[0] <= 'f')
 502                         || (in[0] >= 'A' && in[0] <= 'F')) {
 503                 if ((in[0] >= '0' && in[0] <= '9'))
 504                         code = in[0] - '0';
 505                 if ((in[0] >= 'a' && in[0] <= 'f'))
 506                         code = in[0] - 'a' + 10;
 507                 if ((in[0] >= 'A' && in[0] <= 'F'))
 508                         code = in[0] - 'A' + 10;
 509
 510                 userid = code;
 511                 /* Check user and sending ip number */
 512                 if (check_user_and_ip(userid, q) != 0) {
 513                         write_dns(dns_fd, q, "BADIP", 5);
 514                 } else {
 515                         /* Decode data header */
 516                         int up_seq = (b32_8to5(in[1]) >> 2) & 7;
 517                         int up_frag = ((b32_8to5(in[1]) & 3) << 2) | ((b32_8to5(in[2]) >> 3) & 3);
 518                         int dn_seq = (b32_8to5(in[2]) & 7);
 519                         int dn_frag = b32_8to5(in[3]) >> 1;
 520                         int lastfrag = b32_8to5(in[3]) & 1;
 521
 522                         if (users[userid].q.id != 0) {
 523                                 /* Send reply on earlier query before overwriting */
 524                                 send_chunk(dns_fd, userid);
 525                         }
 526
 527                         /* Update query and time info for user */
 528                         users[userid].last_pkt = time(NULL);
 529                         memcpy(&(users[userid].q), q, sizeof(struct query));
 530
 531                         if (up_seq == users[userid].inpacket.seqno &&
 532                                 up_frag <= users[userid].inpacket.fragment) {
 533                                 /* Got repeated old packet, skip it */
 534                                 if (debug >= 1) {
 535                                         fprintf(stderr, "IN   pkt seq# %d, frag %d, dropped duplicate\n",
 536                                                 up_seq, up_frag);
 537                                 }
 538                                 /* Update seqno and maybe send immediate response packet */
 539                                 update_downstream_seqno(dns_fd, userid, dn_seq, dn_frag);
 540                                 return;
 541                         }
 542                         if (up_seq != users[userid].inpacket.seqno) {
 543                                 /* New packet has arrived */
 544                                 users[userid].inpacket.seqno = up_seq;
 545                                 users[userid].inpacket.len = 0;
 546                                 users[userid].inpacket.offset = 0;
 547                         }
 548                         users[userid].inpacket.fragment = up_frag;
 549
 550                         /* decode with this users encoding */
 551                         read = unpack_data(unpacked, sizeof(unpacked), &(in[4]), domain_len - 4,
 552                                            users[userid].encoder);
 553
 554                         /* copy to packet buffer, update length */
 555                         memcpy(users[userid].inpacket.data + users[userid].inpacket.offset, unpacked, read);
 556                         users[userid].inpacket.len += read;
 557                         users[userid].inpacket.offset += read;
 558
 559                         if (debug >= 1) {
 560                                 fprintf(stderr, "IN   pkt seq# %d, frag %d (last=%d), fragsize %d, total %d, from user %d\n",
 561                                         up_seq, up_frag, lastfrag, read, users[userid].inpacket.len, userid);
 562                         }
 563
 564                         if (lastfrag & 1) { /* packet is complete */
 565                                 int ret;
 566                                 outlen = sizeof(out);
 567                                 ret = uncompress((uint8_t*)out, &outlen,
 568                                            (uint8_t*)users[userid].inpacket.data, users[userid].inpacket.len);
 569
 570                                 if (ret == Z_OK) {
 571                                         hdr = (struct ip*) (out + 4);
 572                                         touser = find_user_by_ip(hdr->ip_dst.s_addr);
 573
 574                                         if (touser == -1) {
 575                                                 /* send the uncompressed packet to tun device */
 576                                                 write_tun(tun_fd, out, outlen);
 577                                         } else {
 578                                                 /* send the compressed packet to other client
 579                                                  * if another packet is queued, throw away this one. TODO build queue */
 580                                                 if (users[touser].outpacket.len == 0) {
 581                                                         memcpy(users[touser].outpacket.data, users[userid].inpacket.data, users[userid].inpacket.len);
 582                                                         users[touser].outpacket.len = users[userid].inpacket.len;
 583                                                 }
 584                                         }
 585                                 } else {
 586                                         fprintf(stderr, "Discarded data, uncompress() result: %d\n", ret);
 587                                 }
 588                                 users[userid].inpacket.len = users[userid].inpacket.offset = 0;
 589                         }
 590                         /* Update seqno and maybe send immediate response packet */
 591                         update_downstream_seqno(dns_fd, userid, dn_seq, dn_frag);
 592                 }
 593         }
 594 }
 595
 596 static void
 597 handle_ns_request(int dns_fd, struct query *q)
 598 {
 599         char buf[64*1024];
 600         int len;
 601
 602         if (ns_ip != INADDR_ANY) {
 603                 memcpy(&q->destination.s_addr, &ns_ip, sizeof(in_addr_t));
 604         }
 605
 606         len = dns_encode_ns_response(buf, sizeof(buf), q, topdomain);
 607
 608         if (debug >= 2) {
 609                 struct sockaddr_in *tempin;
 610                 tempin = (struct sockaddr_in *) &(q->from);
 611                 fprintf(stderr, "TX: client %s, type %d, name %s, %d bytes NS reply\n",
 612                         inet_ntoa(tempin->sin_addr), q->type, q->name, len);
 613         }
 614         if (sendto(dns_fd, buf, len, 0, (struct sockaddr*)&q->from, q->fromlen) <= 0) {
 615                 warn("ns reply send error");
 616         }
 617 }
 618
 619 static void
 620 forward_query(int bind_fd, struct query *q)
 621 {
 622         char buf[64*1024];
 623         int len;
 624         struct fw_query fwq;
 625         struct sockaddr_in *myaddr;
 626         in_addr_t newaddr;
 627
 628         len = dns_encode(buf, sizeof(buf), q, QR_QUERY, q->name, strlen(q->name));
 629
 630         /* Store sockaddr for q->id */
 631         memcpy(&(fwq.addr), &(q->from), q->fromlen);
 632         fwq.addrlen = q->fromlen;
 633         fwq.id = q->id;
 634         fw_query_put(&fwq);
 635
 636         newaddr = inet_addr("127.0.0.1");
 637         myaddr = (struct sockaddr_in *) &(q->from);
 638         memcpy(&(myaddr->sin_addr), &newaddr, sizeof(in_addr_t));
 639         myaddr->sin_port = htons(bind_port);
 640
 641         if (debug >= 2) {
 642                 fprintf(stderr, "TX: NS reply \n");
 643         }
 644
 645         if (sendto(bind_fd, buf, len, 0, (struct sockaddr*)&q->from, q->fromlen) <= 0) {
 646                 warn("forward query error");
 647         }
 648 }
 649
 650 static int
 651 tunnel_bind(int bind_fd, int dns_fd)
 652 {
 653         char packet[64*1024];
 654         struct sockaddr_in from;
 655         socklen_t fromlen;
 656         struct fw_query *query;
 657         unsigned short id;
 658         int r;
 659
 660         fromlen = sizeof(struct sockaddr);
 661         r = recvfrom(bind_fd, packet, sizeof(packet), 0,
 662                 (struct sockaddr*)&from, &fromlen);
 663
 664         if (r <= 0)
 665                 return 0;
 666
 667         id = dns_get_id(packet, r);
 668
 669         if (debug >= 2) {
 670                 fprintf(stderr, "RX: Got response on query %u from DNS\n", (id & 0xFFFF));
 671         }
 672
 673         /* Get sockaddr from id */
 674         fw_query_get(id, &query);
 675         if (!query && debug >= 2) {
 676                 fprintf(stderr, "Lost sender of id %u, dropping reply\n", (id & 0xFFFF));
 677                 return 0;
 678         }
 679
 680         if (debug >= 2) {
 681                 struct sockaddr_in *in;
 682                 in = (struct sockaddr_in *) &(query->addr);
 683                 fprintf(stderr, "TX: client %s id %u, %d bytes\n",
 684                         inet_ntoa(in->sin_addr), (id & 0xffff), r);
 685         }
 686
 687         if (sendto(dns_fd, packet, r, 0, (const struct sockaddr *) &(query->addr),
 688                 query->addrlen) <= 0) {
 689                 warn("forward reply error");
 690         }
 691
 692         return 0;
 693 }
 694
 695 static int
 696 tunnel_dns(int tun_fd, int dns_fd, int bind_fd)
 697 {
 698         struct query q;
 699         int read;
 700         char *domain;
 701         int domain_len;
 702         int inside_topdomain;
 703
 704         if ((read = read_dns(dns_fd, &q)) <= 0)
 705                 return 0;
 706
 707         if (debug >= 2) {
 708                 struct sockaddr_in *tempin;
 709                 tempin = (struct sockaddr_in *) &(q.from);
 710                 fprintf(stderr, "RX: client %s, type %d, name %s\n",
 711                         inet_ntoa(tempin->sin_addr), q.type, q.name);
 712         }
 713
 714         domain = strstr(q.name, topdomain);
 715         inside_topdomain = 0;
 716         if (domain) {
 717                 domain_len = (int) (domain - q.name);
 718                 if (domain_len + strlen(topdomain) == strlen(q.name)) {
 719                         inside_topdomain = 1;
 720                 }
 721         }
 722
 723         if (inside_topdomain) {
 724                 /* This is a query we can handle */
 725                 switch (q.type) {
 726                 case T_NULL:
 727                         handle_null_request(tun_fd, dns_fd, &q, domain_len);
 728                         break;
 729                 case T_NS:
 730                         handle_ns_request(dns_fd, &q);
 731                         break;
 732                 default:
 733                         break;
 734                 }
 735         } else {
 736                 /* Forward query to other port ? */
 737                 if (bind_fd) {
 738                         forward_query(bind_fd, &q);
 739                 }
 740         }
 741         return 0;
 742 }
 743
 744 static int
 745 tunnel(int tun_fd, int dns_fd, int bind_fd)
 746 {
 747         struct timeval tv;
 748         fd_set fds;
 749         int i;
 750
 751         while (running) {
 752                 int maxfd;
 753                 if (users_waiting_on_reply()) {
 754                         tv.tv_sec = 0;
 755                         tv.tv_usec = 15000;
 756                 } else {
 757                         tv.tv_sec = 1;
 758                         tv.tv_usec = 0;
 759                 }
 760
 761                 FD_ZERO(&fds);
 762
 763                 FD_SET(dns_fd, &fds);
 764                 maxfd = dns_fd;
 765
 766                 if (bind_fd) {
 767                         /* wait for replies from real DNS */
 768                         FD_SET(bind_fd, &fds);
 769                         maxfd = MAX(bind_fd, maxfd);
 770                 }
 771
 772                 /* TODO : use some kind of packet queue */
 773                 if(!all_users_waiting_to_send()) {
 774                         FD_SET(tun_fd, &fds);
 775                         maxfd = MAX(tun_fd, maxfd);
 776                 }
 777
 778                 i = select(maxfd + 1, &fds, NULL, NULL, &tv);
 779
 780                 if(i < 0) {
 781                         if (running)
 782                                 warn("select");
 783                         return 1;
 784                 }
 785
 786                 if (i==0) {
 787                         int j;
 788                         for (j = 0; j < USERS; j++) {
 789                                 if (users[j].q.id != 0) {
 790                                         send_chunk(dns_fd, j);
 791                                 }
 792                         }
 793                 } else {
 794                         if(FD_ISSET(tun_fd, &fds)) {
 795                                 tunnel_tun(tun_fd, dns_fd);
 796                                 continue;
 797                         }
 798                         if(FD_ISSET(dns_fd, &fds)) {
 799                                 tunnel_dns(tun_fd, dns_fd, bind_fd);
 800                                 continue;
 801                         }
 802                         if(FD_ISSET(bind_fd, &fds)) {
 803                                 tunnel_bind(bind_fd, dns_fd);
 804                                 continue;
 805                         }
 806                 }
 807         }
 808
 809         return 0;
 810 }
 811
 812 static int
 813 read_dns(int fd, struct query *q)
 814 {
 815         struct sockaddr_in from;
 816         socklen_t addrlen;
 817         char packet[64*1024];
 818         int r;
 819 #ifndef WINDOWS32
 820         char address[96];
 821         struct msghdr msg;
 822         struct iovec iov;
 823         struct cmsghdr *cmsg;
 824
 825         addrlen = sizeof(struct sockaddr);
 826         iov.iov_base = packet;
 827         iov.iov_len = sizeof(packet);
 828
 829         msg.msg_name = (caddr_t) &from;
 830         msg.msg_namelen = (unsigned) addrlen;
 831         msg.msg_iov = &iov;
 832         msg.msg_iovlen = 1;
 833         msg.msg_control = address;
 834         msg.msg_controllen = sizeof(address);
 835         msg.msg_flags = 0;
 836
 837         r = recvmsg(fd, &msg, 0);
 838 #else
 839         addrlen = sizeof(struct sockaddr);
 840         r = recvfrom(fd, packet, sizeof(packet), 0, (struct sockaddr*)&from, &addrlen);
 841 #endif /* !WINDOWS32 */
 842
 843         if (r > 0) {
 844                 dns_decode(NULL, 0, q, QR_QUERY, packet, r);
 845                 memcpy((struct sockaddr*)&q->from, (struct sockaddr*)&from, addrlen);
 846                 q->fromlen = addrlen;
 847
 848 #ifndef WINDOWS32
 849                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
 850                         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 851
 852                         if (cmsg->cmsg_level == IPPROTO_IP &&
 853                                 cmsg->cmsg_type == DSTADDR_SOCKOPT) {
 854
 855                                 q->destination = *dstaddr(cmsg);
 856                                 break;
 857                         }
 858                 }
 859 #endif
 860
 861                 return strlen(q->name);
 862         } else if (r < 0) {
 863                 /* Error */
 864                 warn("read dns");
 865         }
 866
 867         return 0;
 868 }
 869
 870 static void
 871 write_dns(int fd, struct query *q, char *data, int datalen)
 872 {
 873         char buf[64*1024];
 874         int len;
 875
 876         len = dns_encode(buf, sizeof(buf), q, QR_ANSWER, data, datalen);
 877
 878         if (debug >= 2) {
 879                 struct sockaddr_in *tempin;
 880                 tempin = (struct sockaddr_in *) &(q->from);
 881                 fprintf(stderr, "TX: client %s, type %d, name %s, %d bytes data\n",
 882                         inet_ntoa(tempin->sin_addr), q->type, q->name, datalen);
 883         }
 884
 885         sendto(fd, buf, len, 0, (struct sockaddr*)&q->from, q->fromlen);
 886 }
 887
 888 static void
 889 usage() {
 890         extern char *__progname;
 891
 892         fprintf(stderr, "Usage: %s [-v] [-h] [-c] [-s] [-f] [-D] [-u user] "
 893                 "[-t chrootdir] [-d device] [-m mtu] "
 894                 "[-l ip address to listen on] [-p port] [-n external ip] [-b dnsport] [-P password]"
 895                 " tunnel_ip[/netmask] topdomain\n", __progname);
 896         exit(2);
 897 }
 898
 899 static void
 900 help() {
 901         extern char *__progname;
 902
 903         fprintf(stderr, "iodine IP over DNS tunneling server\n");
 904         fprintf(stderr, "Usage: %s [-v] [-h] [-c] [-s] [-f] [-D] [-u user] "
 905                 "[-t chrootdir] [-d device] [-m mtu] "
 906                 "[-l ip address to listen on] [-p port] [-n external ip] [-b dnsport] [-P password]"
 907                 " tunnel_ip[/netmask] topdomain\n", __progname);
 908         fprintf(stderr, "  -v to print version info and exit\n");
 909         fprintf(stderr, "  -h to print this help and exit\n");
 910         fprintf(stderr, "  -c to disable check of client IP/port on each request\n");
 911         fprintf(stderr, "  -s to skip creating and configuring the tun device, "
 912                 "which then has to be created manually\n");
 913         fprintf(stderr, "  -f to keep running in foreground\n");
 914         fprintf(stderr, "  -D to increase debug level\n");
 915         fprintf(stderr, "  -u name to drop privileges and run as user 'name'\n");
 916         fprintf(stderr, "  -t dir to chroot to directory dir\n");
 917         fprintf(stderr, "  -d device to set tunnel device name\n");
 918         fprintf(stderr, "  -m mtu to set tunnel device mtu\n");
 919         fprintf(stderr, "  -l ip address to listen on for incoming dns traffic "
 920                 "(default 0.0.0.0)\n");
 921         fprintf(stderr, "  -p port to listen on for incoming dns traffic (default 53)\n");
 922         fprintf(stderr, "  -n ip to respond with to NS queries\n");
 923         fprintf(stderr, "  -b port to forward normal DNS queries to (on localhost)\n");
 924         fprintf(stderr, "  -P password used for authentication (max 32 chars will be used)\n");
 925         fprintf(stderr, "tunnel_ip is the IP number of the local tunnel interface.\n");
 926         fprintf(stderr, "   /netmask sets the size of the tunnel network.\n");
 927         fprintf(stderr, "topdomain is the FQDN that is delegated to this server.\n");
 928         exit(0);
 929 }
 930
 931 static void
 932 version() {
 933         printf("iodine IP over DNS tunneling server\n");
 934         printf("version: 0.5.1 from 2009-03-21\n");
 935         exit(0);
 936 }
 937
 938 int
 939 main(int argc, char **argv)
 940 {
 941         extern char *__progname;
 942         in_addr_t listen_ip;
 943 #ifndef WINDOWS32
 944         struct passwd *pw;
 945 #endif
 946         int foreground;
 947         char *username;
 948         char *newroot;
 949         char *device;
 950         int dnsd_fd;
 951         int tun_fd;
 952
 953         /* settings for forwarding normal DNS to
 954          * local real DNS server */
 955         int bind_fd;
 956         int bind_enable;
 957
 958         int choice;
 959         int port;
 960         int mtu;
 961         int skipipconfig;
 962         char *netsize;
 963
 964         username = NULL;
 965         newroot = NULL;
 966         device = NULL;
 967         foreground = 0;
 968         bind_enable = 0;
 969         bind_fd = 0;
 970         mtu = 1200;
 971         listen_ip = INADDR_ANY;
 972         port = 53;
 973         ns_ip = INADDR_ANY;
 974         check_ip = 1;
 975         skipipconfig = 0;
 976         debug = 0;
 977         netmask = 27;
 978
 979         b32 = get_base32_encoder();
 980
 981 #ifdef WINDOWS32
 982         WSAStartup(req_version, &wsa_data);
 983 #endif
 984
 985 #if !defined(BSD) && !defined(__GLIBC__)
 986         __progname = strrchr(argv[0], '/');
 987         if (__progname == NULL)
 988                 __progname = argv[0];
 989         else
 990                 __progname++;
 991 #endif
 992
 993         memset(password, 0, sizeof(password));
 994         srand(time(NULL));
 995         fw_query_init();
 996
 997         while ((choice = getopt(argc, argv, "vcsfhDu:t:d:m:l:p:n:b:P:")) != -1) {
 998                 switch(choice) {
 999                 case 'v':
1000                         version();
1001                         break;
1002                 case 'c':
1003                         check_ip = 0;
1004                         break;
1005                 case 's':
1006                         skipipconfig = 1;
1007                         break;
1008                 case 'f':
1009                         foreground = 1;
1010                         break;
1011                 case 'h':
1012                         help();
1013                         break;
1014                 case 'D':
1015                         debug++;
1016                         break;
1017                 case 'u':
1018                         username = optarg;
1019                         break;
1020                 case 't':
1021                         newroot = optarg;
1022                         break;
1023                 case 'd':
1024                         device = optarg;
1025                         break;
1026                 case 'm':
1027                         mtu = atoi(optarg);
1028                         break;
1029                 case 'l':
1030                         listen_ip = inet_addr(optarg);
1031                         break;
1032                 case 'p':
1033                         port = atoi(optarg);
1034                         break;
1035                 case 'n':
1036                         ns_ip = inet_addr(optarg);
1037                         break;
1038                 case 'b':
1039                         bind_enable = 1;
1040                         bind_port = atoi(optarg);
1041                         break;
1042                 case 'P':
1043                         strncpy(password, optarg, sizeof(password));
1044                         password[sizeof(password)-1] = 0;
1045
1046                         /* XXX: find better way of cleaning up ps(1) */
1047                         memset(optarg, 0, strlen(optarg));
1048                         break;
1049                 default:
1050                         usage();
1051                         break;
1052                 }
1053         }
1054
1055         argc -= optind;
1056         argv += optind;
1057
1058         check_superuser(usage);
1059
1060         if (argc != 2)
1061                 usage();
1062
1063         netsize = strchr(argv[0], '/');
1064         if (netsize) {
1065                 *netsize = 0;
1066                 netsize++;
1067                 netmask = atoi(netsize);
1068         }
1069
1070         my_ip = inet_addr(argv[0]);
1071
1072         if (my_ip == INADDR_NONE) {
1073                 warnx("Bad IP address to use inside tunnel.\n");
1074                 usage();
1075         }
1076
1077         topdomain = strdup(argv[1]);
1078         if(strlen(topdomain) <= 128) {
1079                 if(check_topdomain(topdomain)) {
1080                         warnx("Topdomain contains invalid characters.\n");
1081                         usage();
1082                 }
1083         } else {
1084                 warnx("Use a topdomain max 128 chars long.\n");
1085                 usage();
1086         }
1087
1088         if (username != NULL) {
1089 #ifndef WINDOWS32
1090                 if ((pw = getpwnam(username)) == NULL) {
1091                         warnx("User %s does not exist!\n", username);
1092                         usage();
1093                 }
1094 #endif
1095         }
1096
1097         if (mtu <= 0) {
1098                 warnx("Bad MTU given.\n");
1099                 usage();
1100         }
1101
1102         if(port < 1 || port > 65535) {
1103                 warnx("Bad port number given.\n");
1104                 usage();
1105         }
1106
1107         if(bind_enable) {
1108                 if (bind_port < 1 || bind_port > 65535 || bind_port == port) {
1109                         warnx("Bad DNS server port number given.\n");
1110                         usage();
1111                         /* NOTREACHED */
1112                 }
1113                 fprintf(stderr, "Requests for domains outside of %s will be forwarded to port %d\n",
1114                         topdomain, bind_port);
1115         }
1116
1117         if (port != 53) {
1118                 fprintf(stderr, "ALERT! Other dns servers expect you to run on port 53.\n");
1119                 fprintf(stderr, "You must manually forward port 53 to port %d for things to work.\n", port);
1120         }
1121
1122         if (debug) {
1123                 fprintf(stderr, "Debug level %d enabled, will stay in foreground.\n", debug);
1124                 fprintf(stderr, "Add more -D switches to set higher debug level.\n");
1125                 foreground = 1;
1126         }
1127
1128         if (listen_ip == INADDR_NONE) {
1129                 warnx("Bad IP address to listen on.\n");
1130                 usage();
1131         }
1132
1133         if (ns_ip == INADDR_NONE) {
1134                 warnx("Bad IP address to return as nameserver.\n");
1135                 usage();
1136         }
1137         if (netmask > 30 || netmask < 8) {
1138                 warnx("Bad netmask (%d bits). Use 8-30 bits.\n", netmask);
1139                 usage();
1140         }
1141
1142         if (strlen(password) == 0)
1143                 read_password(password, sizeof(password));
1144
1145         if ((tun_fd = open_tun(device)) == -1)
1146                 goto cleanup0;
1147         if (!skipipconfig)
1148                 if (tun_setip(argv[0], netmask) != 0 || tun_setmtu(mtu) != 0)
1149                         goto cleanup1;
1150         if ((dnsd_fd = open_dns(port, listen_ip)) == -1)
1151                 goto cleanup2;
1152         if (bind_enable)
1153                 if ((bind_fd = open_dns(0, INADDR_ANY)) == -1)
1154                         goto cleanup3;
1155
1156         my_mtu = mtu;
1157
1158         created_users = init_users(my_ip, netmask);
1159
1160         if (created_users < USERS) {
1161                 fprintf(stderr, "Limiting to %d simultaneous users because of netmask /%d\n",
1162                         created_users, netmask);
1163         }
1164         fprintf(stderr, "Listening to dns for domain %s\n", topdomain);
1165
1166         if (foreground == 0)
1167                 do_detach();
1168
1169         if (newroot != NULL)
1170                 do_chroot(newroot);
1171
1172         signal(SIGINT, sigint);
1173         if (username != NULL) {
1174 #ifndef WINDOWS32
1175                 gid_t gids[1];
1176                 gids[0] = pw->pw_gid;
1177                 if (setgroups(1, gids) < 0 || setgid(pw->pw_gid) < 0 || setuid(pw->pw_uid) < 0) {
1178                         warnx("Could not switch to user %s!\n", username);
1179                         usage();
1180                 }
1181 #endif
1182         }
1183
1184 #ifndef WINDOWS32
1185         openlog(__progname, LOG_NOWAIT, LOG_DAEMON);
1186 #endif
1187         syslog(LOG_INFO, "started, listening on port %d", port);
1188
1189         tunnel(tun_fd, dnsd_fd, bind_fd);
1190
1191         syslog(LOG_INFO, "stopping");
1192 cleanup3:
1193         close_dns(bind_fd);
1194 cleanup2:
1195         close_dns(dnsd_fd);
1196 cleanup1:
1197         close_tun(tun_fd);
1198 cleanup0:
1199
1200         return 0;
1201 }