/*
 *  jail.c - Ruby jparallel
 *
 *  vim: set nosta noet ts=4 sw=4:
 *
 *  $Id$
 *  
 *  Authors:
 *	* Michael Granger <ged@FaerieMUD.org>
 *	* Mahlon E. Smith <mahlon@martini.nu>
 *  
 *  Copyright (c) 2008, Michael Granger and Mahlon E. Smith
 *  All rights reserved.
 *  
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  
 *	* Redistributions of source code must retain the above copyright notice,
 *	  this list of conditions and the following disclaimer.
 *  
 *	* Redistributions in binary form must reproduce the above copyright notice,
 *	  this list of conditions and the following disclaimer in the documentation
 *	  and/or other materials provided with the distribution.
 *  
 *	* Neither the name of the author/s, nor the names of the project's
 *	  contributors may be used to endorse or promote products derived from this
 *	  software without specific prior written permission.
 *  
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 *  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 *  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *  
 */


#include "jail.h"

VALUE rbjail_mBSD;
VALUE rbjail_cBSDJail;
VALUE rbjail_cIPAddr;


/*
 *  Debug logging function
 */
void
#ifdef HAVE_STDARG_PROTOTYPES
rbjail_debug(const char *fmt, ...)
#else
rbjail_debug( const char *fmt, va_dcl )
#endif
{
	char buf[BUFSIZ], buf2[BUFSIZ];
	va_list args;

	if ( !RTEST(ruby_debug) ) return;

	snprintf( buf, BUFSIZ, "Debug>>> %s", fmt );

	va_init_list( args, fmt );
	vsnprintf( buf2, BUFSIZ, buf, args );
	fputs( buf2, stderr );
	fputs( "\n", stderr );
	fflush( stderr );
	va_end( args );
}


/*
 * Object validity checker. Returns the data pointer.
 */
static struct xprison *
rbjail_check_jail( VALUE self ) {
	debugMsg(( "Checking a BSD::Jail object (%d).", self ));
	Check_Type( self, T_DATA );

	if ( !rb_obj_is_kind_of(self, rbjail_cBSDJail) ) {
		rb_raise( rb_eTypeError, "wrong argument type %s (expected BSD::Jail)",
			rb_class2name(CLASS_OF( self )) );
	}

	return DATA_PTR( self );
}


/*
 * Fetch the data pointer and check it for sanity.
 */
static struct xprison *
rbjail_get_jailptr( VALUE self ) {
	struct xprison *ptr = rbjail_check_jail( self );

	debugMsg(( "Fetching a Jail (%p).", ptr ));
	if ( !ptr )
		rb_raise( rb_eRuntimeError, "uninitialized Jail" );

	return ptr;
}


/*
 * Copy memory from the given 'xp' to a ruby managed object.
 */
static VALUE
rbjail_alloc( VALUE class, struct xprison *xp )
{
	struct xprison *rbjail_xp = ALLOC( struct xprison );
	VALUE rbjail = rb_funcall( class, rb_intern("allocate"), 0 );

	// replace the null pointer obj with an xprison ptr.
	//
	memcpy( rbjail_xp, xp, sizeof( struct xprison ) );
	DATA_PTR( rbjail ) = rbjail_xp;

	return rbjail;
}


/*
 *
 */
static VALUE
rbjail_get_ip( VALUE self )
{
	struct xprison *xp = rbjail_get_jailptr( self );
	struct in_addr in;
	char *ip;

	in.s_addr = ntohl( xp->pr_ip );
	ip = inet_ntoa(in);

	return rb_funcall( rbjail_cIPAddr, rb_intern("new"), 1, rb_str_new2(ip) );
}


/*
 *
 */
static VALUE
rbjail_get_jid( VALUE self )
{
	struct xprison *xp = rbjail_get_jailptr( self );
	return INT2FIX( xp->pr_id );
}


/*
 *
 */
static VALUE
rbjail_get_host( VALUE self )
{
	struct xprison *xp = rbjail_get_jailptr( self );
	return rb_str_new2( xp->pr_host );
}


/*
 *
 */
static VALUE
rbjail_get_path( VALUE self )
{
	struct xprison *xp = rbjail_get_jailptr( self );
	return rb_str_new2( xp->pr_path );
}


/*
 * GC Free function
 */
static void
rbjail_gc_free( struct xprison *ptr ) {
	if ( ptr ) {
		xfree( ptr );
	}

	else {
		debugMsg(( "Not freeing an uninitialized jail" ));
	}
}


/*
 * Allocate a new ruby object with a NULL pointer.
 */
static VALUE
rbjail_s_alloc( VALUE class )
{
	return Data_Wrap_Struct( class, NULL, rbjail_gc_free, NULL );
}


/*
 * Create a new jail object.
 * Returns the +id+ of the newly created jail.
 */
static VALUE
rbjail_jail( int argc, VALUE *argv, VALUE self ) {
	struct jail j;
	struct in_addr in;
	VALUE ip, path, host, securelevel;
	int id;

	rb_scan_args( argc, argv, "31", &ip, &path, &host, &securelevel );

	if ( inet_aton( RSTRING_PTR( rb_obj_as_string(ip) ), &in ) == 0 )
		rb_raise( rb_eArgError, "Could not make sense of ip number: %s", ip );

	SafeStringValue(path);
	SafeStringValue(host);

	j.version   = 0;
	j.path	    = RSTRING_PTR( path );
	j.hostname  = RSTRING_PTR( host );
	j.ip_number = ntohl( in.s_addr );
	id = jail(&j);

	if ( id == -1 ) rb_sys_fail( "jail" );
	if ( chdir("/") == -1 ) rb_sys_fail( "chdir" );

	debugMsg(( "New jail created with id: %d\n", id ));
	return INT2FIX( id );
}


/*
 * Iterate over the currently instantiated jails, returning a jail
 * object that matches the given string/ip/JID -- or nil if none do. 
 * Without an argument, return an array of all JIDs. 
 */ 
static VALUE
rbjail_find( int argc, VALUE *argv, VALUE self )
{ 
	struct xprison *sxp, *xp;
	struct in_addr in;
	size_t i, len;

	VALUE arg, rbjail;
	VALUE jails = rb_ary_new();
	int jid = 0, compare = 0;
	char *str = "";

	rb_scan_args( argc, argv, "01", &arg );

	// An argument was passed, so let's figure out what it was
	// and try to compare it to the current jails.
	//
	if ( argc == 1 ) {
		switch ( TYPE(arg) ) {

			// find by JID
			//
			case T_FIXNUM:
				jid = FIX2INT( arg );
				break;

				// find by IP/hostname
				//
			case T_OBJECT:
			case T_DATA:
			case T_STRING:
				str = RSTRING_PTR( rb_obj_as_string(arg) );
				compare = 1;
				break;

			default:
				rb_raise( rb_eTypeError, "invalid argument to find(): %s",
						RSTRING_PTR(rb_inspect(arg)) );
		}
	}

	// Get the size of the xprison and allocate memory to it.
	//
	if ( sysctlbyname("security.jail.list", NULL, &len, NULL, 0) == -1 )
		rb_sys_fail("sysctlbyname(): security.jail.list");
	if ( len <= 0 ) {
		rb_sys_fail("sysctlbyname(): unable to determine xprison size");
		return Qnil;
	}

	sxp = xp = malloc( len );
	if ( sxp == NULL ) {
		rb_sys_fail("sysctlbyname(): unable to allocate memory");
		return Qnil;
	}

	// Get and sanity check the current prison list
	//
	if ( sysctlbyname("security.jail.list", xp, &len, NULL, 0) == -1 ) {
		if ( errno == ENOMEM ) free( sxp );
		rb_sys_fail("sysctlbyname(): out of memory");
		return Qnil;
	}
	if ( len < sizeof(*xp) || len % sizeof(*xp) || xp->pr_version != XPRISON_VERSION )
		rb_fatal("Kernel and userland out of sync");

	// No arguments to find() -- return an array of all JIDs
	//
	if ( argc == 0 ) {
		for ( i = 0; i < len / sizeof(*xp); i++ ) {
			rb_ary_push( jails, rbjail_alloc( self, xp ) );
			xp++;
		}

		free( sxp );
		return jails;
	}

	// Argument passed to find(): walk the jail list, comparing the arg
	// with each current jail.  Return first match.
	//
	for ( i = 0; i < len / sizeof(*xp); i++ ) {
		in.s_addr = ntohl(xp->pr_ip);
		if (( compare == 0 && xp->pr_id == jid ) ||
				( compare == 1 &&
				  (( strcmp( str, inet_ntoa(in) ) == 0 ) ||
				   (  strcmp( str, xp->pr_host )  == 0 ))
				)) {

			debugMsg(( "Located jail: %d", xp->pr_id ));
			rbjail = rbjail_alloc( self, xp );

			free( sxp );
			return rbjail;
		}
		else {

			xp++;
		}
	}

	free( sxp );
	return Qnil;
}


static void
rbjail_do_jail_attach( int jid )
{
	if ( jail_attach(jid) == -1 )
		rb_sys_fail( "jail_attach" );
}


/* Mostly ripped off from Ruby's process.c */
static VALUE
rbjail_attach_block( int jid )
{
	int pid;

	rb_secure(2);

	fflush(stdout);
	fflush(stderr);

	switch ( pid = fork() ) {
		case 0:
			rb_thread_atfork();
			if ( rb_block_given_p() ) {
				int status;

				rbjail_do_jail_attach( jid );
				rb_protect( rb_yield, Qundef, &status );
				ruby_stop( status );
			}
			return Qnil;

		case -1:
			rb_sys_fail( "fork(2)" );
			return Qnil;

		default:
			return INT2FIX( pid );
	}
}

static VALUE
rbjail_attach( int argc, VALUE *argv, VALUE self )
{
	VALUE jidnum, rval;
	int jid;

	rb_scan_args( argc, argv, "1", &jidnum );
	jid = NUM2INT( jidnum );

	if ( rb_block_given_p() ) {
		rval = rbjail_attach_block( jid );
	}

	else {
		rbjail_do_jail_attach( jid );
		rval = Qtrue;
	}

	return rval;
}


/*
 * Ruby initializer.
 */
void
Init_jail( void )
{
	rbjail_mBSD	= rb_define_module( "BSD" );
	rbjail_cBSDJail = rb_define_class_under( rbjail_mBSD, "Jail", rb_cObject );

	rb_require("ipaddr");
	rbjail_cIPAddr = rb_const_get( rb_cObject, rb_intern("IPAddr") );

	rb_define_alloc_func( rbjail_cBSDJail, rbjail_s_alloc );

	// Make the 'new' method private.
	rb_funcall( rbjail_cBSDJail, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")) );

	// main utility functions
	//
	rb_define_singleton_method( rbjail_cBSDJail, "jail", rbjail_jail, -1 );
	rb_define_singleton_method( rbjail_cBSDJail, "find", rbjail_find, -1 );
	rb_define_method( rbjail_cBSDJail, "attach", rbjail_attach, -1 );
	//	rb_define_alias( rbjail_cBSDJail, "list", "find" );
	
	// accessor functions
	//
	rb_define_method( rbjail_cBSDJail, "jid",  rbjail_get_jid,  0 );
	rb_define_method( rbjail_cBSDJail, "ip",   rbjail_get_ip,   0 );
	rb_define_method( rbjail_cBSDJail, "host", rbjail_get_host, 0 );
	rb_define_method( rbjail_cBSDJail, "path", rbjail_get_path, 0 );
}