#include <stdlib.h>
#include <netconf.h>
#include "kernelconf.h"
#include "kernelconf.m"

#define FS_FILE_MAX "fs.file-max"
#define FS_INODE_MAX "fs.inode-max"
#define FS_DQUOT_MAX "fs.dquot-max"
#define FS_SUPER_MAX "fs.super-max"
#define KERNEL_CTRL_ALT_DEL "kernel.ctrl-alt-del"
#define KERNEL_FAIRSCHED "kernel.fairsched"
#define KERNEL_SHMMAX "kernel.shmmax"
#define KERNEL_SEM "kernel.sem"
#define KERNEL_THREADS_MAX "kernel.threads-max"

static HELP_FILE help_kernelconf("kernelconf","kernelconf");

class KERNELCONF_FIELD {
protected:
	SYSCTL &sysctl;
	const char *varname;
	KERNELCONF_FIELD(
		SYSCTL &_sysctl,
		const char *_varname)
	: sysctl(_sysctl), varname(_varname)
	{
	}
};
static long long kernel_atoL(const char *s, int no)
{
	long long ret = -1;
	while (no > 0){
		s = str_skip(s);
		s = str_skipdig(s);
		no--;
	}
	sscanf (s,"%Ld",&ret);
	return ret;
}

// Sysctl variable with multiple value
class KERNELCONF_FIELD_INTS: public KERNELCONF_FIELD {
protected:
	int var[10];
	int divider[10];
	int defval[10];
	int nbvar;
	const char *varstr;
public:
	KERNELCONF_FIELD_INTS(
		SYSCTL &_sysctl,
		const char *_varname)
		: KERNELCONF_FIELD(_sysctl,_varname)
	{
		varstr = NULL;
		nbvar=0;
	}
	void setfield (
		int no,
		DIALOG &dia,
		const char *title,
		int _defval,
		int _divider,
		const int vals[],
		const char *namevals[])
	{
		var[no] = -1;
		if (no >= nbvar) nbvar = no+1;
		divider[no] = _divider;
		varstr = sysctl.get_from_file(varname);
		if (varstr == NULL){
			varstr = sysctl.get_from_sys(varname);
			if (varstr != NULL){
				var[no] = -1;
				if (_defval == -1) _defval = kernel_atoL(varstr,no)/_divider;
			}
		}else{
			var[no] = kernel_atoL(varstr,no)/_divider;
			if (_defval == -1) _defval = var[no];
		}
		defval[no] = _defval;
		dia.newf_chkm_num(title,var[no],_defval,vals,namevals);
	}
	void update()
	{
		if (varstr != NULL) {
			bool isdef = true;
			SSTRING tmp;
			for (int i=0; i<nbvar; i++){
				int vali;
				if (var[i] != -1){
					vali = var[i];
					isdef = false;
				}else{
					vali = defval[i];
				}
				tmp.appendf (i==0 ? "%Ld" : " %Ld"
					,(long long)vali*divider[i]);
			}
			if (isdef){
				sysctl.erase(varname);
			}else{
				sysctl.set_to_file(varname, tmp.get());
			}
		}
	}
};

// Sysctl variable with one numeric value
class KERNELCONF_FIELD_INT: public KERNELCONF_FIELD_INTS {
public:
	KERNELCONF_FIELD_INT(
		SYSCTL &_sysctl,
		const char *_varname,
		int _divider)
		: KERNELCONF_FIELD_INTS(_sysctl,_varname)
	{
		divider[0] = _divider;
	}
	void setfield (
		DIALOG &dia,
		const char *title,
		int defval,
		const int vals[],
		const char *namevals[])
	{
		KERNELCONF_FIELD_INTS::setfield(0,dia,title,defval,divider[0]
			,vals,namevals);
	}
};

class KERNELCONF_FIELD_CHK: public KERNELCONF_FIELD {
	char var;
	const char *varstr;
public:
	KERNELCONF_FIELD_CHK(
		SYSCTL &_sysctl,
		const char *_varname)
		: KERNELCONF_FIELD(_sysctl,_varname)
	{
		varstr = NULL;
	}
	void setfield (
		DIALOG &dia,
		const char *title,
		const char *vals[])
	{
		varstr = sysctl.get_from_file(varname);
		if (varstr == NULL){
			varstr = sysctl.get_from_sys(varname);
			if (varstr != NULL){
				var = 2;
				dia.newf_chkm(title,var,vals);
			}
		}else{
			var = !atoi(varstr);
			dia.newf_chkm(title,var,vals);
		}
	}
	void update()
	{
		if (varstr != NULL) {
			if (var == 2){
				sysctl.erase(varname);
			}else{
				sysctl.set_to_file(varname, !((int)var));
			}
		}
	}
};


int kernelconf_edit()
{
	int ret = -1;
	static const char *chk[] = {
		MSG_U(I_ENABLE,"Enabled"),MSG_U(I_DISABLE,"Disabled"),
		MSG_U(I_DEFAULT,"Default"),NULL};
	static const char *num[] = {MSG_R(I_DEFAULT),NULL};
	static const int num_vals[] = {-1};
	SYSCTL sysctl;
	DIALOG dia;
	dia.newf_title(MSG_U(F_FS,"File System"),1,"",MSG_R(F_FS));

	KERNELCONF_FIELD_INT file_max (sysctl,FS_FILE_MAX,1);
	file_max.setfield (dia,MSG_U(F_MAXFILE,"Max. file handles")
		,-1,num_vals,num);
			
	KERNELCONF_FIELD_INT inode_max (sysctl,FS_INODE_MAX,1);
	inode_max.setfield (dia,MSG_U(F_MAXINODE,"Max. inode handles")
		,-1,num_vals,num);

	KERNELCONF_FIELD_INT dquot_max (sysctl,FS_DQUOT_MAX,1);
	dquot_max.setfield (dia,MSG_U(F_MAXDQUOT,"Max. num. cached disk quota")
		,-1,num_vals,num);

	KERNELCONF_FIELD_INT super_max (sysctl,FS_SUPER_MAX,1);
	super_max.setfield (dia,MSG_U(F_MAXSUPER,"Max. super block handlers")
		,-1,num_vals,num);
	
	dia.newf_title(MSG_U(T_GENERAL,"General"),1,"",MSG_R(T_GENERAL));
	
	KERNELCONF_FIELD_CHK ctrl_alt_del (sysctl,KERNEL_CTRL_ALT_DEL);
	ctrl_alt_del.setfield (dia,MSG_U(F_CTRLALTDEL,"Ctrl-alt-del"),chk);
	
	KERNELCONF_FIELD_CHK fairsched (sysctl,KERNEL_FAIRSCHED);
	fairsched.setfield (dia,MSG_U(F_FAIRSCHED,"Fair scheduler"),chk);

	KERNELCONF_FIELD_INT shmmax (sysctl,KERNEL_SHMMAX,1024*1024);
	shmmax.setfield (dia,MSG_U(F_SHMMAX,"Shared memory size (meg.)")
		,32,num_vals,num);

	KERNELCONF_FIELD_INT threads (sysctl,KERNEL_THREADS_MAX,1);
	threads.setfield (dia,MSG_U(F_THREADSMAX,"Maximum processes")
		,3070,num_vals,num);

	dia.newf_title(MSG_U(T_SEMAPHORE,"Semaphores"),1,"",MSG_R(T_SEMAPHORE));
	KERNELCONF_FIELD_INTS semconf (sysctl,KERNEL_SEM);
	semconf.setfield (0,dia,MSG_U(F_SEMCONF1,"Max sem. per ID")
		,250,1,num_vals,num);
	semconf.setfield (1,dia,MSG_U(F_SEMCONF2,"Max sem. in system")
		,32000,1,num_vals,num);
	semconf.setfield (2,dia,MSG_U(F_SEMCONF3,"Max oper. per syscall")
		,32,1,num_vals,num);
	semconf.setfield (3,dia,MSG_U(F_SEMCONF4,"Max IDs")
		,128,1,num_vals,num);

	int nof=0;
	while(1){
		MENU_STATUS code = dia.edit(
				MSG_U(T_KERNELCONF,"Kernel Configuration"),
				MSG_U(I_KERNELCONF, "This dialog allows you to change kernel options. BE CAREFUL!"),
				help_kernelconf,nof,
				MENUBUT_ACCEPT|MENUBUT_CANCEL);
		
		if (code == MENU_ESCAPE || code == MENU_QUIT || code == MENU_CANCEL){
			break;
		}else if (code == MENU_ACCEPT){
			file_max.update();
			inode_max.update();
			dquot_max.update();
			super_max.update();
			ctrl_alt_del.update();
			fairsched.update();
			shmmax.update();
			semconf.update();
			threads.update();
			ret = 0;
			break;
		}	
	}
	return ret;
}

#define PROBE_OPT(x) \
	do { \
		if (sysctl.probe(x)){ \
			const char *fromfile = sysctl.get_from_file(x); \
			net_prtlog (NETLOG_CMD,"Executing: sysctl -w " x "=%s\n", fromfile); \
			if (!sim){ \
				sysctl.set_to_sys(x, fromfile); \
			} \
		} \
	} while (0)

int kernelconf_probe(bool sim)
{
	SYSCTL sysctl;
	if (!sim){
		net_title(MSG_U(S_CHECKKERNEL,"Checking kernel configuration"));
	}
	PROBE_OPT(FS_FILE_MAX);
	PROBE_OPT(FS_INODE_MAX);
	PROBE_OPT(FS_DQUOT_MAX);
	PROBE_OPT(FS_SUPER_MAX);
	PROBE_OPT(KERNEL_CTRL_ALT_DEL);
	PROBE_OPT(KERNEL_FAIRSCHED);
	PROBE_OPT(KERNEL_SHMMAX);
	return 0;
}

static void kernelconf_edit0()
{
	kernelconf_edit();
}


#include <modregister.h>

static PUBLISH_VARIABLES_MSG kernel_var_list[]={
	{"maxfile",P_MSG_R(F_MAXFILE)},
	{"maxinode",P_MSG_R(F_MAXINODE)},
	{"dquotmax",P_MSG_R(F_MAXDQUOT)},
	{"maxsuper",P_MSG_R(F_MAXSUPER)},
	{"ctrlaltdel",P_MSG_R(F_CTRLALTDEL)},
	{"fairsched",P_MSG_R(F_FAIRSCHED)},
	{"maxshm",P_MSG_R(F_SHMMAX)},
	{"threads-max",P_MSG_R(F_THREADSMAX)},
	{"semmaxperid",P_MSG_R(F_SEMCONF1)},
	{"semmaxsystem",P_MSG_R(F_SEMCONF2)},
	{"semmaxopm",P_MSG_R(F_SEMCONF3)},
	{"semmaxids",P_MSG_R(F_SEMCONF4)},
	{ NULL, NULL }
};
static REGISTER_VARIABLES kernel_registry1("kernel",kernel_var_list
	,NULL,kernelconf_edit0);

// vim: nowrap