src/aslookup.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2011 Daniel Borkmann.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <errno.h>
  12 #include <netdb.h>
  13 #include <netinet/in.h>
  14
  15 #include "die.h"
  16 #include "xstring.h"
  17 #include "aslookup.h"
  18 #include "xmalloc.h"
  19 #include "built_in.h"
  20
  21 static int ai_family = 0;
  22 static int ai_socktype = 0;
  23 static int ai_protocol = 0;
  24 static struct sockaddr_storage ai_ss;
  25
  26 int aslookup_prepare(const char *server, const char *port)
  27 {
  28         int ret, fd = -1, try = 1;
  29         struct addrinfo hints, *ahead, *ai;
  30         struct sockaddr_in6 *saddr6;
  31
  32         bug_on(!server || !port);
  33
  34         memset(&ai_ss, 0, sizeof(ai_ss));
  35         memset(&hints, 0, sizeof(hints));
  36
  37         hints.ai_family = PF_UNSPEC;
  38         hints.ai_socktype = SOCK_STREAM;
  39         hints.ai_protocol = IPPROTO_TCP;
  40         hints.ai_flags = AI_NUMERICSERV;
  41
  42         ret = getaddrinfo(server, port, &hints, &ahead);
  43         if (ret != 0) {
  44                 whine("Cannot get address info!\n");
  45                 return -EIO;
  46         }
  47
  48         for (ai = ahead; ai != NULL && fd < 0; ai = ai->ai_next) {
  49                 if (ai->ai_family == PF_INET6)
  50                         saddr6 = (struct sockaddr_in6 *) ai->ai_addr;
  51                 fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
  52                 if (fd < 0)
  53                         continue;
  54                 ret = connect(fd, ai->ai_addr, ai->ai_addrlen);
  55                 if (ret < 0) {
  56                         whine("Cannot connect to remote, try %d: %s!\n",
  57                               try++, strerror(errno));
  58                         close(fd);
  59                         fd = -1;
  60                         continue;
  61                 }
  62
  63                 ai_family = ai->ai_family;
  64                 ai_socktype = ai->ai_socktype;
  65                 ai_protocol = ai->ai_protocol;
  66                 memcpy(&ai_ss, ai->ai_addr, ai->ai_addrlen);
  67
  68                 close(fd);
  69                 break;
  70         }
  71
  72         freeaddrinfo(ahead);
  73         return 0;
  74 }
  75
  76 int aslookup(const char *lhost, struct asrecord *rec)
  77 {
  78         int ret, err, fd = -1;
  79         char *buff;
  80         size_t len = 1024;
  81
  82         bug_on(strlen(lhost) + 8 >= len);
  83
  84         fd = socket(ai_family, ai_socktype, ai_protocol);
  85         if (fd < 0)
  86                 return -EIO;
  87
  88         ret = connect(fd, (struct sockaddr *) &ai_ss, sizeof(ai_ss));
  89         if (ret < 0)
  90                 return -EIO;
  91
  92         buff = xzmalloc(len);
  93         slprintf(buff, len, "-v -f %s\r\n", lhost);
  94
  95         err = write(fd, buff, strlen(buff));
  96         if (unlikely(err < 0)) {
  97                 whine("Cannot write to socket!\n");
  98                 close(fd);
  99                 xfree(buff);
 100                 return err;
 101         }
 102
 103         memset(buff, 0, len);
 104         while ((err = read(fd, buff, len)) > 0) {
 105                 int state = 0, i;
 106                 char *ptr = skips(buff), *ptr2;
 107
 108                 for (i = 0; i < len; ++i) {
 109                         if (buff[i] == '|' && state == 0) {
 110                                 buff[i] = 0;
 111                                 ptr2 = &buff[i] - 1;
 112
 113                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 114                                         *ptr2 = 0;
 115                                         ptr2--;
 116                                 }
 117
 118                                 strlcpy(rec->number, ptr, strlen(ptr) + 1);
 119                                 ptr = skips(&buff[i] + 1);
 120                                 state = 1;
 121                         } else if (buff[i] == '|' && state == 1) {
 122                                 buff[i] = 0;
 123                                 ptr2 = &buff[i] - 1;
 124
 125                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 126                                         *ptr2 = 0;
 127                                         ptr2--;
 128                                 }
 129
 130                                 strlcpy(rec->ip, ptr, strlen(ptr) + 1);
 131                                 ptr = skips(&buff[i] + 1);
 132                                 state = 2;
 133                         } else if (buff[i] == '|' && state == 2) {
 134                                 buff[i] = 0;
 135                                 ptr2 = &buff[i] - 1;
 136
 137                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 138                                         *ptr2 = 0;
 139                                         ptr2--;
 140                                 }
 141
 142                                 strlcpy(rec->prefix, ptr, strlen(ptr) + 1);
 143                                 ptr = skips(&buff[i] + 1);
 144                                 state = 3;
 145                         } else if (buff[i] == '|' && state == 3) {
 146                                 buff[i] = 0;
 147                                 ptr2 = &buff[i] - 1;
 148
 149                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 150                                         *ptr2 = 0;
 151                                         ptr2--;
 152                                 }
 153
 154                                 strlcpy(rec->country, ptr, strlen(ptr) + 1);
 155                                 ptr = skips(&buff[i] + 1);
 156                                 state = 4;
 157                         } else if (buff[i] == '|' && state == 4) {
 158                                 buff[i] = 0;
 159                                 ptr2 = &buff[i] - 1;
 160
 161                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 162                                         *ptr2 = 0;
 163                                         ptr2--;
 164                                 }
 165
 166                                 strlcpy(rec->registry, ptr, strlen(ptr) + 1);
 167                                 ptr = skips(&buff[i] + 1);
 168                                 state = 5;
 169                         } else if (buff[i] == '|' && state == 5) {
 170                                 buff[i] = 0;
 171                                 ptr2 = &buff[i] - 1;
 172
 173                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 174                                         *ptr2 = 0;
 175                                         ptr2--;
 176                                 }
 177
 178                                 strlcpy(rec->since, ptr, strlen(ptr) + 1);
 179                                 ptr = skips(&buff[i] + 1);
 180                                 state = 6;
 181                         } else if (buff[i] == '\n' && state == 6) {
 182                                 buff[i] = 0;
 183                                 ptr2 = &buff[i] - 1;
 184
 185                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 186                                         *ptr2 = 0;
 187                                         ptr2--;
 188                                 }
 189
 190                                 strlcpy(rec->name, ptr, strlen(ptr) + 1);
 191                                 goto out;
 192                         }
 193                 }
 194
 195                 memset(buff, 0, len);
 196         }
 197 out:
 198         close(fd);
 199         xfree(buff);
 200         return 0;
 201 }