git.maemo.org Git - monky/blob - src/linux.c

   1 /* Conky, a system monitor, based on torsmo
   2  *
   3  * Any original torsmo code is licensed under the BSD license
   4  *
   5  * All code written since the fork of torsmo is licensed under the GPL
   6  *
   7  * Please see COPYING for details
   8  *
   9  * Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
  10  * Copyright (c) 2007 Toni Spets
  11  * Copyright (c) 2005-2007 Brenden Matthews, Philip Kovacs, et. al.
  12  *      (see AUTHORS)
  13  * All rights reserved.
  14  *
  15  * This program is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation, either version 3 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26  *
  27  * $Id$ */
  28
  29 #include "conky.h"
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <dirent.h>
  34 #include <ctype.h>
  35 #include <errno.h>
  36 #include <limits.h>
  37 #include <sys/types.h>
  38 #include <sys/sysinfo.h>
  39 #include <sys/stat.h>
  40 #ifndef HAVE_CLOCK_GETTIME
  41 #include <sys/time.h>
  42 #endif
  43 #include <fcntl.h>
  44 #include <unistd.h>
  45 // #include <assert.h>
  46 #include <time.h>
  47 #include "top.h"
  48
  49 #include <sys/ioctl.h>
  50 #include <sys/socket.h>
  51 #include <netinet/in.h>
  52 #include <linux/sockios.h>
  53 #include <net/if.h>
  54 #include <arpa/inet.h>
  55 #ifdef _NET_IF_H
  56 #define _LINUX_IF_H
  57 #endif
  58 #include <linux/route.h>
  59 #include <math.h>
  60
  61 #ifdef HAVE_IWLIB
  62 #include <iwlib.h>
  63 #endif
  64
  65 #define SHORTSTAT_TEMPL "%*s %llu %llu %llu"
  66 #define LONGSTAT_TEMPL "%*s %llu %llu %llu "
  67
  68 static int show_nice_processes;
  69
  70 /* This flag tells the linux routines to use the /proc system where possible,
  71  * even if other api's are available, e.g. sysinfo() or getloadavg().
  72  * the reason for this is to allow for /proc-based distributed monitoring.
  73  * using a flag in this manner creates less confusing code. */
  74 static int prefer_proc = 0;
  75
  76 void prepare_update(void)
  77 {
  78 }
  79
  80 void update_uptime(void)
  81 {
  82 #ifdef HAVE_SYSINFO
  83         if (!prefer_proc) {
  84                 struct sysinfo s_info;
  85
  86                 sysinfo(&s_info);
  87                 info.uptime = (double) s_info.uptime;
  88         } else
  89 #endif
  90         {
  91                 static int rep = 0;
  92                 FILE *fp;
  93
  94                 if (!(fp = open_file("/proc/uptime", &rep))) {
  95                         info.uptime = 0.0;
  96                         return;
  97                 }
  98                 fscanf(fp, "%lf", &info.uptime);
  99                 fclose(fp);
 100         }
 101         info.mask |= (1 << INFO_UPTIME);
 102 }
 103
 104 int check_mount(char *s)
 105 {
 106         int ret = 0;
 107         FILE *mtab = fopen("/etc/mtab", "r");
 108
 109         if (mtab) {
 110                 char buf1[256], buf2[128];
 111
 112                 while (fgets(buf1, 256, mtab)) {
 113                         sscanf(buf1, "%*s %128s", buf2);
 114                         if (!strcmp(s, buf2)) {
 115                                 ret = 1;
 116                                 break;
 117                         }
 118                 }
 119                 fclose(mtab);
 120         } else {
 121                 ERR("Could not open mtab");
 122         }
 123         return ret;
 124 }
 125
 126 /* these things are also in sysinfo except Buffers:
 127  * (that's why I'm reading them from proc) */
 128
 129 void update_meminfo(void)
 130 {
 131         FILE *meminfo_fp;
 132         static int rep = 0;
 133
 134         /* unsigned int a; */
 135         char buf[256];
 136
 137         info.mem = info.memmax = info.swap = info.swapmax = info.bufmem =
 138                 info.buffers = info.cached = 0;
 139
 140         if (!(meminfo_fp = open_file("/proc/meminfo", &rep))) {
 141                 return;
 142         }
 143
 144         while (!feof(meminfo_fp)) {
 145                 if (fgets(buf, 255, meminfo_fp) == NULL) {
 146                         break;
 147                 }
 148
 149                 if (strncmp(buf, "MemTotal:", 9) == 0) {
 150                         sscanf(buf, "%*s %llu", &info.memmax);
 151                 } else if (strncmp(buf, "MemFree:", 8) == 0) {
 152                         sscanf(buf, "%*s %llu", &info.mem);
 153                 } else if (strncmp(buf, "SwapTotal:", 10) == 0) {
 154                         sscanf(buf, "%*s %llu", &info.swapmax);
 155                 } else if (strncmp(buf, "SwapFree:", 9) == 0) {
 156                         sscanf(buf, "%*s %llu", &info.swap);
 157                 } else if (strncmp(buf, "Buffers:", 8) == 0) {
 158                         sscanf(buf, "%*s %llu", &info.buffers);
 159                 } else if (strncmp(buf, "Cached:", 7) == 0) {
 160                         sscanf(buf, "%*s %llu", &info.cached);
 161                 }
 162         }
 163
 164         info.mem = info.memmax - info.mem;
 165         info.swap = info.swapmax - info.swap;
 166
 167         info.bufmem = info.cached + info.buffers;
 168
 169         info.mask |= (1 << INFO_MEM) | (1 << INFO_BUFFERS);
 170
 171         fclose(meminfo_fp);
 172 }
 173
 174 int get_laptop_mode(void)
 175 {
 176         FILE *fp;
 177         int val = -1;
 178
 179         if ((fp = fopen("/proc/sys/vm/laptop_mode", "r")) != NULL)
 180                 fscanf(fp, "%d\n", &val);
 181         fclose(fp);
 182         return val;
 183 }
 184
 185 /* my system says:
 186  * # cat /sys/block/sda/queue/scheduler
 187  * noop [anticipatory] cfq
 188  */
 189 char *get_ioscheduler(char *disk)
 190 {
 191         FILE *fp;
 192         char buf[128];
 193
 194         if (!disk)
 195                 return strdup("n/a");
 196
 197         snprintf(buf, 127, "/sys/block/%s/queue/scheduler", disk);
 198         if ((fp = fopen(buf, "r")) == NULL) {
 199                 return strdup("n/a");
 200         }
 201         while (!feof(fp)) {
 202                 fscanf(fp, "%127s", buf);
 203                 if (buf[0] == '[') {
 204                         buf[strlen(buf) - 1] = '\0';
 205                         fclose(fp);
 206                         return strdup(buf + 1);
 207                 }
 208         }
 209         fclose(fp);
 210         return strdup("n/a");
 211 }
 212
 213 int interface_up(const char *dev)
 214 {
 215         int fd;
 216         struct ifreq ifr;
 217
 218         if((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
 219                 CRIT_ERR("could not create sockfd");
 220                 return 0;
 221         }
 222         strncpy(ifr.ifr_name, dev, IFNAMSIZ);
 223         if(ioctl(fd, SIOCGIFFLAGS, &ifr)) {
 224                 /* if device does not exist, treat like not up */
 225                 if (errno != ENODEV)
 226                         perror("SIOCGIFFLAGS");
 227         } else {
 228                 close(fd);
 229                 return (ifr.ifr_flags & IFF_UP);
 230         }
 231         close(fd);
 232         return 0;
 233 }
 234
 235 #define COND_FREE(x) if(x) free(x); x = 0
 236 #define SAVE_SET_STRING(x, y) \
 237         if (x && strcmp((char *)x, (char *)y)) { \
 238                 free(x); \
 239                 x = strdup("multiple"); \
 240         } else if (!x) { \
 241                 x = strdup(y); \
 242         }
 243
 244 void update_gateway_info(void)
 245 {
 246         FILE *fp;
 247         struct in_addr ina;
 248         char iface[64];
 249         unsigned long dest, gate, mask;
 250         unsigned int flags;
 251         short ref, use, metric, mtu, win, irtt;
 252
 253         struct gateway_info *gw_info = &info.gw_info;
 254
 255         COND_FREE(gw_info->iface);
 256         COND_FREE(gw_info->ip);
 257         gw_info->count = 0;
 258
 259         if ((fp = fopen("/proc/net/route", "r")) == NULL) {
 260                 perror("fopen()");
 261                 goto FAIL;
 262         }
 263         if (fscanf(fp, "%*[^\n]\n") == EOF) {
 264                 perror("fscanf()");
 265                 goto CLOSE_FAIL;
 266         }
 267         while (!feof(fp)) {
 268                 // Iface Destination Gateway Flags RefCnt Use Metric Mask MTU Window IRTT
 269                 if(fscanf(fp, "%63s %lx %lx %x %hd %hd %hd %lx %hd %hd %hd\n",
 270                                 iface, &dest, &gate, &flags, &ref, &use,
 271                                 &metric, &mask, &mtu, &win, &irtt) != 11) {
 272                         perror("fscanf()");
 273                         goto CLOSE_FAIL;
 274                 }
 275                 if (flags & RTF_GATEWAY && dest == 0 && mask == 0) {
 276                         gw_info->count++;
 277                         SAVE_SET_STRING(gw_info->iface, iface)
 278                         ina.s_addr = gate;
 279                         SAVE_SET_STRING(gw_info->ip, inet_ntoa(ina))
 280                 }
 281         }
 282         fclose(fp);
 283         return;
 284 CLOSE_FAIL:
 285         fclose(fp);
 286 FAIL:
 287         info.gw_info.iface = info.gw_info.ip = strdup("failed");
 288         return;
 289 }
 290
 291 inline void update_net_stats(void)
 292 {
 293         FILE *net_dev_fp;
 294         static int rep = 0;
 295
 296         // FIXME: arbitrary size chosen to keep code simple.
 297         int i, i2;
 298         unsigned int curtmp1, curtmp2;
 299         unsigned int k;
 300         struct ifconf conf;
 301         char buf[256];
 302         double delta;
 303
 304 #ifdef HAVE_IWLIB
 305         // wireless info variables
 306         int skfd, has_bitrate = 0;
 307         struct wireless_info *winfo;
 308         struct iwreq wrq;
 309 #endif
 310
 311         /* get delta */
 312         delta = current_update_time - last_update_time;
 313         if (delta <= 0.0001) {
 314                 return;
 315         }
 316
 317         /* open file and ignore first two lines */
 318         if (!(net_dev_fp = open_file("/proc/net/dev", &rep))) {
 319                 clear_net_stats();
 320                 return;
 321         }
 322
 323         fgets(buf, 255, net_dev_fp);    /* garbage */
 324         fgets(buf, 255, net_dev_fp);    /* garbage (field names) */
 325
 326         /* read each interface */
 327         for (i2 = 0; i2 < 16; i2++) {
 328                 struct net_stat *ns;
 329                 char *s, *p;
 330                 char temp_addr[17];
 331                 long long r, t, last_recv, last_trans;
 332
 333                 if (fgets(buf, 255, net_dev_fp) == NULL) {
 334                         break;
 335                 }
 336                 p = buf;
 337                 while (isspace((int) *p)) {
 338                         p++;
 339                 }
 340
 341                 s = p;
 342
 343                 while (*p && *p != ':') {
 344                         p++;
 345                 }
 346                 if (*p == '\0') {
 347                         continue;
 348                 }
 349                 *p = '\0';
 350                 p++;
 351
 352                 ns = get_net_stat(s);
 353                 ns->up = 1;
 354                 memset(&(ns->addr.sa_data), 0, 14);
 355
 356                 if(NULL == ns->addrs)
 357                         ns->addrs = (char*) malloc(17 * 16);
 358                 if(NULL != ns->addrs)
 359                         memset(ns->addrs, 0, 17 * 16); /* Up to 17 chars per ip, max 16 interfaces. Nasty memory usage... */
 360
 361                 last_recv = ns->recv;
 362                 last_trans = ns->trans;
 363
 364                 /* bytes packets errs drop fifo frame compressed multicast|bytes ... */
 365                 sscanf(p, "%lld  %*d     %*d  %*d  %*d  %*d   %*d        %*d       %lld",
 366                         &r, &t);
 367
 368                 /* if recv or trans is less than last time, an overflow happened */
 369                 if (r < ns->last_read_recv) {
 370                         last_recv = 0;
 371                 } else {
 372                         ns->recv += (r - ns->last_read_recv);
 373                 }
 374                 ns->last_read_recv = r;
 375
 376                 if (t < ns->last_read_trans) {
 377                         last_trans = 0;
 378                 } else {
 379                         ns->trans += (t - ns->last_read_trans);
 380                 }
 381                 ns->last_read_trans = t;
 382
 383                 /*** ip addr patch ***/
 384                 i = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 385
 386                 conf.ifc_buf = malloc(sizeof(struct ifreq) * 16);
 387                 conf.ifc_len = sizeof(struct ifreq) * 16;
 388                 memset(conf.ifc_buf, 0, conf.ifc_len);
 389
 390                 ioctl((long) i, SIOCGIFCONF, &conf);
 391
 392                 for (k = 0; k < conf.ifc_len / sizeof(struct ifreq); k++) {
 393                         struct net_stat *ns2;
 394
 395                         if (!(((struct ifreq *) conf.ifc_buf) + k))
 396                                 break;
 397
 398                         ns2 = get_net_stat(
 399                                 ((struct ifreq *) conf.ifc_buf)[k].ifr_ifrn.ifrn_name);
 400                         ns2->addr = ((struct ifreq *) conf.ifc_buf)[k].ifr_ifru.ifru_addr;
 401                         if(NULL != ns2->addrs) {
 402                                 sprintf(temp_addr, "%u.%u.%u.%u, ",
 403                                         ns2->addr.sa_data[2] & 255,
 404                                         ns2->addr.sa_data[3] & 255,
 405                                         ns2->addr.sa_data[4] & 255,
 406                                         ns2->addr.sa_data[5] & 255);
 407                                 if(NULL == strstr(ns2->addrs, temp_addr))
 408                                         strncpy(ns2->addrs + strlen(ns2->addrs), temp_addr, 17);
 409                         }
 410                 }
 411
 412                 close((long) i);
 413
 414                 free(conf.ifc_buf);
 415
 416                 /*** end ip addr patch ***/
 417
 418                 /* calculate speeds */
 419                 ns->net_rec[0] = (ns->recv - last_recv) / delta;
 420                 ns->net_trans[0] = (ns->trans - last_trans) / delta;
 421                 curtmp1 = 0;
 422                 curtmp2 = 0;
 423                 // get an average
 424                 for (i = 0; (unsigned) i < info.net_avg_samples; i++) {
 425                         curtmp1 += ns->net_rec[i];
 426                         curtmp2 += ns->net_trans[i];
 427                 }
 428                 if (curtmp1 == 0) {
 429                         curtmp1 = 1;
 430                 }
 431                 if (curtmp2 == 0) {
 432                         curtmp2 = 1;
 433                 }
 434                 ns->recv_speed = curtmp1 / (double) info.net_avg_samples;
 435                 ns->trans_speed = curtmp2 / (double) info.net_avg_samples;
 436                 if (info.net_avg_samples > 1) {
 437                         for (i = info.net_avg_samples; i > 1; i--) {
 438                                 ns->net_rec[i - 1] = ns->net_rec[i - 2];
 439                                 ns->net_trans[i - 1] = ns->net_trans[i - 2];
 440                         }
 441                 }
 442
 443 #ifdef HAVE_IWLIB
 444                 /* update wireless info */
 445                 winfo = malloc(sizeof(struct wireless_info));
 446                 memset(winfo, 0, sizeof(struct wireless_info));
 447
 448                 skfd = iw_sockets_open();
 449                 if (iw_get_basic_config(skfd, s, &(winfo->b)) > -1) {
 450
 451                         // set present winfo variables
 452                         if (iw_get_stats(skfd, s, &(winfo->stats),
 453                                         &winfo->range, winfo->has_range) >= 0) {
 454                                 winfo->has_stats = 1;
 455                         }
 456                         if (iw_get_range_info(skfd, s, &(winfo->range)) >= 0) {
 457                                 winfo->has_range = 1;
 458                         }
 459                         if (iw_get_ext(skfd, s, SIOCGIWAP, &wrq) >= 0) {
 460                                 winfo->has_ap_addr = 1;
 461                                 memcpy(&(winfo->ap_addr), &(wrq.u.ap_addr), sizeof(sockaddr));
 462                         }
 463
 464                         // get bitrate
 465                         if (iw_get_ext(skfd, s, SIOCGIWRATE, &wrq) >= 0) {
 466                                 memcpy(&(winfo->bitrate), &(wrq.u.bitrate), sizeof(iwparam));
 467                                 iw_print_bitrate(ns->bitrate, 16, winfo->bitrate.value);
 468                                 has_bitrate = 1;
 469                         }
 470
 471                         // get link quality
 472                         if (winfo->has_range && winfo->has_stats
 473                                         && ((winfo->stats.qual.level != 0)
 474                                         || (winfo->stats.qual.updated & IW_QUAL_DBM))) {
 475                                 if (!(winfo->stats.qual.updated & IW_QUAL_QUAL_INVALID)) {
 476                                         ns->link_qual = winfo->stats.qual.qual;
 477                                         ns->link_qual_max = winfo->range.max_qual.qual;
 478                                 }
 479                         }
 480
 481                         // get ap mac
 482                         if (winfo->has_ap_addr) {
 483                                 iw_sawap_ntop(&winfo->ap_addr, ns->ap);
 484                         }
 485
 486                         // get essid
 487                         if (winfo->b.has_essid) {
 488                                 if (winfo->b.essid_on) {
 489                                         snprintf(ns->essid, 32, "%s", winfo->b.essid);
 490                                 } else {
 491                                         snprintf(ns->essid, 32, "off/any");
 492                                 }
 493                         }
 494
 495                         snprintf(ns->mode, 16, "%s", iw_operation_mode[winfo->b.mode]);
 496                 }
 497                 iw_sockets_close(skfd);
 498                 free(winfo);
 499 #endif
 500         }
 501
 502         fclose(net_dev_fp);
 503
 504         info.mask |= (1 << INFO_NET);
 505 }
 506
 507 int result;
 508
 509 void update_total_processes(void)
 510 {
 511 #ifdef HAVE_SYSINFO
 512         if (!prefer_proc) {
 513                 struct sysinfo s_info;
 514
 515                 sysinfo(&s_info);
 516                 info.procs = s_info.procs;
 517         } else
 518 #endif
 519         {
 520                 static int rep = 0;
 521                 FILE *fp;
 522
 523                 if (!(fp = open_file("/proc/loadavg", &rep))) {
 524                         info.procs = 0;
 525                         return;
 526                 }
 527                 fscanf(fp, "%*f %*f %*f %*d/%hu", &info.procs);
 528                 fclose(fp);
 529         }
 530         info.mask |= (1 << INFO_PROCS);
 531 }
 532
 533 #define CPU_SAMPLE_COUNT 15
 534 struct cpu_info {
 535         unsigned long long cpu_user;
 536         unsigned long long cpu_system;
 537         unsigned long long cpu_nice;
 538         unsigned long long cpu_idle;
 539         unsigned long long cpu_iowait;
 540         unsigned long long cpu_irq;
 541         unsigned long long cpu_softirq;
 542         unsigned long long cpu_steal;
 543         unsigned long long cpu_total;
 544         unsigned long long cpu_active_total;
 545         unsigned long long cpu_last_total;
 546         unsigned long long cpu_last_active_total;
 547         double cpu_val[CPU_SAMPLE_COUNT];
 548 };
 549 static short cpu_setup = 0;
 550
 551 /* Determine if this kernel gives us "extended" statistics information in
 552  * /proc/stat.
 553  * Kernels around 2.5 and earlier only reported user, system, nice, and
 554  * idle values in proc stat.
 555  * Kernels around 2.6 and greater report these PLUS iowait, irq, softirq,
 556  * and steal */
 557 void determine_longstat(char *buf)
 558 {
 559         unsigned long long iowait = 0;
 560
 561         KFLAG_SETOFF(KFLAG_IS_LONGSTAT);
 562         /* scanf will either return -1 or 1 because there is only 1 assignment */
 563         if (sscanf(buf, "%*s %*d %*d %*d %*d %llu", &iowait) > 0) {
 564                 KFLAG_SETON(KFLAG_IS_LONGSTAT);
 565         }
 566 }
 567
 568 void get_cpu_count(void)
 569 {
 570         FILE *stat_fp;
 571         static int rep = 0;
 572         char buf[256];
 573
 574         if (info.cpu_usage) {
 575                 return;
 576         }
 577
 578         if (!(stat_fp = open_file("/proc/stat", &rep))) {
 579                 return;
 580         }
 581
 582         info.cpu_count = 0;
 583
 584         while (!feof(stat_fp)) {
 585                 if (fgets(buf, 255, stat_fp) == NULL) {
 586                         break;
 587                 }
 588
 589                 if (strncmp(buf, "cpu", 3) == 0 && isdigit(buf[3])) {
 590                         if (info.cpu_count == 0) {
 591                                 determine_longstat(buf);
 592                         }
 593                         info.cpu_count++;
 594                 }
 595         }
 596         info.cpu_usage = malloc((info.cpu_count + 1) * sizeof(float));
 597
 598         fclose(stat_fp);
 599 }
 600
 601 #define TMPL_LONGSTAT "%*s %llu %llu %llu %llu %llu %llu %llu %llu"
 602 #define TMPL_SHORTSTAT "%*s %llu %llu %llu %llu"
 603
 604 inline static void update_stat(void)
 605 {
 606         FILE *stat_fp;
 607         static int rep = 0;
 608         static struct cpu_info *cpu = NULL;
 609         char buf[256];
 610         unsigned int i;
 611         unsigned int idx;
 612         double curtmp;
 613         const char *stat_template = NULL;
 614         unsigned int malloc_cpu_size = 0;
 615
 616         /* add check for !info.cpu_usage since that mem is freed on a SIGUSR1 */
 617         if (!cpu_setup || !info.cpu_usage) {
 618                 get_cpu_count();
 619                 cpu_setup = 1;
 620         }
 621
 622         if (!stat_template) {
 623                 stat_template =
 624                         KFLAG_ISSET(KFLAG_IS_LONGSTAT) ? TMPL_LONGSTAT : TMPL_SHORTSTAT;
 625         }
 626
 627         if (!cpu) {
 628                 malloc_cpu_size = (info.cpu_count + 1) * sizeof(struct cpu_info);
 629                 cpu = malloc(malloc_cpu_size);
 630                 memset(cpu, 0, malloc_cpu_size);
 631         }
 632
 633         if (!(stat_fp = open_file("/proc/stat", &rep))) {
 634                 info.run_procs = 0;
 635                 if (info.cpu_usage) {
 636                         memset(info.cpu_usage, 0, info.cpu_count * sizeof(float));
 637                 }
 638                 return;
 639         }
 640
 641         idx = 0;
 642         while (!feof(stat_fp)) {
 643                 if (fgets(buf, 255, stat_fp) == NULL) {
 644                         break;
 645                 }
 646
 647                 if (strncmp(buf, "procs_running ", 14) == 0) {
 648                         sscanf(buf, "%*s %hu", &info.run_procs);
 649                         info.mask |= (1 << INFO_RUN_PROCS);
 650                 } else if (strncmp(buf, "cpu", 3) == 0) {
 651                         double delta;
 652                         idx = isdigit(buf[3]) ? ((int) buf[3]) - 0x2F : 0;
 653                         sscanf(buf, stat_template, &(cpu[idx].cpu_user),
 654                                 &(cpu[idx].cpu_nice), &(cpu[idx].cpu_system),
 655                                 &(cpu[idx].cpu_idle), &(cpu[idx].cpu_iowait),
 656                                 &(cpu[idx].cpu_irq), &(cpu[idx].cpu_softirq),
 657                                 &(cpu[idx].cpu_steal));
 658
 659                         cpu[idx].cpu_total = cpu[idx].cpu_user + cpu[idx].cpu_nice +
 660                                 cpu[idx].cpu_system + cpu[idx].cpu_idle +
 661                                 cpu[idx].cpu_iowait + cpu[idx].cpu_irq +
 662                                 cpu[idx].cpu_softirq + cpu[idx].cpu_steal;
 663
 664                         cpu[idx].cpu_active_total = cpu[idx].cpu_total -
 665                                 (cpu[idx].cpu_idle + cpu[idx].cpu_iowait);
 666                         info.mask |= (1 << INFO_CPU);
 667
 668                         delta = current_update_time - last_update_time;
 669
 670                         if (delta <= 0.001) {
 671                                 break;
 672                         }
 673
 674                         cpu[idx].cpu_val[0] = (cpu[idx].cpu_active_total -
 675                                 cpu[idx].cpu_last_active_total) /
 676                                 (float) (cpu[idx].cpu_total - cpu[idx].cpu_last_total);
 677                         curtmp = 0;
 678                         for (i = 0; i < info.cpu_avg_samples; i++) {
 679                                 curtmp += cpu[idx].cpu_val[i];
 680                         }
 681                         /* TESTING -- I've removed this, because I don't think it is right.
 682                          * You shouldn't divide by the cpu count here ...
 683                          * removing for testing */
 684                         /* if (idx == 0) {
 685                                 info.cpu_usage[idx] = curtmp / info.cpu_avg_samples /
 686                                         info.cpu_count;
 687                         } else {
 688                                 info.cpu_usage[idx] = curtmp / info.cpu_avg_samples;
 689                         } */
 690                         /* TESTING -- this line replaces the prev. "suspect" if/else */
 691                         info.cpu_usage[idx] = curtmp / info.cpu_avg_samples;
 692
 693                         cpu[idx].cpu_last_total = cpu[idx].cpu_total;
 694                         cpu[idx].cpu_last_active_total = cpu[idx].cpu_active_total;
 695                         for (i = info.cpu_avg_samples - 1; i > 0; i--) {
 696                                 cpu[idx].cpu_val[i] = cpu[idx].cpu_val[i - 1];
 697                         }
 698                 }
 699         }
 700         fclose(stat_fp);
 701 }
 702
 703 void update_running_processes(void)
 704 {
 705         update_stat();
 706 }
 707
 708 void update_cpu_usage(void)
 709 {
 710         update_stat();
 711 }
 712
 713 void update_load_average(void)
 714 {
 715 #ifdef HAVE_GETLOADAVG
 716         if (!prefer_proc) {
 717                 double v[3];
 718
 719                 getloadavg(v, 3);
 720                 info.loadavg[0] = (float) v[0];
 721                 info.loadavg[1] = (float) v[1];
 722                 info.loadavg[2] = (float) v[2];
 723         } else
 724 #endif
 725         {
 726                 static int rep = 0;
 727                 FILE *fp;
 728
 729                 if (!(fp = open_file("/proc/loadavg", &rep))) {
 730                         info.loadavg[0] = info.loadavg[1] = info.loadavg[2] = 0.0;
 731                         return;
 732                 }
 733                 fscanf(fp, "%f %f %f", &info.loadavg[0], &info.loadavg[1],
 734                         &info.loadavg[2]);
 735                 fclose(fp);
 736         }
 737         info.mask |= (1 << INFO_LOADAVG);
 738 }
 739
 740 #define PROC_I8K "/proc/i8k"
 741 #define I8K_DELIM " "
 742 static char *i8k_procbuf = NULL;
 743 void update_i8k(void)
 744 {
 745         FILE *fp;
 746
 747         if (!i8k_procbuf) {
 748                 i8k_procbuf = (char *) malloc(128 * sizeof(char));
 749         }
 750         if ((fp = fopen(PROC_I8K, "r")) == NULL) {
 751                 CRIT_ERR("/proc/i8k doesn't exist! use insmod to make sure the kernel "
 752                         "driver is loaded...");
 753         }
 754
 755         memset(&i8k_procbuf[0], 0, 128);
 756         if (fread(&i8k_procbuf[0], sizeof(char), 128, fp) == 0) {
 757                 ERR("something wrong with /proc/i8k...");
 758         }
 759
 760         fclose(fp);
 761
 762         i8k.version = strtok(&i8k_procbuf[0], I8K_DELIM);
 763         i8k.bios = strtok(NULL, I8K_DELIM);
 764         i8k.serial = strtok(NULL, I8K_DELIM);
 765         i8k.cpu_temp = strtok(NULL, I8K_DELIM);
 766         i8k.left_fan_status = strtok(NULL, I8K_DELIM);
 767         i8k.right_fan_status = strtok(NULL, I8K_DELIM);
 768         i8k.left_fan_rpm = strtok(NULL, I8K_DELIM);
 769         i8k.right_fan_rpm = strtok(NULL, I8K_DELIM);
 770         i8k.ac_status = strtok(NULL, I8K_DELIM);
 771         i8k.buttons_status = strtok(NULL, I8K_DELIM);
 772 }
 773
 774 /***********************************************************/
 775 /***********************************************************/
 776 /***********************************************************/
 777
 778 static int no_dots(const struct dirent *d)
 779 {
 780         if (d->d_name[0] == '.') {
 781                 return 0;
 782         }
 783         return 1;
 784 }
 785
 786 static int get_first_file_in_a_directory(const char *dir, char *s, int *rep)
 787 {
 788         struct dirent **namelist;
 789         int i, n;
 790
 791         n = scandir(dir, &namelist, no_dots, alphasort);
 792         if (n < 0) {
 793                 if (!rep || !*rep) {
 794                         ERR("scandir for %s: %s", dir, strerror(errno));
 795                         if (rep) {
 796                                 *rep = 1;
 797                         }
 798                 }
 799                 return 0;
 800         } else {
 801                 if (n == 0) {
 802                         return 0;
 803                 }
 804
 805                 strncpy(s, namelist[0]->d_name, 255);
 806                 s[255] = '\0';
 807
 808                 for (i = 0; i < n; i++) {
 809                         free(namelist[i]);
 810                 }
 811                 free(namelist);
 812
 813                 return 1;
 814         }
 815 }
 816
 817 int open_sysfs_sensor(const char *dir, const char *dev, const char *type, int n,
 818                 int *divisor, char *devtype)
 819 {
 820         char path[256];
 821         char buf[256];
 822         int fd;
 823         int divfd;
 824
 825         memset(buf, 0, sizeof(buf));
 826
 827         /* if device is NULL or *, get first */
 828         if (dev == NULL || strcmp(dev, "*") == 0) {
 829                 static int rep = 0;
 830
 831                 if (!get_first_file_in_a_directory(dir, buf, &rep)) {
 832                         return -1;
 833                 }
 834                 dev = buf;
 835         }
 836
 837         if (strcmp(dir, "/sys/class/hwmon/") == 0) {
 838                 if (*buf) {
 839                         /* buf holds result from get_first_file_in_a_directory() above,
 840                          * e.g. "hwmon0" -- append "/device" */
 841                         strcat(buf, "/device");
 842                 } else {
 843                         /* dev holds device number N as a string,
 844                          * e.g. "0", -- convert to "hwmon0/device" */
 845                         sprintf(buf, "hwmon%s/device", dev);
 846                         dev = buf;
 847                 }
 848         }
 849
 850         /* change vol to in */
 851         if (strcmp(type, "vol") == 0) {
 852                 type = "in";
 853         }
 854
 855         if (strcmp(type, "tempf") == 0) {
 856                 snprintf(path, 255, "%s%s/%s%d_input", dir, dev, "temp", n);
 857         } else {
 858                 snprintf(path, 255, "%s%s/%s%d_input", dir, dev, type, n);
 859         }
 860         strncpy(devtype, path, 255);
 861
 862         /* open file */
 863         fd = open(path, O_RDONLY);
 864         if (fd < 0) {
 865                 CRIT_ERR("can't open '%s': %s\nplease check your device or remove this "
 866                         "var from Conky", path, strerror(errno));
 867         }
 868
 869         if (strcmp(type, "in") == 0 || strcmp(type, "temp") == 0
 870                         || strcmp(type, "tempf") == 0) {
 871                 *divisor = 1;
 872         } else {
 873                 *divisor = 0;
 874         }
 875         /* fan does not use *_div as a read divisor */
 876         if (strcmp("fan", type) == 0) {
 877                 return fd;
 878         }
 879
 880         /* test if *_div file exist, open it and use it as divisor */
 881         if (strcmp(type, "tempf") == 0) {
 882                 snprintf(path, 255, "%s%s/%s%d_div", dir, "one", "two", n);
 883         } else {
 884                 snprintf(path, 255, "%s%s/%s%d_div", dir, dev, type, n);
 885         }
 886
 887         divfd = open(path, O_RDONLY);
 888         if (divfd > 0) {
 889                 /* read integer */
 890                 char divbuf[64];
 891                 int divn;
 892
 893                 divn = read(divfd, divbuf, 63);
 894                 /* should read until n == 0 but I doubt that kernel will give these
 895                  * in multiple pieces. :) */
 896                 if (divn < 0) {
 897                         ERR("open_sysfs_sensor(): can't read from sysfs");
 898                 } else {
 899                         divbuf[divn] = '\0';
 900                         *divisor = atoi(divbuf);
 901                 }
 902         }
 903
 904         close(divfd);
 905
 906         return fd;
 907 }
 908
 909 double get_sysfs_info(int *fd, int divisor, char *devtype, char *type)
 910 {
 911         int val = 0;
 912
 913         if (*fd <= 0) {
 914                 return 0;
 915         }
 916
 917         lseek(*fd, 0, SEEK_SET);
 918
 919         /* read integer */
 920         {
 921                 char buf[64];
 922                 int n;
 923                 n = read(*fd, buf, 63);
 924                 /* should read until n == 0 but I doubt that kernel will give these
 925                  * in multiple pieces. :) */
 926                 if (n < 0) {
 927                         ERR("get_sysfs_info(): read from %s failed\n", devtype);
 928                 } else {
 929                         buf[n] = '\0';
 930                         val = atoi(buf);
 931                 }
 932         }
 933
 934         close(*fd);
 935         /* open file */
 936         *fd = open(devtype, O_RDONLY);
 937         if (*fd < 0) {
 938                 ERR("can't open '%s': %s", devtype, strerror(errno));
 939         }
 940
 941         /* My dirty hack for computing CPU value
 942          * Filedil, from forums.gentoo.org */
 943         /* if (strstr(devtype, "temp1_input") != NULL) {
 944                 return -15.096 + 1.4893 * (val / 1000.0);
 945         } */
 946
 947         /* divide voltage and temperature by 1000 */
 948         /* or if any other divisor is given, use that */
 949         if (strcmp(type, "tempf") == 0) {
 950                 if (divisor > 1) {
 951                         return ((val / divisor + 40) * 9.0 / 5) - 40;
 952                 } else if (divisor) {
 953                         return ((val / 1000.0 + 40) * 9.0 / 5) - 40;
 954                 } else {
 955                         return ((val + 40) * 9.0 / 5) - 40;
 956                 }
 957         } else {
 958                 if (divisor > 1) {
 959                         return val / divisor;
 960                 } else if (divisor) {
 961                         return val / 1000.0;
 962                 } else {
 963                         return val;
 964                 }
 965         }
 966 }
 967
 968 /* Prior to kernel version 2.6.12, the CPU fan speed was available in
 969  * ADT746X_FAN_OLD, whereas later kernel versions provide this information in
 970  * ADT746X_FAN. */
 971 #define ADT746X_FAN "/sys/devices/temperatures/sensor1_fan_speed"
 972 #define ADT746X_FAN_OLD "/sys/devices/temperatures/cpu_fan_speed"
 973
 974 void get_adt746x_fan(char *p_client_buffer, size_t client_buffer_size)
 975 {
 976         static int rep = 0;
 977         char adt746x_fan_state[64];
 978         FILE *fp;
 979
 980         if (!p_client_buffer || client_buffer_size <= 0) {
 981                 return;
 982         }
 983
 984         if ((fp = open_file(ADT746X_FAN, &rep)) == NULL
 985                         && (fp = open_file(ADT746X_FAN_OLD, &rep)) == NULL) {
 986                 sprintf(adt746x_fan_state, "adt746x not found");
 987         } else {
 988                 fgets(adt746x_fan_state, sizeof(adt746x_fan_state), fp);
 989                 adt746x_fan_state[strlen(adt746x_fan_state) - 1] = 0;
 990                 fclose(fp);
 991         }
 992
 993         snprintf(p_client_buffer, client_buffer_size, "%s", adt746x_fan_state);
 994 }
 995
 996 /* Prior to kernel version 2.6.12, the CPU temperature was found in
 997  * ADT746X_CPU_OLD, whereas later kernel versions provide this information in
 998  * ADT746X_CPU. */
 999 #define ADT746X_CPU "/sys/devices/temperatures/sensor1_temperature"
1000 #define ADT746X_CPU_OLD "/sys/devices/temperatures/cpu_temperature"
1001
1002 void get_adt746x_cpu(char *p_client_buffer, size_t client_buffer_size)
1003 {
1004         static int rep = 0;
1005         char adt746x_cpu_state[64];
1006         FILE *fp;
1007
1008         if (!p_client_buffer || client_buffer_size <= 0) {
1009                 return;
1010         }
1011
1012         if ((fp = open_file(ADT746X_CPU, &rep)) == NULL
1013                         && (fp = open_file(ADT746X_CPU_OLD, &rep)) == NULL) {
1014                 sprintf(adt746x_cpu_state, "adt746x not found");
1015         } else {
1016                 fscanf(fp, "%2s", adt746x_cpu_state);
1017                 fclose(fp);
1018         }
1019
1020         snprintf(p_client_buffer, client_buffer_size, "%s", adt746x_cpu_state);
1021 }
1022
1023 /* Thanks to "Walt Nelson" <wnelsonjr@comcast.net> */
1024
1025 /***********************************************************************/
1026 /* This file is part of x86info.
1027  * (C) 2001 Dave Jones.
1028  *
1029  * Licensed under the terms of the GNU GPL License version 2.
1030  *
1031  * Estimate CPU MHz routine by Andrea Arcangeli <andrea@suse.de>
1032  * Small changes by David Sterba <sterd9am@ss1000.ms.mff.cuni.cz> */
1033
1034 #if  defined(__i386) || defined(__x86_64)
1035 __inline__ unsigned long long int rdtsc(void)
1036 {
1037         unsigned long long int x;
1038
1039         __asm__ volatile(".byte 0x0f, 0x31":"=A" (x));
1040         return x;
1041 }
1042 #endif
1043
1044 /* return system frequency in MHz (use divisor=1) or GHz (use divisor=1000) */
1045 void get_freq_dynamic(char *p_client_buffer, size_t client_buffer_size,
1046                 const char *p_format, int divisor)
1047 {
1048 #if  defined(__i386) || defined(__x86_64)
1049         struct timezone tz;
1050         struct timeval tvstart, tvstop;
1051         unsigned long long cycles[2];   /* gotta be 64 bit */
1052         unsigned int microseconds;      /* total time taken */
1053
1054         if (!p_client_buffer || client_buffer_size <= 0 || !p_format
1055                         || divisor <= 0) {
1056                 return;
1057         }
1058
1059         memset(&tz, 0, sizeof(tz));
1060
1061         /* get this function in cached memory */
1062         gettimeofday(&tvstart, &tz);
1063         cycles[0] = rdtsc();
1064         gettimeofday(&tvstart, &tz);
1065
1066         /* we don't trust that this is any specific length of time */
1067         usleep(100);
1068         cycles[1] = rdtsc();
1069         gettimeofday(&tvstop, &tz);
1070         microseconds = ((tvstop.tv_sec - tvstart.tv_sec) * 1000000) +
1071                 (tvstop.tv_usec - tvstart.tv_usec);
1072
1073         snprintf(p_client_buffer, client_buffer_size, p_format,
1074                 (float) ((cycles[1] - cycles[0]) / microseconds) / divisor);
1075         return;
1076 #else
1077         /* FIXME: hardwired: get freq for first cpu!
1078          * this whole function needs to be rethought and redone for
1079          * multi-cpu/multi-core/multi-threaded environments and
1080          * arbitrary combinations thereof */
1081         get_freq(p_client_buffer, client_buffer_size, p_format, divisor, 1);
1082         return;
1083 #endif
1084 }
1085
1086 #define CPUFREQ_PREFIX "/sys/devices/system/cpu"
1087 #define CPUFREQ_POSTFIX "cpufreq/scaling_cur_freq"
1088
1089 /* return system frequency in MHz (use divisor=1) or GHz (use divisor=1000) */
1090 char get_freq(char *p_client_buffer, size_t client_buffer_size,
1091                 const char *p_format, int divisor, unsigned int cpu)
1092 {
1093         FILE *f;
1094         static int rep = 0;
1095         char frequency[32];
1096         char s[256];
1097         double freq = 0;
1098
1099         if (!p_client_buffer || client_buffer_size <= 0 || !p_format
1100                         || divisor <= 0) {
1101                 return 0;
1102         }
1103
1104         if (!prefer_proc) {
1105                 char current_freq_file[128];
1106
1107                 snprintf(current_freq_file, 127, "%s/cpu%d/%s", CPUFREQ_PREFIX, cpu - 1,
1108                         CPUFREQ_POSTFIX);
1109                 f = fopen(current_freq_file, "r");
1110                 if (f) {
1111                         /* if there's a cpufreq /sys node, read the current frequency from
1112                          * this node and divide by 1000 to get Mhz. */
1113                         if (fgets(s, sizeof(s), f)) {
1114                                 s[strlen(s) - 1] = '\0';
1115                                 freq = strtod(s, NULL);
1116                         }
1117                         fclose(f);
1118                         snprintf(p_client_buffer, client_buffer_size, p_format,
1119                                 (freq / 1000) / divisor);
1120                         return 1;
1121                 }
1122         }
1123
1124         // open the CPU information file
1125         f = open_file("/proc/cpuinfo", &rep);
1126         if (!f) {
1127                 perror("Conky: Failed to access '/proc/cpuinfo' at get_freq()");
1128                 return 0;
1129         }
1130
1131         // read the file
1132         while (fgets(s, sizeof(s), f) != NULL) {
1133
1134 #if defined(__i386) || defined(__x86_64)
1135                 // and search for the cpu mhz
1136                 if (strncmp(s, "cpu MHz", 7) == 0 && cpu == 0) {
1137 #else
1138 #if defined(__alpha)
1139                 // different on alpha
1140                 if (strncmp(s, "cycle frequency [Hz]", 20) == 0 && cpu == 0) {
1141 #else
1142                 // this is different on ppc for some reason
1143                 if (strncmp(s, "clock", 5) == 0 && cpu == 0) {
1144 #endif // defined(__alpha)
1145 #endif // defined(__i386) || defined(__x86_64)
1146
1147                         // copy just the number
1148                         strcpy(frequency, strchr(s, ':') + 2);
1149 #if defined(__alpha)
1150                         // strip " est.\n"
1151                         frequency[strlen(frequency) - 6] = '\0';
1152                         // kernel reports in Hz
1153                         freq = strtod(frequency, NULL) / 1000000;
1154 #else
1155                         // strip \n
1156                         frequency[strlen(frequency) - 1] = '\0';
1157                         freq = strtod(frequency, NULL);
1158 #endif
1159                         break;
1160                 }
1161                 if (strncmp(s, "processor", 9) == 0) {
1162                         cpu--;
1163                         continue;
1164                 }
1165         }
1166
1167         fclose(f);
1168         snprintf(p_client_buffer, client_buffer_size, p_format,
1169                 (float) freq / divisor);
1170         return 1;
1171 }
1172
1173 #define CPUFREQ_VOLTAGE "cpufreq/scaling_voltages"
1174
1175 /* /sys/devices/system/cpu/cpu0/cpufreq/scaling_voltages looks something
1176  * like this:
1177 # frequency voltage
1178 1800000 1340
1179 1600000 1292
1180 1400000 1100
1181 1200000 988
1182 1000000 1116
1183 800000 1004
1184 600000 988
1185  * Peter Tarjan (ptarjan@citromail.hu) */
1186
1187 /* return cpu voltage in mV (use divisor=1) or V (use divisor=1000) */
1188 char get_voltage(char *p_client_buffer, size_t client_buffer_size,
1189                 const char *p_format, int divisor, unsigned int cpu)
1190 {
1191         FILE *f;
1192         char s[256];
1193         int freq = 0;
1194         int voltage = 0;
1195         char current_freq_file[128];
1196         int freq_comp = 0;
1197
1198         /* build the voltage file name */
1199         cpu--;
1200         snprintf(current_freq_file, 127, "%s/cpu%d/%s", CPUFREQ_PREFIX, cpu,
1201                 CPUFREQ_POSTFIX);
1202
1203         if (!p_client_buffer || client_buffer_size <= 0 || !p_format
1204                         || divisor <= 0) {
1205                 return 0;
1206         }
1207
1208         /* read the current cpu frequency from the /sys node */
1209         f = fopen(current_freq_file, "r");
1210         if (f) {
1211                 if (fgets(s, sizeof(s), f)) {
1212                         s[strlen(s) - 1] = '\0';
1213                         freq = strtod(s, NULL);
1214                 }
1215                 fclose(f);
1216         } else {
1217                 fprintf(stderr, "Conky: Failed to access '%s' at ", current_freq_file);
1218                 perror("get_voltage()");
1219                 if (f) {
1220                         fclose(f);
1221                 }
1222                 return 0;
1223         }
1224
1225         snprintf(current_freq_file, 127, "%s/cpu%d/%s", CPUFREQ_PREFIX, cpu,
1226                 CPUFREQ_VOLTAGE);
1227
1228         /* use the current cpu frequency to find the corresponding voltage */
1229         f = fopen(current_freq_file, "r");
1230
1231         if (f) {
1232                 while (!feof(f)) {
1233                         char line[256];
1234
1235                         if (fgets(line, 255, f) == NULL) {
1236                                 break;
1237                         }
1238                         sscanf(line, "%d %d", &freq_comp, &voltage);
1239                         if (freq_comp == freq) {
1240                                 break;
1241                         }
1242                 }
1243                 fclose(f);
1244         } else {
1245                 fprintf(stderr, "Conky: Failed to access '%s' at ", current_freq_file);
1246                 perror("get_voltage()");
1247                 if (f) {
1248                         fclose(f);
1249                 }
1250                 return 0;
1251         }
1252         snprintf(p_client_buffer, client_buffer_size, p_format,
1253                 (float) voltage / divisor);
1254         return 1;
1255 }
1256
1257 #define ACPI_FAN_DIR "/proc/acpi/fan/"
1258
1259 void get_acpi_fan(char *p_client_buffer, size_t client_buffer_size)
1260 {
1261         static int rep = 0;
1262         char buf[256];
1263         char buf2[256];
1264         FILE *fp;
1265
1266         if (!p_client_buffer || client_buffer_size <= 0) {
1267                 return;
1268         }
1269
1270         /* yeah, slow... :/ */
1271         if (!get_first_file_in_a_directory(ACPI_FAN_DIR, buf, &rep)) {
1272                 snprintf(p_client_buffer, client_buffer_size, "no fans?");
1273                 return;
1274         }
1275
1276         snprintf(buf2, sizeof(buf2), "%s%s/state", ACPI_FAN_DIR, buf);
1277
1278         fp = open_file(buf2, &rep);
1279         if (!fp) {
1280                 snprintf(p_client_buffer, client_buffer_size,
1281                         "can't open fan's state file");
1282                 return;
1283         }
1284         memset(buf, 0, sizeof(buf));
1285         fscanf(fp, "%*s %99s", buf);
1286         fclose(fp);
1287
1288         snprintf(p_client_buffer, client_buffer_size, "%s", buf);
1289 }
1290
1291 #define ACPI_AC_ADAPTER_DIR "/proc/acpi/ac_adapter/"
1292
1293 void get_acpi_ac_adapter(char *p_client_buffer, size_t client_buffer_size)
1294 {
1295         static int rep = 0;
1296         char buf[256];
1297         char buf2[256];
1298         FILE *fp;
1299
1300         if (!p_client_buffer || client_buffer_size <= 0) {
1301                 return;
1302         }
1303
1304         /* yeah, slow... :/ */
1305         if (!get_first_file_in_a_directory(ACPI_AC_ADAPTER_DIR, buf, &rep)) {
1306                 snprintf(p_client_buffer, client_buffer_size, "no ac_adapters?");
1307                 return;
1308         }
1309
1310         snprintf(buf2, sizeof(buf2), "%s%s/state", ACPI_AC_ADAPTER_DIR, buf);
1311
1312         fp = open_file(buf2, &rep);
1313         if (!fp) {
1314                 snprintf(p_client_buffer, client_buffer_size,
1315                         "No ac adapter found.... where is it?");
1316                 return;
1317         }
1318         memset(buf, 0, sizeof(buf));
1319         fscanf(fp, "%*s %99s", buf);
1320         fclose(fp);
1321
1322         snprintf(p_client_buffer, client_buffer_size, "%s", buf);
1323 }
1324
1325 /*
1326 /proc/acpi/thermal_zone/THRM/cooling_mode
1327 cooling mode:            active
1328 /proc/acpi/thermal_zone/THRM/polling_frequency
1329 <polling disabled>
1330 /proc/acpi/thermal_zone/THRM/state
1331 state:                   ok
1332 /proc/acpi/thermal_zone/THRM/temperature
1333 temperature:             45 C
1334 /proc/acpi/thermal_zone/THRM/trip_points
1335 critical (S5):           73 C
1336 passive:                 73 C: tc1=4 tc2=3 tsp=40 devices=0xcdf6e6c0
1337 */
1338
1339 #define ACPI_THERMAL_DIR "/proc/acpi/thermal_zone/"
1340 #define ACPI_THERMAL_FORMAT "/proc/acpi/thermal_zone/%s/temperature"
1341
1342 int open_acpi_temperature(const char *name)
1343 {
1344         char path[256];
1345         char buf[256];
1346         int fd;
1347
1348         if (name == NULL || strcmp(name, "*") == 0) {
1349                 static int rep = 0;
1350
1351                 if (!get_first_file_in_a_directory(ACPI_THERMAL_DIR, buf, &rep)) {
1352                         return -1;
1353                 }
1354                 name = buf;
1355         }
1356
1357         snprintf(path, 255, ACPI_THERMAL_FORMAT, name);
1358
1359         fd = open(path, O_RDONLY);
1360         if (fd < 0) {
1361                 ERR("can't open '%s': %s", path, strerror(errno));
1362         }
1363
1364         return fd;
1365 }
1366
1367 static double last_acpi_temp;
1368 static double last_acpi_temp_time;
1369
1370 double get_acpi_temperature(int fd)
1371 {
1372         if (fd <= 0) {
1373                 return 0;
1374         }
1375
1376         /* don't update acpi temperature too often */
1377         if (current_update_time - last_acpi_temp_time < 11.32) {
1378                 return last_acpi_temp;
1379         }
1380         last_acpi_temp_time = current_update_time;
1381
1382         /* seek to beginning */
1383         lseek(fd, 0, SEEK_SET);
1384
1385         /* read */
1386         {
1387                 char buf[256];
1388                 int n;
1389
1390                 n = read(fd, buf, 255);
1391                 if (n < 0) {
1392                         ERR("can't read fd %d: %s", fd, strerror(errno));
1393                 } else {
1394                         buf[n] = '\0';
1395                         sscanf(buf, "temperature: %lf", &last_acpi_temp);
1396                 }
1397         }
1398
1399         return last_acpi_temp;
1400 }
1401
1402 /*
1403 hipo@lepakko hipo $ cat /proc/acpi/battery/BAT1/info
1404 present:                 yes
1405 design capacity:         4400 mAh
1406 last full capacity:      4064 mAh
1407 battery technology:      rechargeable
1408 design voltage:          14800 mV
1409 design capacity warning: 300 mAh
1410 design capacity low:     200 mAh
1411 capacity granularity 1:  32 mAh
1412 capacity granularity 2:  32 mAh
1413 model number:            02KT
1414 serial number:           16922
1415 battery type:            LION
1416 OEM info:                SANYO
1417 */
1418
1419 /*
1420 hipo@lepakko conky $ cat /proc/acpi/battery/BAT1/state
1421 present:                 yes
1422 capacity state:          ok
1423 charging state:          unknown
1424 present rate:            0 mA
1425 remaining capacity:      4064 mAh
1426 present voltage:         16608 mV
1427 */
1428
1429 /*
1430 2213<@jupet�kellari��> jupet@lagi-unstable:~$ cat /proc/apm
1431 2213<@jupet�kellari��> 1.16 1.2 0x03 0x01 0xff 0x10 -1% -1 ?
1432 2213<@jupet�kellari��> (-1 ollee ei akkua kiinni, koska akku on p�yd�ll�)
1433 2214<@jupet�kellari��> jupet@lagi-unstable:~$ cat /proc/apm
1434 2214<@jupet�kellari��> 1.16 1.2 0x03 0x01 0x03 0x09 98% -1 ?
1435
1436 2238<@jupet�kellari��> 1.16 1.2 0x03 0x00 0x00 0x01 100% -1 ? ilman verkkovirtaa
1437 2239<@jupet�kellari��> 1.16 1.2 0x03 0x01 0x00 0x01 99% -1 ? verkkovirralla
1438
1439 2240<@jupet�kellari��> 1.16 1.2 0x03 0x01 0x03 0x09 100% -1 ? verkkovirralla ja monitori p��ll�
1440 2241<@jupet�kellari��> 1.16 1.2 0x03 0x00 0x00 0x01 99% -1 ? monitori p��ll� mutta ilman verkkovirtaa
1441 */
1442
1443 /* Kapil Hari Paranjape <kapil@imsc.res.in>
1444   Linux 2.6.24 onwards battery info is in
1445   /sys/class/power_supply/BAT0/
1446   On my system I get the following.
1447         /sys/class/power_supply/BAT0/uevent:
1448         PHYSDEVPATH=/devices/LNXSYSTM:00/device:00/PNP0A03:00/device:01/PNP0C09:00/PNP0C0A:00
1449         PHYSDEVBUS=acpi
1450         PHYSDEVDRIVER=battery
1451         POWER_SUPPLY_NAME=BAT0
1452         POWER_SUPPLY_TYPE=Battery
1453         POWER_SUPPLY_STATUS=Discharging
1454         POWER_SUPPLY_PRESENT=1
1455         POWER_SUPPLY_TECHNOLOGY=Li-ion
1456         POWER_SUPPLY_VOLTAGE_MIN_DESIGN=10800000
1457         POWER_SUPPLY_VOLTAGE_NOW=10780000
1458         POWER_SUPPLY_CURRENT_NOW=13970000
1459         POWER_SUPPLY_ENERGY_FULL_DESIGN=47510000
1460         POWER_SUPPLY_ENERGY_FULL=27370000
1461         POWER_SUPPLY_ENERGY_NOW=11810000
1462         POWER_SUPPLY_MODEL_NAME=IBM-92P1060
1463         POWER_SUPPLY_MANUFACTURER=Panasonic
1464   On some systems POWER_SUPPLY_ENERGY_* is replaced by POWER_SUPPLY_CHARGE_*
1465 */
1466
1467 #define SYSFS_BATTERY_BASE_PATH "/sys/class/power_supply"
1468 #define ACPI_BATTERY_BASE_PATH "/proc/acpi/battery"
1469 #define APM_PATH "/proc/apm"
1470 #define MAX_BATTERY_COUNT 4
1471
1472 static FILE *sysfs_bat_fp[MAX_BATTERY_COUNT] = { NULL, NULL, NULL, NULL };
1473 static FILE *acpi_bat_fp[MAX_BATTERY_COUNT] = { NULL, NULL, NULL, NULL };
1474 static FILE *apm_bat_fp[MAX_BATTERY_COUNT] = { NULL, NULL, NULL, NULL };
1475
1476 static int batteries_initialized = 0;
1477 static char batteries[MAX_BATTERY_COUNT][32];
1478
1479 static int acpi_last_full[MAX_BATTERY_COUNT];
1480 static int acpi_design_capacity[MAX_BATTERY_COUNT];
1481
1482 /* e.g. "charging 75%" */
1483 static char last_battery_str[MAX_BATTERY_COUNT][64];
1484 /* e.g. "3h 15m" */
1485 static char last_battery_time_str[MAX_BATTERY_COUNT][64];
1486
1487 static double last_battery_time[MAX_BATTERY_COUNT];
1488
1489 static int last_battery_perct[MAX_BATTERY_COUNT];
1490 static double last_battery_perct_time[MAX_BATTERY_COUNT];
1491
1492 void init_batteries(void)
1493 {
1494         int idx;
1495
1496         if (batteries_initialized) {
1497                 return;
1498         }
1499         for (idx = 0; idx < MAX_BATTERY_COUNT; idx++) {
1500                 batteries[idx][0] = '\0';
1501         }
1502         batteries_initialized = 1;
1503 }
1504
1505 int get_battery_idx(const char *bat)
1506 {
1507         int idx;
1508
1509         for (idx = 0; idx < MAX_BATTERY_COUNT; idx++) {
1510                 if (!strlen(batteries[idx]) || !strcmp(batteries[idx], bat)) {
1511                         break;
1512                 }
1513         }
1514
1515         /* if not found, enter a new entry */
1516         if (!strlen(batteries[idx])) {
1517                 snprintf(batteries[idx], 31, "%s", bat);
1518         }
1519
1520         return idx;
1521 }
1522
1523 void get_battery_stuff(char *buffer, unsigned int n, const char *bat, int item)
1524 {
1525         static int idx, rep = 0, rep2 = 0;
1526         char acpi_path[128];
1527         char sysfs_path[128];
1528
1529         snprintf(acpi_path, 127, ACPI_BATTERY_BASE_PATH "/%s/state", bat);
1530         snprintf(sysfs_path, 127, SYSFS_BATTERY_BASE_PATH "/%s/uevent", bat);
1531
1532         init_batteries();
1533
1534         idx = get_battery_idx(bat);
1535
1536         /* don't update battery too often */
1537         if (current_update_time - last_battery_time[idx] < 29.5) {
1538                 goto set_return_value;
1539         }
1540
1541         last_battery_time[idx] = current_update_time;
1542
1543         memset(last_battery_str[idx], 0, sizeof(last_battery_str[idx]));
1544         memset(last_battery_time_str[idx], 0, sizeof(last_battery_time_str[idx]));
1545
1546         /* first try SYSFS if that fails try ACPI */
1547
1548         if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL) {
1549                 sysfs_bat_fp[idx] = open_file(sysfs_path, &rep);
1550                 rep = 0;
1551         }
1552
1553         if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL) {
1554                 acpi_bat_fp[idx] = open_file(acpi_path, &rep);
1555         }
1556
1557         if (sysfs_bat_fp[idx] != NULL) {
1558                 /* SYSFS */
1559                 int present_rate = -1;
1560                 int remaining_capacity = -1;
1561                 char charging_state[64];
1562                 char present[4];
1563
1564                 strcpy(charging_state, "Unknown");
1565
1566                 while (!feof(sysfs_bat_fp[idx])) {
1567                         char buf[256];
1568                         if (fgets(buf, 256, sysfs_bat_fp[idx]) == NULL)
1569                                 break;
1570
1571                         /* let's just hope units are ok */
1572                         if (strncmp (buf, "POWER_SUPPLY_PRESENT=1", 22) == 0)
1573                                 strcpy(present, "Yes");
1574                         else if (strncmp (buf, "POWER_SUPPLY_PRESENT=0", 22) == 0)
1575                                 strcpy(present, "No");
1576                         else if (strncmp (buf, "POWER_SUPPLY_STATUS=", 20) == 0)
1577                                 sscanf(buf, "POWER_SUPPLY_STATUS=%63s", charging_state);
1578                         /* present_rate is not the same as the
1579                         current flowing now but it is the same value
1580                         which was used in the past. so we continue
1581                         the tradition! */
1582                         else if (strncmp(buf, "POWER_SUPPLY_CURRENT_NOW=", 25) == 0)
1583                                 sscanf(buf, "POWER_SUPPLY_CURRENT_NOW=%d", &present_rate);
1584                         else if (strncmp(buf, "POWER_SUPPLY_ENERGY_NOW=", 24) == 0)
1585                                 sscanf(buf, "POWER_SUPPLY_ENERGY_NOW=%d", &remaining_capacity);
1586                         else if (strncmp(buf, "POWER_SUPPLY_ENERGY_FULL=", 25) == 0)
1587                                 sscanf(buf, "POWER_SUPPLY_ENERGY_FULL=%d", &acpi_last_full[idx]);
1588                         else if (strncmp(buf, "POWER_SUPPLY_CHARGE_NOW=", 24) == 0)
1589                                 sscanf(buf, "POWER_SUPPLY_CHARGE_NOW=%d", &remaining_capacity);
1590                         else if (strncmp(buf, "POWER_SUPPLY_CHARGE_FULL=", 25) == 0)
1591                                 sscanf(buf, "POWER_SUPPLY_CHARGE_FULL=%d", &acpi_last_full[idx]);
1592                 }
1593
1594                 fclose(sysfs_bat_fp[idx]);
1595                 sysfs_bat_fp[idx] = NULL;
1596
1597                 /* Hellf[i]re notes that remaining capacity can exceed acpi_last_full */
1598                 if (remaining_capacity > acpi_last_full[idx])
1599                         acpi_last_full[idx] = remaining_capacity;  /* normalize to 100% */
1600
1601                 /* not present */
1602                 if (strcmp(present, "No") == 0) {
1603                         strncpy(last_battery_str[idx], "not present", 64);
1604                 }
1605                 /* charging */
1606                 else if (strcmp(charging_state, "Charging") == 0) {
1607                         if (acpi_last_full[idx] != 0 && present_rate > 0) {
1608                                 /* e.g. charging 75% */
1609                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Charging %i%%",
1610                                         (int) (((float) remaining_capacity / acpi_last_full[idx]) * 100 ));
1611                                 /* e.g. 2h 37m */
1612                                 format_seconds(last_battery_time_str[idx], sizeof(last_battery_time_str[idx])-1,
1613                                               (long) (((float)(acpi_last_full[idx] - remaining_capacity) / present_rate) * 3600));
1614                         } else if (acpi_last_full[idx] != 0 && present_rate <= 0) {
1615                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Charging %d%%",
1616                                         (int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
1617                         } else {
1618                                 strncpy(last_battery_str[idx], "Charging", sizeof(last_battery_str[idx])-1);
1619                         }
1620                 }
1621                 /* discharging */
1622                 else if (strncmp(charging_state, "Discharging", 64) == 0) {
1623                         if (present_rate > 0) {
1624                                 /* e.g. discharging 35% */
1625                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Discharging %i%%",
1626                                         (int) (((float) remaining_capacity / acpi_last_full[idx]) * 100 ));
1627                                 /* e.g. 1h 12m */
1628                                 format_seconds(last_battery_time_str[idx], sizeof(last_battery_time_str[idx])-1,
1629                                               (long) (((float)(acpi_last_full[idx] - remaining_capacity) / present_rate) * 3600));
1630                         } else if (present_rate == 0) { /* Thanks to Nexox for this one */
1631                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Full");
1632                         } else {
1633                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1,
1634                                         "Discharging %d%%",
1635                                         (int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
1636                         }
1637                 }
1638                 /* charged */
1639                 /* thanks to Lukas Zapletal <lzap@seznam.cz> */
1640                 else if (strncmp(charging_state, "Charged", 64) == 0) {
1641                                 /* Below happens with the second battery on my X40,
1642                                  * when the second one is empty and the first one
1643                                  * being charged. */
1644                                 if (remaining_capacity == 0)
1645                                         strcpy(last_battery_str[idx], "Empty");
1646                                 else
1647                                         strcpy(last_battery_str[idx], "Charged");
1648                 }
1649                 /* unknown, probably full / AC */
1650                 else {
1651                         if (acpi_last_full[idx] != 0
1652                             && remaining_capacity != acpi_last_full[idx])
1653                                 snprintf(last_battery_str[idx], 64, "Unknown %d%%",
1654                                         (int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
1655                         else
1656                                 strncpy(last_battery_str[idx], "AC", 64);
1657                 }
1658         } else if (acpi_bat_fp[idx] != NULL) {
1659                 /* ACPI */
1660                 int present_rate = -1;
1661                 int remaining_capacity = -1;
1662                 char charging_state[64];
1663                 char present[4];
1664
1665                 /* read last full capacity if it's zero */
1666                 if (acpi_last_full[idx] == 0) {
1667                         static int rep3 = 0;
1668                         char path[128];
1669                         FILE *fp;
1670
1671                         snprintf(path, 127, ACPI_BATTERY_BASE_PATH "/%s/info", bat);
1672                         fp = open_file(path, &rep3);
1673                         if (fp != NULL) {
1674                                 while (!feof(fp)) {
1675                                         char b[256];
1676
1677                                         if (fgets(b, 256, fp) == NULL) {
1678                                                 break;
1679                                         }
1680                                         if (sscanf(b, "last full capacity: %d",
1681                                                         &acpi_last_full[idx]) != 0) {
1682                                                 break;
1683                                         }
1684                                 }
1685
1686                                 fclose(fp);
1687                         }
1688                 }
1689
1690                 fseek(acpi_bat_fp[idx], 0, SEEK_SET);
1691
1692                 strcpy(charging_state, "unknown");
1693
1694                 while (!feof(acpi_bat_fp[idx])) {
1695                         char buf[256];
1696
1697                         if (fgets(buf, 256, acpi_bat_fp[idx]) == NULL) {
1698                                 break;
1699                         }
1700
1701                         /* let's just hope units are ok */
1702                         if (strncmp(buf, "present:", 8) == 0) {
1703                                 sscanf(buf, "present: %4s", present);
1704                         } else if (strncmp(buf, "charging state:", 15) == 0) {
1705                                 sscanf(buf, "charging state: %63s", charging_state);
1706                         } else if (strncmp(buf, "present rate:", 13) == 0) {
1707                                 sscanf(buf, "present rate: %d", &present_rate);
1708                         } else if (strncmp(buf, "remaining capacity:", 19) == 0) {
1709                                 sscanf(buf, "remaining capacity: %d", &remaining_capacity);
1710                         }
1711                 }
1712                 /* Hellf[i]re notes that remaining capacity can exceed acpi_last_full */
1713                 if (remaining_capacity > acpi_last_full[idx]) {
1714                         /* normalize to 100% */
1715                         acpi_last_full[idx] = remaining_capacity;
1716                 }
1717
1718                 /* not present */
1719                 if (strcmp(present, "no") == 0) {
1720                         strncpy(last_battery_str[idx], "not present", 64);
1721                 /* charging */
1722                 } else if (strcmp(charging_state, "charging") == 0) {
1723                         if (acpi_last_full[idx] != 0 && present_rate > 0) {
1724                                 /* e.g. charging 75% */
1725                                 snprintf(last_battery_str[idx],
1726                                         sizeof(last_battery_str[idx]) - 1, "charging %i%%",
1727                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1728                                 /* e.g. 2h 37m */
1729                                 format_seconds(last_battery_time_str[idx],
1730                                         sizeof(last_battery_time_str[idx]) - 1,
1731                                         (long) (((acpi_last_full[idx] - remaining_capacity) *
1732                                         3600) / present_rate));
1733                         } else if (acpi_last_full[idx] != 0 && present_rate <= 0) {
1734                                 snprintf(last_battery_str[idx],
1735                                         sizeof(last_battery_str[idx]) - 1, "charging %d%%",
1736                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1737                         } else {
1738                                 strncpy(last_battery_str[idx], "charging",
1739                                         sizeof(last_battery_str[idx]) - 1);
1740                         }
1741                 /* discharging */
1742                 } else if (strncmp(charging_state, "discharging", 64) == 0) {
1743                         if (present_rate > 0) {
1744                                 /* e.g. discharging 35% */
1745                                 snprintf(last_battery_str[idx],
1746                                         sizeof(last_battery_str[idx]) - 1, "discharging %i%%",
1747                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1748                                 /* e.g. 1h 12m */
1749                                 format_seconds(last_battery_time_str[idx],
1750                                         sizeof(last_battery_time_str[idx]) - 1,
1751                                         (long) ((remaining_capacity * 3600) / present_rate));
1752                         } else if (present_rate == 0) { /* Thanks to Nexox for this one */
1753                                 snprintf(last_battery_str[idx],
1754                                         sizeof(last_battery_str[idx]) - 1, "full");
1755                         } else {
1756                                 snprintf(last_battery_str[idx],
1757                                         sizeof(last_battery_str[idx]) - 1, "discharging %d%%",
1758                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1759                         }
1760                 /* charged */
1761                 } else if (strncmp(charging_state, "charged", 64) == 0) {
1762                         /* thanks to Lukas Zapletal <lzap@seznam.cz> */
1763                         /* Below happens with the second battery on my X40,
1764                          * when the second one is empty and the first one being charged. */
1765                         if (remaining_capacity == 0) {
1766                                 strcpy(last_battery_str[idx], "empty");
1767                         } else {
1768                                 strcpy(last_battery_str[idx], "charged");
1769                         }
1770                 /* unknown, probably full / AC */
1771                 } else {
1772                         if (acpi_last_full[idx] != 0
1773                                         && remaining_capacity != acpi_last_full[idx]) {
1774                                 snprintf(last_battery_str[idx], 64, "unknown %d%%",
1775                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1776                         } else {
1777                                 strncpy(last_battery_str[idx], "AC", 64);
1778                         }
1779                 }
1780         } else {
1781                 /* APM */
1782                 if (apm_bat_fp[idx] == NULL) {
1783                         apm_bat_fp[idx] = open_file(APM_PATH, &rep2);
1784                 }
1785
1786                 if (apm_bat_fp[idx] != NULL) {
1787                         unsigned int ac, status, flag;
1788                         int life;
1789
1790                         fscanf(apm_bat_fp[idx], "%*s %*s %*x %x   %x       %x     %d%%",
1791                                 &ac, &status, &flag, &life);
1792
1793                         if (life == -1) {
1794                                 /* could check now that there is ac */
1795                                 snprintf(last_battery_str[idx], 64, "AC");
1796
1797                         /* could check that status == 3 here? */
1798                         } else if (ac && life != 100) {
1799                                 snprintf(last_battery_str[idx], 64, "charging %d%%", life);
1800                         } else {
1801                                 snprintf(last_battery_str[idx], 64, "%d%%", life);
1802                         }
1803
1804                         /* it seemed to buffer it so file must be closed (or could use
1805                          * syscalls directly but I don't feel like coding it now) */
1806                         fclose(apm_bat_fp[idx]);
1807                         apm_bat_fp[idx] = NULL;
1808                 }
1809         }
1810
1811 set_return_value:
1812         switch (item) {
1813                 case BATTERY_STATUS:
1814                         snprintf(buffer, n, "%s", last_battery_str[idx]);
1815                         break;
1816                 case BATTERY_TIME:
1817                         snprintf(buffer, n, "%s", last_battery_time_str[idx]);
1818                         break;
1819                 default:
1820                         break;
1821         }
1822 }
1823
1824 int get_battery_perct(const char *bat)
1825 {
1826         static int rep = 0;
1827         int idx;
1828         char acpi_path[128];
1829         char sysfs_path[128];
1830         int remaining_capacity = -1;
1831
1832         snprintf(acpi_path, 127, ACPI_BATTERY_BASE_PATH "/%s/state", bat);
1833         snprintf(sysfs_path, 127, SYSFS_BATTERY_BASE_PATH "/%s/uevent", bat);
1834
1835         init_batteries();
1836
1837         idx = get_battery_idx(bat);
1838
1839         /* don't update battery too often */
1840         if (current_update_time - last_battery_perct_time[idx] < 30) {
1841                 return last_battery_perct[idx];
1842         }
1843         last_battery_perct_time[idx] = current_update_time;
1844
1845         /* Only check for SYSFS or ACPI */
1846
1847         if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL) {
1848                 sysfs_bat_fp[idx] = open_file(sysfs_path, &rep);
1849                 rep = 0;
1850         }
1851
1852         if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL) {
1853                 acpi_bat_fp[idx] = open_file(acpi_path, &rep);
1854         }
1855
1856         if (sysfs_bat_fp[idx] != NULL) {
1857                 /* SYSFS */
1858                 while (!feof(sysfs_bat_fp[idx])) {
1859                         char buf[256];
1860                         if (fgets(buf, 256, sysfs_bat_fp[idx]) == NULL)
1861                                 break;
1862
1863                         if (strncmp(buf, "POWER_SUPPLY_CHARGE_NOW=", 24) == 0) {
1864                                 sscanf(buf, "POWER_SUPPLY_CHARGE_NOW=%d", &remaining_capacity);
1865                         } else if (strncmp(buf, "POWER_SUPPLY_CHARGE_FULL=",25) == 0) {
1866                                 sscanf(buf, "POWER_SUPPLY_CHARGE_FULL=%d", &acpi_design_capacity[idx]);
1867                         } else if (strncmp(buf, "POWER_SUPPLY_ENERGY_NOW=", 24) == 0) {
1868                                 sscanf(buf, "POWER_SUPPLY_ENERGY_NOW=%d", &remaining_capacity);
1869                         } else if (strncmp(buf, "POWER_SUPPLY_ENERGY_FULL=",25) == 0) {
1870                                 sscanf(buf, "POWER_SUPPLY_ENERGY_FULL=%d", &acpi_design_capacity[idx]);
1871                         }
1872                 }
1873
1874                 fclose(sysfs_bat_fp[idx]);
1875                 sysfs_bat_fp[idx] = NULL;
1876
1877         } else if (acpi_bat_fp[idx] != NULL) {
1878                 /* ACPI */
1879                 /* read last full capacity if it's zero */
1880                 if (acpi_design_capacity[idx] == 0) {
1881                         static int rep2;
1882                         char path[128];
1883                         FILE *fp;
1884
1885                         snprintf(path, 127, ACPI_BATTERY_BASE_PATH "/%s/info", bat);
1886                         fp = open_file(path, &rep2);
1887                         if (fp != NULL) {
1888                                 while (!feof(fp)) {
1889                                         char b[256];
1890
1891                                         if (fgets(b, 256, fp) == NULL) {
1892                                                 break;
1893                                         }
1894                                         if (sscanf(b, "last full capacity: %d",
1895                                                                 &acpi_design_capacity[idx]) != 0) {
1896                                                 break;
1897                                         }
1898                                 }
1899                                 fclose(fp);
1900                         }
1901                 }
1902
1903                 fseek(acpi_bat_fp[idx], 0, SEEK_SET);
1904
1905                 while (!feof(acpi_bat_fp[idx])) {
1906                         char buf[256];
1907
1908                         if (fgets(buf, 256, acpi_bat_fp[idx]) == NULL) {
1909                                 break;
1910                         }
1911
1912                         if (buf[0] == 'r') {
1913                                 sscanf(buf, "remaining capacity: %d", &remaining_capacity);
1914                         }
1915                 }
1916         }
1917         if (remaining_capacity < 0) {
1918                 return 0;
1919         }
1920         /* compute the battery percentage */
1921         last_battery_perct[idx] =
1922                 (int) (((float) remaining_capacity / acpi_design_capacity[idx]) * 100);
1923         return last_battery_perct[idx];
1924 }
1925
1926 int get_battery_perct_bar(const char *bar)
1927 {
1928         int idx;
1929
1930         get_battery_perct(bar);
1931         idx = get_battery_idx(bar);
1932         return (int) (last_battery_perct[idx] * 2.56 - 1);
1933 }
1934
1935 /* On Apple powerbook and ibook:
1936 $ cat /proc/pmu/battery_0
1937 flags      : 00000013
1938 charge     : 3623
1939 max_charge : 3720
1940 current    : 388
1941 voltage    : 16787
1942 time rem.  : 900
1943 $ cat /proc/pmu/info
1944 PMU driver version     : 2
1945 PMU firmware version   : 0c
1946 AC Power               : 1
1947 Battery count          : 1
1948 */
1949
1950 /* defines as in <linux/pmu.h> */
1951 #define PMU_BATT_PRESENT                0x00000001
1952 #define PMU_BATT_CHARGING               0x00000002
1953
1954 static FILE *pmu_battery_fp;
1955 static FILE *pmu_info_fp;
1956 static char pb_battery_info[3][32];
1957 static double pb_battery_info_update;
1958
1959 #define PMU_PATH "/proc/pmu"
1960 void get_powerbook_batt_info(char *buffer, size_t n, int i)
1961 {
1962         static int rep = 0;
1963         const char *batt_path = PMU_PATH "/battery_0";
1964         const char *info_path = PMU_PATH "/info";
1965         unsigned int flags;
1966         int charge, max_charge, ac = -1;
1967         long timeval = -1;
1968
1969         /* don't update battery too often */
1970         if (current_update_time - pb_battery_info_update < 29.5) {
1971                 snprintf(buffer, n, "%s", pb_battery_info[i]);
1972                 return;
1973         }
1974         pb_battery_info_update = current_update_time;
1975
1976         if (pmu_battery_fp == NULL) {
1977                 pmu_battery_fp = open_file(batt_path, &rep);
1978         }
1979
1980         if (pmu_battery_fp != NULL) {
1981                 rewind(pmu_battery_fp);
1982                 while (!feof(pmu_battery_fp)) {
1983                         char buf[32];
1984
1985                         if (fgets(buf, sizeof(buf), pmu_battery_fp) == NULL) {
1986                                 break;
1987                         }
1988
1989                         if (buf[0] == 'f') {
1990                                 sscanf(buf, "flags      : %8x", &flags);
1991                         } else if (buf[0] == 'c' && buf[1] == 'h') {
1992                                 sscanf(buf, "charge     : %d", &charge);
1993                         } else if (buf[0] == 'm') {
1994                                 sscanf(buf, "max_charge : %d", &max_charge);
1995                         } else if (buf[0] == 't') {
1996                                 sscanf(buf, "time rem.  : %ld", &timeval);
1997                         }
1998                 }
1999         }
2000         if (pmu_info_fp == NULL) {
2001                 pmu_info_fp = open_file(info_path, &rep);
2002         }
2003
2004         if (pmu_info_fp != NULL) {
2005                 rewind(pmu_info_fp);
2006                 while (!feof(pmu_info_fp)) {
2007                         char buf[32];
2008
2009                         if (fgets(buf, sizeof(buf), pmu_info_fp) == NULL) {
2010                                 break;
2011                         }
2012                         if (buf[0] == 'A') {
2013                                 sscanf(buf, "AC Power               : %d", &ac);
2014                         }
2015                 }
2016         }
2017         /* update status string */
2018         if ((ac && !(flags & PMU_BATT_PRESENT))) {
2019                 strcpy(pb_battery_info[PB_BATT_STATUS], "AC");
2020         } else if (ac && (flags & PMU_BATT_PRESENT)
2021                         && !(flags & PMU_BATT_CHARGING)) {
2022                 strcpy(pb_battery_info[PB_BATT_STATUS], "charged");
2023         } else if ((flags & PMU_BATT_PRESENT) && (flags & PMU_BATT_CHARGING)) {
2024                 strcpy(pb_battery_info[PB_BATT_STATUS], "charging");
2025         } else {
2026                 strcpy(pb_battery_info[PB_BATT_STATUS], "discharging");
2027         }
2028
2029         /* update percentage string */
2030         if (timeval == 0) {
2031                 pb_battery_info[PB_BATT_PERCENT][0] = 0;
2032         } else {
2033                 snprintf(pb_battery_info[PB_BATT_PERCENT],
2034                         sizeof(pb_battery_info[PB_BATT_PERCENT]), "%d%%",
2035                         (charge * 100) / max_charge);
2036         }
2037
2038         /* update time string */
2039         if (timeval == 0) {                     /* fully charged or battery not present */
2040                 pb_battery_info[PB_BATT_TIME][0] = 0;
2041         } else if (timeval < 60 * 60) { /* don't show secs */
2042                 format_seconds_short(pb_battery_info[PB_BATT_TIME],
2043                         sizeof(pb_battery_info[PB_BATT_TIME]), timeval);
2044         } else {
2045                 format_seconds(pb_battery_info[PB_BATT_TIME],
2046                         sizeof(pb_battery_info[PB_BATT_TIME]), timeval);
2047         }
2048
2049         snprintf(buffer, n, "%s", pb_battery_info[i]);
2050 }
2051
2052 void update_top(void)
2053 {
2054         show_nice_processes = 1;
2055         process_find_top(info.cpu, info.memu);
2056         info.first_process = get_first_process();
2057 }
2058
2059 /* The following ifdefs were adapted from gkrellm */
2060 #include <linux/major.h>
2061
2062 #if !defined(MD_MAJOR)
2063 #define MD_MAJOR 9
2064 #endif
2065
2066 #if !defined(LVM_BLK_MAJOR)
2067 #define LVM_BLK_MAJOR 58
2068 #endif
2069
2070 #if !defined(NBD_MAJOR)
2071 #define NBD_MAJOR 43
2072 #endif
2073
2074 void update_diskio(void)
2075 {
2076         static unsigned int last = UINT_MAX;
2077         static unsigned int last_read = UINT_MAX;
2078         static unsigned int last_write = UINT_MAX;
2079         FILE *fp;
2080         static int rep = 0;
2081
2082         char buf[512], devbuf[64];
2083         int i;
2084         unsigned int major, minor;
2085         unsigned int current = 0;
2086         unsigned int current_read = 0;
2087         unsigned int current_write = 0;
2088         unsigned int reads, writes = 0;
2089         int col_count = 0;
2090         int tot, tot_read, tot_write;
2091
2092         if (!(fp = open_file("/proc/diskstats", &rep))) {
2093                 diskio_value = 0;
2094                 return;
2095         }
2096
2097         /* read reads and writes from all disks (minor = 0), including cd-roms
2098          * and floppies, and sum them up */
2099         while (!feof(fp)) {
2100                 fgets(buf, 512, fp);
2101                 col_count = sscanf(buf, "%u %u %s %*u %*u %u %*u %*u %*u %u", &major,
2102                         &minor, devbuf, &reads, &writes);
2103                 /* ignore subdevices (they have only 3 matching entries in their line)
2104                  * and virtual devices (LVM, network block devices, RAM disks, Loopback)
2105                  *
2106                  * XXX: ignore devices which are part of a SW RAID (MD_MAJOR) */
2107                 if (col_count == 5 && major != LVM_BLK_MAJOR && major != NBD_MAJOR
2108                                 && major != RAMDISK_MAJOR && major != LOOP_MAJOR) {
2109                         current += reads + writes;
2110                         current_read += reads;
2111                         current_write += writes;
2112                 } else {
2113                         col_count = sscanf(buf, "%u %u %s %*u %u %*u %u",
2114                                 &major, &minor, devbuf, &reads, &writes);
2115                         if (col_count != 5) {
2116                                 continue;
2117                         }
2118                 }
2119                 for (i = 0; i < MAX_DISKIO_STATS; i++) {
2120                         if (diskio_stats[i].dev &&
2121                                         strcmp(devbuf, diskio_stats[i].dev) == 0) {
2122                                 diskio_stats[i].current =
2123                                         (reads + writes - diskio_stats[i].last) / 2;
2124                                 diskio_stats[i].current_read =
2125                                         (reads - diskio_stats[i].last_read) / 2;
2126                                 diskio_stats[i].current_write =
2127                                         (writes - diskio_stats[i].last_write) / 2;
2128                                 if (reads + writes < diskio_stats[i].last) {
2129                                         diskio_stats[i].current = 0;
2130                                 }
2131                                 if (reads < diskio_stats[i].last_read) {
2132                                         diskio_stats[i].current_read = 0;
2133                                         diskio_stats[i].current = diskio_stats[i].current_write;
2134                                 }
2135                                 if (writes < diskio_stats[i].last_write) {
2136                                         diskio_stats[i].current_write = 0;
2137                                         diskio_stats[i].current = diskio_stats[i].current_read;
2138                                 }
2139                                 diskio_stats[i].last = reads + writes;
2140                                 diskio_stats[i].last_read = reads;
2141                                 diskio_stats[i].last_write = writes;
2142                         }
2143                 }
2144         }
2145
2146         /* since the values in /proc/diststats are absolute, we have to substract
2147          * our last reading. The numbers stand for "sectors read", and we therefore
2148          * have to divide by two to get KB */
2149         tot = ((double) (current - last) / 2);
2150         tot_read = ((double) (current_read - last_read) / 2);
2151         tot_write = ((double) (current_write - last_write) / 2);
2152
2153         if (last_read > current_read) {
2154                 tot_read = 0;
2155         }
2156         if (last_write > current_write) {
2157                 tot_write = 0;
2158         }
2159
2160         if (last > current) {
2161                 /* we hit this either if it's the very first time we run this, or
2162                  * when /proc/diskstats overflows; while 0 is not correct, it's at
2163                  * least not way off */
2164                 tot = 0;
2165         }
2166         last = current;
2167         last_read = current_read;
2168         last_write = current_write;
2169
2170         diskio_value = tot;
2171         diskio_read_value = tot_read;
2172         diskio_write_value = tot_write;
2173
2174         fclose(fp);
2175 }
2176
2177 /* Here come the IBM ACPI-specific things. For reference, see
2178  * http://ibm-acpi.sourceforge.net/README
2179  * If IBM ACPI is installed, /proc/acpi/ibm contains the following files:
2180 bay
2181 beep
2182 bluetooth
2183 brightness
2184 cmos
2185 dock
2186 driver
2187 ecdump
2188 fan
2189 hotkey
2190 led
2191 light
2192 thermal
2193 video
2194 volume
2195  * The content of these files is described in detail in the aforementioned
2196  * README - some of them also in the following functions accessing them.
2197  * Peter Tarjan (ptarjan@citromail.hu) */
2198
2199 #define IBM_ACPI_DIR "/proc/acpi/ibm"
2200
2201 /* get fan speed on IBM/Lenovo laptops running the ibm acpi.
2202  * /proc/acpi/ibm/fan looks like this (3 lines):
2203 status:         disabled
2204 speed:          2944
2205 commands:       enable, disable
2206  * Peter Tarjan (ptarjan@citromail.hu) */
2207
2208 void get_ibm_acpi_fan(char *p_client_buffer, size_t client_buffer_size)
2209 {
2210         FILE *fp;
2211         unsigned int speed = 0;
2212         char fan[128];
2213
2214         if (!p_client_buffer || client_buffer_size <= 0) {
2215                 return;
2216         }
2217
2218         snprintf(fan, 127, "%s/fan", IBM_ACPI_DIR);
2219
2220         fp = fopen(fan, "r");
2221         if (fp != NULL) {
2222                 while (!feof(fp)) {
2223                         char line[256];
2224
2225                         if (fgets(line, 255, fp) == NULL) {
2226                                 break;
2227                         }
2228                         if (sscanf(line, "speed: %u", &speed)) {
2229                                 break;
2230                         }
2231                 }
2232         } else {
2233                 CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
2234                         "ibm* from your Conky config file.", fan, strerror(errno));
2235         }
2236
2237         fclose(fp);
2238         snprintf(p_client_buffer, client_buffer_size, "%d", speed);
2239 }
2240
2241 /* get the measured temperatures from the temperature sensors
2242  * on IBM/Lenovo laptops running the ibm acpi.
2243  * There are 8 values in /proc/acpi/ibm/thermal, and according to
2244  * http://ibm-acpi.sourceforge.net/README
2245  * these mean the following (at least on an IBM R51...)
2246  * 0:  CPU (also on the T series laptops)
2247  * 1:  Mini PCI Module (?)
2248  * 2:  HDD (?)
2249  * 3:  GPU (also on the T series laptops)
2250  * 4:  Battery (?)
2251  * 5:  N/A
2252  * 6:  Battery (?)
2253  * 7:  N/A
2254  * I'm not too sure about those with the question mark, but the values I'm
2255  * reading from *my* thermal file (on a T42p) look realistic for the
2256  * hdd and the battery.
2257  * #5 and #7 are always -128.
2258  * /proc/acpi/ibm/thermal looks like this (1 line):
2259 temperatures:   41 43 31 46 33 -128 29 -128
2260  * Peter Tarjan (ptarjan@citromail.hu) */
2261
2262 static double last_ibm_acpi_temp_time;
2263 void get_ibm_acpi_temps(void)
2264 {
2265
2266         FILE *fp;
2267         char thermal[128];
2268
2269         /* don't update too often */
2270         if (current_update_time - last_ibm_acpi_temp_time < 10.00) {
2271                 return;
2272         }
2273         last_ibm_acpi_temp_time = current_update_time;
2274
2275         /* if (!p_client_buffer || client_buffer_size <= 0) {
2276                 return;
2277         } */
2278
2279         snprintf(thermal, 127, "%s/thermal", IBM_ACPI_DIR);
2280         fp = fopen(thermal, "r");
2281
2282         if (fp != NULL) {
2283                 while (!feof(fp)) {
2284                         char line[256];
2285
2286                         if (fgets(line, 255, fp) == NULL) {
2287                                 break;
2288                         }
2289                         if (sscanf(line, "temperatures: %d %d %d %d %d %d %d %d",
2290                                         &ibm_acpi.temps[0], &ibm_acpi.temps[1], &ibm_acpi.temps[2],
2291                                         &ibm_acpi.temps[3], &ibm_acpi.temps[4], &ibm_acpi.temps[5],
2292                                         &ibm_acpi.temps[6], &ibm_acpi.temps[7])) {
2293                                 break;
2294                         }
2295                 }
2296         } else {
2297                 CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
2298                         "ibm* from your Conky config file.", thermal, strerror(errno));
2299         }
2300
2301         fclose(fp);
2302 }
2303
2304 /* get volume (0-14) on IBM/Lenovo laptops running the ibm acpi.
2305  * "Volume" here is none of the mixer volumes, but a "master of masters"
2306  * volume adjusted by the IBM volume keys.
2307  * /proc/acpi/ibm/fan looks like this (4 lines):
2308 level:          4
2309 mute:           off
2310 commands:       up, down, mute
2311 commands:       level <level> (<level> is 0-15)
2312  * Peter Tarjan (ptarjan@citromail.hu) */
2313
2314 void get_ibm_acpi_volume(char *p_client_buffer, size_t client_buffer_size)
2315 {
2316         FILE *fp;
2317         char volume[128];
2318         unsigned int vol = -1;
2319         char mute[3] = "";
2320
2321         if (!p_client_buffer || client_buffer_size <= 0) {
2322                 return;
2323         }
2324
2325         snprintf(volume, 127, "%s/volume", IBM_ACPI_DIR);
2326
2327         fp = fopen(volume, "r");
2328         if (fp != NULL) {
2329                 while (!feof(fp)) {
2330                         char line[256];
2331                         unsigned int read_vol = -1;
2332
2333                         if (fgets(line, 255, fp) == NULL) {
2334                                 break;
2335                         }
2336                         if (sscanf(line, "level: %u", &read_vol)) {
2337                                 vol = read_vol;
2338                                 continue;
2339                         }
2340                         if (sscanf(line, "mute: %s", mute)) {
2341                                 break;
2342                         }
2343                 }
2344         } else {
2345                 CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
2346                         "ibm* from your Conky config file.", volume, strerror(errno));
2347         }
2348
2349         fclose(fp);
2350
2351         if (strcmp(mute, "on") == 0) {
2352                 snprintf(p_client_buffer, client_buffer_size, "%s", "mute");
2353                 return;
2354         } else {
2355                 snprintf(p_client_buffer, client_buffer_size, "%d", vol);
2356                 return;
2357         }
2358 }
2359
2360 /* static FILE *fp = NULL; */
2361
2362 /* get LCD brightness on IBM/Lenovo laptops running the ibm acpi.
2363  * /proc/acpi/ibm/brightness looks like this (3 lines):
2364 level:          7
2365 commands:       up, down
2366 commands:       level <level> (<level> is 0-7)
2367  * Peter Tarjan (ptarjan@citromail.hu) */
2368
2369 void get_ibm_acpi_brightness(char *p_client_buffer, size_t client_buffer_size)
2370 {
2371         FILE *fp;
2372         unsigned int brightness = 0;
2373         char filename[128];
2374
2375         if (!p_client_buffer || client_buffer_size <= 0) {
2376                 return;
2377         }
2378
2379         snprintf(filename, 127, "%s/brightness", IBM_ACPI_DIR);
2380
2381         fp = fopen(filename, "r");
2382         if (fp != NULL) {
2383                 while (!feof(fp)) {
2384                         char line[256];
2385
2386                         if (fgets(line, 255, fp) == NULL) {
2387                                 break;
2388                         }
2389                         if (sscanf(line, "level: %u", &brightness)) {
2390                                 break;
2391                         }
2392                 }
2393         } else {
2394                 CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
2395                         "ibm* from your Conky config file.", filename, strerror(errno));
2396         }
2397
2398         fclose(fp);
2399
2400         snprintf(p_client_buffer, client_buffer_size, "%d", brightness);
2401 }
2402
2403 void update_entropy(void)
2404 {
2405         static int rep = 0;
2406         const char *entropy_avail = "/proc/sys/kernel/random/entropy_avail";
2407         const char *entropy_poolsize = "/proc/sys/kernel/random/poolsize";
2408         FILE *fp1, *fp2;
2409
2410         info.entropy.entropy_avail = 0;
2411         info.entropy.poolsize = 0;
2412
2413         if ((fp1 = open_file(entropy_avail, &rep)) == NULL) {
2414                 return;
2415         }
2416
2417         if ((fp2 = open_file(entropy_poolsize, &rep)) == NULL) {
2418                 fclose(fp1);
2419                 return;
2420         }
2421
2422         fscanf(fp1, "%u", &info.entropy.entropy_avail);
2423         fscanf(fp2, "%u", &info.entropy.poolsize);
2424
2425         fclose(fp1);
2426         fclose(fp2);
2427
2428         info.mask |= (1 << INFO_ENTROPY);
2429 }
2430
2431 const char *get_disk_protect_queue(const char *disk)
2432 {
2433         FILE *fp;
2434         char path[128];
2435         int state;
2436
2437         snprintf(path, 127, "/sys/block/%s/queue/protect", disk);
2438         if ((fp = fopen(path, "r")) == NULL)
2439                 return "n/a   ";
2440         if (fscanf(fp, "%d\n", &state) != 1) {
2441                 fclose(fp);
2442                 return "failed";
2443         }
2444         fclose(fp);
2445         return state ? "frozen" : "free  ";
2446 }
2447