/* GKrellM
|  Copyright (C) 1999-2021 Bill Wilson
|
|  Author:  Bill Wilson
|  Latest versions might be found at:  https://gkrellm.srcbox.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.
*/

#ifndef GKRELLM_SYSDEPS_H
#define GKRELLM_SYSDEPS_H

/* These functions define the GKrellM interface to the system dependent
|  data reading module.  All gkrellm_sys_xxx() functions must exist in
|  an implementation.
|
|  The gkrellm_sys_init_xxx() functions will be called at GKrellM startup
|  and must return TRUE if the monitor is supported in the implementation.
|  Data initializations for a monitor interface may be done in these functions.
|
|  gkrellm_xxx_client_divert() functions provide for the system dependent
|  module to be implemented in a client module which will override the builtin
|  implementation and read data from a server.
*/

/* User registered ports 1024 - 49151
|  Dynamic/private ports 49152 - 65535
*/
#define GKRELLMD_SERVER_PORT	19150

/* ===================================================================== */
/* gkrellm_sys_main_init() is called at GKrellM startup before any other
|      gkrellm_sys_xxx_init() calls are made.
|  gkrellm_sys_main_cleanup() is called when GKrellM exits any time after
|     all gkrellm_sys_xxx_init() calls have been made.
*/

void	gkrellm_sys_main_init(void);
void	gkrellm_sys_main_cleanup(void);

	/* If the sysdep code needs to call a function for additional
	|  setup after the main() arguments are parsed and GTK is
	|  initialized, register the function by calling this from
	|  gkrellm_sys_main_init().
	*/
void	gkrellm_sys_setup_connect(void (*setup_func)(gint argc, gchar **argv));

	/* The setup function will be passed the main() argc and argv and
	|  should be declared like:  void XXX_setup(gint ac, gchar **av);
	*/

/* ===================================================================== */
/* Misc monitor interface functions */

gchar	*gkrellm_sys_get_host_name(void);
gchar	*gkrellm_sys_get_system_name(void);

gint	gkrellm_get_timer_ticks(void);

  /* If local mailboxes are not applicable, call this from
  |  gkrellm_sys_main_init().
  */
void	gkrellm_mail_local_unsupported(void);

GThread *gkrellm_mail_get_active_thread(void);

/* ===================================================================== */
/* CPU monitor interface
|
|  gkrellm_cpu_set_number_of_cpus() must be called in gkrellm_sys_cpu_init().
|
|  gkrellm_cpu_add_instance() should be used if the platform's cpus
|      have noncontiguous instance numbers.  It should be called once for
|      each cpu before gkrellm_cpu_set_number_of_cpus() is called.
|
|  gkrellm_cpu_assign_composite_data() may be optionally called if an
|      implementation has composite cpu data.  If this function is not called,
|      GKrellM will automatically accumulate composite cpu data.
|
|  gkrellm_cpu_assign_data() must be called for each real cpuN, N = {list of
|      all cpu instance numbers}
*/

gboolean gkrellm_sys_cpu_init(void);
void	gkrellm_sys_cpu_read_data(void);

typedef void (*GkrellmCpuReadFunc)(void);

void	gkrellm_cpu_client_divert(GkrellmCpuReadFunc read_func);
void	gkrellm_cpu_set_number_of_cpus(gint n_cpus);
void	gkrellm_cpu_add_instance(gint inst);
void	gkrellm_cpu_nice_time_unsupported(void);
void	gkrellm_cpu_assign_composite_data(gulong user, gulong nice,
				gulong sys, gulong idle);
void	gkrellm_cpu_assign_data(gint n, gulong user, gulong nice,
				gulong sys, gulong idle);


/* ===================================================================== */
/* Proc monitor interface
*/

gboolean gkrellm_sys_proc_init(void);
void	gkrellm_sys_proc_read_data(void);
void	gkrellm_sys_proc_read_users(void);

typedef void (*GkrellmProcReadProcFunc)(void);
typedef void (*GkrellmProcReadUsersFunc)(void);

void	gkrellm_proc_client_divert(GkrellmProcReadProcFunc read_proc_func,
				GkrellmProcReadUsersFunc read_users_func);
void	gkrellm_proc_assign_data(gint n_processes, gint n_running,
				gulong n_forks, gfloat load);
void	gkrellm_proc_assign_users(gint n_users);


/* ===================================================================== */
/* Disk monitor interface
|
|  An implementation can choose to assign disk data by one of three methods.
|  If gkrellm_disk_assign_data_by_device() is used, then the function
|      gkrellm_sys_disk_name_from_device() must provide a name mapping from
|      the device numbers to an identifying name.  It may also set an order
|      value for the name to control the stacking order of the disk chart.
|  If gkrellm_disk_assign_data_by_name() is used, then an order may be
|      optionally specified with gkrellm_sys_disk_order_from_name().
|      (the default order of -1 simply appends disk charts as data for them
|      is reported).  After this function is called for a disk, the function
|      gkrellm_disk_subdisk_assign_data_by_name() may be called for subdisk
|      (partition) data for the disk if available.  Subdisk data is not
|      added to the composite disk since a subdisk data is expected to be
|      a portion of the previously reported whole disk data.
|  If gkrellm_disk_assign_data_nth() is used, default DiskA, DiskB, ... names
|      will be used.
*/

gboolean gkrellm_sys_disk_init(void);
void	gkrellm_sys_disk_read_data(void);
gchar	*gkrellm_sys_disk_name_from_device(gint device_number,
				gint unit_number, gint *order);
gint	gkrellm_sys_disk_order_from_name(const gchar *name);

typedef void (*GkrellmDiskReadFunc)(void);
typedef gchar* (*GkrellmDiskNameFromDeviceFunc)(gint device_number,
				gint uint_number, gint *order);
typedef gint (*GkrellmDiskOrderFromNameFunc)(const gchar *name);

void	gkrellm_disk_client_divert(GkrellmDiskReadFunc read_func,
				GkrellmDiskNameFromDeviceFunc name_from_device_func,
				GkrellmDiskOrderFromNameFunc order_from_name_func);
void    gkrellm_disk_add_by_name(const gchar *name, const gchar *label);
void	gkrellm_disk_assign_data_by_device(gint device_number,
				gint unit_number, guint64 r, guint64 w, gboolean virtual);
void	gkrellm_disk_assign_data_nth(gint n, guint64 r, guint64 w,
				gboolean virtual);
void	gkrellm_disk_assign_data_by_name(gchar *name,
				guint64 r, guint64 w, gboolean virtual);
void	gkrellm_disk_subdisk_assign_data_by_name(gchar *subdisk_name,
				gchar *disk_name, guint64 r, guint64 w);

void	gkrellm_disk_reset_composite(void);	/* Only Linux may need this */
void	gkrellm_disk_units_are_blocks(void);	/* Otherwise bytes */


/* ===================================================================== */
/* Inet monitor interface
|
|  System dependent code should #include "inet.h" and inet.h
|  should #define INET6 if IPV6 protocol is available.
*/

gboolean gkrellm_sys_inet_init(void);
void	gkrellm_sys_inet_read_tcp_data(void);

typedef void (*GkrellmInetReadFunc)(void);

void	gkrellm_inet_client_divert(GkrellmInetReadFunc read_func);
void	gkrellm_inet_log_tcp_port_data(gpointer tcp);


/* ===================================================================== */
/* Net monitor interface
|
|  Works in one of two ways:
|  1) When gkrellm_sys_net_read_data() is called, simply loop through
|     available net interfaces and call gkrellm_net_assign_data() on them.
|     Each second the net code will check if data is still being assigned
|     to each interface and mark a net down if not.  For this mode do not
|     call gkrellm_net_use_routed() or gkrellm_net_routed_event(), and
|     gkrellm_sys_net_check_routes() should be an empty function.
|  2) If routed information is available separately from net data stats, the
|     net up/down state can be controlled by the system dependent code.  For
|     this mode, call gkrellm_net_use_routed(TRUE) from gkrellm_sys_net_init().
|     Then, each second the gkrellm_sys_net_check_routes() function will be
|     called and it should call gkrellm_net_routed_event() on any net
|     interfaces that have had a change in routed state.
*/
gboolean gkrellm_sys_net_init(void);
void	gkrellm_sys_net_read_data(void);
void	gkrellm_sys_net_check_routes(void);
gboolean gkrellm_sys_net_isdn_online(void);

typedef void (*GkrellmNetReadFunc)(void);
typedef void (*GkrellmNetCheckRoutesFunc)(void);
typedef gboolean (*GkrellmNetIsdnIsOnlineFunc)(void);

void	gkrellm_net_client_divert(GkrellmNetReadFunc read_func,
				GkrellmNetCheckRoutesFunc check_routes_func,
				GkrellmNetIsdnIsOnlineFunc isdn_online_func);
void	gkrellm_net_assign_data(gchar *, gulong, gulong);
gchar	*gkrellm_net_mon_first(void);
gchar	*gkrellm_net_mon_next(void);
void	gkrellm_net_routed_event(gchar *name, gboolean routed);

  /* Routines optionally called from gkrellm_sys_net_init()
  *  or client_sys_net_init().
  */
void	gkrellm_net_use_routed(gboolean);
void	gkrellm_net_add_timer_type_ppp(gchar *);
void	gkrellm_net_add_timer_type_ippp(gchar *);
void	gkrellm_net_set_lock_directory(gchar *);


/* ===================================================================== */
/* Memory/Swap monitor interface
*/

gboolean gkrellm_sys_mem_init(void);
void	gkrellm_sys_mem_read_data(void);
void	gkrellm_sys_swap_read_data(void);

typedef void (*GkrellmMemReadMemFunc)(void);
typedef void (*GkrellmMemReadSwapFunc)(void);

void	gkrellm_mem_client_divert(GkrellmMemReadMemFunc read_mem_func,
				GkrellmMemReadSwapFunc read_swap_func);
void	gkrellm_mem_assign_data(guint64 total, guint64 used, guint64 free,
				guint64 shared, guint64 buffers, guint64 cached);
void	gkrellm_swap_assign_data(guint64 total, guint64 used,
				gulong swap_in, gulong swap_out);


/* ===================================================================== */
/* FS monitor interface
|
|  gkrellm_sys_fs_init() should call gkrellm_fs_set_eject_commands() if the
|  commands are available.
*/

gboolean gkrellm_sys_fs_init(void);
void	gkrellm_sys_fs_get_fsusage(gpointer fs, gchar *dir);
void	gkrellm_sys_fs_get_mounts_list(void);
void	gkrellm_sys_fs_get_fstab_list(void);
gboolean gkrellm_sys_fs_fstab_modified(void);

typedef void (*GkrellmFsGetUsageFunc)(gpointer mon, gchar *dir);
typedef void (*GkrellmFsGetMountsListFunc)(void);
typedef void (*GkrellmFsGetFstabListFunc)(void);
typedef gboolean (*GkrellmFsGetFstabModifiedFunc)(void);

typedef void (*GkrellmFsEjectFunc)(gchar *dev);
typedef void (*GkrellmFsCloseFunc)(gchar *dev);

void	gkrellm_fs_client_divert(GkrellmFsGetUsageFunc get_usage_func,
				GkrellmFsGetMountsListFunc get_mounts_func,
				GkrellmFsGetFstabListFunc get_fstab_func,
				GkrellmFsGetFstabModifiedFunc get_fstab_modified_func);
void	gkrellm_fs_assign_fsusage_data(gpointer fs,
				gint64 blocks, gint64 avail, gint64 free, gint64 bsize);
void	gkrellm_fs_add_to_fstab_list(gchar *dir, gchar *dev, gchar *type,
				gchar *options);
void	gkrellm_fs_add_to_mounts_list(gchar *dir, gchar *dev, gchar *type);
void	gkrellm_fs_setup_eject(gchar *eject_tray, gchar *close_tray,
				GkrellmFsEjectFunc eject_func,
				GkrellmFsCloseFunc close_func);
void	gkrellm_fs_mounting_unsupported(void);


/* ===================================================================== */
/* Battery monitor interface
*/

#define	GKRELLM_BATTERY_COMPOSITE_ID	-1

gboolean gkrellm_sys_battery_init(void);
void	gkrellm_sys_battery_read_data(void);

typedef void (*GkrellmBatteryReadFunc)(void);

gint gkrellm_battery_full_cap_fallback(void);
void	gkrellm_battery_client_divert(GkrellmBatteryReadFunc read_func);
void	gkrellm_battery_assign_data(gint id, gboolean available,
				gboolean on_line, gboolean charging,
				gint percent, gint time_left /* minutes */);

/* ===================================================================== */
/* Uptime monitor interface
*/

gboolean gkrellm_sys_uptime_init(void);
time_t	gkrellm_sys_uptime_read_uptime(void);

typedef time_t (*GkrellmUptimeReadFunc)(void);

void	gkrellm_uptime_client_divert(GkrellmUptimeReadFunc read_func);
void	gkrellm_uptime_set_base_uptime(time_t base_uptime);


/* ===================================================================== */
/* Sensor monitor interface
*/

typedef gboolean (*GkrellmSensorsGetTempFunc)(gchar *name, gint id,
				gint iodev, gint inter, gfloat *t);
typedef gboolean (*GkrellmSensorsGetFanFunc)(gchar *name, gint id,
				gint iodev, gint inter, gfloat *f);
typedef gboolean (*GkrellmSensorsGetVoltFunc)(gchar *name, gint id,
				gint iodev, gint inter, gfloat *v);
typedef gboolean (*GkrellmSensorsGetPowerFunc)(gchar *name, gint id,
				gint iodev, gint inter, gfloat *p);
typedef void (*GkrellmSensorsSysdepOptionFunc)(gboolean value);

gboolean gkrellm_sys_sensors_init(void);
gboolean gkrellm_sys_sensors_get_temperature(gchar *name, gint id,
			gint iodev, gint inter, gfloat *t);
gboolean gkrellm_sys_sensors_get_fan(gchar *name, gint id,
			gint iodev, gint inter, gfloat *f);
gboolean gkrellm_sys_sensors_get_voltage(gchar *name, gint id,
			gint iodev, gint inter, gfloat *v);
gboolean gkrellm_sys_sensors_get_power(gchar *name, gint id,
			gint iodev, gint inter, gfloat *p);

void	gkrellm_sensors_client_divert(GkrellmSensorsGetTempFunc get_temp_func,
				GkrellmSensorsGetFanFunc get_fan_func,
				GkrellmSensorsGetVoltFunc get_volt_func,
				GkrellmSensorsGetPowerFunc get_power_func);
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);
void	gkrellm_sensors_set_group(gpointer sr, gint group);
void	gkrellm_sensors_sysdep_option(gchar *keyword, gchar *label,
			GkrellmSensorsSysdepOptionFunc func);

  /* Common sensor reading from daemons.  Interfaces from 0 - 20 are available
  |  for system dependent interfaces.  Interfaces from 20 up are used here
  |  for the common daemon interfaces.
  */
#define HDDTEMP_INTERFACE	20
#define MBMON_INTERFACE		21

  /* Common hddtemp interface*/
void	gkrellm_sys_sensors_hddtemp_check(void);
gboolean gkrellm_sys_sensors_hddtemp_get_value(gchar *name, gfloat *value);

  /* Common mbmon interface*/
gboolean	gkrellm_sys_sensors_mbmon_supported(void);
gboolean	gkrellm_sys_sensors_mbmon_check(gboolean force);
gboolean	gkrellm_sys_sensors_mbmon_get_value(gchar *name, gfloat *value);
gboolean	gkrellm_sys_sensors_mbmon_port_change(gint port);

  /* Config migration helper */

typedef gboolean (*GkrellmSensorsConfigMigrateFunc)(gchar *current_name,
				gchar *config_name, gint current, gint config);

void	gkrellm_sensors_config_migrate_connect(
				GkrellmSensorsConfigMigrateFunc config_migrate_func,
				gint sysdep_private);

#endif