/** \file builtin_ulimit.c Functions defining the ulimit builtin

Functions used for implementing the ulimit builtin. 

*/
#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>
#include <wctype.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
#include <errno.h>

#include "fallback.h"
#include "util.h"

#include "builtin.h"
#include "common.h"
#include "wgetopt.h"


/**
   Struct describing a resource limit
*/
struct resource_t
{
	/**
	   Resource id
	 */
	int resource;
	/**
	   Description of resource
	*/
	const wchar_t *desc;
	/**
	   Switch used on commandline to specify resource
	*/
	wchar_t switch_char;	
	/**
	   The implicit multiplier used when setting getting values
	*/
	int multiplier;	
}
	;

/**
   Array of resource_t structs, describing all known resource types.
*/
static const struct resource_t resource_arr[] =
{
	{
		RLIMIT_CORE, L"Maximum size of core files created", L'c', 1024
	}
	,
	{
		RLIMIT_DATA, L"Maximum size of a process’s data segment", L'd', 1024
	}
	,
	{
		RLIMIT_FSIZE, L"Maximum size of files created by the shell", L'f', 1024
	}
	,
#ifdef RLIMIT_MEMLOCK
	{
		RLIMIT_MEMLOCK, L"Maximum size that may be locked into memory", L'l', 1024
	}
	,
#endif
#ifdef RLIMIT_RSS
	{
		RLIMIT_RSS, L"Maximum resident set size", L'm', 1024
	}
	,
#endif
	{
		RLIMIT_NOFILE, L"Maximum number of open file descriptors", L'n', 1
	}
	,
	{
		RLIMIT_STACK, L"Maximum stack size", L's', 1024
	}
	,
	{
		RLIMIT_CPU, L"Maximum amount of cpu time in seconds", L't', 1
	}
	,
#ifdef RLIMIT_NPROC
	{
		RLIMIT_NPROC, L"Maximum number of processes available to a single user", L'u', 1
	}
	,
#endif
#ifdef RLIMIT_AS
	{
		RLIMIT_AS, L"Maximum amount of virtual memory available to the shell", L'v', 1024
	}	
	,
#endif
	{
		0, 0, 0, 0
	}
}
	;

/**
   Get the implicit multiplication factor for the specified resource limit
*/
static int get_multiplier( int what )
{
	int i;
	
	for( i=0; resource_arr[i].desc; i++ )
	{
		if( resource_arr[i].resource == what )
		{
			return resource_arr[i].multiplier;
		}
	}
	return -1;
}

/**
   Return the value for the specified resource limit. This function
   does _not_ multiply the limit value by the multiplier constant used
   by the commandline ulimit.
*/
static rlim_t get( int resource, int hard )
{
	struct rlimit ls;
	
	getrlimit( resource, &ls );
	
	return hard ? ls.rlim_max:ls.rlim_cur;
}

/**
   Print the value of the specified resource limit
*/
static void print( int resource, int hard )
{
	rlim_t l = get( resource, hard );

	if( l == RLIM_INFINITY )
		stdout_buffer.append( L"unlimited\n" );
	else
		append_format(stdout_buffer, L"%d\n", l / get_multiplier( resource ) );
	
}

/**
   Print values of all resource limits
*/
static void print_all( int hard )
{
	int i;
	int w=0;
	
	for( i=0; resource_arr[i].desc; i++ )
	{
		w=maxi( w, my_wcswidth(resource_arr[i].desc));
	}
	
	for( i=0; resource_arr[i].desc; i++ )
	{
		struct rlimit ls;
		rlim_t l;
		getrlimit( resource_arr[i].resource, &ls );
		l = hard ? ls.rlim_max:ls.rlim_cur;

		const wchar_t *unit = ((resource_arr[i].resource==RLIMIT_CPU)?L"(seconds, ":(get_multiplier(resource_arr[i].resource)==1?L"(":L"(kB, "));
		
		append_format(stdout_buffer,
				   L"%-*ls %10ls-%lc) ", 
				   w, 
				   resource_arr[i].desc, 
				   unit,
				   resource_arr[i].switch_char);
		
		if( l == RLIM_INFINITY )
		{
			stdout_buffer.append( L"unlimited\n" );
		}
		else
		{
			append_format(stdout_buffer, L"%d\n", l/get_multiplier(resource_arr[i].resource) );
		}
	}
		
}

/**
   Returns the description for the specified resource limit
*/
static const wchar_t *get_desc( int what )
{
	int i;
	
	for( i=0; resource_arr[i].desc; i++ )
	{
		if( resource_arr[i].resource == what )
		{
			return resource_arr[i].desc;
		}
	}
	return L"Not a resource";
}

/**
   Set the new value of the specified resource limit. This function
   does _not_ multiply the limit value by the multiplier constant used
   by the commandline ulimit.
*/
static int set( int resource, int hard, int soft, rlim_t value )
{
	struct rlimit ls;
	getrlimit( resource, &ls );
	
	if( hard )
	{
		ls.rlim_max = value;
	}
	
	if( soft )
	{
		ls.rlim_cur = value;
		
		/*
		  Do not attempt to set the soft limit higher than the hard limit
		*/
		if( ( value == RLIM_INFINITY && ls.rlim_max != RLIM_INFINITY ) || 
			( value != RLIM_INFINITY && ls.rlim_max != RLIM_INFINITY && value > ls.rlim_max))
		{
			ls.rlim_cur = ls.rlim_max;
		}		
	}
	
	if( setrlimit( resource, &ls ) )
	{
		if( errno == EPERM )
			append_format(stderr_buffer, L"ulimit: Permission denied when changing resource of type '%ls'\n", get_desc( resource ) );
		else
			builtin_wperror( L"ulimit" );
		return 1;
	}	
	return 0;	
}

/**
   The ulimit builtin, used for setting resource limits. Defined in
   builtin_ulimit.c.
*/
static int builtin_ulimit( parser_t &parser, wchar_t ** argv )
{
	int hard=0;
	int soft=0;
	
	int what = RLIMIT_FSIZE;
	int report_all = 0;

	int argc = builtin_count_args( argv );
	
	woptind=0;
	
	while( 1 )
	{
		static const struct woption
			long_options[] =
			{
				{
					L"all", no_argument, 0, 'a'
				}
				,
				{
					L"hard", no_argument, 0, 'H'
				}
				,
				{
					L"soft", no_argument, 0, 'S'
				}
				,
				{
					L"core-size", no_argument, 0, 'c'
				}
				,
				{
					L"data-size", no_argument, 0, 'd'
				}
				,
				{
					L"file-size", no_argument, 0, 'f'
				}
				,
				{
					L"lock-size", no_argument, 0, 'l'
				}
				,
				{
					L"resident-set-size", no_argument, 0, 'm'
				}
				,
				{
					L"file-descriptor-count", no_argument, 0, 'n'
				}
				,
				{
					L"stack-size", no_argument, 0, 's'
				}
				,
				{
					L"cpu-time", no_argument, 0, 't'
				}
				,
				{
					L"process-count", no_argument, 0, 'u'
				}
				,
				{
					L"virtual-memory-size", no_argument, 0, 'v'
				}
				,
				{ 
					L"help", no_argument, 0, 'h' 
				} 
				,
				{
					0, 0, 0, 0 
				}
			}
		;		
		

		int opt_index = 0;
		
		int opt = wgetopt_long( argc,
								argv, 
								L"aHScdflmnstuvh", 
								long_options, 
								&opt_index );
		if( opt == -1 )
			break;
			
		switch( opt )
		{
			case 0:
				if(long_options[opt_index].flag != 0)
					break;
                append_format(stderr_buffer,
                           BUILTIN_ERR_UNKNOWN,
                           argv[0],
                           long_options[opt_index].name );
				builtin_print_help( parser, argv[0], stderr_buffer );

				return 1;
				
			case L'a':
				report_all=1;
				break;

			case L'H':
				hard=1;
				break;

			case L'S':
				soft=1;				
				break;

			case L'c':
				what=RLIMIT_CORE;
				break;
				
			case L'd':
				what=RLIMIT_DATA;
				break;
				
			case L'f':
				what=RLIMIT_FSIZE;
				break;
#ifdef RLIMIT_MEMLOCK
			case L'l':
				what=RLIMIT_MEMLOCK;
				break;
#endif

#ifdef RLIMIT_RSS				
			case L'm':
				what=RLIMIT_RSS;
				break;
#endif
				
			case L'n':
				what=RLIMIT_NOFILE;
				break;
				
			case L's':
				what=RLIMIT_STACK;
				break;
				
			case L't':
				what=RLIMIT_CPU;
				break;
			
#ifdef RLIMIT_NPROC	
			case L'u':
				what=RLIMIT_NPROC;
				break;
#endif
				
#ifdef RLIMIT_AS				
			case L'v':
				what=RLIMIT_AS;
				break;
#endif
				
			case L'h':
				builtin_print_help( parser, argv[0], stdout_buffer );				
				return 0;

			case L'?':
				builtin_unknown_option( parser, argv[0], argv[woptind-1] );
				return 1;	
		}
	}		

	if( report_all )
	{
		if( argc - woptind == 0 )
		{
			print_all( hard );
		}
		else
		{
            stderr_buffer.append(argv[0]);
            stderr_buffer.append(L": Too many arguments\n");
			builtin_print_help( parser, argv[0], stderr_buffer );
			return 1;
		}

		return 0;
	}
	
	switch( argc - woptind )
	{
		case 0:
		{
			/*
			  Show current limit value
			*/
			print( what, hard );
			break;
		}
		
		case 1:
		{
			/*
			  Change current limit value
			*/
			rlim_t new_limit;
			wchar_t *end;

			/*
			  Set both hard and soft limits if nothing else was specified
			*/
			if( !(hard+soft) )
			{
				hard=soft=1;
			}
			
			if( wcscasecmp( argv[woptind], L"unlimited" )==0)
			{
				new_limit = RLIM_INFINITY;
			}
			else if( wcscasecmp( argv[woptind], L"hard" )==0)
			{
				new_limit = get( what, 1 );
			}
			else if( wcscasecmp( argv[woptind], L"soft" )==0)
			{
				new_limit = get( what, soft );
			}
			else
			{
				errno=0;				
				new_limit = wcstol( argv[woptind], &end, 10 );
				if( errno || *end )
				{
					append_format(stderr_buffer, 
							   L"%ls: Invalid limit '%ls'\n", 
							   argv[0], 
							   argv[woptind] );
					builtin_print_help( parser, argv[0], stderr_buffer );
					return 1;
				}
				new_limit *= get_multiplier( what );
			}
			
			return set( what, hard, soft, new_limit );
		}
		
		default:
		{
            stderr_buffer.append(argv[0]);
            stderr_buffer.append(L": Too many arguments\n");
			builtin_print_help( parser, argv[0], stderr_buffer );
			return 1;
		}
		
	}
	return 0;	
}