xutils.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Copyright 2009, 2010 Daniel Borkmann.
   4  * Copyright 2009, 2010 Emmanuel Roullit.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #define _GNU_SOURCE
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <stdint.h>
  12 #include <fcntl.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15 #include <errno.h>
  16 #include <stdarg.h>
  17 #include <ctype.h>
  18 #include <signal.h>
  19 #include <arpa/inet.h>
  20 #include <time.h>
  21 #include <sched.h>
  22 #include <limits.h>
  23 #include <stdbool.h>
  24 #include <netdb.h>
  25 #include <ifaddrs.h>
  26 #include <sys/time.h>
  27 #include <sys/socket.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/mman.h>
  30 #include <sys/resource.h>
  31 #include <sys/epoll.h>
  32 #include <sys/syscall.h>
  33 #include <asm/unistd.h>
  34 #include <linux/if.h>
  35 #include <linux/socket.h>
  36 #include <linux/types.h>
  37 #include <linux/if_ether.h>
  38 #include <linux/if_packet.h>
  39 #include <linux/sockios.h>
  40 #include <netinet/tcp.h>
  41 #include <netinet/udp.h>
  42
  43 #include "die.h"
  44 #include "str.h"
  45 #include "xutils.h"
  46 #include "ring.h"
  47 #include "built_in.h"
  48
  49 enum {
  50         sock_rmem_max = 0,
  51         sock_rmem_def,
  52         sock_wmem_max,
  53         sock_wmem_def,
  54 };
  55
  56 #define SMEM_SUG_MAX    104857600
  57 #define SMEM_SUG_DEF    4194304
  58
  59 static const char *const to_prio[] = {
  60         "none",
  61         "realtime",
  62         "best-effort",
  63         "idle",
  64 };
  65
  66 static const char *const sock_mem[] = {
  67         "/proc/sys/net/core/rmem_max",
  68         "/proc/sys/net/core/rmem_default",
  69         "/proc/sys/net/core/wmem_max",
  70         "/proc/sys/net/core/wmem_default",
  71 };
  72
  73 int af_socket(int af)
  74 {
  75         int sock;
  76
  77         if (unlikely(af != AF_INET && af != AF_INET6))
  78                 panic("Wrong AF socket type!\n");
  79
  80         sock = socket(af, SOCK_DGRAM, 0);
  81         if (unlikely(sock < 0))
  82                 panic("Creation AF socket failed!\n");
  83
  84         return sock;
  85 }
  86
  87 int pf_socket(void)
  88 {
  89         int sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
  90         if (unlikely(sock < 0))
  91                 panic("Creation of PF socket failed!\n");
  92
  93         return sock;
  94 }
  95
  96 void set_sock_prio(int fd, int prio)
  97 {
  98         int ret, val = prio;
  99
 100         ret = setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &val, sizeof(val));
 101         if (unlikely(ret))
 102                 panic("Cannot set socket priority!\n");
 103 }
 104
 105 void set_nonblocking(int fd)
 106 {
 107         int ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFD, 0) | O_NONBLOCK);
 108         if (unlikely(ret < 0))
 109                 panic("Cannot fcntl!\n");
 110 }
 111
 112 int set_nonblocking_sloppy(int fd)
 113 {
 114         return fcntl(fd, F_SETFL, fcntl(fd, F_GETFD, 0) | O_NONBLOCK);
 115 }
 116
 117 void set_socket_keepalive(int fd)
 118 {
 119         int ret, one = 1;
 120
 121         ret = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one));
 122         if (unlikely(ret))
 123                 panic("Cannot set TCP keepalive!\n");
 124 }
 125
 126 void set_tcp_nodelay(int fd)
 127 {
 128         int one = 1;
 129         setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
 130 }
 131
 132 int set_ipv6_only(int fd)
 133 {
 134         int one = 1;
 135         return setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
 136 }
 137
 138 int set_reuseaddr(int fd)
 139 {
 140         int ret, one = 1;
 141
 142         ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
 143         if (unlikely(ret < 0))
 144                 panic("Cannot reuse addr!\n");
 145
 146         return 0;
 147 }
 148
 149 void set_mtu_disc_dont(int fd)
 150 {
 151         int mtu = IP_PMTUDISC_DONT, ret;
 152
 153         ret = setsockopt(fd, SOL_IP, IP_MTU_DISCOVER, &mtu, sizeof(mtu));
 154         if (unlikely(ret))
 155                 panic("Cannot set MTU discovery options!\n");
 156 }
 157
 158 void set_epoll_descriptor(int fd_epoll, int action, int fd_toadd, int events)
 159 {
 160         int ret;
 161         struct epoll_event ev;
 162
 163         memset(&ev, 0, sizeof(ev));
 164         ev.events = events;
 165         ev.data.fd = fd_toadd;
 166
 167         ret = epoll_ctl(fd_epoll, action, fd_toadd, &ev);
 168         if (ret < 0)
 169                 panic("Cannot add socket for epoll!\n");
 170 }
 171
 172 int set_epoll_descriptor2(int fd_epoll, int action, int fd_toadd, int events)
 173 {
 174         struct epoll_event ev;
 175
 176         memset(&ev, 0, sizeof(ev));
 177         ev.events = events;
 178         ev.data.fd = fd_toadd;
 179
 180         return epoll_ctl(fd_epoll, action, fd_toadd, &ev);
 181 }
 182
 183 u32 wireless_bitrate(const char *ifname)
 184 {
 185         int sock, ret, rate_in_mbit;
 186         struct iwreq iwr;
 187
 188         sock = af_socket(AF_INET);
 189
 190         memset(&iwr, 0, sizeof(iwr));
 191         strlcpy(iwr.ifr_name, ifname, IFNAMSIZ);
 192
 193         ret = ioctl(sock, SIOCGIWRATE, &iwr);
 194         if (!ret)
 195                 rate_in_mbit = iwr.u.bitrate.value / 1000000;
 196         else
 197                 rate_in_mbit = 0;
 198
 199         close(sock);
 200
 201         return rate_in_mbit;
 202 }
 203
 204 int get_system_socket_mem(int which)
 205 {
 206         int fd, val = -1;
 207         ssize_t ret;
 208         const char *file = sock_mem[which];
 209         char buff[64];
 210
 211         fd = open(file, O_RDONLY);
 212         if (fd < 0)
 213                 return val;
 214
 215         ret = read(fd, buff, sizeof(buff));
 216         if (ret > 0)
 217                 val = atoi(buff);
 218
 219         close(fd);
 220         return val;
 221 }
 222
 223 void set_system_socket_mem(int which, int val)
 224 {
 225         int fd;
 226         const char *file = sock_mem[which];
 227         ssize_t ret;
 228         char buff[64];
 229
 230         fd = open(file, O_WRONLY);
 231         if (fd < 0)
 232                 return;
 233
 234         memset(buff, 0, sizeof(buff));
 235         slprintf(buff, sizeof(buff), "%d", val);
 236
 237         ret = write(fd, buff, strlen(buff));
 238         ret = ret;
 239
 240         close(fd);
 241 }
 242
 243 int wireless_sigqual(const char *ifname, struct iw_statistics *stats)
 244 {
 245         int ret, sock;
 246         struct iwreq iwr;
 247
 248         sock = af_socket(AF_INET);
 249
 250         memset(&iwr, 0, sizeof(iwr));
 251         strlcpy(iwr.ifr_name, ifname, IFNAMSIZ);
 252
 253         iwr.u.data.pointer = (caddr_t) stats;
 254         iwr.u.data.length = sizeof(*stats);
 255         iwr.u.data.flags = 1;
 256
 257         ret = ioctl(sock, SIOCGIWSTATS, &iwr);
 258
 259         close(sock);
 260
 261         return ret;
 262 }
 263
 264 int wireless_rangemax_sigqual(const char *ifname)
 265 {
 266         int ret, sock, sigqual;
 267         struct iwreq iwr;
 268         struct iw_range iwrange;
 269
 270         sock = af_socket(AF_INET);
 271
 272         memset(&iwrange, 0, sizeof(iwrange));
 273
 274         memset(&iwr, 0, sizeof(iwr));
 275         strlcpy(iwr.ifr_name, ifname, IFNAMSIZ);
 276
 277         iwr.u.data.pointer = (caddr_t) &iwrange;
 278         iwr.u.data.length = sizeof(iwrange);
 279         iwr.u.data.flags = 0;
 280
 281         ret = ioctl(sock, SIOCGIWRANGE, &iwr);
 282         if (!ret)
 283                 sigqual = iwrange.max_qual.qual;
 284         else
 285                 sigqual = 0;
 286
 287         close(sock);
 288
 289         return sigqual;
 290 }
 291
 292 u32 ethtool_bitrate(const char *ifname)
 293 {
 294         int ret, sock, bitrate;
 295         struct ifreq ifr;
 296         struct ethtool_cmd ecmd;
 297
 298         sock = af_socket(AF_INET);
 299
 300         memset(&ecmd, 0, sizeof(ecmd));
 301
 302         memset(&ifr, 0, sizeof(ifr));
 303         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 304
 305         ecmd.cmd = ETHTOOL_GSET;
 306         ifr.ifr_data = (char *) &ecmd;
 307
 308         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 309         if (ret) {
 310                 bitrate = 0;
 311                 goto out;
 312         }
 313
 314         switch (ecmd.speed) {
 315         case SPEED_10:
 316         case SPEED_100:
 317         case SPEED_1000:
 318         case SPEED_2500:
 319         case SPEED_10000:
 320                 bitrate = ecmd.speed;
 321                 break;
 322         default:
 323                 bitrate = 0;
 324                 break;
 325         };
 326 out:
 327         close(sock);
 328
 329         return bitrate;
 330 }
 331
 332 int ethtool_link(const char *ifname)
 333 {
 334         int ret, sock;
 335         struct ifreq ifr;
 336         struct ethtool_value ecmd;
 337
 338         sock = af_socket(AF_INET);
 339
 340         memset(&ecmd, 0, sizeof(ecmd));
 341
 342         memset(&ifr, 0, sizeof(ifr));
 343         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 344
 345         ecmd.cmd = ETHTOOL_GLINK;
 346         ifr.ifr_data = (char *) &ecmd;
 347
 348         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 349         if (ret)
 350                 ret = -EINVAL;
 351         else
 352                 ret = !!ecmd.data;
 353
 354         close(sock);
 355         return ret;
 356 }
 357
 358 int ethtool_drvinf(const char *ifname, struct ethtool_drvinfo *drvinf)
 359 {
 360         int ret, sock;
 361         struct ifreq ifr;
 362
 363         sock = af_socket(AF_INET);
 364
 365         memset(drvinf, 0, sizeof(*drvinf));
 366
 367         memset(&ifr, 0, sizeof(ifr));
 368         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 369
 370         drvinf->cmd = ETHTOOL_GDRVINFO;
 371         ifr.ifr_data = (char *) drvinf;
 372
 373         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 374
 375         close(sock);
 376
 377         return ret;
 378 }
 379
 380 void register_signal(int signal, void (*handler)(int))
 381 {
 382         sigset_t block_mask;
 383         struct sigaction saction;
 384
 385         sigfillset(&block_mask);
 386
 387         saction.sa_handler = handler;
 388         saction.sa_mask = block_mask;
 389         saction.sa_flags = SA_RESTART;
 390
 391         sigaction(signal, &saction, NULL);
 392 }
 393
 394 void register_signal_f(int signal, void (*handler)(int), int flags)
 395 {
 396         sigset_t block_mask;
 397         struct sigaction saction;
 398
 399         sigfillset(&block_mask);
 400
 401         saction.sa_handler = handler;
 402         saction.sa_mask = block_mask;
 403         saction.sa_flags = flags;
 404
 405         sigaction(signal, &saction, NULL);
 406 }
 407
 408 void cpu_affinity(int cpu)
 409 {
 410         int ret;
 411         cpu_set_t cpu_bitmask;
 412
 413         CPU_ZERO(&cpu_bitmask);
 414         CPU_SET(cpu, &cpu_bitmask);
 415
 416         ret = sched_setaffinity(getpid(), sizeof(cpu_bitmask),
 417                                 &cpu_bitmask);
 418         if (ret)
 419                 panic("Can't set this cpu affinity!\n");
 420 }
 421
 422 int set_proc_prio(int priority)
 423 {
 424         int ret = setpriority(PRIO_PROCESS, getpid(), priority);
 425         if (ret)
 426                 panic("Can't set nice val to %i!\n", priority);
 427
 428         return 0;
 429 }
 430
 431 int set_sched_status(int policy, int priority)
 432 {
 433         int ret, min_prio, max_prio;
 434         struct sched_param sp;
 435
 436         max_prio = sched_get_priority_max(policy);
 437         min_prio = sched_get_priority_min(policy);
 438
 439         if (max_prio == -1 || min_prio == -1)
 440                 printf("Cannot determine scheduler prio limits!\n");
 441         else if (priority < min_prio)
 442                 priority = min_prio;
 443         else if (priority > max_prio)
 444                 priority = max_prio;
 445
 446         memset(&sp, 0, sizeof(sp));
 447         sp.sched_priority = priority;
 448
 449         ret = sched_setscheduler(getpid(), policy, &sp);
 450         if (ret) {
 451                 printf("Cannot set scheduler policy!\n");
 452                 return -EINVAL;
 453         }
 454
 455         ret = sched_setparam(getpid(), &sp);
 456         if (ret) {
 457                 printf("Cannot set scheduler prio!\n");
 458                 return -EINVAL;
 459         }
 460
 461         return 0;
 462 }
 463
 464 int get_default_sched_policy(void)
 465 {
 466         return SCHED_FIFO;
 467 }
 468
 469 int get_default_sched_prio(void)
 470 {
 471         return sched_get_priority_max(get_default_sched_policy());
 472 }
 473
 474 int get_default_proc_prio(void)
 475 {
 476         return -20;
 477 }
 478
 479 void set_system_socket_memory(int *vals, size_t len)
 480 {
 481         bug_on(len != 4);
 482
 483         if ((vals[0] = get_system_socket_mem(sock_rmem_max)) < SMEM_SUG_MAX)
 484                 set_system_socket_mem(sock_rmem_max, SMEM_SUG_MAX);
 485         if ((vals[1] = get_system_socket_mem(sock_rmem_def)) < SMEM_SUG_DEF)
 486                 set_system_socket_mem(sock_rmem_def, SMEM_SUG_DEF);
 487         if ((vals[2] = get_system_socket_mem(sock_wmem_max)) < SMEM_SUG_MAX)
 488                 set_system_socket_mem(sock_wmem_max, SMEM_SUG_MAX);
 489         if ((vals[3] = get_system_socket_mem(sock_wmem_def)) < SMEM_SUG_DEF)
 490                 set_system_socket_mem(sock_wmem_def, SMEM_SUG_DEF);
 491 }
 492
 493 void reset_system_socket_memory(int *vals, size_t len)
 494 {
 495         bug_on(len != 4);
 496
 497         set_system_socket_mem(sock_rmem_max, vals[0]);
 498         set_system_socket_mem(sock_rmem_def, vals[1]);
 499         set_system_socket_mem(sock_wmem_max, vals[2]);
 500         set_system_socket_mem(sock_wmem_def, vals[3]);
 501 }
 502
 503 void set_itimer_interval_value(struct itimerval *itimer, unsigned long sec,
 504                                unsigned long usec)
 505 {
 506         itimer->it_interval.tv_sec = sec;
 507         itimer->it_interval.tv_usec = usec;
 508
 509         itimer->it_value.tv_sec = sec;
 510         itimer->it_value.tv_usec = usec;
 511 }