client.c

系统任务管理器

	{
	GList		*list;
	ActiveTCP	*tcp;

	for (list = inet_list; list; list = list->next)
		{
		tcp = (ActiveTCP *) list->data;
		gkrellm_inet_log_tcp_port_data(tcp);
		}
	}

static void
client_inet_reset(void)
	{
	gkrellm_free_glist_and_data(&inet_list);
	}

static void
client_sys_inet_init(void)
	{
	if (inet_unsupported)
		return;
	gkrellm_inet_client_divert(read_tcp_data);
	}

static void
client_inet_setup(gchar *line)
	{
	if (!strcmp(line, "inet_unsupported"))
		inet_unsupported = TRUE;
	}

/* ================================================================= */
struct
	{
	guint64		total,
				used,
				free,
				shared,
				buffers,
				cached;
	guint64		swap_total,
				swap_used;
	gulong		swap_in,
				swap_out;
	}
	mem;

static void
client_mem_line_from_server(gchar *line)
	{
	sscanf(line, "%llu %llu %llu %llu %llu %llu",
			&mem.total, &mem.used, &mem.free,
			&mem.shared, &mem.buffers, &mem.cached);
	}

static void
client_swap_line_from_server(gchar *line)
	{
	sscanf(line, "%llu %llu %lu %lu",
			&mem.swap_total, &mem.swap_used,
			&mem.swap_in, &mem.swap_out);
	}

static void
read_mem_data(void)
	{
	gkrellm_mem_assign_data(mem.total, mem.used, mem.free, mem.shared,
				mem.buffers, mem.cached);
	}

static void
read_swap_data(void)
	{
	gkrellm_swap_assign_data(mem.swap_total, mem.swap_used,
				mem.swap_in, mem.swap_out);
	}

static void
client_sys_mem_init(void)
	{
	gkrellm_mem_client_divert(read_mem_data, read_swap_data);
	}

/* ================================================================= */
typedef struct
	{
	gchar	*directory,
			*device,
			*type;
	gulong	blocks,
			bavail,
			bfree,
			bsize;
	}
	Mount;

static GList	*mounts_list,
				*fstab_list;

static gboolean fstab_modified,
				mounting_unsupported;

static void
client_fstab_line_from_server(gchar *line)
	{
	GList	*list;
	Mount	*m;
	gchar	dir[128], dev[64], type[64];

	if (!strcmp(line, ".clear"))
		{
		for (list = fstab_list; list; list = list->next)
			{
			m = (Mount *) list->data;
			g_free(m->directory);
			g_free(m->device);
			g_free(m->type);
			g_free(m);
			}
		g_list_free(fstab_list);
		fstab_list = NULL;
		fstab_modified = TRUE;
		}
	else
		{
		m = g_new0(Mount, 1);
		sscanf(line, "%127s %63s %63s", dir, dev, type);
		m->directory = g_strdup(dir);
		m->device = g_strdup(dev);
		m->type = g_strdup(type);
		fstab_list = g_list_append(fstab_list, m);
		}
	}

static void
client_mounts_line_from_server(gchar *line)
	{
	GList	*list;
	Mount	*m;
	gchar	dir[128], dev[64], type[64];

	if (!strcmp(line, ".clear"))
		{
		for (list = mounts_list; list; list = list->next)
			{
			m = (Mount *) list->data;
			g_free(m->directory);
			g_free(m->device);
			g_free(m->type);
			g_free(m);
			}
		g_list_free(mounts_list);
		mounts_list = NULL;
		}
	else
		{
		m = g_new0(Mount, 1);
		sscanf(line, "%127s %63s %63s %lu %lu %lu %lu", dir, dev, type,
				&m->blocks, &m->bavail, &m->bfree, &m->bsize);
		m->directory = g_strdup(dir);
		m->device = g_strdup(dev);
		m->type = g_strdup(type);
		mounts_list = g_list_append(mounts_list, m);
		}
	}

static void
client_fs_line_from_server(gchar *line)
	{
	GList	*list;
	Mount	*m;
	gchar	dir[128], dev[64];
	gulong	blocks, bavail, bfree, bsize;

	sscanf(line, "%127s %63s %lu %lu %lu %lu", dir, dev,
				&blocks, &bavail, &bfree, &bsize);
	for (list = mounts_list; list; list = list->next)
		{
		m = (Mount *) list->data;
		if (!strcmp(m->directory, dir) && !strcmp(m->device, dev))
			{
			m->blocks = blocks;
			m->bavail = bavail;
			m->bfree = bfree;
			m->bsize = bsize;
			break;
			}
		}
	}

static void
get_fsusage(gpointer fs, gchar *dir)
	{
	GList	*list;
	Mount	*m;

	for (list = mounts_list; list; list = list->next)
		{
		m = (Mount *) list->data;
		if (!strcmp(m->directory, dir))
			{
			gkrellm_fs_assign_fsusage_data(fs, m->blocks, m->bavail,
						m->bfree, m->bsize);
			break;
			}
		}
	}

static void
get_mounts_list(void)
	{
	GList	*list;
	Mount	*m;

	for (list = mounts_list; list; list = list->next)
		{
		m = (Mount *) list->data;
		gkrellm_fs_add_to_mounts_list(m->directory, m->device, m->type);
		}
	}

static void
get_fstab_list(void)
	{
	GList	*list;
	Mount	*m;

	for (list = fstab_list; list; list = list->next)
		{
		m = (Mount *) list->data;
		gkrellm_fs_add_to_fstab_list(m->directory, m->device,
				m->type, "none" /* options NA since no mounting */ );
		}
	fstab_modified = FALSE;
	}

static gboolean
get_fstab_modified(void)
	{
	return fstab_modified;
	}

static void
client_sys_fs_init(void)
	{
	gkrellm_fs_client_divert(get_fsusage, get_mounts_list,
				get_fstab_list, get_fstab_modified);
	if (mounting_unsupported)
		gkrellm_fs_mounting_unsupported();
	}

static void
client_fs_setup(gchar *line)
	{
	if (!strcmp(line, "mounting_unsupported"))
		mounting_unsupported = TRUE;
	}

/* ================================================================= */
typedef struct
	{
	gchar		*path;
	gint		total,
				new;
	gpointer	mbox_ptr;
	}
	Mailbox;

static GList	*mailbox_list;

static gboolean
check_mail(Mailbox *mbox)
	{
	gkrellm_set_external_mbox_counts(mbox->mbox_ptr, mbox->total, mbox->new);
	return TRUE;
	}

static void
client_mail_line_from_server(gchar *line)
	{
	Mailbox		*mbox = NULL;
	GList		*list;
	gchar		path[256];
//	gchar		*s;
	gint		total, new;

	if (sscanf(line, "%255s %d %d", path, &total, &new) < 3)
		return;
	for (list = mailbox_list; list; list = list->next)
		{
		mbox = (Mailbox *) list->data;
		if (!strcmp(path, mbox->path))
			break;
		}
	if (!list)
		{
		mbox = g_new0(Mailbox, 1);
		mbox->path = g_strdup(path);
		mailbox_list = g_list_append(mailbox_list, mbox);
		mbox->mbox_ptr =
				gkrellm_add_external_mbox(check_mail, FALSE, mbox);
		gkrellm_set_external_mbox_tooltip(mbox->mbox_ptr, mbox->path);

//		s = g_strdup_printf("%s:%s", _GK.server_hostname, mbox->path);
//		gkrellm_set_external_mbox_tooltip(mbox->mbox_ptr, s);
//		g_free(s);
		}
	if (mbox)
		{
		mbox->total = total;
		mbox->new = new;
		}
	}

static void
client_sys_mail_init(void)
	{
	}

static void
client_mail_setup(gchar *line)
	{
	}

/* ================================================================= */
GList		*battery_list;

gboolean 	batteries_available;

typedef struct
	{
	gint		id;
    gboolean	present,
				on_line,
				charging;
	gint		percent;
	gint		time_left;
	}
	Battery;

static Battery	*composite_battery;

static Battery *
battery_nth(gint n)
	{
	Battery		*bat;
	static gint	n_batteries;

	if (n > 10)
		return NULL;
	if (n < 0)
		{
		if (!composite_battery)
			{
			bat = g_new0(Battery, 1);
			battery_list = g_list_prepend(battery_list, bat);
			bat->id = GKRELLM_BATTERY_COMPOSITE_ID;
			composite_battery = bat;
			}
		return composite_battery;
		}

	if (composite_battery)
		++n;

	while ((bat = (Battery *)g_list_nth_data(battery_list, n)) == NULL)
		{
		bat = g_new0(Battery, 1);
		battery_list = g_list_append(battery_list, bat);
		bat->id = n_batteries++;
		}
	return bat;
	}


static void
client_battery_line_from_server(gchar *line)
	{
	Battery		*bat;
	gboolean	present, on_line, charging;
	gint		percent, time_left, n = 0;

	/* 2.1.9 adds 6th arg battery id number
	*/
	if (sscanf(line, "%d %d %d %d %d %d",
				&present, &on_line, &charging, &percent, &time_left, &n) < 5)
		return;

	bat = battery_nth(n);
	if (!bat)
		return;
	bat->present = present;
	bat->on_line = on_line;
	bat->charging = charging;
	bat->percent = percent;
	bat->time_left = time_left;
	}

static void
read_battery_data(void)
	{
	GList	*list;
	Battery	*bat;

	for (list = battery_list; list; list = list->next)
		{
		bat = (Battery *) list->data;
		gkrellm_battery_assign_data(bat->id, bat->present,
				bat->on_line, bat->charging,
				bat->percent, bat->time_left);
		}
	}

static void
client_sys_battery_init(void)
	{
	if (batteries_available)
		gkrellm_battery_client_divert(read_battery_data);
	}

static void
client_battery_setup(gchar *line)
	{
	if (   !strcmp(line, "apm_available")
		|| !strcmp(line, "battery_available")
	   )
		batteries_available = TRUE;
	}

/* ================================================================= */
typedef struct
	{
	gint		type;

	gchar		*basename;
	gint		id;
	gint		iodev;
	gint		inter;

	gint		group;

	gchar		*vref;
	gchar		*default_label;

	gfloat		factor;
	gfloat		offset;
	gfloat		raw_value;
	}
	Sensor;

static GList	*sensors_list;


static void
client_sensors_line_from_server(gchar *line)
	{
	GList	*list;
	Sensor	s, *sensor;
	gchar	basename[128];

	if (need_locale_fix)
		locale_fix(line);
	sscanf(line, "%d \"%127[^\"]\" %d %d %d %f",
			&s.type, basename, &s.id, &s.iodev, &s.inter, &s.raw_value);
	for (list = sensors_list; list; list = list->next)
		{
		sensor = (Sensor *) list->data;
		if (   sensor->type == s.type && !strcmp(sensor->basename, basename)
			&& sensor->id == s.id && sensor->iodev == s.iodev
			&& sensor->inter == s.inter
		   )
			{
			sensor->raw_value = s.raw_value;
			break;
			}
		}
	}

static gboolean
get_temperature(gchar *path, gint id, gint iodev, gint inter, gfloat *value)
	{
	GList	*list;
	Sensor	*s;

	for (list = sensors_list; list; list = list->next)
		{
		s = (Sensor *) list->data;
		if (   s->type == SENSOR_TEMPERATURE && !strcmp(s->basename, path)
			&& s->id == id && s->iodev == iodev && s->inter == inter
		   )
			{
			*value = s->raw_value;
			return TRUE;
			}
		}
	return FALSE;
	}

static gboolean
get_fan(gchar *path, gint id, gint iodev, gint inter, gfloat *value)
	{
	GList	*list;
	Sensor	*s;

	for (list = sensors_list; list; list = list->next)
		{
		s = (Sensor *) list->data;
		if (   s->type == SENSOR_FAN && !strcmp(s->basename, path)
			&& s->id == id && s->iodev == iodev && s->inter == inter
		   )
			{
			*value = s->raw_value;
			return TRUE;
			}
		}
	return FALSE;
	}

static gboolean
get_voltage(gchar *path, gint id, gint iodev, gint inter, gfloat *value)
	{
	GList	*list;
	Sensor	*s;

	for (list = sensors_list; list; list = list->next)
		{
		s = (Sensor *) list->data;
		if (   s->type == SENSOR_VOLTAGE && !strcmp(s->basename, path)
			&& s->id == id && s->iodev == iodev && s->inter == inter
		   )
			{
			*value = s->raw_value;
			return TRUE;
			}
		}
	return FALSE;
	}

static void
client_sys_sensors_init(void)
	{
	GList			*list;
	Sensor			*s;
	gpointer		sr;

	if (!sensors_list)
		return;

	gkrellm_sensors_client_divert(get_temperature, get_fan, get_voltage);
	for (list = sensors_list; list; list = list->next)
		{
		s = (Sensor *) list->data;

		/* The sysdep code in the server may be using the dir arg to get sensor
		|  values, but dir is no longer needed.
		*/
		sr = gkrellm_sensors_add_sensor(s->type, NULL, s->basename,
					s->id, s->iodev, s->inter,
					s->factor, s->offset,
					s->vref, s->default_label);
		gkrellm_sensors_set_group(sr, s->group);
		}
	}

static void
client_sensors_setup(gchar *line)
	{
	Sensor	*s;
	gchar	basename[128], vref[32], default_label[32];

	if (need_locale_fix)
		locale_fix(line);

	s = g_new0(Sensor, 1);
	s->group = SENSOR_GROUP_MAINBOARD;	/* Not in pre 2.2.0 versions */
	if (sscanf(line,
			"%d \"%127[^\"]\" %d %d %d %f %f \"%31[^\"]\" \"%31[^\"]\" %d",
			&s->type, basename, &s->id, &s->iodev, &s->inter,
			&s->factor, &s->offset, vref, default_label, &s->group) >= 9)
		{
		s->basename = g_strdup(basename);
		if (strcmp(vref, "NONE"))
			s->vref = g_strdup(vref);
		if (strcmp(default_label, "NONE"))
			s->default_label = g_strdup(default_label);

		sensors_list = g_list_append(sensors_list, s);
		}
	else
		g_free(s);
	}

/* ================================================================= */
static time_t		server_uptime;

static void
client_uptime_line_from_server(gchar *s)
	{
	gulong		up_minutes;

	sscanf(s, "%lu", &up_minutes);
	server_uptime = ((time_t) up_minutes) * 60;
	}

static time_t
client_read_uptime(void)
	{
	return server_uptime;
	}

static void
client_sys_uptime_init(void)
	{
	gkrellm_uptime_client_divert(client_read_uptime);
	}

/* ================================================================= */
static struct tm	server_time;

  /* clock monitor doesn't have a sysdep interface, so it needs a hook
  |  to get server system time when in client mode.
  */
struct tm *
gkrellm_client_server_time(void)
	{
	return &server_time;
	}

static void
client_time_line_from_server(gchar *s)