示例#1
0
static int parse_imon_status(const char *channel)
{
    char buf[256], status[25];
    char *s;
    int age;

    qprintf(buf, sizeof(buf), "status %s", channel);

    /* reread every half sec only */
    age = hash_age(&IMON, buf);
    if (age > 0 && age <= 500)
	return 0;

    init();			/* establish connection */

    if (err)
	return -1;

    qprintf(buf, sizeof(buf), "status %s", channel);
    s = get_value(buf);

    if (sscanf(s, "%s", status) != 1)
	return -1;

    qprintf(buf, sizeof(buf), "status %s", channel);
    if (strcasecmp(status, "Online") == 0)
	hash_put(&IMON, buf, "1");
    else
	hash_put(&IMON, buf, "0");

    return 0;
}
示例#2
0
static void my_imon_version(RESULT * result)
{
    char *val;
    int age;

    if (configure_imon() < 0) {
	SetResult(&result, R_STRING, "");
	return;
    }

    /* read only once */
    age = hash_age(&IMON, "version");
    if (age < 0) {
	char *s;
	init();
	if (err) {
	    SetResult(&result, R_STRING, "");
	    return;
	}
	s = get_value("version");
	for (;;) {		/* interne Versionsnummer killen */
	    if (s[0] == ' ') {
		s = s + 1;
		break;
	    }
	    s = s + 1;
	}
	hash_put(&IMON, "version", s);
    }

    val = hash_get(&IMON, "version", NULL);
    if (val == NULL)
	val = "";
    SetResult(&result, R_STRING, val);
}
示例#3
0
static int parse_imon_quantity(const char *channel)
{
    char buf[256], fill1[25], in[25], fill2[25], out[25];
    char *s;
    int age;

    qprintf(buf, sizeof(buf), "quantity %s in", channel);

    /* reread every half sec only */
    age = hash_age(&IMON, buf);
    if (age > 0 && age <= 500)
	return 0;

    init();			/* establish connection */

    if (err)
	return -1;

    qprintf(buf, sizeof(buf), "quantity %s", channel);
    s = get_value(buf);

    if (sscanf(s, "%s %s %s %s", fill1, in, fill2, out) != 4)
	return -1;

    qprintf(buf, sizeof(buf), "quantity %s in", channel);
    hash_put(&IMON, buf, in);
    qprintf(buf, sizeof(buf), "quantity %s out", channel);
    hash_put(&IMON, buf, out);

    return 0;
}
示例#4
0
static int get_essid(const char *dev, const char *key)
{
    /* Get ESSID */
    struct iwreq req;
    char key_buffer[32];
    char essid_buffer[IW_ESSID_MAX_SIZE + 1];
    int age;


    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
    age = hash_age(&wireless, key);

    /* reread every HASH_TTL msec only */
    if (age > 0 && age <= HASH_TTL) {
	return (0);
    }

    if (get_ifname(&req, dev) != 0) {
	return (-1);
    }

    memset(essid_buffer, 0, sizeof(essid_buffer));
    req.u.essid.pointer = (caddr_t) essid_buffer;
    req.u.essid.length = IW_ESSID_MAX_SIZE + 1;
    req.u.essid.flags = 0;

    if (do_ioctl(sock, dev, SIOCGIWESSID, &req) < 0) {
	ioctl_error(__LINE__);
	return -1;
    }

    hash_put(&wireless, key_buffer, essid_buffer);
    return (0);

}
示例#5
0
static int get_op_mode(const char *dev, const char *key)
{
    /* Get operation mode */
    struct iwreq req;
    char key_buffer[32];
    int age;

    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
    age = hash_age(&wireless, key);

    /* reread every HASH_TTL msec only */
    if (age > 0 && age <= HASH_TTL) {
	return (0);
    }

    if (get_ifname(&req, dev) != 0) {
	return (-1);
    }

    if (do_ioctl(sock, dev, SIOCGIWMODE, &req) < 0) {
	ioctl_error(__LINE__);
	return -1;
    }

    /* Fixme: req.u.mode is unsigned and therefore never < 0 */
    /* if((req.u.mode > 6) || (req.u.mode < 0)) { */

    if (req.u.mode > 6) {
	req.u.mode = 7;		/* mode not available */
    }

    hash_put(&wireless, key_buffer, operation_mode[req.u.mode]);
    return (0);

}
示例#6
0
static int parse_proc_apm(void)
{
    char *key[] = { "driver_version",
	"bios_version",
	"bios_flags",
	"line_status",
	"battery_status",
	"battery_flag",
	"battery_percent",
	"battery_remaining",
	"time_units"
    };

    char buffer[128], *beg, *end;
    int age, i;

    /* reread every 10 msec only */
    age = hash_age(&APM, NULL);
    if (age > 0 && age <= 10)
	return 0;

    if (fd == -2) {
	fd = open("/proc/apm", O_RDONLY | O_NDELAY);
	if (fd == -1) {
	    error("open(/proc/apm) failed: %s", strerror(errno));
	    return -1;
	}
    }

    if (lseek(fd, 0L, SEEK_SET) != 0) {
	error("lseek(/proc/apm) failed: %s", strerror(errno));
	fd = -1;
	return -1;
    }

    if (read(fd, &buffer, sizeof(buffer) - 1) == -1) {
	error("read(/proc/apm) failed: %s", strerror(errno));
	fd = -1;
	return -1;
    }

    beg = buffer;
    for (i = 0; i < 9 && beg != NULL; i++) {
	while (*beg == ' ')
	    beg++;
	if ((end = strpbrk(beg, " \n")))
	    *end = '\0';
	hash_put(&APM, key[i], beg);
	beg = end ? end + 1 : NULL;
    }

    return 0;
}
示例#7
0
static int parse_meminfo(void)
{
    int age;

    /* reread every 10 msec only */
    age = hash_age(&MemInfo, NULL);
    if (age > 0 && age <= 10)
	return 0;

    if (stream == NULL)
	stream = fopen("/proc/meminfo", "r");
    if (stream == NULL) {
	error("fopen(/proc/meminfo) failed: %s", strerror(errno));
	return -1;
    }

    rewind(stream);
    while (!feof(stream)) {
	char buffer[256];
	char *c, *key, *val;
	fgets(buffer, sizeof(buffer), stream);
	c = strchr(buffer, ':');
	if (c == NULL)
	    continue;
	key = buffer;
	val = c + 1;
	/* strip leading blanks from key */
	while (isspace(*key))
	    *key++ = '\0';
	/* strip trailing blanks from key */
	do
	    *c = '\0';
	while (isspace(*--c));
	/* strip leading blanks from value */
	while (isspace(*val))
	    *val++ = '\0';
	/* strip trailing blanks from value */
	for (c = val; *c != '\0'; c++);
	while (isspace(*--c))
	    *c = '\0';
	/* skip lines that do not end with " kB" */
	if (*c == 'B' && *(c - 1) == 'k' && *(c - 2) == ' ') {
	    /* strip trailing " kB" from value */
	    *(c - 2) = '\0';
	    /* add entry to hash table */
	    hash_put(&MemInfo, key, val);
	}
    }
    return 0;
}
示例#8
0
static int parse_xmms_info(void)
{
    int age;
    FILE *xmms_stream;
    char zeile[200];

    /* reread every 100msec only */
    age = hash_age(&xmms, NULL);
    if (age >= 0 && age <= 200)
	return 0;
    /* Open Filestream for '/tmp/xmms-info' */
    xmms_stream = fopen("/tmp/xmms-info", "r");

    /* Check for File */
    if (!xmms_stream) {
	error("Error: Cannot open XMMS-Info Stream! Is XMMS started?");
	return -1;
    }

    /* Read Lines from the Stream */
    while (fgets(zeile, sizeof(zeile), xmms_stream)) {
	char *c, *key, *val;
	c = strchr(zeile, ':');
	if (c == NULL)
	    continue;
	key = zeile;
	val = c + 1;
	/* strip leading blanks from key */
	while (isspace(*key))
	    *key++ = '\0';
	/* strip trailing blanks from key */
	do
	    *c = '\0';
	while (isspace(*--c));
	/* strip leading blanks from value */
	while (isspace(*val))
	    *val++ = '\0';
	/* strip trailing blanks from value */
	for (c = val; *c != '\0'; c++);
	while (isspace(*--c))
	    *c = '\0';
	hash_put(&xmms, key, val);
    }

    fclose(xmms_stream);
    return 0;

}
示例#9
0
static int parse_imon(const char *cmd)
{
    /* reread every half sec only */
    int age = hash_age(&IMON, cmd);
    if (age > 0 && age <= 500)
	return 0;

    init();			/* establish connection */

    if (err)
	return -1;

    hash_put(&IMON, cmd, get_value(cmd));

    return 0;
}
示例#10
0
static int get_sec_mode(const char *dev, const char *key)
{
    /* Get encryption information  */
    struct iwreq req;
    char key_buffer[32];
    char encrypt_key[IW_ENCODING_TOKEN_MAX + 1];
    int age;
    int has_key = 0;
    int key_flags = 0;
    int key_size = 0;

    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
    age = hash_age(&wireless, key);

    /* reread every HASH_TTL msec only */
    if (age > 0 && age <= HASH_TTL) {
	return (0);
    }

    if (get_ifname(&req, dev) != 0) {
	return (-1);
    }

    req.u.data.pointer = (caddr_t) & encrypt_key;
    req.u.data.length = IW_ENCODING_TOKEN_MAX;
    req.u.data.flags = 0;

    if (do_ioctl(sock, dev, SIOCGIWENCODE, &req) >= 0) {
	has_key = 1;
	key_flags = req.u.data.flags;
	key_size = req.u.data.length;
    } else {
	return (-1);
    }

    /* Display encryption information  */
    /*if(has_key && (key_flags & IW_ENCODE_INDEX) > 1) */
    /*  printf(" [%d]", info->key_flags & IW_ENCODE_INDEX); */

    if (has_key && (key_flags & IW_ENCODE_RESTRICTED))
	hash_put(&wireless, key_buffer, "restricted");
    else if (has_key && (key_flags & IW_ENCODE_OPEN))
	hash_put(&wireless, key_buffer, "open");

    return (0);
}
示例#11
0
static int get_sens(const char *dev, const char *key)
{
    /* Get sensitivity */
    struct iwreq req;
    struct iw_range range;
    char key_buffer[32];
    char buffer[64];
    int age;
    int has_sens = 0;
    int has_range = 0;

    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
    age = hash_age(&wireless, key);

    /* reread every HASH_TTL msec only */
    if (age > 0 && age <= HASH_TTL) {
	return (0);
    }

    if (get_ifname(&req, dev) != 0) {
	return (-1);
    }

    if (do_ioctl(sock, dev, SIOCGIWSENS, &req) >= 0) {
	has_sens = 1;
    }

    if (get_range_info(sock, dev, &range) < 0) {
	memset(&range, 0, sizeof(range));
    } else {
	has_range = 1;
    }

    if (has_range) {
	if (req.u.sens.value < 0) {
	    qprintf(buffer, sizeof(buffer), "%d dBm", req.u.sens.value);
	} else {
	    qprintf(buffer, sizeof(buffer), "%d/%d", req.u.sens.value, range.sensitivity);
	}
    } else {
	qprintf(buffer, sizeof(buffer), "%d", req.u.sens.value);
    }

    hash_put(&wireless, key_buffer, buffer);
    return (0);
}
示例#12
0
static int get_frequency(const char *dev, const char *key)
{
    /* Get frequency / channel */
    struct iwreq req;
    char qprintf_buffer[1024];
    char key_buffer[32];
    double freq;
    int age;

    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
    age = hash_age(&wireless, key);

    /* reread every HASH_TTL msec only */
    if (age > 0 && age <= HASH_TTL) {
	return (0);
    }

    if (get_ifname(&req, dev) != 0) {
	return (-1);
    }

    req.u.data.length = 0;
    req.u.data.flags = 1;	/* Clear updated flag */

    if (do_ioctl(sock, dev, SIOCGIWFREQ, &req) < 0) {
	ioctl_error(__LINE__);
	return -1;
    }

    freq = FREQ2FLOAT(req.u.freq.m, req.u.freq.e);

    /*if( freq>= GIGA)
       snprintf(qprintf_buffer,sizeof(qprintf_buffer), "%g GHz", freq / GIGA);
       else
       if(freq>= MEGA)
       snprintf(qprintf_buffer,sizeof(qprintf_buffer), "%g MHz", freq / MEGA);
       else
       snprintf(qprintf_buffer,sizeof(qprintf_buffer), "%g kHz", freq / KILO);
     */
    snprintf(qprintf_buffer, sizeof(qprintf_buffer), "%g", freq);

    hash_put(&wireless, key_buffer, qprintf_buffer);
    return (0);

}
示例#13
0
static int get_bitrate(const char *dev, const char *key)
{
    /* Get bit rate */
    struct iwreq req;
    char key_buffer[32];
    char bitrate_buffer[64];
    int age;
    double bitrate = 0;

    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
    age = hash_age(&wireless, key);

    /* reread every HASH_TTL msec only */
    if (age > 0 && age <= HASH_TTL) {
	return (0);
    }

    if (get_ifname(&req, dev) != 0) {
	return (-1);
    }

    if (do_ioctl(sock, dev, SIOCGIWRATE, &req) < 0) {
	ioctl_error(__LINE__);
	return -1;
    }

    bitrate_buffer[0] = '\0';
    bitrate = (double) (req.u.bitrate.value);
/*  if( bitrate>= GIGA)
    snprintf(bitrate_buffer,sizeof(bitrate_buffer), "%gGb/s", bitrate / GIGA);
  else
    if(bitrate >= MEGA)
      snprintf(bitrate_buffer,sizeof(bitrate_buffer), "%gMb/s", bitrate / MEGA);
    else
      snprintf(bitrate_buffer,sizeof(bitrate_buffer), "%gkb/s", bitrate / KILO);
*/
    snprintf(bitrate_buffer, sizeof(bitrate_buffer), "%g", bitrate);

    hash_put(&wireless, key_buffer, bitrate_buffer);

    return (0);
}
示例#14
0
static int parse_telmon()
{
    static int telmond_fd = -2;
    static char oldanswer[128];
    int age;

    /* reread every 1 sec only */
    age = hash_age(&TELMON, NULL);
    if (age > 0 && age <= 1000)
	return 0;

    if (telmond_fd != -1) {
	char telbuf[128];

	telmond_fd = service_connect(thost, tport);
	if (telmond_fd >= 0) {
	    int l = read(telmond_fd, telbuf, 127);
	    if ((l > 0) && (strcmp(telbuf, oldanswer))) {
		char date[11];
		char time[11];
		char number[256];
		char msn[256];
		sscanf(telbuf, "%s %s %s %s", date, time, number, msn);
		hash_put(&TELMON, "time", time);
		date[4] = '\0';
		date[7] = '\0';
		qprintf(time, sizeof(time), "%s.%s.%s", date + 8, date + 5, date);
		hash_put(&TELMON, "number", number);
		hash_put(&TELMON, "msn", msn);
		hash_put(&TELMON, "date", time);
		phonebook(number);
		phonebook(msn);
		hash_put(&TELMON, "name", number);
		hash_put(&TELMON, "msnname", msn);
	    }
	    close(telmond_fd);
	    strcpy(oldanswer, telbuf);
	}
    }
    return 0;
}
示例#15
0
static int get_stats(const char *dev, const char *key)
{
    struct iw_statistics stats;
    struct iwreq req;
    char qprintf_buffer[1024];
    char key_buffer[32];
    int age;
    struct iw_range range;

    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
    age = hash_age(&wireless, key);

    /* reread every HASH_TTL msec only */
    if (age > 0 && age <= HASH_TTL) {
	return (0);
    }

    if (get_ifname(&req, dev) != 0) {
	return (-1);
    }

    req.u.data.pointer = (caddr_t) & stats;
    req.u.data.length = sizeof(stats);
    req.u.data.flags = 1;	/* Clear updated flag */

    if (do_ioctl(sock, dev, SIOCGIWSTATS, &req) < 0) {
	ioctl_error(__LINE__);
	return -1;
    }

    if (get_range_info(sock, dev, &range) < 0)
	memset(&range, 0, sizeof(range));

    if (stats.qual.level > range.max_qual.level) {
	qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d", stats.qual.level - 0x100);
	qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
	hash_put(&wireless, key_buffer, qprintf_buffer);

	qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d", stats.qual.noise - 0x100);
	qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_NOISE);
	hash_put(&wireless, key_buffer, qprintf_buffer);

	qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.qual, range.max_qual.qual);
	qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_QUALITY);
	hash_put(&wireless, key_buffer, qprintf_buffer);
    } else {

	qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.level, range.max_qual.level);
	qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
	hash_put(&wireless, key_buffer, qprintf_buffer);

	qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.noise, range.max_qual.noise);
	qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_NOISE);
	hash_put(&wireless, key_buffer, qprintf_buffer);

	qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.qual, range.max_qual.qual);
	qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_QUALITY);
	hash_put(&wireless, key_buffer, qprintf_buffer);
    }

    return 0;
}
示例#16
0
static int parse_proc_stat(void)
{
    int age;

    /* reread every 10 msec only */
    age = hash_age(&Stat, NULL);
    if (age > 0 && age <= 10)
	return 0;

#ifndef __MAC_OS_X_VERSION_10_3

    /* Linux Kernel, /proc-filesystem */

    if (stream == NULL)
	stream = fopen("/proc/stat", "r");
    if (stream == NULL) {
	error("fopen(/proc/stat) failed: %s", strerror(errno));
	return -1;
    }

    rewind(stream);

    while (!feof(stream)) {
	char buffer[1024];
	if (fgets(buffer, sizeof(buffer), stream) == NULL)
	    break;

	if (strncmp(buffer, "cpu", 3) == 0) {
	    char *key[] = { "user", "nice", "system", "idle", "iow", "irq", "sirq" };
	    char delim[] = " \t\n";
	    char *cpu, *beg, *end;
	    int i;

	    cpu = buffer;

	    /* skip "cpu" or "cpu0" block */
	    if ((end = strpbrk(buffer, delim)) != NULL)
		*end = '\0';
	    beg = end ? end + 1 : NULL;

	    for (i = 0; i < 7 && beg != NULL; i++) {
		while (strchr(delim, *beg))
		    beg++;
		if ((end = strpbrk(beg, delim)))
		    *end = '\0';
		hash_put2(cpu, key[i], beg);
		beg = end ? end + 1 : NULL;
	    }
	}

	else if (strncmp(buffer, "page ", 5) == 0) {
	    char *key[] = { "in", "out" };
	    char delim[] = " \t\n";
	    char *beg, *end;
	    int i;

	    for (i = 0, beg = buffer + 5; i < 2 && beg != NULL; i++) {
		while (strchr(delim, *beg))
		    beg++;
		if ((end = strpbrk(beg, delim)))
		    *end = '\0';
		hash_put2("page", key[i], beg);
		beg = end ? end + 1 : NULL;
	    }
	}

	else if (strncmp(buffer, "swap ", 5) == 0) {
	    char *key[] = { "in", "out" };
	    char delim[] = " \t\n";
	    char *beg, *end;
	    int i;

	    for (i = 0, beg = buffer + 5; i < 2 && beg != NULL; i++) {
		while (strchr(delim, *beg))
		    beg++;
		if ((end = strpbrk(beg, delim)))
		    *end = '\0';
		hash_put2("swap", key[i], beg);
		beg = end ? end + 1 : NULL;
	    }
	}

	else if (strncmp(buffer, "intr ", 5) == 0) {
	    char delim[] = " \t\n";
	    char *beg, *end, num[4];
	    int i;

	    for (i = 0, beg = buffer + 5; i < 17 && beg != NULL; i++) {
		while (strchr(delim, *beg))
		    beg++;
		if ((end = strpbrk(beg, delim)))
		    *end = '\0';
		if (i == 0)
		    strcpy(num, "sum");
		else
		    qprintf(num, sizeof(num), "%d", i - 1);
		hash_put2("intr", num, beg);
		beg = end ? end + 1 : NULL;
	    }
	}

	else if (strncmp(buffer, "disk_io:", 8) == 0) {
	    char *key[] = { "io", "rio", "rblk", "wio", "wblk" };
	    char delim[] = " ():,\t\n";
	    char *dev, *beg, *end, *p;
	    int i;

	    dev = buffer + 8;
	    while (dev != NULL) {
		while (strchr(delim, *dev))
		    dev++;
		if ((end = strchr(dev, ')')))
		    *end = '\0';
		while ((p = strchr(dev, ',')) != NULL)
		    *p = ':';
		beg = end ? end + 1 : NULL;
		for (i = 0; i < 5 && beg != NULL; i++) {
		    while (strchr(delim, *beg))
			beg++;
		    if ((end = strpbrk(beg, delim)))
			*end = '\0';
		    hash_put3("disk_io", dev, key[i], beg);
		    beg = end ? end + 1 : NULL;
		}
		dev = beg;
	    }
	}

	else {
	    char delim[] = " \t\n";
	    char *beg, *end;

	    beg = buffer;
	    if ((end = strpbrk(beg, delim)))
		*end = '\0';
	    beg = end ? end + 1 : NULL;
	    if ((end = strpbrk(beg, delim)))
		*end = '\0';
	    while (strchr(delim, *beg))
		beg++;
	    hash_put1(buffer, beg);
	}
    }

#else

    /* MACH Kernel, MacOS X */

    kern_return_t err;
    mach_msg_type_number_t count;
    host_info_t r_load;
    host_cpu_load_info_data_t cpu_load;
    char s_val[8];

    r_load = &cpu_load;
    count = HOST_CPU_LOAD_INFO_COUNT;
    err = host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, r_load, &count);
    if (KERN_SUCCESS != err) {
	error("Error getting cpu load");
	return -1;
    }
    snprintf(s_val, sizeof(s_val), "%d", cpu_load.cpu_ticks[CPU_STATE_USER]);
    hash_put2("cpu", "user", s_val);
    snprintf(s_val, sizeof(s_val), "%d", cpu_load.cpu_ticks[CPU_STATE_NICE]);
    hash_put2("cpu", "nice", s_val);
    snprintf(s_val, sizeof(s_val), "%d", cpu_load.cpu_ticks[CPU_STATE_SYSTEM]);
    hash_put2("cpu", "system", s_val);
    snprintf(s_val, sizeof(s_val), "%d", cpu_load.cpu_ticks[CPU_STATE_IDLE]);
    hash_put2("cpu", "idle", s_val);

#endif

    return 0;
}