git.sur5r.net Git - i3/i3status/blob - src/print_wireless_info.c

   1 // vim:ts=4:sw=4:expandtab
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <yajl/yajl_gen.h>
   5 #include <yajl/yajl_version.h>
   6
   7 #ifdef LINUX
   8 #include <iwlib.h>
   9 #else
  10 #ifndef __FreeBSD__
  11 #define IW_ESSID_MAX_SIZE 32
  12 #endif
  13 #endif
  14
  15 #ifdef __FreeBSD__
  16 #include <sys/param.h>
  17 #include <sys/ioctl.h>
  18 #include <sys/socket.h>
  19 #include <ifaddrs.h>
  20 #include <net/if.h>
  21 #include <net/if_media.h>
  22 #include <net80211/ieee80211.h>
  23 #include <net80211/ieee80211_ioctl.h>
  24 #include <unistd.h>
  25 #define IW_ESSID_MAX_SIZE IEEE80211_NWID_LEN
  26 #endif
  27
  28 #ifdef __DragonFly__
  29 #include <sys/param.h>
  30 #include <sys/ioctl.h>
  31 #include <sys/socket.h>
  32 #include <ifaddrs.h>
  33 #include <net/if.h>
  34 #include <net/if_media.h>
  35 #include <netproto/802_11/ieee80211.h>
  36 #include <netproto/802_11/ieee80211_ioctl.h>
  37 #include <unistd.h>
  38 #define IW_ESSID_MAX_SIZE IEEE80211_NWID_LEN
  39 #endif
  40
  41 #ifdef __OpenBSD__
  42 #include <sys/ioctl.h>
  43 #include <sys/socket.h>
  44 #include <net/if.h>
  45 #include <sys/types.h>
  46 #include <netinet/in.h>
  47 #include <netinet/if_ether.h>
  48 #include <net80211/ieee80211.h>
  49 #include <net80211/ieee80211_ioctl.h>
  50 #endif
  51
  52 #include "i3status.h"
  53
  54 #define WIRELESS_INFO_FLAG_HAS_ESSID (1 << 0)
  55 #define WIRELESS_INFO_FLAG_HAS_QUALITY (1 << 1)
  56 #define WIRELESS_INFO_FLAG_HAS_SIGNAL (1 << 2)
  57 #define WIRELESS_INFO_FLAG_HAS_NOISE (1 << 3)
  58 #define WIRELESS_INFO_FLAG_HAS_FREQUENCY (1 << 4)
  59
  60 #define PERCENT_VALUE(value, total) ((int)(value * 100 / (float)total + 0.5f))
  61
  62 typedef struct {
  63     int flags;
  64     char essid[IW_ESSID_MAX_SIZE + 1];
  65     int quality;
  66     int quality_max;
  67     int quality_average;
  68     int signal_level;
  69     int signal_level_max;
  70     int noise_level;
  71     int noise_level_max;
  72     int bitrate;
  73     double frequency;
  74 } wireless_info_t;
  75
  76 static int get_wireless_info(const char *interface, wireless_info_t *info) {
  77     memset(info, 0, sizeof(wireless_info_t));
  78
  79 #ifdef LINUX
  80     int skfd = iw_sockets_open();
  81     if (skfd < 0) {
  82         perror("iw_sockets_open");
  83         return 0;
  84     }
  85
  86     wireless_config wcfg;
  87     if (iw_get_basic_config(skfd, interface, &wcfg) < 0) {
  88         close(skfd);
  89         return 0;
  90     }
  91
  92     if (wcfg.has_essid && wcfg.essid_on) {
  93         info->flags |= WIRELESS_INFO_FLAG_HAS_ESSID;
  94         strncpy(&info->essid[0], wcfg.essid, IW_ESSID_MAX_SIZE);
  95         info->essid[IW_ESSID_MAX_SIZE] = '\0';
  96     }
  97
  98     if (wcfg.has_freq) {
  99         info->frequency = wcfg.freq;
 100         info->flags |= WIRELESS_INFO_FLAG_HAS_FREQUENCY;
 101     }
 102
 103     /* If the function iw_get_stats does not return proper stats, the
 104      * wifi is considered as down.
 105      * Since ad-hoc network does not have theses stats, we need to return
 106      * here for this mode. */
 107     if (wcfg.mode == 1) {
 108         close(skfd);
 109         return 1;
 110     }
 111
 112     /* Wireless quality is a relative value in a driver-specific range.
 113      * Signal and noise level can be either relative or absolute values
 114      * in dBm. Furthermore, noise and quality can be expressed directly
 115      * in dBm or in RCPI (802.11k), which we convert to dBm. When those
 116      * values are expressed directly in dBm, they range from -192 to 63,
 117      * and since the values are packed into 8 bits, we need to perform
 118      * 8-bit arithmetic on them. Assume absolute values if everything
 119      * else fails (driver bug). */
 120
 121     iwrange range;
 122     if (iw_get_range_info(skfd, interface, &range) < 0) {
 123         close(skfd);
 124         return 0;
 125     }
 126
 127     iwstats stats;
 128     if (iw_get_stats(skfd, interface, &stats, &range, 1) < 0) {
 129         close(skfd);
 130         return 0;
 131     }
 132
 133     if (stats.qual.level != 0 || (stats.qual.updated & (IW_QUAL_DBM | IW_QUAL_RCPI))) {
 134         if (!(stats.qual.updated & IW_QUAL_QUAL_INVALID)) {
 135             info->quality = stats.qual.qual;
 136             info->quality_max = range.max_qual.qual;
 137             info->quality_average = range.avg_qual.qual;
 138             info->flags |= WIRELESS_INFO_FLAG_HAS_QUALITY;
 139         }
 140
 141         if (stats.qual.updated & IW_QUAL_RCPI) {
 142             if (!(stats.qual.updated & IW_QUAL_LEVEL_INVALID)) {
 143                 info->signal_level = stats.qual.level / 2.0 - 110 + 0.5;
 144                 info->flags |= WIRELESS_INFO_FLAG_HAS_SIGNAL;
 145             }
 146             if (!(stats.qual.updated & IW_QUAL_NOISE_INVALID)) {
 147                 info->noise_level = stats.qual.noise / 2.0 - 110 + 0.5;
 148                 info->flags |= WIRELESS_INFO_FLAG_HAS_NOISE;
 149             }
 150         } else {
 151             if ((stats.qual.updated & IW_QUAL_DBM) || stats.qual.level > range.max_qual.level) {
 152                 if (!(stats.qual.updated & IW_QUAL_LEVEL_INVALID)) {
 153                     info->signal_level = stats.qual.level;
 154                     if (info->signal_level > 63)
 155                         info->signal_level -= 256;
 156                     info->flags |= WIRELESS_INFO_FLAG_HAS_SIGNAL;
 157                 }
 158                 if (!(stats.qual.updated & IW_QUAL_NOISE_INVALID)) {
 159                     info->noise_level = stats.qual.noise;
 160                     if (info->noise_level > 63)
 161                         info->noise_level -= 256;
 162                     info->flags |= WIRELESS_INFO_FLAG_HAS_NOISE;
 163                 }
 164             } else {
 165                 if (!(stats.qual.updated & IW_QUAL_LEVEL_INVALID)) {
 166                     info->signal_level = stats.qual.level;
 167                     info->signal_level_max = range.max_qual.level;
 168                     info->flags |= WIRELESS_INFO_FLAG_HAS_SIGNAL;
 169                 }
 170                 if (!(stats.qual.updated & IW_QUAL_NOISE_INVALID)) {
 171                     info->noise_level = stats.qual.noise;
 172                     info->noise_level_max = range.max_qual.noise;
 173                     info->flags |= WIRELESS_INFO_FLAG_HAS_NOISE;
 174                 }
 175             }
 176         }
 177     } else {
 178         if (!(stats.qual.updated & IW_QUAL_QUAL_INVALID)) {
 179             info->quality = stats.qual.qual;
 180             info->flags |= WIRELESS_INFO_FLAG_HAS_QUALITY;
 181         }
 182         if (!(stats.qual.updated & IW_QUAL_LEVEL_INVALID)) {
 183             info->quality = stats.qual.level;
 184             info->flags |= WIRELESS_INFO_FLAG_HAS_SIGNAL;
 185         }
 186         if (!(stats.qual.updated & IW_QUAL_NOISE_INVALID)) {
 187             info->quality = stats.qual.noise;
 188             info->flags |= WIRELESS_INFO_FLAG_HAS_NOISE;
 189         }
 190     }
 191
 192     struct iwreq wrq;
 193     if (iw_get_ext(skfd, interface, SIOCGIWRATE, &wrq) >= 0)
 194         info->bitrate = wrq.u.bitrate.value;
 195
 196     close(skfd);
 197     return 1;
 198 #endif
 199 #if defined(__FreeBSD__) || defined(__DragonFly__)
 200     int s, inwid;
 201     union {
 202         struct ieee80211req_sta_req req;
 203         uint8_t buf[24 * 1024];
 204     } u;
 205     struct ieee80211req na;
 206     char bssid[IEEE80211_ADDR_LEN];
 207     size_t len;
 208
 209     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
 210         return (0);
 211
 212     memset(&na, 0, sizeof(na));
 213     strlcpy(na.i_name, interface, sizeof(na.i_name));
 214     na.i_type = IEEE80211_IOC_SSID;
 215     na.i_data = &info->essid[0];
 216     na.i_len = IEEE80211_NWID_LEN + 1;
 217     if ((inwid = ioctl(s, SIOCG80211, (caddr_t)&na)) == -1) {
 218         close(s);
 219         return (0);
 220     }
 221     if (inwid == 0) {
 222         if (na.i_len <= IEEE80211_NWID_LEN)
 223             len = na.i_len + 1;
 224         else
 225             len = IEEE80211_NWID_LEN + 1;
 226         info->essid[len - 1] = '\0';
 227     } else {
 228         close(s);
 229         return (0);
 230     }
 231     info->flags |= WIRELESS_INFO_FLAG_HAS_ESSID;
 232
 233     memset(&na, 0, sizeof(na));
 234     strlcpy(na.i_name, interface, sizeof(na.i_name));
 235     na.i_type = IEEE80211_IOC_BSSID;
 236     na.i_data = bssid;
 237     na.i_len = sizeof(bssid);
 238
 239     if (ioctl(s, SIOCG80211, (caddr_t)&na) == -1) {
 240         close(s);
 241         return (0);
 242     }
 243
 244     memcpy(u.req.is_u.macaddr, bssid, sizeof(bssid));
 245     memset(&na, 0, sizeof(na));
 246     strlcpy(na.i_name, interface, sizeof(na.i_name));
 247     na.i_type = IEEE80211_IOC_STA_INFO;
 248     na.i_data = &u;
 249     na.i_len = sizeof(u);
 250
 251     if (ioctl(s, SIOCG80211, (caddr_t)&na) == -1) {
 252         close(s);
 253         return (0);
 254     }
 255
 256     close(s);
 257     if (na.i_len >= sizeof(u.req)) {
 258         /*
 259          * Just use the first BSSID returned even if there are
 260          * multiple APs sharing the same BSSID.
 261          */
 262         info->signal_level = u.req.info[0].isi_rssi / 2 +
 263                              u.req.info[0].isi_noise;
 264         info->flags |= WIRELESS_INFO_FLAG_HAS_SIGNAL;
 265         info->noise_level = u.req.info[0].isi_noise;
 266         info->flags |= WIRELESS_INFO_FLAG_HAS_NOISE;
 267     }
 268
 269     return 1;
 270 #endif
 271 #ifdef __OpenBSD__
 272     struct ifreq ifr;
 273     struct ieee80211_bssid bssid;
 274     struct ieee80211_nwid nwid;
 275     struct ieee80211_nodereq nr;
 276
 277     struct ether_addr ea;
 278
 279     int s, len, ibssid, inwid;
 280     u_int8_t zero_bssid[IEEE80211_ADDR_LEN];
 281
 282     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
 283         return (0);
 284
 285     memset(&ifr, 0, sizeof(ifr));
 286     ifr.ifr_data = (caddr_t)&nwid;
 287     (void)strlcpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name));
 288     inwid = ioctl(s, SIOCG80211NWID, (caddr_t)&ifr);
 289
 290     memset(&bssid, 0, sizeof(bssid));
 291     strlcpy(bssid.i_name, interface, sizeof(bssid.i_name));
 292     ibssid = ioctl(s, SIOCG80211BSSID, &bssid);
 293
 294     if (ibssid != 0 || inwid != 0) {
 295         close(s);
 296         return 0;
 297     }
 298
 299     /* NWID */
 300     {
 301         if (nwid.i_len <= IEEE80211_NWID_LEN)
 302             len = nwid.i_len + 1;
 303         else
 304             len = IEEE80211_NWID_LEN + 1;
 305
 306         strncpy(&info->essid[0], nwid.i_nwid, len);
 307         info->essid[IW_ESSID_MAX_SIZE] = '\0';
 308         info->flags |= WIRELESS_INFO_FLAG_HAS_ESSID;
 309     }
 310
 311     /* Signal strength */
 312     {
 313         memset(&zero_bssid, 0, sizeof(zero_bssid));
 314         if (ibssid == 0 && memcmp(bssid.i_bssid, zero_bssid, IEEE80211_ADDR_LEN) != 0) {
 315             memcpy(&ea.ether_addr_octet, bssid.i_bssid, sizeof(ea.ether_addr_octet));
 316
 317             bzero(&nr, sizeof(nr));
 318             bcopy(bssid.i_bssid, &nr.nr_macaddr, sizeof(nr.nr_macaddr));
 319             strlcpy(nr.nr_ifname, interface, sizeof(nr.nr_ifname));
 320
 321             if (ioctl(s, SIOCG80211NODE, &nr) == 0 && nr.nr_rssi) {
 322                 info->signal_level = nr.nr_rssi;
 323                 if (nr.nr_max_rssi)
 324                     info->signal_level_max = nr.nr_max_rssi;
 325
 326                 info->flags |= WIRELESS_INFO_FLAG_HAS_SIGNAL;
 327             }
 328         }
 329     }
 330
 331     close(s);
 332     return 1;
 333 #endif
 334     return 0;
 335 }
 336
 337 void print_wireless_info(yajl_gen json_gen, char *buffer, const char *interface, const char *format_up, const char *format_down) {
 338     const char *walk;
 339     char *outwalk = buffer;
 340     wireless_info_t info;
 341
 342     INSTANCE(interface);
 343
 344     const char *ip_address = get_ip_addr(interface);
 345     if (ip_address == NULL) {
 346         START_COLOR("color_bad");
 347         outwalk += sprintf(outwalk, "%s", format_down);
 348         goto out;
 349     }
 350
 351     if (get_wireless_info(interface, &info)) {
 352         walk = format_up;
 353         if (info.flags & WIRELESS_INFO_FLAG_HAS_QUALITY)
 354             START_COLOR((info.quality < info.quality_average ? "color_degraded" : "color_good"));
 355         else
 356             START_COLOR((BEGINS_WITH(ip_address, "no IP") ? "color_degraded" : "color_good"));
 357     } else {
 358         walk = format_down;
 359         START_COLOR("color_bad");
 360     }
 361
 362     for (; *walk != '\0'; walk++) {
 363         if (*walk != '%') {
 364             *(outwalk++) = *walk;
 365             continue;
 366         }
 367
 368         if (BEGINS_WITH(walk + 1, "quality")) {
 369             if (info.flags & WIRELESS_INFO_FLAG_HAS_QUALITY) {
 370                 if (info.quality_max)
 371                     outwalk += sprintf(outwalk, "%03d%%", PERCENT_VALUE(info.quality, info.quality_max));
 372                 else
 373                     outwalk += sprintf(outwalk, "%d", info.quality);
 374             } else {
 375                 *(outwalk++) = '?';
 376             }
 377             walk += strlen("quality");
 378         }
 379
 380         if (BEGINS_WITH(walk + 1, "signal")) {
 381             if (info.flags & WIRELESS_INFO_FLAG_HAS_SIGNAL) {
 382                 if (info.signal_level_max)
 383                     outwalk += sprintf(outwalk, "%03d%%", PERCENT_VALUE(info.signal_level, info.signal_level_max));
 384                 else
 385                     outwalk += sprintf(outwalk, "%d dBm", info.signal_level);
 386             } else {
 387                 *(outwalk++) = '?';
 388             }
 389             walk += strlen("signal");
 390         }
 391
 392         if (BEGINS_WITH(walk + 1, "noise")) {
 393             if (info.flags & WIRELESS_INFO_FLAG_HAS_NOISE) {
 394                 if (info.noise_level_max)
 395                     outwalk += sprintf(outwalk, "%03d%%", PERCENT_VALUE(info.noise_level, info.noise_level_max));
 396                 else
 397                     outwalk += sprintf(outwalk, "%d dBm", info.noise_level);
 398             } else {
 399                 *(outwalk++) = '?';
 400             }
 401             walk += strlen("noise");
 402         }
 403
 404         if (BEGINS_WITH(walk + 1, "essid")) {
 405             if (info.flags & WIRELESS_INFO_FLAG_HAS_ESSID)
 406                 outwalk += sprintf(outwalk, "%s", info.essid);
 407             else
 408                 *(outwalk++) = '?';
 409             walk += strlen("essid");
 410         }
 411
 412         if (BEGINS_WITH(walk + 1, "frequency")) {
 413             if (info.flags & WIRELESS_INFO_FLAG_HAS_FREQUENCY)
 414                 outwalk += sprintf(outwalk, "%1.1f GHz", info.frequency / 1e9);
 415             else
 416                 *(outwalk++) = '?';
 417             walk += strlen("frequency");
 418         }
 419
 420         if (BEGINS_WITH(walk + 1, "ip")) {
 421             outwalk += sprintf(outwalk, "%s", ip_address);
 422             walk += strlen("ip");
 423         }
 424
 425 #ifdef LINUX
 426         if (BEGINS_WITH(walk + 1, "bitrate")) {
 427             char br_buffer[128];
 428
 429             iw_print_bitrate(br_buffer, sizeof(br_buffer), info.bitrate);
 430
 431             outwalk += sprintf(outwalk, "%s", br_buffer);
 432             walk += strlen("bitrate");
 433         }
 434 #endif
 435     }
 436
 437 out:
 438     END_COLOR;
 439     OUTPUT_FULL_TEXT(buffer);
 440 }