components/netspeeds.c

   1 /* See LICENSE file for copyright and license details. */
   2 #include <stdio.h>
   3 #include <limits.h>
   4
   5 #include "../util.h"
   6
   7 #if defined(__linux__)
   8         #include <stdint.h>
   9
  10         const char *
  11         netspeed_rx(const char *interface)
  12         {
  13                 uint64_t oldrxbytes;
  14                 static uint64_t rxbytes = 0;
  15                 extern const unsigned int interval;
  16                 char path[PATH_MAX];
  17
  18                 oldrxbytes = rxbytes;
  19
  20                 snprintf(path, sizeof(path),
  21                          "/sys/class/net/%s/statistics/rx_bytes", interface);
  22                 if (pscanf(path, "%llu", &rxbytes) != 1) {
  23                         return NULL;
  24                 }
  25
  26                 return oldrxbytes ? fmt_scaled((rxbytes - oldrxbytes) /
  27                                                interval * 1000) : NULL;
  28         }
  29
  30         const char *
  31         netspeed_tx(const char *interface)
  32         {
  33                 uint64_t oldtxbytes;
  34                 static uint64_t txbytes = 0;
  35                 extern const unsigned int interval;
  36                 char path[PATH_MAX];
  37
  38                 oldtxbytes = txbytes;
  39
  40                 snprintf(path, sizeof(path),
  41                          "/sys/class/net/%s/statistics/tx_bytes", interface);
  42                 if (pscanf(path, "%llu", &txbytes) != 1) {
  43                         return NULL;
  44                 }
  45
  46                 return oldtxbytes ? fmt_scaled((txbytes - oldtxbytes) /
  47                                                interval * 1000) : NULL;
  48         }
  49 #elif defined(__OpenBSD__)
  50         #include <string.h>
  51         #include <ifaddrs.h>
  52         #include <sys/types.h>
  53         #include <sys/socket.h>
  54         #include <net/if.h>
  55
  56         const char *
  57         netspeed_rx(const char *interface)
  58         {
  59                 struct ifaddrs *ifal, *ifa;
  60                 struct if_data *ifd;
  61                 uint64_t oldrxbytes;
  62                 static uint64_t rxbytes = 0;
  63                 extern const unsigned int interval;
  64                 char if_ok = 0;
  65
  66                 if (getifaddrs(&ifal) == -1) {
  67                         warn("getifaddrs failed");
  68                         return NULL;
  69                 }
  70                 oldrxbytes = rxbytes;
  71                 for (ifa = ifal; ifa; ifa = ifa->ifa_next) {
  72                         if (!strcmp(ifa->ifa_name, interface) &&
  73                            (ifd = (struct if_data *)ifa->ifa_data)) {
  74                                 rxbytes += ifd->ifi_ibytes, if_ok = 1;
  75                         }
  76                 }
  77                 freeifaddrs(ifal);
  78                 if (!if_ok) {
  79                         warn("reading 'if_data' failed");
  80                         return NULL;
  81                 }
  82
  83                 return oldrxbytes ? fmt_scaled((rxbytes - oldrxbytes) /
  84                                                interval * 1000) : NULL;
  85         }
  86
  87         const char *
  88         netspeed_tx(const char *interface)
  89         {
  90                 struct ifaddrs *ifal, *ifa;
  91                 struct if_data *ifd;
  92                 uint64_t oldtxbytes;
  93                 static uint64_t txbytes = 0;
  94                 extern const unsigned int interval;
  95                 char if_ok = 0;
  96
  97                 if (getifaddrs(&ifal) == -1) {
  98                         warn("getifaddrs failed");
  99                         return NULL;
 100                 }
 101                 oldtxbytes = txbytes;
 102                 for (ifa = ifal; ifa; ifa = ifa->ifa_next) {
 103                         if (!strcmp(ifa->ifa_name, interface) &&
 104                            (ifd = (struct if_data *)ifa->ifa_data)) {
 105                                 txbytes += ifd->ifi_obytes, if_ok = 1;
 106                         }
 107                 }
 108                 freeifaddrs(ifal);
 109                 if (!if_ok) {
 110                         warn("reading 'if_data' failed");
 111                         return NULL;
 112                 }
 113
 114                 return oldtxbytes ? fmt_scaled((txbytes - oldtxbytes) /
 115                                                interval * 1000) : NULL;
 116         }
 117 #endif