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                 for (ifa = ifal; ifa; ifa = ifa->ifa_next) {
  71                         if (!strcmp(ifa->ifa_name, interface) &&
  72                            (ifd = (struct if_data *)ifa->ifa_data)) {
  73                                 rxbytes += ifd->ifi_ibytes, if_ok = 1;
  74                         }
  75                 }
  76                 freeifaddrs(ifal);
  77                 if (!if_ok) {
  78                         warn("reading 'if_data' failed");
  79                         return NULL;
  80                 }
  81
  82                 return oldrxbytes ? fmt_scaled((rxbytes - oldrxbytes) /
  83                                                interval * 1000) : NULL;
  84         }
  85
  86         const char *
  87         netspeed_tx(const char *interface)
  88         {
  89                 struct ifaddrs *ifal, *ifa;
  90                 struct if_data *ifd;
  91                 uint64_t oldtxbytes;
  92                 static uint64_t txbytes = 0;
  93                 extern const unsigned int interval;
  94                 char if_ok = 0;
  95
  96                 if (getifaddrs(&ifal) == -1) {
  97                         warn("getifaddrs failed");
  98                         return NULL;
  99                 }
 100                 for (ifa = ifal; ifa; ifa = ifa->ifa_next) {
 101                         if (!strcmp(ifa->ifa_name, interface) &&
 102                            (ifd = (struct if_data *)ifa->ifa_data)) {
 103                                 txbytes += ifd->ifi_obytes, if_ok = 1;
 104                         }
 105                 }
 106                 freeifaddrs(ifal);
 107                 if (!if_ok) {
 108                         warn("reading 'if_data' failed");
 109                         return NULL;
 110                 }
 111
 112                 return oldtxbytes ? fmt_scaled((txbytes - oldtxbytes) /
 113                                                interval * 1000) : NULL;
 114         }
 115 #endif