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 enum parser_state {
  22         STATE_AS,
  23         STATE_IP,
  24         STATE_BGP_PREFIX,
  25         STATE_CC,
  26         STATE_REGISTRY,
  27         STATE_ALLOCATED,
  28         STATE_AS_NAME,
  29 };
  30
  31 static int ai_family = 0, ai_socktype = 0, ai_protocol = 0;
  32 static struct sockaddr_storage ai_ss;
  33
  34 int aslookup_prepare(const char *server, const char *port)
  35 {
  36         int ret, fd = -1, try = 1;
  37         struct addrinfo hints, *ahead, *ai;
  38
  39         bug_on(!server || !port);
  40
  41         memset(&ai_ss, 0, sizeof(ai_ss));
  42         memset(&hints, 0, sizeof(hints));
  43
  44         hints.ai_family = PF_UNSPEC;
  45         hints.ai_socktype = SOCK_STREAM;
  46         hints.ai_protocol = IPPROTO_TCP;
  47         hints.ai_flags = AI_NUMERICSERV;
  48
  49         ret = getaddrinfo(server, port, &hints, &ahead);
  50         if (ret != 0) {
  51                 whine("Cannot get address info!\n");
  52                 return -EIO;
  53         }
  54
  55         for (ai = ahead; ai != NULL && fd < 0; ai = ai->ai_next) {
  56                 fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
  57                 if (fd < 0)
  58                         continue;
  59
  60                 ret = connect(fd, ai->ai_addr, ai->ai_addrlen);
  61                 if (ret < 0) {
  62                         whine("Cannot connect to remote, try %d: %s!\n",
  63                               try++, strerror(errno));
  64                         close(fd);
  65                         fd = -1;
  66                         continue;
  67                 }
  68
  69                 ai_family = ai->ai_family;
  70                 ai_socktype = ai->ai_socktype;
  71                 ai_protocol = ai->ai_protocol;
  72                 memcpy(&ai_ss, ai->ai_addr, ai->ai_addrlen);
  73
  74                 /* we know details for later connections, close for now */
  75                 close(fd);
  76                 break;
  77         }
  78
  79         freeaddrinfo(ahead);
  80
  81         return 0;
  82 }
  83
  84 int aslookup(const char *lhost, struct asrecord *rec)
  85 {
  86         char *buff;
  87         int ret, fd;
  88         size_t len = 1024;
  89
  90         bug_on(strlen(lhost) + 8 >= len);
  91
  92         fd = socket(ai_family, ai_socktype, ai_protocol);
  93         if (unlikely(fd < 0))
  94                 panic("Cannot create socket!\n");
  95
  96         ret = connect(fd, (struct sockaddr *) &ai_ss, sizeof(ai_ss));
  97         if (unlikely(ret < 0))
  98                 panic("Cannot connect to AS server!\n");
  99
 100         buff = xzmalloc(len);
 101         slprintf(buff, len, "-v -f %s\r\n", lhost);
 102         ret = write(fd, buff, strlen(buff));
 103         if (unlikely(ret < 0))
 104                 panic("Cannot write to AS server!\n");
 105
 106         memset(buff, 0, len);
 107         while ((ret = read(fd, buff, len)) > 0) {
 108                 int i;
 109                 enum parser_state state = STATE_AS;
 110                 char *ptr = skips(buff), *ptr2;
 111
 112                 for (i = 0; i < len; ++i) {
 113                         if (buff[i] == '|' && state == STATE_AS) {
 114                                 buff[i] = 0;
 115                                 ptr2 = &buff[i] - 1;
 116
 117                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 118                                         *ptr2 = 0;
 119                                         ptr2--;
 120                                 }
 121
 122                                 strlcpy(rec->number, ptr, strlen(ptr) + 1);
 123                                 ptr = skips(&buff[i] + 1);
 124                                 state = STATE_IP;
 125                         } else if (buff[i] == '|' && state == STATE_IP) {
 126                                 buff[i] = 0;
 127                                 ptr2 = &buff[i] - 1;
 128
 129                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 130                                         *ptr2 = 0;
 131                                         ptr2--;
 132                                 }
 133
 134                                 strlcpy(rec->ip, ptr, strlen(ptr) + 1);
 135                                 ptr = skips(&buff[i] + 1);
 136                                 state = STATE_BGP_PREFIX;
 137                         } else if (buff[i] == '|' && state == STATE_BGP_PREFIX) {
 138                                 buff[i] = 0;
 139                                 ptr2 = &buff[i] - 1;
 140
 141                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 142                                         *ptr2 = 0;
 143                                         ptr2--;
 144                                 }
 145
 146                                 strlcpy(rec->prefix, ptr, strlen(ptr) + 1);
 147                                 ptr = skips(&buff[i] + 1);
 148                                 state = STATE_CC;
 149                         } else if (buff[i] == '|' && state == STATE_CC) {
 150                                 buff[i] = 0;
 151                                 ptr2 = &buff[i] - 1;
 152
 153                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 154                                         *ptr2 = 0;
 155                                         ptr2--;
 156                                 }
 157
 158                                 strlcpy(rec->country, ptr, strlen(ptr) + 1);
 159                                 ptr = skips(&buff[i] + 1);
 160                                 state = STATE_REGISTRY;
 161                         } else if (buff[i] == '|' && state == STATE_REGISTRY) {
 162                                 buff[i] = 0;
 163                                 ptr2 = &buff[i] - 1;
 164
 165                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 166                                         *ptr2 = 0;
 167                                         ptr2--;
 168                                 }
 169
 170                                 strlcpy(rec->registry, ptr, strlen(ptr) + 1);
 171                                 ptr = skips(&buff[i] + 1);
 172                                 state = STATE_ALLOCATED;
 173                         } else if (buff[i] == '|' && state == STATE_ALLOCATED) {
 174                                 buff[i] = 0;
 175                                 ptr2 = &buff[i] - 1;
 176
 177                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 178                                         *ptr2 = 0;
 179                                         ptr2--;
 180                                 }
 181
 182                                 strlcpy(rec->since, ptr, strlen(ptr) + 1);
 183                                 ptr = skips(&buff[i] + 1);
 184                                 state = 6;
 185                         } else if (buff[i] == '\n' && state == STATE_AS_NAME) {
 186                                 buff[i] = 0;
 187                                 ptr2 = &buff[i] - 1;
 188
 189                                 while (*ptr2 == ' ' && ptr2 > ptr) {
 190                                         *ptr2 = 0;
 191                                         ptr2--;
 192                                 }
 193
 194                                 strlcpy(rec->name, ptr, strlen(ptr) + 1);
 195                                 goto out;
 196                         }
 197                 }
 198
 199                 memset(buff, 0, len);
 200         }
 201 out:
 202         close(fd);
 203         xfree(buff);
 204
 205         return 0;
 206 }