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 void drop_privileges(bool enforce, uid_t uid, gid_t gid)
 205 {
 206         if (enforce) {
 207                 if (uid == getuid())
 208                         panic("Uid cannot be the same as the current user!\n");
 209                 if (gid == getgid())
 210                         panic("Gid cannot be the same as the current user!\n");
 211         }
 212         if (setgid(gid) != 0)
 213                 panic("Unable to drop group privileges: %s!\n", strerror(errno));
 214         if (setuid(uid) != 0)
 215                 panic("Unable to drop user privileges: %s!\n", strerror(errno));
 216 }
 217
 218 int get_system_socket_mem(int which)
 219 {
 220         int fd, val = -1;
 221         ssize_t ret;
 222         const char *file = sock_mem[which];
 223         char buff[64];
 224
 225         fd = open(file, O_RDONLY);
 226         if (fd < 0)
 227                 return val;
 228
 229         ret = read(fd, buff, sizeof(buff));
 230         if (ret > 0)
 231                 val = atoi(buff);
 232
 233         close(fd);
 234         return val;
 235 }
 236
 237 void set_system_socket_mem(int which, int val)
 238 {
 239         int fd;
 240         const char *file = sock_mem[which];
 241         ssize_t ret;
 242         char buff[64];
 243
 244         fd = open(file, O_WRONLY);
 245         if (fd < 0)
 246                 return;
 247
 248         memset(buff, 0, sizeof(buff));
 249         slprintf(buff, sizeof(buff), "%d", val);
 250
 251         ret = write(fd, buff, strlen(buff));
 252         ret = ret;
 253
 254         close(fd);
 255 }
 256
 257 int wireless_sigqual(const char *ifname, struct iw_statistics *stats)
 258 {
 259         int ret, sock;
 260         struct iwreq iwr;
 261
 262         sock = af_socket(AF_INET);
 263
 264         memset(&iwr, 0, sizeof(iwr));
 265         strlcpy(iwr.ifr_name, ifname, IFNAMSIZ);
 266
 267         iwr.u.data.pointer = (caddr_t) stats;
 268         iwr.u.data.length = sizeof(*stats);
 269         iwr.u.data.flags = 1;
 270
 271         ret = ioctl(sock, SIOCGIWSTATS, &iwr);
 272
 273         close(sock);
 274
 275         return ret;
 276 }
 277
 278 int wireless_rangemax_sigqual(const char *ifname)
 279 {
 280         int ret, sock, sigqual;
 281         struct iwreq iwr;
 282         struct iw_range iwrange;
 283
 284         sock = af_socket(AF_INET);
 285
 286         memset(&iwrange, 0, sizeof(iwrange));
 287
 288         memset(&iwr, 0, sizeof(iwr));
 289         strlcpy(iwr.ifr_name, ifname, IFNAMSIZ);
 290
 291         iwr.u.data.pointer = (caddr_t) &iwrange;
 292         iwr.u.data.length = sizeof(iwrange);
 293         iwr.u.data.flags = 0;
 294
 295         ret = ioctl(sock, SIOCGIWRANGE, &iwr);
 296         if (!ret)
 297                 sigqual = iwrange.max_qual.qual;
 298         else
 299                 sigqual = 0;
 300
 301         close(sock);
 302
 303         return sigqual;
 304 }
 305
 306 u32 ethtool_bitrate(const char *ifname)
 307 {
 308         int ret, sock, bitrate;
 309         struct ifreq ifr;
 310         struct ethtool_cmd ecmd;
 311
 312         sock = af_socket(AF_INET);
 313
 314         memset(&ecmd, 0, sizeof(ecmd));
 315
 316         memset(&ifr, 0, sizeof(ifr));
 317         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 318
 319         ecmd.cmd = ETHTOOL_GSET;
 320         ifr.ifr_data = (char *) &ecmd;
 321
 322         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 323         if (ret) {
 324                 bitrate = 0;
 325                 goto out;
 326         }
 327
 328         switch (ecmd.speed) {
 329         case SPEED_10:
 330         case SPEED_100:
 331         case SPEED_1000:
 332         case SPEED_2500:
 333         case SPEED_10000:
 334                 bitrate = ecmd.speed;
 335                 break;
 336         default:
 337                 bitrate = 0;
 338                 break;
 339         };
 340 out:
 341         close(sock);
 342
 343         return bitrate;
 344 }
 345
 346 int ethtool_link(const char *ifname)
 347 {
 348         int ret, sock;
 349         struct ifreq ifr;
 350         struct ethtool_value ecmd;
 351
 352         sock = af_socket(AF_INET);
 353
 354         memset(&ecmd, 0, sizeof(ecmd));
 355
 356         memset(&ifr, 0, sizeof(ifr));
 357         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 358
 359         ecmd.cmd = ETHTOOL_GLINK;
 360         ifr.ifr_data = (char *) &ecmd;
 361
 362         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 363         if (ret)
 364                 ret = -EINVAL;
 365         else
 366                 ret = !!ecmd.data;
 367
 368         close(sock);
 369         return ret;
 370 }
 371
 372 int ethtool_drvinf(const char *ifname, struct ethtool_drvinfo *drvinf)
 373 {
 374         int ret, sock;
 375         struct ifreq ifr;
 376
 377         sock = af_socket(AF_INET);
 378
 379         memset(drvinf, 0, sizeof(*drvinf));
 380
 381         memset(&ifr, 0, sizeof(ifr));
 382         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 383
 384         drvinf->cmd = ETHTOOL_GDRVINFO;
 385         ifr.ifr_data = (char *) drvinf;
 386
 387         ret = ioctl(sock, SIOCETHTOOL, &ifr);
 388
 389         close(sock);
 390
 391         return ret;
 392 }
 393
 394 void register_signal(int signal, void (*handler)(int))
 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 = SA_RESTART;
 404
 405         sigaction(signal, &saction, NULL);
 406 }
 407
 408 void register_signal_f(int signal, void (*handler)(int), int flags)
 409 {
 410         sigset_t block_mask;
 411         struct sigaction saction;
 412
 413         sigfillset(&block_mask);
 414
 415         saction.sa_handler = handler;
 416         saction.sa_mask = block_mask;
 417         saction.sa_flags = flags;
 418
 419         sigaction(signal, &saction, NULL);
 420 }
 421
 422 void cpu_affinity(int cpu)
 423 {
 424         int ret;
 425         cpu_set_t cpu_bitmask;
 426
 427         CPU_ZERO(&cpu_bitmask);
 428         CPU_SET(cpu, &cpu_bitmask);
 429
 430         ret = sched_setaffinity(getpid(), sizeof(cpu_bitmask),
 431                                 &cpu_bitmask);
 432         if (ret)
 433                 panic("Can't set this cpu affinity!\n");
 434 }
 435
 436 int set_proc_prio(int priority)
 437 {
 438         int ret = setpriority(PRIO_PROCESS, getpid(), priority);
 439         if (ret)
 440                 panic("Can't set nice val to %i!\n", priority);
 441
 442         return 0;
 443 }
 444
 445 int set_sched_status(int policy, int priority)
 446 {
 447         int ret, min_prio, max_prio;
 448         struct sched_param sp;
 449
 450         max_prio = sched_get_priority_max(policy);
 451         min_prio = sched_get_priority_min(policy);
 452
 453         if (max_prio == -1 || min_prio == -1)
 454                 printf("Cannot determine scheduler prio limits!\n");
 455         else if (priority < min_prio)
 456                 priority = min_prio;
 457         else if (priority > max_prio)
 458                 priority = max_prio;
 459
 460         memset(&sp, 0, sizeof(sp));
 461         sp.sched_priority = priority;
 462
 463         ret = sched_setscheduler(getpid(), policy, &sp);
 464         if (ret) {
 465                 printf("Cannot set scheduler policy!\n");
 466                 return -EINVAL;
 467         }
 468
 469         ret = sched_setparam(getpid(), &sp);
 470         if (ret) {
 471                 printf("Cannot set scheduler prio!\n");
 472                 return -EINVAL;
 473         }
 474
 475         return 0;
 476 }
 477
 478 int get_default_sched_policy(void)
 479 {
 480         return SCHED_FIFO;
 481 }
 482
 483 int get_default_sched_prio(void)
 484 {
 485         return sched_get_priority_max(get_default_sched_policy());
 486 }
 487
 488 int get_default_proc_prio(void)
 489 {
 490         return -20;
 491 }
 492
 493 void set_system_socket_memory(int *vals, size_t len)
 494 {
 495         bug_on(len != 4);
 496
 497         if ((vals[0] = get_system_socket_mem(sock_rmem_max)) < SMEM_SUG_MAX)
 498                 set_system_socket_mem(sock_rmem_max, SMEM_SUG_MAX);
 499         if ((vals[1] = get_system_socket_mem(sock_rmem_def)) < SMEM_SUG_DEF)
 500                 set_system_socket_mem(sock_rmem_def, SMEM_SUG_DEF);
 501         if ((vals[2] = get_system_socket_mem(sock_wmem_max)) < SMEM_SUG_MAX)
 502                 set_system_socket_mem(sock_wmem_max, SMEM_SUG_MAX);
 503         if ((vals[3] = get_system_socket_mem(sock_wmem_def)) < SMEM_SUG_DEF)
 504                 set_system_socket_mem(sock_wmem_def, SMEM_SUG_DEF);
 505 }
 506
 507 void reset_system_socket_memory(int *vals, size_t len)
 508 {
 509         bug_on(len != 4);
 510
 511         set_system_socket_mem(sock_rmem_max, vals[0]);
 512         set_system_socket_mem(sock_rmem_def, vals[1]);
 513         set_system_socket_mem(sock_wmem_max, vals[2]);
 514         set_system_socket_mem(sock_wmem_def, vals[3]);
 515 }
 516
 517 void set_itimer_interval_value(struct itimerval *itimer, unsigned long sec,
 518                                unsigned long usec)
 519 {
 520         itimer->it_interval.tv_sec = sec;
 521         itimer->it_interval.tv_usec = usec;
 522
 523         itimer->it_value.tv_sec = sec;
 524         itimer->it_value.tv_usec = usec;
 525 }