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, len, inwid;
 201     uint8_t buf[24 * 1024], *cp;
 202     struct ieee80211req na;
 203     char network_id[IEEE80211_NWID_LEN + 1];
 204
 205     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
 206         return (0);
 207
 208     memset(&na, 0, sizeof(na));
 209     strlcpy(na.i_name, interface, sizeof(na.i_name));
 210     na.i_type = IEEE80211_IOC_SSID;
 211     na.i_data = &info->essid[0];
 212     na.i_len = IEEE80211_NWID_LEN + 1;
 213     if ((inwid = ioctl(s, SIOCG80211, (caddr_t)&na)) == -1) {
 214         close(s);
 215         return (0);
 216     }
 217     if (inwid == 0) {
 218         if (na.i_len <= IEEE80211_NWID_LEN)
 219             len = na.i_len + 1;
 220         else
 221             len = IEEE80211_NWID_LEN + 1;
 222         info->essid[len - 1] = '\0';
 223     } else {
 224         close(s);
 225         return (0);
 226     }
 227     info->flags |= WIRELESS_INFO_FLAG_HAS_ESSID;
 228
 229     memset(&na, 0, sizeof(na));
 230     strlcpy(na.i_name, interface, sizeof(na.i_name));
 231     na.i_type = IEEE80211_IOC_SCAN_RESULTS;
 232     na.i_data = buf;
 233     na.i_len = sizeof(buf);
 234
 235     if (ioctl(s, SIOCG80211, (caddr_t)&na) == -1) {
 236         printf("fail\n");
 237         close(s);
 238         return (0);
 239     }
 240
 241     close(s);
 242     len = na.i_len;
 243     cp = buf;
 244     struct ieee80211req_scan_result *sr;
 245     uint8_t *vp;
 246     sr = (struct ieee80211req_scan_result *)cp;
 247     vp = (u_int8_t *)(sr + 1);
 248     strlcpy(network_id, (const char *)vp, sr->isr_ssid_len + 1);
 249     if (!strcmp(network_id, &info->essid[0])) {
 250         info->signal_level = sr->isr_rssi;
 251         info->flags |= WIRELESS_INFO_FLAG_HAS_SIGNAL;
 252         info->noise_level = sr->isr_noise;
 253         info->flags |= WIRELESS_INFO_FLAG_HAS_NOISE;
 254         info->quality = sr->isr_intval;
 255         info->flags |= WIRELESS_INFO_FLAG_HAS_QUALITY;
 256     }
 257
 258     return 1;
 259 #endif
 260 #ifdef __OpenBSD__
 261     struct ifreq ifr;
 262     struct ieee80211_bssid bssid;
 263     struct ieee80211_nwid nwid;
 264     struct ieee80211_nodereq nr;
 265
 266     struct ether_addr ea;
 267
 268     int s, len, ibssid, inwid;
 269     u_int8_t zero_bssid[IEEE80211_ADDR_LEN];
 270
 271     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
 272         return (0);
 273
 274     memset(&ifr, 0, sizeof(ifr));
 275     ifr.ifr_data = (caddr_t)&nwid;
 276     (void)strlcpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name));
 277     inwid = ioctl(s, SIOCG80211NWID, (caddr_t)&ifr);
 278
 279     memset(&bssid, 0, sizeof(bssid));
 280     strlcpy(bssid.i_name, interface, sizeof(bssid.i_name));
 281     ibssid = ioctl(s, SIOCG80211BSSID, &bssid);
 282
 283     if (ibssid != 0 || inwid != 0) {
 284         close(s);
 285         return 0;
 286     }
 287
 288     /* NWID */
 289     {
 290         if (nwid.i_len <= IEEE80211_NWID_LEN)
 291             len = nwid.i_len + 1;
 292         else
 293             len = IEEE80211_NWID_LEN + 1;
 294
 295         strncpy(&info->essid[0], nwid.i_nwid, len);
 296         info->essid[IW_ESSID_MAX_SIZE] = '\0';
 297         info->flags |= WIRELESS_INFO_FLAG_HAS_ESSID;
 298     }
 299
 300     /* Signal strength */
 301     {
 302         memset(&zero_bssid, 0, sizeof(zero_bssid));
 303         if (ibssid == 0 && memcmp(bssid.i_bssid, zero_bssid, IEEE80211_ADDR_LEN) != 0) {
 304             memcpy(&ea.ether_addr_octet, bssid.i_bssid, sizeof(ea.ether_addr_octet));
 305
 306             bzero(&nr, sizeof(nr));
 307             bcopy(bssid.i_bssid, &nr.nr_macaddr, sizeof(nr.nr_macaddr));
 308             strlcpy(nr.nr_ifname, interface, sizeof(nr.nr_ifname));
 309
 310             if (ioctl(s, SIOCG80211NODE, &nr) == 0 && nr.nr_rssi) {
 311                 if (nr.nr_max_rssi)
 312                     info->signal_level_max = IEEE80211_NODEREQ_RSSI(&nr);
 313                 else
 314                     info->signal_level = nr.nr_rssi;
 315
 316                 info->flags |= WIRELESS_INFO_FLAG_HAS_SIGNAL;
 317             }
 318         }
 319     }
 320
 321     close(s);
 322     return 1;
 323 #endif
 324     return 0;
 325 }
 326
 327 void print_wireless_info(yajl_gen json_gen, char *buffer, const char *interface, const char *format_up, const char *format_down) {
 328     const char *walk;
 329     char *outwalk = buffer;
 330     wireless_info_t info;
 331
 332     INSTANCE(interface);
 333
 334     const char *ip_address = get_ip_addr(interface);
 335     if (ip_address == NULL) {
 336         START_COLOR("color_bad");
 337         outwalk += sprintf(outwalk, "%s", format_down);
 338         goto out;
 339     }
 340
 341     if (get_wireless_info(interface, &info)) {
 342         walk = format_up;
 343         if (info.flags & WIRELESS_INFO_FLAG_HAS_QUALITY)
 344             START_COLOR((info.quality < info.quality_average ? "color_degraded" : "color_good"));
 345         else
 346             START_COLOR("color_good");
 347     } else {
 348         walk = format_down;
 349         START_COLOR("color_bad");
 350     }
 351
 352     for (; *walk != '\0'; walk++) {
 353         if (*walk != '%') {
 354             *(outwalk++) = *walk;
 355             continue;
 356         }
 357
 358         if (BEGINS_WITH(walk + 1, "quality")) {
 359             if (info.flags & WIRELESS_INFO_FLAG_HAS_QUALITY) {
 360                 if (info.quality_max)
 361                     outwalk += sprintf(outwalk, "%03d%%", PERCENT_VALUE(info.quality, info.quality_max));
 362                 else
 363                     outwalk += sprintf(outwalk, "%d", info.quality);
 364             } else {
 365                 *(outwalk++) = '?';
 366             }
 367             walk += strlen("quality");
 368         }
 369
 370         if (BEGINS_WITH(walk + 1, "signal")) {
 371             if (info.flags & WIRELESS_INFO_FLAG_HAS_SIGNAL) {
 372                 if (info.signal_level_max)
 373                     outwalk += sprintf(outwalk, "%03d%%", PERCENT_VALUE(info.signal_level, info.signal_level_max));
 374                 else
 375                     outwalk += sprintf(outwalk, "%d dBm", info.signal_level);
 376             } else {
 377                 *(outwalk++) = '?';
 378             }
 379             walk += strlen("signal");
 380         }
 381
 382         if (BEGINS_WITH(walk + 1, "noise")) {
 383             if (info.flags & WIRELESS_INFO_FLAG_HAS_NOISE) {
 384                 if (info.noise_level_max)
 385                     outwalk += sprintf(outwalk, "%03d%%", PERCENT_VALUE(info.noise_level, info.noise_level_max));
 386                 else
 387                     outwalk += sprintf(outwalk, "%d dBm", info.noise_level);
 388             } else {
 389                 *(outwalk++) = '?';
 390             }
 391             walk += strlen("noise");
 392         }
 393
 394         if (BEGINS_WITH(walk + 1, "essid")) {
 395             if (info.flags & WIRELESS_INFO_FLAG_HAS_ESSID)
 396                 outwalk += sprintf(outwalk, "%s", info.essid);
 397             else
 398                 *(outwalk++) = '?';
 399             walk += strlen("essid");
 400         }
 401
 402         if (BEGINS_WITH(walk + 1, "frequency")) {
 403             if (info.flags & WIRELESS_INFO_FLAG_HAS_FREQUENCY)
 404                 outwalk += sprintf(outwalk, "%1.1f GHz", info.frequency / 1e9);
 405             else
 406                 *(outwalk++) = '?';
 407             walk += strlen("frequency");
 408         }
 409
 410         if (BEGINS_WITH(walk + 1, "ip")) {
 411             outwalk += sprintf(outwalk, "%s", ip_address);
 412             walk += strlen("ip");
 413         }
 414
 415 #ifdef LINUX
 416         if (BEGINS_WITH(walk + 1, "bitrate")) {
 417             char br_buffer[128];
 418
 419             iw_print_bitrate(br_buffer, sizeof(br_buffer), info.bitrate);
 420
 421             outwalk += sprintf(outwalk, "%s", br_buffer);
 422             walk += strlen("bitrate");
 423         }
 424 #endif
 425     }
 426
 427 out:
 428     END_COLOR;
 429     OUTPUT_FULL_TEXT(buffer);
 430 }