/* GKrellM
|  Copyright (C) 1999-2009 Bill Wilson
|
|  Author:  Bill Wilson    billw@gkrellm.net
|  Latest versions might be found at:  http://gkrellm.net
|
|
|  GKrellM is free software: you can redistribute it and/or modify it
|  under the terms of the GNU General Public License as published by
|  the Free Software Foundation, either version 3 of the License, or
|  (at your option) any later version.
|
|  GKrellM is distributed in the hope that it will be useful, but WITHOUT
|  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|  License for more details.
|
|  You should have received a copy of the GNU General Public License
|  along with this program. If not, see http://www.gnu.org/licenses/
|
|
|  Additional permission under GNU GPL version 3 section 7
|
|  If you modify this program, or any covered work, by linking or
|  combining it with the OpenSSL project's OpenSSL library (or a
|  modified version of that library), containing parts covered by
|  the terms of the OpenSSL or SSLeay licenses, you are granted
|  additional permission to convey the resulting work.
|  Corresponding Source for a non-source form of such a combination
|  shall include the source code for the parts of OpenSSL used as well
|  as that of the covered work.
*/

#include "gkrellmd.h"
#include "gkrellmd-private.h"
#include <inttypes.h>

GList			*gkrellmd_monitor_list;

static GList	*serveflag_done_list;

static struct tm	gkrellmd_current_tm;

gint
gkrellm_get_timer_ticks(void)
	{
	return GK.timer_ticks;
	}

gboolean
gkrellmd_check_client_version(GkrellmdMonitor *mon,
				gint major, gint minor, gint rev)
	{
	GkrellmdClient	*client = mon->privat->client;

	if (   client->major_version > major
		|| (client->major_version == major && client->minor_version > minor)
	    || (   client->major_version == major && client->minor_version == minor
			&& client->rev_version >= rev
		   )
	   )
		return TRUE;
	return FALSE;
	}

void
gkrellmd_add_serveflag_done(gboolean *flag)
	{
	serveflag_done_list = g_list_append(serveflag_done_list, flag);
	}


void
gkrellmd_set_serve_name(GkrellmdMonitor *mon, const gchar *tag)
	{
	GkrellmdMonitorPrivate	*mp = mon->privat;

	mp->serve_name = tag;
	mp->serve_name_sent = FALSE;
	}

void
gkrellmd_serve_data(GkrellmdMonitor *mon, gchar *line)
	{
	GkrellmdMonitorPrivate	*mp = mon->privat;
	gchar					buf[128];

	if (!line || !*line)
		return;
	if (!mp->serve_name_sent)
		{
		if (mp->serve_name)
			{
			snprintf(buf, sizeof(buf), "<%s>\n", mp->serve_name);
			mp->serve_gstring = g_string_append(mp->serve_gstring, buf);
			mp->serve_name_sent = TRUE;
			}
		else
			{
			printf("gkrellmd: %s forgot to gkrellmd_set_serve_name()\n",
					mon->name);
			return;
			}
		}
	mp->serve_gstring = g_string_append(mp->serve_gstring, line);
	}

/* ======================================================= */
typedef struct
	{
	gint	instance;
	gulong	user,
			nice,
			sys,
			idle;
	}
	CpuData;

static gchar	*n_cpus_setup;
static gboolean	nice_time_unsupported;

static GList	*cpu_list;
static GList	*instance_list;

void
gkrellm_cpu_set_number_of_cpus(gint n)
	{
	CpuData	*cpu;
	GList	*list;
	gint	i;

	n_cpus_setup = g_strdup_printf("n_cpus %d\n", n);
	for (i = 0; i < n; ++i)
		{
		cpu = g_new0(CpuData, 1);
		cpu_list = g_list_append(cpu_list, cpu);

		if (instance_list && (list = g_list_nth(instance_list, i)) != NULL)
			cpu->instance = GPOINTER_TO_INT(list->data);
		else
			cpu->instance = i;
		}
	}

void
gkrellm_cpu_add_instance(gint instance)
	{
	instance_list = g_list_append(instance_list, GINT_TO_POINTER(instance));
	}

void
gkrellm_cpu_nice_time_unsupported(void)
	{
	nice_time_unsupported = TRUE;
	}

void
gkrellm_cpu_assign_composite_data(gulong user, gulong nice,
			gulong sys, gulong idle)
	{
	return;		/* let client gkrellm compute it */
	}

void
gkrellm_cpu_assign_data(gint n, gulong user, gulong nice,
			gulong sys, gulong idle)
	{
	CpuData	*cpu = NULL;
	GList	*list;

	for (list = cpu_list; list; list = list->next)
		{
		cpu = (CpuData *) list->data;
		if (cpu->instance == n)
			break;
		}
	if (list)
		{
		cpu->user = user;
		cpu->nice = nice;
		cpu->sys = sys;
		cpu->idle = idle;
		}
	}

static void
update_cpu(GkrellmdMonitor *mon, gboolean first_update)
	{
	gkrellm_sys_cpu_read_data();
	gkrellmd_need_serve(mon);
	}

static void
serve_cpu_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	CpuData	*cpu;
	GList	*list;
	gchar	buf[128];

	gkrellmd_set_serve_name(mon, "cpu");
	for (list = cpu_list; list; list = list->next)
		{
		cpu = (CpuData *) list->data;
		sprintf(buf, "%d %lu %lu %lu %lu\n", cpu->instance,
				cpu->user, cpu->nice, cpu->sys, cpu->idle);
		gkrellmd_serve_data(mon, buf);
		}
	}

static void
serve_cpu_setup(GkrellmdMonitor *mon)
	{
	GkrellmdClient	*client = mon->privat->client;
	GList			*list;
	gchar			buf[64];

	gkrellmd_send_to_client(client, "<cpu_setup>\n");
	for (list = instance_list; list; list = list->next)
		{
		snprintf(buf, sizeof(buf), "cpu_instance %d\n",
				GPOINTER_TO_INT(list->data));
		gkrellmd_send_to_client(client, buf);
		}
	gkrellmd_send_to_client(client, n_cpus_setup);
	if (nice_time_unsupported)
		gkrellmd_send_to_client(client, "nice_time_unsupported\n");
	}

static GkrellmdMonitor cpu_monitor =
	{
	"cpu",
	update_cpu,
	serve_cpu_data,
	serve_cpu_setup
	};


static GkrellmdMonitor *
init_cpu_monitor(void)
	{
	if (gkrellm_sys_cpu_init())
		return &cpu_monitor;
	return NULL;
	}

/* ======================================================= */
struct
	{
	gboolean	changed;
	gint		n_processes,
				n_running,
				n_users;
	gulong		n_forks;
	gfloat		fload;
	}
	proc;

void
gkrellm_proc_assign_data(gint n_processes, gint n_running,
			gulong n_forks, gfloat load)
	{
	if (   proc.n_processes != n_processes
		|| proc.n_running != n_running
		|| proc.n_forks != n_forks
		|| proc.fload != load
	   )
		{
		proc.n_processes = n_processes;
		proc.n_running = n_running;
		proc.n_forks = n_forks;
		proc.fload = load;
		proc.changed = TRUE;
		}
	}

void
gkrellm_proc_assign_users(gint n_users)
	{
	if (proc.n_users != n_users)
		{
		proc.n_users = n_users;
		proc.changed = TRUE;
		}
	}

static void
update_proc(GkrellmdMonitor *mon, gboolean first_update)
	{
	proc.changed = FALSE;
	gkrellm_sys_proc_read_data();
	if (first_update || GK.five_second_tick)
		gkrellm_sys_proc_read_users();

	if (proc.changed)
		gkrellmd_need_serve(mon);
	}

static void
serve_proc_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	gchar	buf[128];

	gkrellmd_set_serve_name(mon, "proc");
	snprintf(buf, sizeof(buf), "%d %d %lu %.2f %d\n",
			 proc.n_processes, proc.n_running,
			 proc.n_forks, proc.fload, proc.n_users);
	gkrellmd_serve_data(mon, buf);
	}

static GkrellmdMonitor proc_monitor =
	{
	"proc",
	update_proc,
	serve_proc_data,
	NULL
	};


static GkrellmdMonitor *
init_proc_monitor(void)
	{
	if (!gkrellm_sys_proc_init())
		return NULL;
	serveflag_done_list = g_list_append(serveflag_done_list, &proc.changed);
	return &proc_monitor;
	}

/* ======================================================= */
typedef struct
	{
	gchar		*name;
	gchar		*subdisk_parent;
	gint		order,
				subdisk,
				changed;
	gint		device_number,
				unit_number;
	gboolean	virtual;
	guint64		rb,
				wb;
	}
	DiskData;

static GList	*disk_list;
static gint		n_disks;
static gboolean	units_are_blocks;


static DiskData *
add_disk(gchar *name, gint order, gint device_number, gint unit_number)
	{
	DiskData	*disk;
	GList		*list;
	gint		i;

	disk = g_new0(DiskData, 1);
	disk->name = g_strdup(name);
	disk->order = order;
	disk->subdisk = -1;
	disk->device_number = device_number;
	disk->unit_number = unit_number;
	if (order >= 0)
		{
		for (i = 0, list = disk_list; list; list = list->next, ++i)
			if (disk->order < ((DiskData *) list->data)->order)
				break;
		disk_list = g_list_insert(disk_list, disk, i);
		}
	else
		disk_list = g_list_append(disk_list, disk);
	++n_disks;
	return disk;
	}

static DiskData *
add_subdisk(gchar *subdisk_name, gchar *disk_name, gint subdisk)
	{
	DiskData	*sdisk = NULL;
#if GLIB_CHECK_VERSION(2,0,0)
	DiskData	*disk;
	GList		*list = NULL;

	for (list = disk_list; list; list = list->next)
		{
		disk = (DiskData * ) list->data;
		if (!strcmp(disk_name, disk->name))
			break;
		}
	if (!list)
		return NULL;
	sdisk = g_new0(DiskData, 1);
	sdisk->name = g_strdup(subdisk_name);
	sdisk->subdisk_parent = g_strdup(disk_name);
	sdisk->order = disk->order;
	sdisk->subdisk = subdisk;

	for (list = list->next; list; list = list->next)
		{
		disk = (DiskData * ) list->data;
		if (disk->subdisk == -1 || disk->subdisk > subdisk)
			break;
		}
	disk_list = g_list_insert_before(disk_list, list, sdisk);
	++n_disks;
#endif
	return sdisk;
	}

static void
disk_assign_data(DiskData *disk, guint64 rb, guint64 wb, gboolean virtual)
	{
	if (disk)
		{
		if (disk->rb != rb || disk->wb != wb)
			disk->changed = TRUE;
		else
			disk->changed = FALSE;
		disk->rb = rb;
		disk->wb = wb;
		disk->virtual = virtual;
		}
	}

void
gkrellm_disk_reset_composite(void)
	{
	/* Don't handle this. */
	}

void
gkrellm_disk_units_are_blocks(void)
	{
	units_are_blocks = TRUE;
	}

void
gkrellm_disk_assign_data_by_device(gint device_number, gint unit_number,
			guint64 rb, guint64 wb, gboolean virtual)
	{
	GList		*list;
	DiskData	*disk = NULL;
	gchar		*name;
	gint		order = -1;

	for (list = disk_list; list; list = list->next)
		{
		disk = (DiskData * ) list->data;
		if (   disk->device_number == device_number
			&& disk->unit_number == unit_number
		   )
			break;
		disk = NULL;
		}
	if (!disk)
		{
		name = gkrellm_sys_disk_name_from_device(device_number,
					unit_number, &order);
		if (name)
			disk = add_disk(name, order, device_number, unit_number);
		}
	disk_assign_data(disk, rb, wb, virtual);
	}

void
gkrellm_disk_assign_data_nth(gint n, guint64 rb, guint64 wb, gboolean virtual)
	{
	DiskData	*disk;
	gchar		name[32];

	if (n < n_disks)
		disk = (DiskData *) g_list_nth_data(disk_list, n);
	else
		{
		sprintf(name, "%s%c", _("Disk"), 'A' + n);
		disk = add_disk(name, n, 0, 0);
		}
	disk_assign_data(disk, rb, wb, virtual);
	}

void
gkrellm_disk_assign_data_by_name(gchar *name,
			guint64 rb, guint64 wb, gboolean virtual)
	{
	GList		*list;
	DiskData	*disk = NULL;
	gint		order = -1;

	for (list = disk_list; list; list = list->next)
		{
		disk = (DiskData * ) list->data;
		if (!strcmp(name, disk->name))
			break;
		disk = NULL;
		}
	if (!disk)
		{
		order = gkrellm_sys_disk_order_from_name(name);
		disk = add_disk(name, order, 0, 0);
		}
	disk_assign_data(disk, rb, wb, virtual);
	}

void
gkrellm_disk_subdisk_assign_data_by_name(gchar *subdisk_name, gchar *disk_name,
				guint64 rb, guint64 wb)
	{
	GList		*list;
	DiskData	*disk = NULL;
	gchar		*s, *endptr;
	gint		subdisk;

	if (!subdisk_name || !disk_name)
		return;
	for (list = disk_list; list; list = list->next)
		{
		disk = (DiskData * ) list->data;
		if (!strcmp(subdisk_name, disk->name))
			break;
		disk = NULL;
		}
	if (!disk)
		{
		/* A subdisk name is expected to be the disk_name with a number string
		|  appended.  Eg. "hda1" is a subdisk_name of disk_name "hda"
		*/
		s = subdisk_name + strlen(disk_name);
		subdisk = strtol(s, &endptr, 0);
		if (!*s || *endptr)
			return;
		disk = add_subdisk(subdisk_name, disk_name, subdisk);
		}
	disk_assign_data(disk, rb, wb, FALSE);
	}

static void
update_disk(GkrellmdMonitor *mon, gboolean first_update)
	{
	GList		*list;
	DiskData	*disk = NULL;

	gkrellm_sys_disk_read_data();
	for (list = disk_list; list; list = list->next)
		{
		disk = (DiskData * ) list->data;
		if (disk->changed)
			{
			gkrellmd_need_serve(mon);
			break;
			}
		}
	}


static void
serve_disk_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	DiskData	*disk;
	GList		*list;
	gchar		buf[128];

	gkrellmd_set_serve_name(mon, "disk");
	for (list = disk_list; list; list = list->next)
		{
		disk = (DiskData *) list->data;
		if (!disk->changed && !first_serve)
			continue;
		if (!disk->subdisk_parent)
			{
			if (gkrellmd_check_client_version(mon, 2, 2, 7) && disk->virtual)
				snprintf(buf, sizeof(buf), "%s virtual %" PRIu64 " %" PRIu64 "\n",
							disk->name, disk->rb, disk->wb);
			else
				snprintf(buf, sizeof(buf), "%s %" PRIu64 " %" PRIu64 "\n",
							disk->name, disk->rb, disk->wb);
			}
		else if (mon->privat->client->feature_subdisk)
			snprintf(buf, sizeof(buf), "%s %s %" PRIu64 " %" PRIu64 "\n",
						disk->name, disk->subdisk_parent, disk->rb, disk->wb);
		else
			continue;
		gkrellmd_serve_data(mon, buf);
		}
	}

static void
serve_disk_setup(GkrellmdMonitor *mon)
	{
	GkrellmdClient	*client = mon->privat->client;

	if (units_are_blocks)
		gkrellmd_send_to_client(client, "<disk_setup>\nunits_are_blocks\n");
	if (gkrellmd_check_client_version(mon, 2,1,3))
		client->feature_subdisk = TRUE;
	}

static GkrellmdMonitor disk_monitor =
	{
	"disk",
	update_disk,
	serve_disk_data,
	serve_disk_setup
	};


static GkrellmdMonitor *
init_disk_monitor(void)
	{
	if (gkrellm_sys_disk_init())
		return &disk_monitor;
	return NULL;
	}

/* ======================================================= */
#include "../src/inet.h"

typedef struct
	{
	ActiveTCP	tcp;
	gboolean	alive,
				new_connection;
	}
	InetData;

static GList	*inet_list,
				*inet_dead_list;

static gboolean	inet_unsupported,
				inet_new;

void
gkrellm_inet_log_tcp_port_data(gpointer data)
	{
	GList		*list;
	InetData	*in;
	ActiveTCP	*tcp, *active_tcp = NULL;
	gchar		*ap, *aap;
	gint		slen;

	tcp = (ActiveTCP *) data;
	for (list = inet_list; list; list = list->next)
		{
		in = (InetData *) list->data;
		active_tcp = &in->tcp;
		if (tcp->family == AF_INET)
			{
			ap = (char *)&tcp->remote_addr;
			aap = (char *)&active_tcp->remote_addr;
			slen = sizeof(struct in_addr);
			}
#if defined(INET6)
		else if (tcp->family == AF_INET6)
			{
			ap = (char *)&tcp->remote_addr6;
			aap = (char *)&active_tcp->remote_addr6;
			slen = sizeof(struct in6_addr);
			}
#endif
		else
			return;
		if (   memcmp(aap, ap, slen) == 0
			&& active_tcp->remote_port == tcp->remote_port
			&& active_tcp->local_port == tcp->local_port
		   )
			{
			in->alive = TRUE;	/* Old alive connection still alive */
			return;
			}
		}
	inet_new = TRUE;
	in = g_new0(InetData, 1);
	in->tcp = *tcp;
	in->alive = TRUE;
	in->new_connection = TRUE;
	inet_list = g_list_append(inet_list, in);
	}

static void
update_inet(GkrellmdMonitor *mon, gboolean first_update)
	{
	GList		*list;
	InetData	*in;
	static gint	check_tcp;

	
	if (!first_update && !GK.second_tick)
		return;

	if (first_update || check_tcp == 0)
		{
		gkrellm_free_glist_and_data(&inet_dead_list);
		inet_new = FALSE;
		for (list = inet_list; list; list = list->next)
			{
			in = (InetData *) list->data;
			in->alive = FALSE;
			in->new_connection = FALSE;
			}

		gkrellm_sys_inet_read_tcp_data();

		for (list = inet_list; list; )
			{
			in = (InetData *) list->data;
			if (!in->alive)
				{
				if (list == inet_list)
					inet_list = inet_list->next;
				list = g_list_remove(list, in);
				inet_dead_list = g_list_append(inet_dead_list, in);
				}
			else
				list = list->next;
			}
		if (inet_new || inet_dead_list)
			gkrellmd_need_serve(mon);
		}
	check_tcp = (check_tcp + 1) % _GK.inet_interval;
	}

static void
serve_inet_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	InetData	*in;
	ActiveTCP	*tcp;
	GList		*list;
	gchar		buf[128], *cp;
#if defined(INET6) && defined(HAVE_GETADDRINFO)
	struct sockaddr_in6	sin6;
	char		addrbuf[NI_MAXHOST];
#endif

	if (inet_new || first_serve)
		{
		gkrellmd_set_serve_name(mon, "inet");
		for (list = inet_list; list; list = list->next)
			{
			in = (InetData *) list->data;
			tcp = &in->tcp;
			if (   tcp->family == AF_INET
				&& (in->new_connection || first_serve)
			   )
				{
				cp = inet_ntoa(tcp->remote_addr);
				sprintf(buf, "+0 %x %s:%x\n",
							tcp->local_port, cp, tcp->remote_port);
				}
#if defined(INET6) && defined(HAVE_GETADDRINFO)
			else if (tcp->family == AF_INET6
				 && (in->new_connection || first_serve))
				{
				memset(&sin6, 0, sizeof(sin6));
				memcpy(&sin6.sin6_addr, &tcp->remote_addr6,
				       sizeof(struct in6_addr));
				sin6.sin6_family = AF_INET6;
#ifdef SIN6_LEN
				sin6.sin6_len = sizeof(struct sockaddr_in6);
#endif
				if (getnameinfo((struct sockaddr *)&sin6,
						sizeof(struct sockaddr_in6),
						addrbuf, sizeof(addrbuf),
						NULL, 0,
						NI_NUMERICHOST|NI_WITHSCOPEID)
				    != 0)
					continue;
				snprintf(buf, sizeof(buf), "+6 %x [%s]:%x\n",
					 tcp->local_port, addrbuf,
					 tcp->remote_port);
				}
#endif
			else
				continue;

			gkrellmd_serve_data(mon, buf);
			}
		}
	if (!first_serve)
		{
		gkrellmd_set_serve_name(mon, "inet");
		for (list = inet_dead_list; list; list = list->next)
			{
			in = (InetData *) list->data;
			tcp = &in->tcp;
			if (tcp->family == AF_INET)
				{
				cp = inet_ntoa(tcp->remote_addr);
				sprintf(buf, "-0 %x %s:%x\n",
							tcp->local_port, cp, tcp->remote_port);
				}
#if defined(INET6) && defined(HAVE_GETADDRINFO)
			else if (tcp->family == AF_INET6)
				{
				memset(&sin6, 0, sizeof(sin6));
				memcpy(&sin6.sin6_addr, &tcp->remote_addr6,
				       sizeof(struct in6_addr));
				sin6.sin6_family = AF_INET6;
#ifdef SIN6_LEN
				sin6.sin6_len = sizeof(struct sockaddr_in6);
#endif
				if (getnameinfo((struct sockaddr *)&sin6,
						sizeof(struct sockaddr_in6),
						addrbuf, sizeof(addrbuf),
						NULL, 0,
						NI_NUMERICHOST|NI_WITHSCOPEID)
				    != 0)
					continue;
				snprintf(buf, sizeof(buf), "-6 %x [%s]:%x\n",
					 tcp->local_port, addrbuf,
					 tcp->remote_port);
				}
#endif
			else
				continue;

			gkrellmd_serve_data(mon, buf);
			}
		}
	}

static void
serve_inet_setup(GkrellmdMonitor *mon)
	{
	GkrellmdClient	*client = mon->privat->client;

	if (inet_unsupported)
		gkrellmd_send_to_client(client, "<inet_setup>\ninet_unsupported\n");
	}

static GkrellmdMonitor inet_monitor =
	{
	"inet",
	update_inet,
	serve_inet_data,
	serve_inet_setup
	};


static GkrellmdMonitor *
init_inet_monitor(void)
	{
	if (_GK.inet_interval > 0 && gkrellm_sys_inet_init())
		return &inet_monitor;
	inet_unsupported = TRUE;
	return NULL;
	}

/* ======================================================= */

#define TIMER_TYPE_NONE	0
#define TIMER_TYPE_PPP	1
#define TIMER_TYPE_IPPP	2

typedef struct
	{
	gchar		*name;
	gboolean	changed,
				up,
				up_prev,
				up_event,
				down_event;

	gboolean	timed_changed;
	time_t		up_time;

	gulong		rx,
				tx;
	}
	NetData;

static NetData	*net_timer;

static GList	*net_list,
				*net_sys_list;

static time_t	net_timer0;
static gint		net_timer_type;

static gboolean	net_use_routed;


gchar *
gkrellm_net_mon_first(void)
	{
	gchar	*name = NULL;

	net_sys_list = net_list;
	if (net_sys_list)
		{
		name = ((NetData *) (net_sys_list->data))->name;
		net_sys_list = net_sys_list->next;
		}
	return name;
	}

gchar *
gkrellm_net_mon_next(void)
	{
	gchar	*name = NULL;

	if (net_sys_list)
		{
		name = ((NetData *) (net_sys_list->data))->name;
		net_sys_list = net_sys_list->next;
		}
	return name;
	}

void
gkrellm_net_use_routed(gboolean real_routed /* not applicable in server */)
	{
	net_use_routed = TRUE;
	}

static NetData *
net_new(gchar *name)
	{
	NetData	*net;

	net = g_new0(NetData, 1);
	net->name = g_strdup(name);
	net_list = g_list_append(net_list, net);

	if (net_timer_type != TIMER_TYPE_NONE && !strcmp(_GK.net_timer, net->name))
		net_timer = net;

	return net;
	}

void
gkrellm_net_assign_data(gchar *name, gulong rx, gulong tx)
	{
	GList	*list;
	NetData	*net;

	for (list = net_list; list; list = list->next)
		{
		net = (NetData *) list->data;
		if (!strcmp(net->name, name))
			{
			if (net->rx != rx || net->tx != tx)
				net->changed = TRUE;
			else
				net->changed = FALSE;
			break;
			}
		}
	if (!list)
		net = net_new(name);

	if (GK.second_tick && !net_use_routed)
		net->up = TRUE;
	net->rx = rx;
	net->tx = tx;
	}

void
gkrellm_net_routed_event(gchar *name, gboolean routed)
	{
	GList	*list;
	NetData	*net;

	for (list = net_list; list; list = list->next)
		{
		net = (NetData *) list->data;
		if (!strcmp(net->name, name))
			break;
		}
	if (!list)
		net = net_new(name);

	if (routed)
		net->up_event = TRUE;
	else
		net->down_event = TRUE;
	net->up = routed;
	}

void
gkrellm_net_add_timer_type_ppp(gchar *name)
	{
	if (!_GK.net_timer || !name)
		return;
	if (name && !strncmp(_GK.net_timer, name, strlen(name) - 1))
		net_timer_type = TIMER_TYPE_PPP;
	}

void
gkrellm_net_add_timer_type_ippp(gchar *name)
	{
	if (!_GK.net_timer || !name)
		return;
	if (name && !strncmp(_GK.net_timer, name, strlen(name) - 1))
		net_timer_type = TIMER_TYPE_IPPP;
	}

void
gkrellm_net_set_lock_directory(gchar *dir)
	{
	/* Not supported remotely */
	}

static void
update_net(GkrellmdMonitor *mon, gboolean first_update)
	{
	GList		*list;
	NetData		*net;
	gint		up_time = 0;

	if (GK.second_tick)
		{
		if (!net_use_routed)
			{
			for (list = net_list; list; list = list->next)
				{
				net = (NetData *) list->data;
				net->up_prev = net->up;
				net->up = FALSE;
				}
			}
		else
			gkrellm_sys_net_check_routes();
		}
	gkrellm_sys_net_read_data();
	
	if (GK.second_tick && !net_use_routed)
		{
		for (list = net_list; list; list = list->next)
			{
			net = (NetData *) list->data;
			if (net->up && !net->up_prev)
				net->up_event = TRUE;
			else if (!net->up && net->up_prev)
				net->down_event = TRUE;
			}
		}

	if (net_timer && GK.second_tick)
		{
		if (net_timer_type == TIMER_TYPE_PPP)
			{
			struct stat		st;
			gchar			buf[256];

			if (net_timer->up_event)
				{
				snprintf(buf, sizeof(buf), "/var/run/%s.pid", net_timer->name);
				if (g_stat(buf, &st) == 0)
					net_timer0 = st.st_mtime;
				else
					time(&net_timer0);
				}
			if (net_timer->up)
				up_time = (int) (time(0) - net_timer0);
			}
		else if (net_timer_type == TIMER_TYPE_IPPP)
			{
			/* get all isdn status from its connect state because the
			|  net_timer->up can be UP even with isdn line not connected.
			|  Can't get time history if gkrellmd started after connects.
			*/
			static gboolean		old_connected;
			gboolean			connected;

			connected = gkrellm_sys_net_isdn_online();
			if (connected && !old_connected)
				time(&net_timer0);			/* New session just started */
			old_connected = connected;

			up_time = (int) (time(0) - net_timer0);
			}
		if (up_time != net_timer->up_time)
			net_timer->timed_changed = TRUE;
		net_timer->up_time = up_time;
		}

	gkrellmd_need_serve(mon);	/* serve func checks for changed */
	}

static void
serve_net_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	NetData		*net;
	GList		*list;
	gchar		buf[128];
	gboolean	fake_up_event;

	gkrellmd_set_serve_name(mon, "net");
	for (list = net_list; list; list = list->next)
		{
		net = (NetData *) list->data;
		if (net->changed || first_serve)
			{
			sprintf(buf, "%s %lu %lu\n", net->name, net->rx, net->tx);
			gkrellmd_serve_data(mon, buf);
			}
		}

	/* Since the server transmits changes only, use the routed interface
	|  to the client regardless if the sysdep code uses routed.
	*/
	if (GK.second_tick || first_serve)
		{
		gkrellmd_set_serve_name(mon, "net_routed");
		for (list = net_list; list; list = list->next)
			{
			net = (NetData *) list->data;
			fake_up_event = (first_serve && net->up);
			if (net->up_event || net->down_event || fake_up_event)
				{
				sprintf(buf, "%s %d\n", net->name,
						fake_up_event ? TRUE : net->up_event);
				gkrellmd_serve_data(mon, buf);
				}
			if (mon->privat->client->last_client)
				net->up_event = net->down_event = FALSE;
			}
		}

	if (net_timer && GK.second_tick)
		{
		if (net_timer->timed_changed || first_serve)
			{
			gkrellmd_set_serve_name(mon, "net_timer");
			sprintf(buf, "%s %d\n", net_timer->name, (gint)net_timer->up_time);
			gkrellmd_serve_data(mon, buf);
			}
		}
	}

static void
serve_net_setup(GkrellmdMonitor *mon)
	{
	GkrellmdClient	*client = mon->privat->client;
	gchar			buf[128];

	/* The client <-> server link always uses routed mode, but the client
	|  needs to know if server sysdep uses routed for config purposes.
	*/
	if (net_use_routed)
		gkrellmd_send_to_client(client, "<net_setup>\nnet_use_routed\n");

	if (net_timer_type != TIMER_TYPE_NONE)
		{
		snprintf(buf, sizeof(buf),
				"<net_setup>\nnet_timer %s\n", _GK.net_timer);
		gkrellmd_send_to_client(client, buf);
		}
	}

static GkrellmdMonitor net_monitor =
	{
	"net",
	update_net,
	serve_net_data,
	serve_net_setup
	};


static GkrellmdMonitor *
init_net_monitor(void)
	{
	net_timer_type = TIMER_TYPE_NONE;
	if (gkrellm_sys_net_init())
		return &net_monitor;
	return NULL;
	}


/* ======================================================= */
struct
	{
	gboolean	mem_changed;
	guint64		total,
				used,
				free,
				shared,
				buffers,
				cached;

	gboolean	swap_changed;
	guint64		swap_total,
				swap_used;
	gulong		swap_in,
				swap_out;
	}
	mem;

void
gkrellm_mem_assign_data(guint64 total, guint64 used, guint64 free,
			guint64 shared, guint64 buffers, guint64 cached)
	{
	if (   mem.total != total
		|| mem.used != used
		|| mem.free != free
		|| mem.shared != shared
		|| mem.buffers != buffers
		|| mem.cached != cached
	   )
		{
		mem.total = total;
		mem.used = used;
		mem.free = free;
		mem.shared = shared;
		mem.buffers = buffers;
		mem.cached = cached;
		mem.mem_changed = TRUE;
		}
	}

void
gkrellm_swap_assign_data(guint64 total, guint64 used,
			gulong swap_in, gulong swap_out)
	{
	if (   mem.swap_total != total
		|| mem.swap_used != used
		|| mem.swap_in != swap_in
		|| mem.swap_out != swap_out
	   )
		{
		mem.swap_total = total;
		mem.swap_used = used;
		mem.swap_in = swap_in;
		mem.swap_out = swap_out;
		mem.swap_changed = TRUE;
		}
	}

static void
update_mem(GkrellmdMonitor *mon, gboolean first_update)
	{
	mem.mem_changed = mem.swap_changed = FALSE;

	gkrellm_sys_swap_read_data();
	if (first_update || GK.five_second_tick)
		gkrellm_sys_mem_read_data();

	if (mem.mem_changed || mem.swap_changed)
		gkrellmd_need_serve(mon);
	}

static void
serve_mem_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	gchar	buf[128];

	if (mem.mem_changed || first_serve)
		{
		gkrellmd_set_serve_name(mon, "mem");
		snprintf(buf, sizeof(buf), "%" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
				mem.total, mem.used, mem.free,
				mem.shared, mem.buffers, mem.cached);
		gkrellmd_serve_data(mon, buf);
		}

	if (mem.swap_changed || first_serve)
		{
		gkrellmd_set_serve_name(mon, "swap");
		snprintf(buf, sizeof(buf), "%" PRIu64 " %" PRIu64 " %lu %lu\n",
				mem.swap_total, mem.swap_used,
				mem.swap_in, mem.swap_out);
		gkrellmd_serve_data(mon, buf);
		}
	}

static GkrellmdMonitor mem_monitor =
	{
	"mem",
	update_mem,
	serve_mem_data,
	NULL
	};


static GkrellmdMonitor *
init_mem_monitor(void)
	{
	if (!gkrellm_sys_mem_init())
		return NULL;
	serveflag_done_list = g_list_append(serveflag_done_list, &mem.mem_changed);
	serveflag_done_list = g_list_append(serveflag_done_list,&mem.swap_changed);
	return &mem_monitor;
	}

/* ======================================================= */
typedef struct
	{
	gboolean	busy,
				deleted,
				is_mounted,
				is_nfs,
				changed;
	gchar		*directory,
				*device,
				*type,
				*options;
	glong		blocks,
				bavail,
				bfree,
				bsize;
	}
	Mount;

static GList	*mounts_list,
				*fstab_list;

static gboolean	nfs_check,
				fs_check,
				fs_need_serve,
				fstab_list_modified,
				mounts_list_modified,
				mounting_unsupported;

static gchar *remote_fs_types[] =
	{
	"nfs",
	"smbfs"
	};

void
gkrellm_fs_setup_eject(gchar *eject_tray, gchar *close_tray,
			void (*eject_func)(), void (*close_func)())
	{
	/* Not supported remotely */
	}

void
gkrellm_fs_add_to_mounts_list(gchar *dir, gchar *dev, gchar *type)
	{
	GList	*list;
	Mount	*m;
	gint	i;

	for (list = mounts_list; list; list = list->next)
		{
		m = (Mount *) list->data;
		if (   !strcmp(m->directory, dir)
			&& !strcmp(m->device, dev)
			&& !strcmp(m->type, type)
		   )
			break;
		}
	if (!list)
		{
		m = g_new0(Mount, 1);
		m->directory = g_strdup(dir);
		m->device = g_strdup(dev);
		m->type = g_strdup(type);
		mounts_list = g_list_append(mounts_list, m);
		mounts_list_modified = TRUE;
		serveflag_done_list = g_list_append(serveflag_done_list, &m->changed);

		for (i = 0; i < (sizeof(remote_fs_types) / sizeof(gchar *)); ++i)
			{
			if (!strcmp(m->type, remote_fs_types[i]))
				{
				m->is_nfs = TRUE;
				break;
				}
			}
		}
	m->is_mounted = TRUE;
	}

void
gkrellm_fs_add_to_fstab_list(gchar *dir, gchar *dev, gchar *type, gchar *opt)
	{
	Mount	*m;

	m = g_new0(Mount, 1);
	m->directory = g_strdup(dir);
	m->device = g_strdup(dev);
	m->type = g_strdup(type);
	fstab_list = g_list_append(fstab_list, m);
	}

void
gkrellm_fs_assign_fsusage_data(gpointer pointer,
			glong blocks, glong bavail, glong bfree, glong bsize)
	{
	Mount	*m = (Mount *) pointer;

	if (   m->blocks != blocks
		|| m->bavail != bavail
		|| m->bfree  != bfree
		|| m->bsize  != bsize
	   )
		{
		m->blocks = blocks;
		m->bavail = bavail;
		m->bfree  = bfree;
		m->bsize  = bsize;

		m->changed = TRUE;
		}
	}

void
gkrellm_fs_mounting_unsupported(void)
	{
	mounting_unsupported = TRUE;
	}

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

	for (list = mounts_list; list; list = list->next)
		((Mount *) list->data)->is_mounted = FALSE;

	gkrellm_sys_fs_get_mounts_list();

	for (list = mounts_list; list; )
		{
		m = (Mount *) list->data;
		if (!m->is_mounted)
			{
			if (list == mounts_list)
				mounts_list = mounts_list->next;
			list = g_list_remove_link(list, list);
			g_free(m->directory);
			g_free(m->device);
			g_free(m->type);
			serveflag_done_list = g_list_remove(serveflag_done_list,
						&m->changed);
			if (m->busy)
				m->deleted = TRUE;
			else
				g_free(m);
			mounts_list_modified = TRUE;
			}
		else
			list = list->next;
		}
	}

static void
refresh_fstab_list(void)
	{
	Mount	*m;

	while (fstab_list)
		{
		m = (Mount *) fstab_list->data;
		g_free(m->directory);
		g_free(m->device);
		g_free(m->type);
		g_free(m);
		fstab_list = g_list_remove(fstab_list, fstab_list->data);
		}
	gkrellm_sys_fs_get_fstab_list();
	fstab_list_modified = TRUE;
	}

#if GLIB_CHECK_VERSION(2,0,0)
static gpointer
get_fsusage_thread(void *data)
	{
	Mount	*m = (Mount *) data;

	gkrellm_sys_fs_get_fsusage(m, m->directory);

	if (m->deleted)
		g_free(m);
	else
		{
		if (m->changed)
			fs_need_serve = TRUE;
		m->busy = FALSE;
		}
	return NULL;
	}
#endif

static void
update_fs(GkrellmdMonitor *mon, gboolean first_update)
	{
	GList		*list;
	Mount		*m;
	static gint	check_tick;

	if (fs_need_serve)		/* Asynchronous change in fsusage thread? */
		gkrellmd_need_serve(mon);
	fs_need_serve = FALSE;

	if (GK.second_tick)
		++check_tick;
	fs_check = !(check_tick % _GK.fs_interval);

	if (_GK.nfs_interval > 0)
		nfs_check = !(check_tick % _GK.nfs_interval);
	else
		nfs_check = 0;

	if (!first_update && (!GK.second_tick || (!fs_check && !nfs_check)))
		return;
	refresh_mounts_list();
	for (list = mounts_list; list; list = list->next)
		{
		m = (Mount *) list->data;
		if (fs_check && !m->is_nfs)
			gkrellm_sys_fs_get_fsusage(m, m->directory);
		else if (nfs_check && m->is_nfs && !m->busy)
			{
#if GLIB_CHECK_VERSION(2,0,0)
			m->busy = TRUE;
			g_thread_create(get_fsusage_thread, m, FALSE, NULL);
#else
			gkrellm_sys_fs_get_fsusage(m, m->directory);
#endif
			}
		}
	if (gkrellm_sys_fs_fstab_modified())
		refresh_fstab_list();

	gkrellmd_need_serve(mon);
	}

static void
serve_fs_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	Mount	*m;
	GList	*list;
	gchar	buf[128];

	if (mounts_list_modified || first_serve)
		{
		gkrellmd_set_serve_name(mon, "fs_mounts");
		gkrellmd_serve_data(mon, ".clear\n");
		for (list = mounts_list; list; list = list->next)
			{
			m = (Mount *) list->data;
			snprintf(buf, sizeof(buf), "%s %s %s %ld %ld %ld %ld\n",
					m->directory, m->device, m->type,
					m->blocks, m->bavail, m->bfree, m->bsize);
			gkrellmd_serve_data(mon, buf);
			}
		}
	else
		{
		gkrellmd_set_serve_name(mon, "fs");
		for (list = mounts_list; list; list = list->next)
			{
			m = (Mount *) list->data;
			if (!m->changed)
				continue;
			snprintf(buf, sizeof(buf), "%s %s %ld %ld %ld %ld\n",
					m->directory, m->device,
					m->blocks, m->bavail, m->bfree, m->bsize);
			gkrellmd_serve_data(mon, buf);
			}
		}
	if (fstab_list_modified || first_serve)
		{
		gkrellmd_set_serve_name(mon, "fs_fstab");
		gkrellmd_serve_data(mon, ".clear\n");
		for (list = fstab_list; list; list = list->next)
			{
			m = (Mount *) list->data;
			snprintf(buf, sizeof(buf), "%s %s %s\n",
					m->directory, m->device, m->type);
			gkrellmd_serve_data(mon, buf);
			}
		}
	}

static void
serve_fs_setup(GkrellmdMonitor *mon)
	{
	GkrellmdClient	*client = mon->privat->client;

	if (mounting_unsupported)
		gkrellmd_send_to_client(client, "<fs_setup>\nmounting_unsupported\n");
	}

static GkrellmdMonitor fs_monitor =
	{
	"fs",
	update_fs,
	serve_fs_data,
	serve_fs_setup
	};


static GkrellmdMonitor *
init_fs_monitor(void)
	{
	if (!gkrellm_sys_fs_init())
		return NULL;
	serveflag_done_list =
				g_list_append(serveflag_done_list, &fstab_list_modified);
	serveflag_done_list =
				g_list_append(serveflag_done_list, &mounts_list_modified);
	return &fs_monitor;
	}

/* ======================================================= */


typedef struct
	{
	gboolean	changed,
				have_data;

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

static GList	*battery_list;

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;
			serveflag_done_list = g_list_append(serveflag_done_list,
								&composite_battery->changed);
			}
		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++;
		serveflag_done_list = g_list_append(serveflag_done_list,
								&bat->changed);
		}
	return bat;
	}

void
gkrellm_battery_assign_data(gint id, gboolean present, gboolean on_line,
			gboolean charging, gint percent, gint time_left)
	{
	Battery	*bat;

	bat = battery_nth(id);
	if (!bat)
		return;

	if (   present   != bat->present
		|| on_line   != bat->on_line
		|| charging  != bat->charging
		|| percent   != bat->percent
		|| time_left != bat->time_left
	   )
		{
		bat->present = present;
		bat->on_line = on_line;
		bat->charging = charging;
		bat->percent = percent;
		bat->time_left = time_left;
		bat->changed = TRUE;
		}

	bat->have_data = TRUE;
	}

gint
gkrellm_battery_full_cap_fallback()
	{
	return 5000;	/* XXX Linux ACPI bug not handled by server */
	}

static void
update_battery(GkrellmdMonitor *mon, gboolean first_update)
	{
	GList	*list;
	Battery	*bat;

	if (!first_update && !GK.five_second_tick)
		return;

	for (list = battery_list; list; list = list->next)
		{
		bat = (Battery *) list->data;
		bat->have_data = FALSE;
		bat->changed = FALSE;
		}
	gkrellm_sys_battery_read_data();

	for (list = battery_list; list; list = list->next)
		{
		bat = (Battery *) list->data;
		if (!bat->have_data && bat->present)
			{
			bat->present = FALSE;
			bat->changed = TRUE;
			}
		if (bat->changed)
			gkrellmd_need_serve(mon);
		}
	}

static void
serve_battery_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	Battery		*bat;
	GList		*list;
	gchar		buf[128];

	gkrellmd_set_serve_name(mon, "battery");
	for (list = battery_list; list; list = list->next)
		{
		bat = (Battery *) list->data;

		if (   (!bat->changed && !first_serve)
			|| (   !gkrellmd_check_client_version(mon, 2,1,9)
				&& bat->id > 0
			   )
		   )
			continue;
		snprintf(buf, sizeof(buf), "%d %d %d %d %d %d\n",
					bat->present, bat->on_line, bat->charging,
					bat->percent, bat->time_left, bat->id);
		gkrellmd_serve_data(mon, buf);
		}
	}

static void
serve_battery_setup(GkrellmdMonitor *mon)
	{
	GkrellmdClient	*client = mon->privat->client;

	gkrellm_sys_battery_read_data();
	if (battery_list)
		gkrellmd_send_to_client(client,
					"<battery_setup>\nbattery_available\n");
	}

static GkrellmdMonitor battery_monitor =
	{
	"battery",
	update_battery,
	serve_battery_data,
	serve_battery_setup
	};

static GkrellmdMonitor *
init_battery_monitor(void)
	{
	if (!gkrellm_sys_battery_init())
		return NULL;
	return &battery_monitor;
	}

/* ======================================================= */

typedef struct
	{
	gboolean	changed;
	gint		type;

	gchar		*path;			/* Pathname to sensor data or device file */

	gchar		*id_name;		/* These 4 are unique sensor identification */
	gint		id;				/*   of a particular sensor type */
	gint		iodev;			/* One or any combination may be used. */
	gint		inter;

	gchar		*vref;
	gchar		*default_label;
	gint		group;

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

static GList	*sensors_list;

static gboolean thread_busy,
				sensors_need_serve;

static gpointer
read_sensors(void *data)
	{
	GList		*list;
	Sensor		*sensor;
	gfloat		tmp;
	gboolean	need_serve = FALSE;

	for (list = sensors_list; list; list = list->next)
		{
		sensor = (Sensor *) list->data;
		tmp = sensor->raw_value;
		if (sensor->type == SENSOR_TEMPERATURE)
			gkrellm_sys_sensors_get_temperature(sensor->path, sensor->id,
				sensor->iodev, sensor->inter, &sensor->raw_value);
		else if (sensor->type == SENSOR_FAN)
			gkrellm_sys_sensors_get_fan(sensor->path, sensor->id,
				sensor->iodev, sensor->inter, &sensor->raw_value);
		else if (sensor->type == SENSOR_VOLTAGE)
			gkrellm_sys_sensors_get_voltage(sensor->path, sensor->id,
				sensor->iodev, sensor->inter, &sensor->raw_value);
		if (sensor->raw_value != tmp)
			{
			sensor->changed = TRUE;
			need_serve = TRUE;
			}
		else
			sensor->changed = FALSE;
		}
	thread_busy = FALSE;
	sensors_need_serve = need_serve; /* Thread, so set after data collected */

	return NULL;
	}

static void
run_sensors_thread(void)
	{
#if GLIB_CHECK_VERSION(2,0,0)
	if (thread_busy)
		return;
	thread_busy = TRUE;
	g_thread_create(read_sensors, NULL, FALSE, NULL);
#else
	read_sensors(NULL);
#endif
	}


void
gkrellm_sensors_config_migrate_connect(gboolean (*func)(), gint sysdep_version)
	{
	}

void
gkrellm_sensors_update_volt_order_base(void)
	{
	}

void
gkrellm_sensors_set_group(gpointer sr, gint group)
	{
	Sensor	*sensor = (Sensor *) sr;

	if (sensor)
		sensor->group = group;
	}

void
gkrellm_sensors_sysdep_option(gchar *keyword, gchar *label, void (*func)())
	{
	}

  /* A sensor within a type is uniquely identified by its id_name.
  |  A sysdep interface may additionally use any of the triple integer
  |  set (id, iodev, inter) for internal identification.
  |  Monitor code here uses path to read the sensor values, but id_name is only
  |  passed to the client since that is all that is needed for identification
  |  (the client is no longer interfacing to sysdep code).
  */
gpointer
gkrellm_sensors_add_sensor(gint type, gchar *sensor_path, gchar *id_name,
		gint id, gint iodev, gint inter,
		gfloat factor, gfloat offset, gchar *vref, gchar *default_label)
	{
	Sensor	*sensor;

	if (!id_name || !*id_name || type < 0 || type > 2)
		return NULL;

	sensor = g_new0(Sensor, 1);
	sensor->id_name = g_strdup(id_name);

	if (sensor_path)
		sensor->path = g_strdup(sensor_path);
	else
		sensor->path = g_strdup(id_name);

	sensor->vref = g_strdup(vref ? vref : "NONE");
	sensor->default_label = g_strdup(default_label ? default_label : "NONE");

	sensor->factor = factor;
	sensor->offset = offset;
	sensor->type = type;
	sensor->id = id;
	sensor->iodev = iodev;
	sensor->inter = inter;
	sensors_list = g_list_append(sensors_list, sensor);
	return sensor;
	}

static void
update_sensors(GkrellmdMonitor *mon, gboolean first_update)
	{
	if (sensors_need_serve)		/* Asynchronously set in thread */
		gkrellmd_need_serve(mon);
	sensors_need_serve = FALSE;

	if (!GK.five_second_tick && !first_update)
		return;
	if (first_update)
		read_sensors(NULL);		/* No thread on first read */
	else
		run_sensors_thread();
	}

static void
serve_sensors_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	Sensor			*sr;
	GList			*list;
	gchar			buf[128];
	gboolean		sensor_disk_ok;

	gkrellmd_set_serve_name(mon, "sensors");
	sensor_disk_ok = gkrellmd_check_client_version(mon, 2,2,0);
	for (list = sensors_list; list; list = list->next)
		{
		sr = (Sensor *) list->data;
		if (sr->group == SENSOR_GROUP_DISK && !sensor_disk_ok)
			continue;
		if (sr->changed || first_serve)
			{
			sprintf(buf, "%d \"%s\" %d %d %d %.2f\n",
					sr->type, sr->id_name,
					sr->id, sr->iodev, sr->inter, sr->raw_value);
			gkrellmd_serve_data(mon, buf);
			}
		}
	}

static void
serve_sensors_setup(GkrellmdMonitor *mon)
	{
	GkrellmdClient	*client = mon->privat->client;
	GList			*list;
	Sensor			*s;
	gchar			buf[256];
	gboolean		sensor_disk_ok;

	gkrellmd_send_to_client(client, "<sensors_setup>\n");
	sensor_disk_ok = gkrellmd_check_client_version(mon, 2,2,0);
	for (list = sensors_list; list; list = list->next)
		{
		s = (Sensor *) list->data;
		if (s->group == SENSOR_GROUP_DISK && !sensor_disk_ok)
			continue;
		if (sensor_disk_ok)
			sprintf(buf, "%d \"%s\" %d %d %d %.4f %.4f \"%s\" \"%s\" %d\n",
					s->type, s->id_name,
					s->id, s->iodev, s->inter,
					s->factor, s->offset, s->vref, s->default_label, s->group);
		else
			sprintf(buf, "%d \"%s\" %d %d %d %.4f %.4f \"%s\" \"%s\"\n",
					s->type, s->id_name,
					s->id, s->iodev, s->inter,
					s->factor, s->offset, s->vref, s->default_label);
		gkrellmd_send_to_client(client, buf);
		}
	}

static GkrellmdMonitor sensors_monitor =
	{
	"sensors",
	update_sensors,
	serve_sensors_data,
	serve_sensors_setup
	};

static GkrellmdMonitor *
init_sensors_monitor(void)
	{
	if (!gkrellm_sys_sensors_init())
		return NULL;
	return &sensors_monitor;
	}

/* ======================================================= */
static time_t	base_uptime,
				up_seconds;
static gulong	up_minutes = -1;

void
gkrellm_uptime_set_base_uptime(time_t base)
	{
	base_uptime = base;
	}

static void
update_uptime(GkrellmdMonitor *mon, gboolean first_update)
	{
	gint	prev_up;

	if (GK.ten_second_tick || up_minutes < 0 || first_update)
		{
		prev_up = up_minutes;
		up_seconds = gkrellm_sys_uptime_read_uptime();
		if (up_seconds > 0)
			up_minutes = (gint) (up_seconds / 60);
		else
			up_minutes = (gint)(time(0) - _GK.start_time + base_uptime) / 60;
		if (up_minutes != prev_up)
			gkrellmd_need_serve(mon);
		}
	}

static void
serve_uptime_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	gchar	buf[128];

	gkrellmd_set_serve_name(mon, "uptime");
	snprintf(buf, sizeof(buf), "%lu\n", (gulong) up_minutes);
	gkrellmd_serve_data(mon, buf);
	}

static GkrellmdMonitor uptime_monitor =
	{
	"uptime",
	update_uptime,
	serve_uptime_data,
	NULL
	};

static GkrellmdMonitor *
init_uptime_monitor(void)
	{
	if (!gkrellm_sys_uptime_init())
		return NULL;
	return &uptime_monitor;
	}

/* ======================================================= */
static void
send_time(GkrellmdClient *client)
	{
	struct tm	*t;
	gchar		buf[128];

	t = &gkrellmd_current_tm;
	sprintf(buf, "<time>\n%d %d %d %d %d %d %d %d %d\n",
		t->tm_sec, t->tm_min, t->tm_hour,
		t->tm_mday, t->tm_mon, t->tm_year,
		t->tm_wday, t->tm_yday, t->tm_isdst);
	gkrellmd_send_to_client(client, buf);
	}

/* ======================================================= */

void
gkrellmd_plugin_serve_setup(GkrellmdMonitor *mon, gchar *name, gchar *line)
	{
	GkrellmdClient	*client = mon->privat->client;
	gchar			buf[256];

	if (!mon || !name || !line)
		return;
	gkrellmd_send_to_client(client, "<plugin_setup>\n");
	snprintf(buf, sizeof(buf), "%s %s\n", name, line);
	gkrellmd_send_to_client(client, buf);
	}

static void
add_monitor(GkrellmdMonitor *mon)
	{
	if (!mon)
		return;
	mon->privat = g_new0(GkrellmdMonitorPrivate, 1);
	mon->privat->serve_gstring = g_string_new("");
	gkrellmd_monitor_list = g_list_append(gkrellmd_monitor_list, mon);
	}

void
gkrellmd_load_monitors(void)
	{
	GList			*list;
	GkrellmdMonitor	*mon;

	add_monitor(init_sensors_monitor());
	add_monitor(init_cpu_monitor());
	add_monitor(init_proc_monitor());
	add_monitor(init_disk_monitor());
	add_monitor(init_net_monitor());
	add_monitor(init_inet_monitor());
	add_monitor(init_mem_monitor());
	add_monitor(init_fs_monitor());
	add_monitor(gkrellmd_init_mail_monitor());
	add_monitor(init_battery_monitor());
	add_monitor(init_uptime_monitor());

	list = gkrellmd_plugins_load();
	if (_GK.list_plugins)
		exit(0);
	if (_GK.log_plugins)
		printf("%s\n", plugin_install_log ? plugin_install_log :
				_("No plugins found\n"));
	for (  ; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		mon->privat->serve_gstring = g_string_new("");
		mon->privat->is_plugin = TRUE;
		gkrellmd_monitor_list = g_list_append(gkrellmd_monitor_list, mon);
		}
	}

void
gkrellmd_need_serve(GkrellmdMonitor *mon)
	{
	if (mon)
		mon->privat->need_serve = TRUE;
	}

gint
gkrellmd_update_monitors(void)
	{
	GList			*list, *c_list;
	GkrellmdMonitor			*mon;
	GkrellmdMonitorPrivate	*mp;
	GkrellmdClient			*client;
	struct tm				*pCur;
	static time_t			time_prev;
	gchar					buf[64];
	static gboolean			first_update = TRUE;
	static GString			*serve_gstring;

	time(&_GK.time_now);
	GK.second_tick = (_GK.time_now == time_prev) ? FALSE : TRUE;
	time_prev = _GK.time_now;

	if (GK.second_tick)
		{
		pCur = localtime(&_GK.time_now);
		GK.two_second_tick  = ((pCur->tm_sec % 2) == 0) ? TRUE : FALSE;
		GK.five_second_tick = ((pCur->tm_sec % 5) == 0) ? TRUE : FALSE;
		GK.ten_second_tick  = ((pCur->tm_sec % 10) == 0) ? TRUE : FALSE;
		GK.minute_tick = (pCur->tm_min  != gkrellmd_current_tm.tm_min);
		gkrellmd_current_tm = *pCur;
		}
	else
		{
		GK.two_second_tick = FALSE;
		GK.five_second_tick = FALSE;
		GK.ten_second_tick = FALSE;
		GK.minute_tick = FALSE;
		}

	for (list = gkrellmd_monitor_list; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		if (mon->update_monitor)
			(*(mon->update_monitor))(mon, first_update);
		}
	++GK.timer_ticks;
	if (!serve_gstring)
		serve_gstring = g_string_new("");
	for (c_list = gkrellmd_client_list; c_list; c_list = c_list->next)
		{
		client = (GkrellmdClient *) c_list->data;
		client->last_client = !c_list->next;
		if (!client->served)
			gkrellmd_send_to_client(client, "<initial_update>\n");
		for (list = gkrellmd_monitor_list; list; list = list->next)
			{
			mon = (GkrellmdMonitor *) list->data;
			mp = mon->privat;
			if (!mon->serve_data || (!mp->need_serve && client->served))
				continue;
			mp->client = client;
			mp->serve_name_sent = FALSE;
			(*(mon->serve_data))(mon, client->served ? FALSE : TRUE);
			if (mp->serve_gstring->len > 0)
				{
				serve_gstring =
					g_string_append(serve_gstring, mp->serve_gstring->str);
				mp->serve_gstring = g_string_truncate(mp->serve_gstring, 0);
				}
			}
		gkrellmd_send_to_client(client, serve_gstring->str);
		serve_gstring = g_string_truncate(serve_gstring, 0);
		
		if (GK.minute_tick || !client->served)
			send_time(client);
		else if (GK.second_tick)
			{
			sprintf(buf, "<.%d>\n", gkrellmd_current_tm.tm_sec);
			gkrellmd_send_to_client(client, buf);
			}

		if (!client->served)
			gkrellmd_send_to_client(client, "</initial_update>\n");
		client->served = TRUE;
		}

	for (list = gkrellmd_monitor_list; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		mp = mon->privat;
		mp->need_serve = FALSE;
		}

	for (list = serveflag_done_list; list; list = list->next)
		*((gboolean *) list->data) = FALSE;

	first_update = FALSE;
	return TRUE;
	}

void
gkrellmd_serve_setup(GkrellmdClient *client)
	{
	GList			*list;
	GkrellmdMonitor	*mon;
	struct lconv	*lc;
	gchar			buf[32], *s, *name;

	gkrellmd_send_to_client(client, "<gkrellmd_setup>\n");

	s = g_strdup_printf("<version>\ngkrellmd %d.%d.%d%s\n",
				GKRELLMD_VERSION_MAJOR, GKRELLMD_VERSION_MINOR,
				GKRELLMD_VERSION_REV, GKRELLMD_EXTRAVERSION);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	lc = localeconv();
	sprintf(buf, "%c\n", *lc->decimal_point);
	s = g_strconcat("<decimal_point>\n", buf, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	for (list = gkrellmd_monitor_list; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		mon->privat->client = client;
		if (mon->serve_setup)
			(*(mon->serve_setup))(mon);
		}
	name = gkrellm_sys_get_host_name();
	s = g_strconcat("<hostname>\n", name, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	name = gkrellm_sys_get_system_name();
	s = g_strconcat("<sysname>\n", name, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	send_time(client);

	gkrellmd_send_to_client(client, "<monitors>\n");
	for (list = gkrellmd_monitor_list; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		sprintf(buf, "%s\n", mon->name);
		gkrellmd_send_to_client(client, buf);
		}

	sprintf(buf, "%d\n", _GK.io_timeout);
	s = g_strconcat("<io_timeout>\n", buf, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	sprintf(buf, "%d\n", _GK.reconnect_timeout);
	s = g_strconcat("<reconnect_timeout>\n", buf, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	gkrellmd_send_to_client(client, "</gkrellmd_setup>\n");
	}

void
gkrellmd_client_input_connect(GkrellmdMonitor *mon,
			void (*func)(GkrellmdClient *, gchar *))
	{
	mon->privat->client_input_func = func;
	}

void
gkrellmd_client_read(gint fd, gint nbytes)
	{
	GList					*list;
	GkrellmdClient			*client = NULL;
	GkrellmdMonitor			*mon;
	GkrellmdMonitorPrivate	*mp;
	gchar					buf[513], *s, *e;
	gint					n, buflen;

	for (list = gkrellmd_client_list; list; list = list->next)
		{
		client = (GkrellmdClient *) list->data;
		if (client->fd != fd)
			continue;

		if (!client->input_gstring)
			client->input_gstring = g_string_new("");

		buflen = sizeof(buf) - 1;
		while (nbytes > 0)
			{
			n = (nbytes > buflen) ? buflen : nbytes;
			n = recv(fd, buf, n, 0);
			if (n <= 0)
				break;
			nbytes -= n;
			buf[n] = '\0';
			client->input_gstring =
						g_string_append(client->input_gstring, buf);
			}
		break;
		}
	if (!list)
		return;

	while (gkrellmd_getline_from_gstring(&client->input_gstring,
				buf, sizeof(buf) - 1))
		{
		if (*buf == '<')
			{
			client->input_func = NULL;
			s = buf + 1;
			for (list = gkrellmd_monitor_list; list; list = list->next)
				{
				mon = (GkrellmdMonitor *) list->data;
				mp = mon->privat;
				if (!mp->serve_name)
					continue;
				n = strlen(mp->serve_name);
				e = s + n;
				if (*e == '>' && !strncmp(mp->serve_name, s, n))
					{
					client->input_func = mp->client_input_func;
					break;
					}
				}
			}
		else if (client->input_func)
			(*client->input_func)(client, buf);
//		printf("%s: %s", client->hostname, buf);
		}
	}