#include "linux/vswitch.h"
#include "linux/namespace.h"
#include "linux/legacy.h"
#include "linux/limit_cmd.h"
#include "linux/context_cmd.h"
#include <errno.h>
#include <asm/unistd.h>
#include <string.h>

#define _UNISTD_H
#ifndef PROTO_SKIP
extern "C" long int syscall (long int __sysno, ...) __THROW;
#endif
#include <linux/unistd.h>
#include "old_syscall.p"
#include <stdio.h>

#ifndef __NR_vserver
#  define __NR_vserver	273
#endif

static enum KERNEL_TYPE{
	K_UNKNOWN,	// Do not support vserver at all
	K_NEW,		// New vserver kernel
	K_OLD		// Old vserver kernel
} state = K_UNKNOWN;


_syscall3(int, vserver, uint32_t, cmd, uint32_t, id, void *, data);


static void init()
{
	if (state == K_UNKNOWN){
		int ret = vserver (VCMD_get_version,0,NULL);
		if (ret == -1){
			state = K_OLD;
		}else{
			state = K_NEW;
		}
	}
}
	

extern "C" int call_new_s_context(
	int nbctx,
	int ctxs[],
	unsigned int remove_cap,
	unsigned long long flags,
	unsigned long long flagmask)
{
	int ret = -1;
	init();
	#if 0
		fprintf (stderr,"new_s_context ctx=%d %x %Lx\n"
			,ctxs != NULL ? ctxs[0] : -10
			,remove_cap,flags);
	#endif
	if (state == K_NEW){
		if (ctxs != NULL){
			if (ctxs[0] == 1){
				ret = vserver (VCMD_ctx_migrate,1,NULL);
			}else{
				ret = vserver (VCMD_ctx_create,ctxs[0],NULL);
				//fprintf (stderr,"After create ctxs[0]=%d ret=%d errno=%d %d\n",ctxs[0],ret,errno,EINVAL);
				//if (ret == -1 && ((int)errno == EEXIST || (int)errno == EINVAL)){
				if (ret == -1){
					// In older kernel, it returns EINVAL instead of EEXIST
					// Since we know we are calling properly, we try
					// a migrate whenever we get an error
					ret = vserver (VCMD_ctx_migrate,ctxs[0],NULL);
					// fprintf (stderr,"After migrate ctxs[0]=%d ret=%d errno=%d\n",ctxs[0],ret,errno);
					flagmask = 0;	// We can't set the flags
									// if we migrate
					remove_cap = 0;
				}
			}
		}else{
			ret = 0;
		}
		if (ret != -1 && remove_cap != 0){
			vcmd_ctx_caps_v0 data;
			data.bcaps = (unsigned long long)-1 & (~remove_cap);
			data.ccaps = 0;
			data.cmask = (unsigned long long)-1;
			int fret = vserver (VCMD_set_ccaps,(unsigned)-1,&data);
			if (fret == -1){
				//fprintf (stderr,"set_ccaps %d %d\n",fret,errno);
				ret = -1;
			}
		}
		if (ret != -1 && flagmask != 0){
			vcmd_ctx_flags_v0 data;
			data.flagword = flags;
			data.mask = flagmask;
			int fret = vserver (VCMD_set_cflags,(unsigned)-1,&data);
			if (fret == -1){
				//fprintf (stderr,"set_flags %d %d\n",fret,errno);
				ret = -1;
			}
		}
		// fprintf (stderr,"End new_s_context\n");
		#if 0
		vcmd_new_s_context_v1 data;
		data.remove_cap = remove_cap;
		data.flags = flags;
		ret = vserver (VCMD_new_s_context,nbctx==0 ? -2 : ctxs[0],&data);
		#endif
	}else{
		ret = call_old_new_s_context (nbctx,ctxs,remove_cap,flags);
	}
	return ret;
}

extern "C" int call_set_ipv4root(
	unsigned long ip[],
	int nb,
	unsigned long bcast,
	unsigned long mask[])
{
	int ret = -1;
	init();
	if (state == K_NEW){
		vcmd_set_ipv4root_v3 data;
		data.broadcast = bcast;
		for (int i=0; i<nb && i <NB_IPV4ROOT; i++){
			data.nx_mask_pair[i].ip = ip[i];
			data.nx_mask_pair[i].mask = mask[i];
		}
		ret = vserver (VCMD_set_ipv4root,nb,&data);
	}else{
		ret = call_old_set_ipv4root(ip,nb,bcast,mask);
	}
	return ret;
}

extern "C" int call_set_ctxlimit (int res, long lim)
{
	int ret = -1;
	init();
	if (state == K_NEW){
		vcmd_ctx_rlimit_v0 data;
		data.id = res;
		data.minimum = 0;
		data.softlimit = lim;
		data.maximum = lim;
		ret = vserver (VCMD_set_rlimit,0,&data);
	}else if (state == K_OLD){
		ret = call_old_set_ctxlimit (res,lim);
	}
	return ret;
}
/*
	Change something in the namespace of a vserver
*/
static int call_setvhi (int field, const char *val)
{
	int ret = -1;
	init();
	if (state == K_NEW){
		vcmd_vx_vhi_name_v0 data;
		data.field = field;
		snprintf (data.name,sizeof(data.name)-1,"%s",val);
		ret = vserver (VCMD_vx_set_vhi_name,(uint32_t)-1,&data);
		// fprintf (stderr,"Setting id %d to :%s: %d errno=%d(%s)\n",field,data.name,ret,errno,strerror(errno));
	}
	return ret;
}

/*
	Change the architecture for the vserver
*/
extern "C" int call_setarch (const char *arch)
{
	return call_setvhi (VHIN_MACHINE,arch);
}

/*
	Change the kernel release for the vserver
*/
extern "C" int call_setkrelease (const char *rel)
{
	return call_setvhi (VHIN_RELEASE,rel);
}