*
* Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
* Copyright (c) 2007 Toni Spets
- * Copyright (c) 2005-2007 Brenden Matthews, Philip Kovacs, et. al.
+ * Copyright (c) 2005-2008 Brenden Matthews, Philip Kovacs, et. al.
* (see AUTHORS)
* All rights reserved.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
- * $Id$ */
+ */
#include "conky.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include "logging.h"
+#include "common.h"
+#include "linux.h"
#include <dirent.h>
#include <ctype.h>
#include <errno.h>
* using a flag in this manner creates less confusing code. */
static int prefer_proc = 0;
-void prepare_update()
+void prepare_update(void)
{
}
-void update_uptime()
+void update_uptime(void)
{
#ifdef HAVE_SYSINFO
if (!prefer_proc) {
/* these things are also in sysinfo except Buffers:
* (that's why I'm reading them from proc) */
-void update_meminfo()
+void update_meminfo(void)
{
FILE *meminfo_fp;
static int rep = 0;
char buf[256];
info.mem = info.memmax = info.swap = info.swapmax = info.bufmem =
- info.buffers = info.cached = 0;
+ info.buffers = info.cached = info.memfree = info.memeasyfree = 0;
if (!(meminfo_fp = open_file("/proc/meminfo", &rep))) {
return;
}
if (strncmp(buf, "MemTotal:", 9) == 0) {
- sscanf(buf, "%*s %Lu", &info.memmax);
+ sscanf(buf, "%*s %llu", &info.memmax);
} else if (strncmp(buf, "MemFree:", 8) == 0) {
- sscanf(buf, "%*s %Lu", &info.mem);
+ sscanf(buf, "%*s %llu", &info.memfree);
} else if (strncmp(buf, "SwapTotal:", 10) == 0) {
- sscanf(buf, "%*s %Lu", &info.swapmax);
+ sscanf(buf, "%*s %llu", &info.swapmax);
} else if (strncmp(buf, "SwapFree:", 9) == 0) {
- sscanf(buf, "%*s %Lu", &info.swap);
+ sscanf(buf, "%*s %llu", &info.swap);
} else if (strncmp(buf, "Buffers:", 8) == 0) {
- sscanf(buf, "%*s %Lu", &info.buffers);
+ sscanf(buf, "%*s %llu", &info.buffers);
} else if (strncmp(buf, "Cached:", 7) == 0) {
- sscanf(buf, "%*s %Lu", &info.cached);
+ sscanf(buf, "%*s %llu", &info.cached);
}
}
- info.mem = info.memmax - info.mem;
+ info.mem = info.memmax - info.memfree;
+ info.memeasyfree = info.memfree;
info.swap = info.swapmax - info.swap;
info.bufmem = info.cached + info.buffers;
fclose(meminfo_fp);
}
-int get_laptop_mode()
+int get_laptop_mode(void)
{
FILE *fp;
int val = -1;
char buf[128];
if (!disk)
- return "n/a";
+ return strndup("n/a", text_buffer_size);
snprintf(buf, 127, "/sys/block/%s/queue/scheduler", disk);
if ((fp = fopen(buf, "r")) == NULL) {
- return strdup("n/a");
+ return strndup("n/a", text_buffer_size);
}
while (!feof(fp)) {
fscanf(fp, "%127s", buf);
if (buf[0] == '[') {
buf[strlen(buf) - 1] = '\0';
fclose(fp);
- return strdup(buf + 1);
+ return strndup(buf + 1, text_buffer_size);
}
}
fclose(fp);
- return strdup("n/a");
+ return strndup("n/a", text_buffer_size);
}
int interface_up(const char *dev)
int fd;
struct ifreq ifr;
- if((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
+ if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
CRIT_ERR("could not create sockfd");
return 0;
}
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
- if(ioctl(fd, SIOCGIFFLAGS, &ifr)) {
+ if (ioctl(fd, SIOCGIFFLAGS, &ifr)) {
/* if device does not exist, treat like not up */
if (errno != ENODEV)
perror("SIOCGIFFLAGS");
- } else {
- close(fd);
- return (ifr.ifr_flags & IFF_UP);
+ goto END_FALSE;
+ }
+
+ if (!(ifr.ifr_flags & IFF_UP)) /* iface is not up */
+ goto END_FALSE;
+ if (ifup_strictness == IFUP_UP)
+ goto END_TRUE;
+
+ if (!(ifr.ifr_flags & IFF_RUNNING))
+ goto END_FALSE;
+ if (ifup_strictness == IFUP_LINK)
+ goto END_TRUE;
+
+ if (ioctl(fd, SIOCGIFADDR, &ifr)) {
+ perror("SIOCGIFADDR");
+ goto END_FALSE;
}
+ if (((struct sockaddr_in *)&(ifr.ifr_ifru.ifru_addr))->sin_addr.s_addr)
+ goto END_TRUE;
+
+END_FALSE:
close(fd);
return 0;
+END_TRUE:
+ close(fd);
+ return 1;
}
#define COND_FREE(x) if(x) free(x); x = 0
#define SAVE_SET_STRING(x, y) \
if (x && strcmp((char *)x, (char *)y)) { \
free(x); \
- x = strdup("multiple"); \
+ x = strndup("multiple", text_buffer_size); \
} else if (!x) { \
- x = strdup(y); \
+ x = strndup(y, text_buffer_size); \
}
-void update_gateway_info()
+void update_gateway_info_failure(const char *reason)
+{
+ if(reason != NULL) {
+ perror(reason);
+ }
+ //2 pointers to 1 location causes a crash when we try to free them both
+ info.gw_info.iface = strndup("failed", text_buffer_size);
+ info.gw_info.ip = strndup("failed", text_buffer_size);
+}
+
+void update_gateway_info(void)
{
FILE *fp;
struct in_addr ina;
gw_info->count = 0;
if ((fp = fopen("/proc/net/route", "r")) == NULL) {
- perror("fopen()");
- goto FAIL;
+ update_gateway_info_failure("fopen()");
+ return;
}
if (fscanf(fp, "%*[^\n]\n") == EOF) {
- perror("fscanf()");
- goto CLOSE_FAIL;
+ //NULL because a empty table is not a error
+ update_gateway_info_failure(NULL);
+ fclose(fp);
+ return;
}
while (!feof(fp)) {
// Iface Destination Gateway Flags RefCnt Use Metric Mask MTU Window IRTT
if(fscanf(fp, "%63s %lx %lx %x %hd %hd %hd %lx %hd %hd %hd\n",
- iface, &dest, &gate, &flags, &ref, &use,
- &metric, &mask, &mtu, &win, &irtt) != 11) {
- perror("fscanf()");
- goto CLOSE_FAIL;
+ iface, &dest, &gate, &flags, &ref, &use,
+ &metric, &mask, &mtu, &win, &irtt) != 11) {
+ update_gateway_info_failure("fscanf()");
+ fclose(fp);
+ return;
}
if (flags & RTF_GATEWAY && dest == 0 && mask == 0) {
gw_info->count++;
SAVE_SET_STRING(gw_info->iface, iface)
- ina.s_addr = gate;
+ ina.s_addr = gate;
SAVE_SET_STRING(gw_info->ip, inet_ntoa(ina))
}
}
fclose(fp);
return;
-CLOSE_FAIL:
- fclose(fp);
-FAIL:
- info.gw_info.iface = info.gw_info.ip = strdup("failed");
- return;
}
-inline void update_net_stats()
+void update_net_stats(void)
{
FILE *net_dev_fp;
static int rep = 0;
for (i2 = 0; i2 < 16; i2++) {
struct net_stat *ns;
char *s, *p;
- char temp_addr[17];
+ char temp_addr[18];
long long r, t, last_recv, last_trans;
if (fgets(buf, 255, net_dev_fp) == NULL) {
memset(&(ns->addr.sa_data), 0, 14);
if(NULL == ns->addrs)
- ns->addrs = (char*) malloc(17 * 16);
+ ns->addrs = (char*) malloc(17 * 16 + 1);
if(NULL != ns->addrs)
- memset(ns->addrs, 0, 17 * 16); /* Up to 17 chars per ip, max 16 interfaces. Nasty memory usage... */
+ memset(ns->addrs, 0, 17 * 16 + 1); /* Up to 17 chars per ip, max 16 interfaces. Nasty memory usage... */
last_recv = ns->recv;
last_trans = ns->trans;
/* bytes packets errs drop fifo frame compressed multicast|bytes ... */
- sscanf(p, "%Ld %*d %*d %*d %*d %*d %*d %*d %Ld",
+ sscanf(p, "%lld %*d %*d %*d %*d %*d %*d %*d %lld",
&r, &t);
/* if recv or trans is less than last time, an overflow happened */
ioctl((long) i, SIOCGIFCONF, &conf);
for (k = 0; k < conf.ifc_len / sizeof(struct ifreq); k++) {
- struct net_stat *ns;
+ struct net_stat *ns2;
if (!(((struct ifreq *) conf.ifc_buf) + k))
break;
- ns = get_net_stat(
+ ns2 = get_net_stat(
((struct ifreq *) conf.ifc_buf)[k].ifr_ifrn.ifrn_name);
- ns->addr = ((struct ifreq *) conf.ifc_buf)[k].ifr_ifru.ifru_addr;
- if(NULL != ns->addrs) {
+ ns2->addr = ((struct ifreq *) conf.ifc_buf)[k].ifr_ifru.ifru_addr;
+ if(NULL != ns2->addrs) {
sprintf(temp_addr, "%u.%u.%u.%u, ",
- ns->addr.sa_data[2] & 255,
- ns->addr.sa_data[3] & 255,
- ns->addr.sa_data[4] & 255,
- ns->addr.sa_data[5] & 255);
- if(NULL == strstr(ns->addrs, temp_addr))
- strncpy(ns->addrs + strlen(ns->addrs), temp_addr, 17);
+ ns2->addr.sa_data[2] & 255,
+ ns2->addr.sa_data[3] & 255,
+ ns2->addr.sa_data[4] & 255,
+ ns2->addr.sa_data[5] & 255);
+ if(NULL == strstr(ns2->addrs, temp_addr))
+ strncpy(ns2->addrs + strlen(ns2->addrs), temp_addr, 17);
}
}
int result;
-void update_total_processes()
+void update_total_processes(void)
{
#ifdef HAVE_SYSINFO
if (!prefer_proc) {
info.procs = 0;
return;
}
- fscanf(fp, "%*f %*f %*f %*d/%hd", &info.procs);
+ fscanf(fp, "%*f %*f %*f %*d/%hu", &info.procs);
fclose(fp);
}
info.mask |= (1 << INFO_PROCS);
}
}
-void get_cpu_count()
+void get_cpu_count(void)
{
FILE *stat_fp;
static int rep = 0;
+ char buf[256];
if (info.cpu_usage) {
return;
}
- char buf[256];
if (!(stat_fp = open_file("/proc/stat", &rep))) {
return;
#define TMPL_LONGSTAT "%*s %llu %llu %llu %llu %llu %llu %llu %llu"
#define TMPL_SHORTSTAT "%*s %llu %llu %llu %llu"
-inline static void update_stat()
+inline static void update_stat(void)
{
FILE *stat_fp;
static int rep = 0;
static struct cpu_info *cpu = NULL;
char buf[256];
unsigned int i;
- unsigned int index;
+ unsigned int idx;
double curtmp;
- char *stat_template = NULL;
+ const char *stat_template = NULL;
unsigned int malloc_cpu_size = 0;
/* add check for !info.cpu_usage since that mem is freed on a SIGUSR1 */
return;
}
- index = 0;
+ idx = 0;
while (!feof(stat_fp)) {
if (fgets(buf, 255, stat_fp) == NULL) {
break;
sscanf(buf, "%*s %hu", &info.run_procs);
info.mask |= (1 << INFO_RUN_PROCS);
} else if (strncmp(buf, "cpu", 3) == 0) {
- index = isdigit(buf[3]) ? ((int) buf[3]) - 0x2F : 0;
- sscanf(buf, stat_template, &(cpu[index].cpu_user),
- &(cpu[index].cpu_nice), &(cpu[index].cpu_system),
- &(cpu[index].cpu_idle), &(cpu[index].cpu_iowait),
- &(cpu[index].cpu_irq), &(cpu[index].cpu_softirq),
- &(cpu[index].cpu_steal));
-
- cpu[index].cpu_total = cpu[index].cpu_user + cpu[index].cpu_nice +
- cpu[index].cpu_system + cpu[index].cpu_idle +
- cpu[index].cpu_iowait + cpu[index].cpu_irq +
- cpu[index].cpu_softirq + cpu[index].cpu_steal;
-
- cpu[index].cpu_active_total = cpu[index].cpu_total -
- (cpu[index].cpu_idle + cpu[index].cpu_iowait);
+ double delta;
+ if (isdigit(buf[3])) {
+ idx = atoi(&buf[3]) + 1;
+ } else {
+ idx = 0;
+ }
+ sscanf(buf, stat_template, &(cpu[idx].cpu_user),
+ &(cpu[idx].cpu_nice), &(cpu[idx].cpu_system),
+ &(cpu[idx].cpu_idle), &(cpu[idx].cpu_iowait),
+ &(cpu[idx].cpu_irq), &(cpu[idx].cpu_softirq),
+ &(cpu[idx].cpu_steal));
+
+ cpu[idx].cpu_total = cpu[idx].cpu_user + cpu[idx].cpu_nice +
+ cpu[idx].cpu_system + cpu[idx].cpu_idle +
+ cpu[idx].cpu_iowait + cpu[idx].cpu_irq +
+ cpu[idx].cpu_softirq + cpu[idx].cpu_steal;
+
+ cpu[idx].cpu_active_total = cpu[idx].cpu_total -
+ (cpu[idx].cpu_idle + cpu[idx].cpu_iowait);
info.mask |= (1 << INFO_CPU);
- double delta = current_update_time - last_update_time;
+ delta = current_update_time - last_update_time;
if (delta <= 0.001) {
break;
}
- cpu[index].cpu_val[0] = (cpu[index].cpu_active_total -
- cpu[index].cpu_last_active_total) /
- (float) (cpu[index].cpu_total - cpu[index].cpu_last_total);
+ cpu[idx].cpu_val[0] = (cpu[idx].cpu_active_total -
+ cpu[idx].cpu_last_active_total) /
+ (float) (cpu[idx].cpu_total - cpu[idx].cpu_last_total);
curtmp = 0;
for (i = 0; i < info.cpu_avg_samples; i++) {
- curtmp += cpu[index].cpu_val[i];
+ curtmp += cpu[idx].cpu_val[i];
}
/* TESTING -- I've removed this, because I don't think it is right.
* You shouldn't divide by the cpu count here ...
* removing for testing */
- /* if (index == 0) {
- info.cpu_usage[index] = curtmp / info.cpu_avg_samples /
+ /* if (idx == 0) {
+ info.cpu_usage[idx] = curtmp / info.cpu_avg_samples /
info.cpu_count;
} else {
- info.cpu_usage[index] = curtmp / info.cpu_avg_samples;
+ info.cpu_usage[idx] = curtmp / info.cpu_avg_samples;
} */
/* TESTING -- this line replaces the prev. "suspect" if/else */
- info.cpu_usage[index] = curtmp / info.cpu_avg_samples;
+ info.cpu_usage[idx] = curtmp / info.cpu_avg_samples;
- cpu[index].cpu_last_total = cpu[index].cpu_total;
- cpu[index].cpu_last_active_total = cpu[index].cpu_active_total;
+ cpu[idx].cpu_last_total = cpu[idx].cpu_total;
+ cpu[idx].cpu_last_active_total = cpu[idx].cpu_active_total;
for (i = info.cpu_avg_samples - 1; i > 0; i--) {
- cpu[index].cpu_val[i] = cpu[index].cpu_val[i - 1];
+ cpu[idx].cpu_val[i] = cpu[idx].cpu_val[i - 1];
}
}
}
fclose(stat_fp);
}
-void update_running_processes()
+void update_running_processes(void)
{
update_stat();
}
-void update_cpu_usage()
+void update_cpu_usage(void)
{
update_stat();
}
-void update_load_average()
+void update_load_average(void)
{
#ifdef HAVE_GETLOADAVG
if (!prefer_proc) {
#define PROC_I8K "/proc/i8k"
#define I8K_DELIM " "
static char *i8k_procbuf = NULL;
-void update_i8k()
+void update_i8k(void)
{
FILE *fp;
}
int open_sysfs_sensor(const char *dir, const char *dev, const char *type, int n,
- int *div, char *devtype)
+ int *divisor, char *devtype)
{
char path[256];
char buf[256];
fd = open(path, O_RDONLY);
if (fd < 0) {
CRIT_ERR("can't open '%s': %s\nplease check your device or remove this "
- "var from Conky", path, strerror(errno));
+ "var from "PACKAGE_NAME, path, strerror(errno));
}
if (strcmp(type, "in") == 0 || strcmp(type, "temp") == 0
|| strcmp(type, "tempf") == 0) {
- *div = 1;
+ *divisor = 1;
} else {
- *div = 0;
+ *divisor = 0;
}
/* fan does not use *_div as a read divisor */
if (strcmp("fan", type) == 0) {
ERR("open_sysfs_sensor(): can't read from sysfs");
} else {
divbuf[divn] = '\0';
- *div = atoi(divbuf);
+ *divisor = atoi(divbuf);
}
}
return fd;
}
-double get_sysfs_info(int *fd, int div, char *devtype, char *type)
+double get_sysfs_info(int *fd, int divisor, char *devtype, char *type)
{
int val = 0;
/* divide voltage and temperature by 1000 */
/* or if any other divisor is given, use that */
if (strcmp(type, "tempf") == 0) {
- if (div > 1) {
- return ((val / div + 40) * 9.0 / 5) - 40;
- } else if (div) {
+ if (divisor > 1) {
+ return ((val / divisor + 40) * 9.0 / 5) - 40;
+ } else if (divisor) {
return ((val / 1000.0 + 40) * 9.0 / 5) - 40;
} else {
return ((val + 40) * 9.0 / 5) - 40;
}
} else {
- if (div > 1) {
- return val / div;
- } else if (div) {
+ if (divisor > 1) {
+ return val / divisor;
+ } else if (divisor) {
return val / 1000.0;
} else {
return val;
snprintf(p_client_buffer, client_buffer_size, "%s", adt746x_cpu_state);
}
-/* Thanks to "Walt Nelson" <wnelsonjr@comcast.net> */
-
-/***********************************************************************/
-/* This file is part of x86info.
- * (C) 2001 Dave Jones.
- *
- * Licensed under the terms of the GNU GPL License version 2.
- *
- * Estimate CPU MHz routine by Andrea Arcangeli <andrea@suse.de>
- * Small changes by David Sterba <sterd9am@ss1000.ms.mff.cuni.cz> */
-
-#if defined(__i386) || defined(__x86_64)
-__inline__ unsigned long long int rdtsc()
-{
- unsigned long long int x;
-
- __asm__ volatile(".byte 0x0f, 0x31":"=A" (x));
- return x;
-}
-#endif
-
-/* return system frequency in MHz (use divisor=1) or GHz (use divisor=1000) */
-void get_freq_dynamic(char *p_client_buffer, size_t client_buffer_size,
- char *p_format, int divisor)
-{
-#if defined(__i386) || defined(__x86_64)
- struct timezone tz;
- struct timeval tvstart, tvstop;
- unsigned long long cycles[2]; /* gotta be 64 bit */
- unsigned int microseconds; /* total time taken */
-
- if (!p_client_buffer || client_buffer_size <= 0 || !p_format
- || divisor <= 0) {
- return;
- }
-
- memset(&tz, 0, sizeof(tz));
-
- /* get this function in cached memory */
- gettimeofday(&tvstart, &tz);
- cycles[0] = rdtsc();
- gettimeofday(&tvstart, &tz);
-
- /* we don't trust that this is any specific length of time */
- usleep(100);
- cycles[1] = rdtsc();
- gettimeofday(&tvstop, &tz);
- microseconds = ((tvstop.tv_sec - tvstart.tv_sec) * 1000000) +
- (tvstop.tv_usec - tvstart.tv_usec);
-
- snprintf(p_client_buffer, client_buffer_size, p_format,
- (float) ((cycles[1] - cycles[0]) / microseconds) / divisor);
- return;
-#else
- /* FIXME: hardwired: get freq for first cpu!
- * this whole function needs to be rethought and redone for
- * multi-cpu/multi-core/multi-threaded environments and
- * arbitrary combinations thereof */
- get_freq(p_client_buffer, client_buffer_size, p_format, divisor, 1);
- return;
-#endif
-}
-
#define CPUFREQ_PREFIX "/sys/devices/system/cpu"
#define CPUFREQ_POSTFIX "cpufreq/scaling_cur_freq"
/* return system frequency in MHz (use divisor=1) or GHz (use divisor=1000) */
-char get_freq(char *p_client_buffer, size_t client_buffer_size, char *p_format,
- int divisor, unsigned int cpu)
+char get_freq(char *p_client_buffer, size_t client_buffer_size,
+ const char *p_format, int divisor, unsigned int cpu)
{
FILE *f;
static int rep = 0;
// open the CPU information file
f = open_file("/proc/cpuinfo", &rep);
if (!f) {
- perror("Conky: Failed to access '/proc/cpuinfo' at get_freq()");
+ perror(PACKAGE_NAME": Failed to access '/proc/cpuinfo' at get_freq()");
return 0;
}
/* return cpu voltage in mV (use divisor=1) or V (use divisor=1000) */
char get_voltage(char *p_client_buffer, size_t client_buffer_size,
- char *p_format, int divisor, unsigned int cpu)
+ const char *p_format, int divisor, unsigned int cpu)
{
FILE *f;
char s[256];
}
fclose(f);
} else {
- fprintf(stderr, "Conky: Failed to access '%s' at ", current_freq_file);
+ fprintf(stderr, PACKAGE_NAME": Failed to access '%s' at ", current_freq_file);
perror("get_voltage()");
if (f) {
fclose(f);
}
fclose(f);
} else {
- fprintf(stderr, "Conky: Failed to access '%s' at ", current_freq_file);
+ fprintf(stderr, PACKAGE_NAME": Failed to access '%s' at ", current_freq_file);
perror("get_voltage()");
if (f) {
fclose(f);
snprintf(p_client_buffer, client_buffer_size, "%s", buf);
}
+#define SYSFS_AC_ADAPTER_DIR "/sys/class/power_supply/AC"
#define ACPI_AC_ADAPTER_DIR "/proc/acpi/ac_adapter/"
+/* Linux 2.6.25 onwards ac adapter info is in
+ /sys/class/power_supply/AC/
+ On my system I get the following.
+ /sys/class/power_supply/AC/uevent:
+ PHYSDEVPATH=/devices/LNXSYSTM:00/device:00/PNP0A08:00/device:01/PNP0C09:00/ACPI0003:00
+ PHYSDEVBUS=acpi
+ PHYSDEVDRIVER=ac
+ POWER_SUPPLY_NAME=AC
+ POWER_SUPPLY_TYPE=Mains
+ POWER_SUPPLY_ONLINE=1
+*/
void get_acpi_ac_adapter(char *p_client_buffer, size_t client_buffer_size)
{
static int rep = 0;
+
char buf[256];
char buf2[256];
FILE *fp;
return;
}
- /* yeah, slow... :/ */
- if (!get_first_file_in_a_directory(ACPI_AC_ADAPTER_DIR, buf, &rep)) {
- snprintf(p_client_buffer, client_buffer_size, "no ac_adapters?");
- return;
- }
+ snprintf(buf2, sizeof(buf2), "%s/uevent", SYSFS_AC_ADAPTER_DIR);
+ fp = open_file(buf2, &rep);
+ if (fp) {
+ /* sysfs processing */
+ while (!feof(fp)) {
+ if (fgets(buf, sizeof(buf), fp) == NULL)
+ break;
- snprintf(buf2, sizeof(buf2), "%s%s/state", ACPI_AC_ADAPTER_DIR, buf);
+ if (strncmp(buf, "POWER_SUPPLY_ONLINE=", 20) == 0) {
+ int online = 0;
+ sscanf(buf, "POWER_SUPPLY_ONLINE=%d", &online);
+ snprintf(p_client_buffer, client_buffer_size,
+ "%s-line", (online ? "on" : "off"));
+ break;
+ }
+ }
+ fclose(fp);
+ } else {
+ /* yeah, slow... :/ */
+ if (!get_first_file_in_a_directory(ACPI_AC_ADAPTER_DIR, buf, &rep)) {
+ snprintf(p_client_buffer, client_buffer_size, "no ac_adapters?");
+ return;
+ }
- fp = open_file(buf2, &rep);
- if (!fp) {
- snprintf(p_client_buffer, client_buffer_size,
- "No ac adapter found.... where is it?");
- return;
- }
- memset(buf, 0, sizeof(buf));
- fscanf(fp, "%*s %99s", buf);
- fclose(fp);
+ snprintf(buf2, sizeof(buf2), "%s%s/state", ACPI_AC_ADAPTER_DIR, buf);
- snprintf(p_client_buffer, client_buffer_size, "%s", buf);
+ fp = open_file(buf2, &rep);
+ if (!fp) {
+ snprintf(p_client_buffer, client_buffer_size,
+ "No ac adapter found.... where is it?");
+ return;
+ }
+ memset(buf, 0, sizeof(buf));
+ fscanf(fp, "%*s %99s", buf);
+ fclose(fp);
+
+ snprintf(p_client_buffer, client_buffer_size, "%s", buf);
+ }
}
/*
#define APM_PATH "/proc/apm"
#define MAX_BATTERY_COUNT 4
-static FILE *sysfs_bat_fp[MAX_BATTERY_COUNT];
-static FILE *acpi_bat_fp[MAX_BATTERY_COUNT];
-static FILE *apm_bat_fp[MAX_BATTERY_COUNT];
+static FILE *sysfs_bat_fp[MAX_BATTERY_COUNT] = { NULL, NULL, NULL, NULL };
+static FILE *acpi_bat_fp[MAX_BATTERY_COUNT] = { NULL, NULL, NULL, NULL };
+static FILE *apm_bat_fp[MAX_BATTERY_COUNT] = { NULL, NULL, NULL, NULL };
static int batteries_initialized = 0;
static char batteries[MAX_BATTERY_COUNT][32];
return idx;
}
-void get_battery_stuff(char *buf, unsigned int n, const char *bat, int item)
+void set_return_value(char *buffer, unsigned int n, int item, int idx);
+
+void get_battery_stuff(char *buffer, unsigned int n, const char *bat, int item)
{
- static int idx, rep = 0, rep2 = 0;
+ static int idx, rep = 0, rep1 = 0, rep2 = 0;
char acpi_path[128];
+ char sysfs_path[128];
snprintf(acpi_path, 127, ACPI_BATTERY_BASE_PATH "/%s/state", bat);
- char sysfs_path[128];
snprintf(sysfs_path, 127, SYSFS_BATTERY_BASE_PATH "/%s/uevent", bat);
init_batteries();
/* don't update battery too often */
if (current_update_time - last_battery_time[idx] < 29.5) {
- goto set_return_value;
+ set_return_value(buffer, n, item, idx);
+ return;
}
last_battery_time[idx] = current_update_time;
memset(last_battery_time_str[idx], 0, sizeof(last_battery_time_str[idx]));
/* first try SYSFS if that fails try ACPI */
-
- if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL)
+
+ if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL) {
sysfs_bat_fp[idx] = open_file(sysfs_path, &rep);
-
- if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL)
- acpi_bat_fp[idx] = open_file(acpi_path, &rep);
-
+ }
+
+ if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL) {
+ acpi_bat_fp[idx] = open_file(acpi_path, &rep1);
+ }
+
if (sysfs_bat_fp[idx] != NULL) {
/* SYSFS */
int present_rate = -1;
int remaining_capacity = -1;
char charging_state[64];
char present[4];
-
- strcpy(charging_state, "Unknown");
-
+
+ strcpy(charging_state, "unknown");
+
while (!feof(sysfs_bat_fp[idx])) {
char buf[256];
if (fgets(buf, 256, sysfs_bat_fp[idx]) == NULL)
break;
-
+
/* let's just hope units are ok */
if (strncmp (buf, "POWER_SUPPLY_PRESENT=1", 22) == 0)
- strcpy(present, "Yes");
+ strcpy(present, "yes");
else if (strncmp (buf, "POWER_SUPPLY_PRESENT=0", 22) == 0)
- strcpy(present, "No");
+ strcpy(present, "no");
else if (strncmp (buf, "POWER_SUPPLY_STATUS=", 20) == 0)
sscanf(buf, "POWER_SUPPLY_STATUS=%63s", charging_state);
/* present_rate is not the same as the
else if (strncmp(buf, "POWER_SUPPLY_CHARGE_FULL=", 25) == 0)
sscanf(buf, "POWER_SUPPLY_CHARGE_FULL=%d", &acpi_last_full[idx]);
}
-
+
fclose(sysfs_bat_fp[idx]);
sysfs_bat_fp[idx] = NULL;
-
+
/* Hellf[i]re notes that remaining capacity can exceed acpi_last_full */
if (remaining_capacity > acpi_last_full[idx])
acpi_last_full[idx] = remaining_capacity; /* normalize to 100% */
-
+
/* not present */
if (strcmp(present, "No") == 0) {
strncpy(last_battery_str[idx], "not present", 64);
else if (strcmp(charging_state, "Charging") == 0) {
if (acpi_last_full[idx] != 0 && present_rate > 0) {
/* e.g. charging 75% */
- snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Charging %i%%",
+ snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "charging %i%%",
(int) (((float) remaining_capacity / acpi_last_full[idx]) * 100 ));
/* e.g. 2h 37m */
format_seconds(last_battery_time_str[idx], sizeof(last_battery_time_str[idx])-1,
(long) (((float)(acpi_last_full[idx] - remaining_capacity) / present_rate) * 3600));
} else if (acpi_last_full[idx] != 0 && present_rate <= 0) {
- snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Charging %d%%",
+ snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "charging %d%%",
(int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
+ snprintf(last_battery_time_str[idx],
+ sizeof(last_battery_time_str[idx]) - 1, "unknown");
} else {
- strncpy(last_battery_str[idx], "Charging", sizeof(last_battery_str[idx])-1);
+ strncpy(last_battery_str[idx], "charging", sizeof(last_battery_str[idx])-1);
+ snprintf(last_battery_time_str[idx],
+ sizeof(last_battery_time_str[idx]) - 1, "unknown");
}
}
/* discharging */
else if (strncmp(charging_state, "Discharging", 64) == 0) {
if (present_rate > 0) {
/* e.g. discharging 35% */
- snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Discharging %i%%",
+ snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "discharging %i%%",
(int) (((float) remaining_capacity / acpi_last_full[idx]) * 100 ));
/* e.g. 1h 12m */
format_seconds(last_battery_time_str[idx], sizeof(last_battery_time_str[idx])-1,
- (long) (((float)(acpi_last_full[idx] - remaining_capacity) / present_rate) * 3600));
+ (long) (((float) remaining_capacity / present_rate) * 3600));
} else if (present_rate == 0) { /* Thanks to Nexox for this one */
- snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Full");
+ snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "full");
+ snprintf(last_battery_time_str[idx],
+ sizeof(last_battery_time_str[idx]) - 1, "unknown");
} else {
snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1,
- "Discharging %d%%",
+ "discharging %d%%",
(int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
+ snprintf(last_battery_time_str[idx],
+ sizeof(last_battery_time_str[idx]) - 1, "unknown");
}
}
/* charged */
* when the second one is empty and the first one
* being charged. */
if (remaining_capacity == 0)
- strcpy(last_battery_str[idx], "Empty");
+ strcpy(last_battery_str[idx], "empty");
else
- strcpy(last_battery_str[idx], "Charged");
+ strcpy(last_battery_str[idx], "charged");
}
/* unknown, probably full / AC */
else {
if (acpi_last_full[idx] != 0
&& remaining_capacity != acpi_last_full[idx])
- snprintf(last_battery_str[idx], 64, "Unknown %d%%",
+ snprintf(last_battery_str[idx], 64, "unknown %d%%",
(int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
else
strncpy(last_battery_str[idx], "AC", 64);
/* read last full capacity if it's zero */
if (acpi_last_full[idx] == 0) {
- static int rep = 0;
+ static int rep3 = 0;
char path[128];
FILE *fp;
snprintf(path, 127, ACPI_BATTERY_BASE_PATH "/%s/info", bat);
- fp = open_file(path, &rep);
+ fp = open_file(path, &rep3);
if (fp != NULL) {
while (!feof(fp)) {
char b[256];
snprintf(last_battery_str[idx],
sizeof(last_battery_str[idx]) - 1, "charging %d%%",
(int) ((remaining_capacity * 100) / acpi_last_full[idx]));
+ snprintf(last_battery_time_str[idx],
+ sizeof(last_battery_time_str[idx]) - 1, "unknown");
} else {
strncpy(last_battery_str[idx], "charging",
sizeof(last_battery_str[idx]) - 1);
+ snprintf(last_battery_time_str[idx],
+ sizeof(last_battery_time_str[idx]) - 1, "unknown");
}
/* discharging */
} else if (strncmp(charging_state, "discharging", 64) == 0) {
} else if (present_rate == 0) { /* Thanks to Nexox for this one */
snprintf(last_battery_str[idx],
sizeof(last_battery_str[idx]) - 1, "full");
+ snprintf(last_battery_time_str[idx],
+ sizeof(last_battery_time_str[idx]) - 1, "unknown");
} else {
snprintf(last_battery_str[idx],
sizeof(last_battery_str[idx]) - 1, "discharging %d%%",
(int) ((remaining_capacity * 100) / acpi_last_full[idx]));
+ snprintf(last_battery_time_str[idx],
+ sizeof(last_battery_time_str[idx]) - 1, "unknown");
}
/* charged */
} else if (strncmp(charging_state, "charged", 64) == 0) {
}
if (apm_bat_fp[idx] != NULL) {
- int ac, status, flag, life;
+ unsigned int ac, status, flag;
+ int life;
fscanf(apm_bat_fp[idx], "%*s %*s %*x %x %x %x %d%%",
&ac, &status, &flag, &life);
apm_bat_fp[idx] = NULL;
}
}
+ set_return_value(buffer, n, item, idx);
+}
-set_return_value:
+void set_return_value(char *buffer, unsigned int n, int item, int idx)
+{
switch (item) {
case BATTERY_STATUS:
- snprintf(buf, n, "%s", last_battery_str[idx]);
+ snprintf(buffer, n, "%s", last_battery_str[idx]);
break;
case BATTERY_TIME:
- snprintf(buf, n, "%s", last_battery_time_str[idx]);
+ snprintf(buffer, n, "%s", last_battery_time_str[idx]);
break;
default:
break;
int get_battery_perct(const char *bat)
{
- static int rep;
+ static int rep = 0;
int idx;
char acpi_path[128];
+ char sysfs_path[128];
+ int remaining_capacity = -1;
snprintf(acpi_path, 127, ACPI_BATTERY_BASE_PATH "/%s/state", bat);
- char sysfs_path[128];
snprintf(sysfs_path, 127, SYSFS_BATTERY_BASE_PATH "/%s/uevent", bat);
init_batteries();
/* Only check for SYSFS or ACPI */
- if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL)
+ if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL) {
sysfs_bat_fp[idx] = open_file(sysfs_path, &rep);
+ rep = 0;
+ }
- if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL)
+ if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL) {
acpi_bat_fp[idx] = open_file(acpi_path, &rep);
-
- int remaining_capacity = -1;
+ }
if (sysfs_bat_fp[idx] != NULL) {
/* SYSFS */
/* ACPI */
/* read last full capacity if it's zero */
if (acpi_design_capacity[idx] == 0) {
- static int rep;
+ static int rep2;
char path[128];
FILE *fp;
snprintf(path, 127, ACPI_BATTERY_BASE_PATH "/%s/info", bat);
- fp = open_file(path, &rep);
+ fp = open_file(path, &rep2);
if (fp != NULL) {
while (!feof(fp)) {
char b[256];
/* compute the battery percentage */
last_battery_perct[idx] =
(int) (((float) remaining_capacity / acpi_design_capacity[idx]) * 100);
+ if (last_battery_perct[idx] > 100) last_battery_perct[idx] = 100;
return last_battery_perct[idx];
}
static double pb_battery_info_update;
#define PMU_PATH "/proc/pmu"
-void get_powerbook_batt_info(char *buf, size_t n, int i)
+void get_powerbook_batt_info(char *buffer, size_t n, int i)
{
static int rep = 0;
const char *batt_path = PMU_PATH "/battery_0";
const char *info_path = PMU_PATH "/info";
- int flags, charge, max_charge, ac = -1;
- long time = -1;
+ unsigned int flags;
+ int charge, max_charge, ac = -1;
+ long timeval = -1;
/* don't update battery too often */
if (current_update_time - pb_battery_info_update < 29.5) {
- snprintf(buf, n, "%s", pb_battery_info[i]);
+ snprintf(buffer, n, "%s", pb_battery_info[i]);
return;
}
pb_battery_info_update = current_update_time;
} else if (buf[0] == 'm') {
sscanf(buf, "max_charge : %d", &max_charge);
} else if (buf[0] == 't') {
- sscanf(buf, "time rem. : %ld", &time);
+ sscanf(buf, "time rem. : %ld", &timeval);
}
}
}
}
/* update percentage string */
- if (time == 0) {
+ if (timeval == 0) {
pb_battery_info[PB_BATT_PERCENT][0] = 0;
} else {
snprintf(pb_battery_info[PB_BATT_PERCENT],
}
/* update time string */
- if (time == 0) { /* fully charged or battery not present */
+ if (timeval == 0) { /* fully charged or battery not present */
pb_battery_info[PB_BATT_TIME][0] = 0;
- } else if (time < 60 * 60) { /* don't show secs */
+ } else if (timeval < 60 * 60) { /* don't show secs */
format_seconds_short(pb_battery_info[PB_BATT_TIME],
- sizeof(pb_battery_info[PB_BATT_TIME]), time);
+ sizeof(pb_battery_info[PB_BATT_TIME]), timeval);
} else {
format_seconds(pb_battery_info[PB_BATT_TIME],
- sizeof(pb_battery_info[PB_BATT_TIME]), time);
+ sizeof(pb_battery_info[PB_BATT_TIME]), timeval);
}
- snprintf(buf, n, "%s", pb_battery_info[i]);
+ snprintf(buffer, n, "%s", pb_battery_info[i]);
}
-void update_top()
+void update_top(void)
{
show_nice_processes = 1;
process_find_top(info.cpu, info.memu);
info.first_process = get_first_process();
}
-/* The following ifdefs were adapted from gkrellm */
-#include <linux/major.h>
-
-#if !defined(MD_MAJOR)
-#define MD_MAJOR 9
-#endif
-
-#if !defined(LVM_BLK_MAJOR)
-#define LVM_BLK_MAJOR 58
-#endif
-
-#if !defined(NBD_MAJOR)
-#define NBD_MAJOR 43
-#endif
-
-void update_diskio()
-{
- static unsigned int last = UINT_MAX;
- static unsigned int last_read = UINT_MAX;
- static unsigned int last_write = UINT_MAX;
- FILE *fp;
- static int rep = 0;
-
- char buf[512], devbuf[64];
- int major, minor, i;
- unsigned int current = 0;
- unsigned int current_read = 0;
- unsigned int current_write = 0;
- unsigned int reads, writes = 0;
- int col_count = 0;
-
- if (!(fp = open_file("/proc/diskstats", &rep))) {
- diskio_value = 0;
- return;
- }
-
- /* read reads and writes from all disks (minor = 0), including cd-roms
- * and floppies, and sum them up */
- while (!feof(fp)) {
- fgets(buf, 512, fp);
- col_count = sscanf(buf, "%u %u %s %*u %*u %u %*u %*u %*u %u", &major,
- &minor, devbuf, &reads, &writes);
- /* ignore subdevices (they have only 3 matching entries in their line)
- * and virtual devices (LVM, network block devices, RAM disks, Loopback)
- *
- * XXX: ignore devices which are part of a SW RAID (MD_MAJOR) */
- if (col_count == 5 && major != LVM_BLK_MAJOR && major != NBD_MAJOR
- && major != RAMDISK_MAJOR && major != LOOP_MAJOR) {
- current += reads + writes;
- current_read += reads;
- current_write += writes;
- } else {
- col_count = sscanf(buf, "%u %u %s %*u %u %*u %u",
- &major, &minor, devbuf, &reads, &writes);
- if (col_count != 5) {
- continue;
- }
- }
- for (i = 0; i < MAX_DISKIO_STATS; i++) {
- if (diskio_stats[i].dev &&
- strcmp(devbuf, diskio_stats[i].dev) == 0) {
- diskio_stats[i].current =
- (reads + writes - diskio_stats[i].last) / 2;
- diskio_stats[i].current_read =
- (reads - diskio_stats[i].last_read) / 2;
- diskio_stats[i].current_write =
- (writes - diskio_stats[i].last_write) / 2;
- if (reads + writes < diskio_stats[i].last) {
- diskio_stats[i].current = 0;
- }
- if (reads < diskio_stats[i].last_read) {
- diskio_stats[i].current_read = 0;
- diskio_stats[i].current = diskio_stats[i].current_write;
- }
- if (writes < diskio_stats[i].last_write) {
- diskio_stats[i].current_write = 0;
- diskio_stats[i].current = diskio_stats[i].current_read;
- }
- diskio_stats[i].last = reads + writes;
- diskio_stats[i].last_read = reads;
- diskio_stats[i].last_write = writes;
- }
- }
- }
-
- /* since the values in /proc/diststats are absolute, we have to substract
- * our last reading. The numbers stand for "sectors read", and we therefore
- * have to divide by two to get KB */
- int tot = ((double) (current - last) / 2);
- int tot_read = ((double) (current_read - last_read) / 2);
- int tot_write = ((double) (current_write - last_write) / 2);
-
- if (last_read > current_read) {
- tot_read = 0;
- }
- if (last_write > current_write) {
- tot_write = 0;
- }
-
- if (last > current) {
- /* we hit this either if it's the very first time we run this, or
- * when /proc/diskstats overflows; while 0 is not correct, it's at
- * least not way off */
- tot = 0;
- }
- last = current;
- last_read = current_read;
- last_write = current_write;
-
- diskio_value = tot;
- diskio_read_value = tot_read;
- diskio_write_value = tot_write;
-
- fclose(fp);
-}
-
/* Here come the IBM ACPI-specific things. For reference, see
* http://ibm-acpi.sourceforge.net/README
* If IBM ACPI is installed, /proc/acpi/ibm contains the following files:
void get_ibm_acpi_fan(char *p_client_buffer, size_t client_buffer_size)
{
- if (!p_client_buffer || client_buffer_size <= 0) {
- return;
- }
-
FILE *fp;
unsigned int speed = 0;
char fan[128];
+ if (!p_client_buffer || client_buffer_size <= 0) {
+ return;
+ }
+
snprintf(fan, 127, "%s/fan", IBM_ACPI_DIR);
fp = fopen(fan, "r");
if (fgets(line, 255, fp) == NULL) {
break;
}
- if (sscanf(line, "speed: %d", &speed)) {
+ if (sscanf(line, "speed: %u", &speed)) {
break;
}
}
} else {
CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
- "ibm* from your Conky config file.", fan, strerror(errno));
+ "ibm* from your "PACKAGE_NAME" config file.", fan, strerror(errno));
}
fclose(fp);
* Peter Tarjan (ptarjan@citromail.hu) */
static double last_ibm_acpi_temp_time;
-void get_ibm_acpi_temps()
+void get_ibm_acpi_temps(void)
{
+ FILE *fp;
+ char thermal[128];
+
/* don't update too often */
if (current_update_time - last_ibm_acpi_temp_time < 10.00) {
return;
return;
} */
- FILE *fp;
-
- char thermal[128];
-
snprintf(thermal, 127, "%s/thermal", IBM_ACPI_DIR);
fp = fopen(thermal, "r");
}
} else {
CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
- "ibm* from your Conky config file.", thermal, strerror(errno));
+ "ibm* from your "PACKAGE_NAME" config file.", thermal, strerror(errno));
}
fclose(fp);
void get_ibm_acpi_volume(char *p_client_buffer, size_t client_buffer_size)
{
+ FILE *fp;
+ char volume[128];
+ unsigned int vol = -1;
+ char mute[3] = "";
+
if (!p_client_buffer || client_buffer_size <= 0) {
return;
}
- FILE *fp;
-
- char volume[128];
-
snprintf(volume, 127, "%s/volume", IBM_ACPI_DIR);
- unsigned int vol = -1;
- char mute[3] = "";
fp = fopen(volume, "r");
if (fp != NULL) {
if (fgets(line, 255, fp) == NULL) {
break;
}
- if (sscanf(line, "level: %d", &read_vol)) {
+ if (sscanf(line, "level: %u", &read_vol)) {
vol = read_vol;
continue;
}
}
} else {
CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
- "ibm* from your Conky config file.", volume, strerror(errno));
+ "ibm* from your "PACKAGE_NAME" config file.", volume, strerror(errno));
}
fclose(fp);
void get_ibm_acpi_brightness(char *p_client_buffer, size_t client_buffer_size)
{
- if (!p_client_buffer || client_buffer_size <= 0) {
- return;
- }
-
FILE *fp;
unsigned int brightness = 0;
char filename[128];
+ if (!p_client_buffer || client_buffer_size <= 0) {
+ return;
+ }
+
snprintf(filename, 127, "%s/brightness", IBM_ACPI_DIR);
fp = fopen(filename, "r");
if (fgets(line, 255, fp) == NULL) {
break;
}
- if (sscanf(line, "level: %d", &brightness)) {
+ if (sscanf(line, "level: %u", &brightness)) {
break;
}
}
} else {
CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
- "ibm* from your Conky config file.", filename, strerror(errno));
+ "ibm* from your "PACKAGE_NAME" config file.", filename, strerror(errno));
}
fclose(fp);
info.mask |= (1 << INFO_ENTROPY);
}
-char *get_disk_protect_queue(char *disk)
+const char *get_disk_protect_queue(const char *disk)
{
FILE *fp;
char path[128];
int state;
- snprintf(path, 127, "/sys/block/%s/queue/protect", disk);
+ snprintf(path, 127, "/sys/block/%s/device/unload_heads", disk);
+ if (access(path, F_OK)) {
+ snprintf(path, 127, "/sys/block/%s/queue/protect", disk);
+ }
if ((fp = fopen(path, "r")) == NULL)
return "n/a ";
if (fscanf(fp, "%d\n", &state) != 1) {
return "failed";
}
fclose(fp);
- return state ? "frozen" : "free ";
+ return (state > 0) ? "frozen" : "free ";
}
projects / monky / blobdiff