/*

 *  dict.c - Ruby LinkParser - Dict Class

 *  $Id$

 *  

 *  Authors:

 *    * Michael Granger <ged@FaerieMUD.org>

 *  

 *  Copyright (c) 2006 The FaerieMUD Consortium.

 *  

 *  This work is licensed under the Creative Commons Attribution License. To

 *  view a copy of this license, visit

 *  http://creativecommons.org/licenses/by/1.0 or send a letter to Creative

 *  Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

 *  

 */

#include <ruby.h>

#include <intern.h>

#include <stdio.h>

#include <sys/param.h>

#include <sys/jail.h>

#include <sys/types.h>

#include <unistd.h>

VALUE rbjail_mBSD;

VALUE rbjail_cBSDJail;

/*

 *  Debug logging function

 */

void

#ifdef HAVE_STDARG_PROTOTYPES

rlink_debug(const char *fmt, ...)

#else

rlink_debug( const char *fmt, va_dcl )

#endif

{

	char buf[BUFSIZ], buf2[BUFSIZ];

	va_list	args;

	if ( !RTEST(ruby_debug) ) return;

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

	va_init_list( args, fmt );

	vsnprintf( buf2, BUFSIZ, buf, args );

	fputs( buf2, stderr );

	fputs( "\n", stderr );

	fflush( stderr );

	va_end( args );

}

/*

struct jail {

	u_int32_t       version;

	char            *path;

	char            *hostname;

	u_int32_t       ip_number;

};

*/

/*

 * Allocation function

 */

static jail *

rbjail_jail_alloc() {

	jail *ptr = ALLOC( jail );

	ptr->version	= 0;

	ptr->path		= NULL;

	ptr->hostname	= NULL;

	ptr->ip_number	= 0;

	debugMsg(( "Initialized a jail pointer <%p>", ptr ));

	return ptr;

}

/*

 * GC Free function

 */

static void

rbjail_gc_free( jail *ptr ) {

	if ( ptr ) {

		if ( ptr->path ) xfree( ptr->path );

		if ( ptr->hostname ) xfree( ptr->hostname );

		ptr->path		= NULL;

		ptr->hostname	= NULL;

		xfree( ptr );

	}

	else {

		debugMsg(( "Not freeing an uninitialized jail" ));

	}

}

/*

 * Object validity checker. Returns the data pointer.

 */

static jail *

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 jail *

rbjail_get_jail( VALUE self ) {

	jail *ptr = check_sentence( self );

	debugMsg(( "Fetching a Jail (%p).", ptr ));

	if ( !ptr )

		rb_raise( rb_eRuntimeError, "uninitialized Sentence" );

	return ptr;

}

/* --------------------------------------------------------------

 * Jail utility functions

 * -------------------------------------------------------------- */

/*

 * Try to jail_attach() to the specified +jid+, raising an exception if it fails.

 */

static void

rbjail_do_jail_attach( int jid )

{

	if ( jail_attach(jid) == -1 )

		rb_sys_fail( "jail_attach" );

}

/* 

 * Fork + Block function for rbjail_attach(). Mostly stolen 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 );

	}

}

/* --------------------------------------------------------------

 * Class methods

 * -------------------------------------------------------------- */

/*

 *  call-seq:

 *     BSD::Jail.allocate   -> bsdjail

 *

 *  Allocate a new BSD::Jail object.

 *

 */

static VALUE

rbjail_jail_s_allocate( VALUE klass ) {

	return Data_Wrap_Struct( klass, 0, rbjail_gc_free, 0 );

}

/*

 *  call-seq:

 *     BSD::Jail.list   -> array

 *

 *  Return an Array of all the running jails on the host.

 *

 */

static VALUE

rbjail_jail_s_list( VALUE klass ) {

	VALUE rval = rb_ary_new();

	struct xprison *xp;

	struct in_addr in;

	size_t i, len;

	if ( sysctlbyname("jail.list", NULL, &len, NULL, 0) == -1 )

		rb_sys_fail( "sysctlbyname(): jail.list" );

	xp = ALLOCA_N( xprison, 1 );

	if ( sysctlbyname("jail.list", xp, &len, NULL, 0) == -1 ) {

		rb_sys_fail( "sysctlbyname(): jail.list" );

	}

	if ( len < sizeof(*xp) || len % sizeof(*xp) ||

		xp->pr_version != KINFO_PRISON_VERSION )

		rb_fatal( "Kernel and userland out of sync" );

	len /= sizeof( *xp );

	for ( i = 0; i < len; i++ ) {

		VALUE jail, args[3];

		/* Hostname */

		args[0] = rb_str_new2( xp->pr_host );

		/* IP */

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

		args[1] = rb_str_new2( inet_ntoa(in) );

		/* Path */

		args[2] = rb_str_new2( xp->pr_path );

		jail = rb_class_new_instance( 3, args, klass );

		rb_ary_push( rval, jail );

		xp++;

	}

	return rval;

}

/* --------------------------------------------------------------

 * Instance methods

 * -------------------------------------------------------------- */

/*

 *  call-seq:

 *     BSD::Jail.new( hostname, ip, path )           -> new_jail

 *

 *  Create a new jail for the given +hostname+, +ip+, and +path+.

 */

static VALUE

rbjail_jail_initialize( VALUE self, VALUE hostname, VALUE ip, VALUE path ) {

	if ( !rbjail_check_jail(self) ) {

		struct jail *ptr = rbjail_jail_alloc();

		char *pathstr = NULL, *hostnamestr = NULL;

		Check_Type( hostname, T_STRING );

		Check_Type( ip, T_STRING );

		pathstr = ALLOC_N( char, RSTRING(path)->len );

		strncpy( pathstr, RSTRING(path)->ptr, RSTRING(path)->len );

		hostnamestr = ALLOC_N( char, RSTRING(hostname)->len );

		strncpy( hostnamestr, RSTRING(hostname)->ptr, RSTRING(hostname)->len );

		/*

		struct jail {

			u_int32_t       version;

			char            *path;

			char            *hostname;

			u_int32_t       ip_number;

		};

		*/

		ptr->version = 0;   /* Per the manpage's recommendation */

		ptr->ip_number = inet_addr( StringValuePtr(ip) );

		ptr->path = path;

		ptr->hostname = hostname;

	}

}

/*

 *  call-seq:

 *     jail.attach             -> true or false

 *     jail.attach { block }   -> pid

 *

 *  Attach to the given jail. In the non-block form, attach the current process to the

 *  jail and return +true+ if it succeeds. This is a one-way operation, and requires root

 *  privileges.

 *  

 *  In the block form, the process will be forked, and the block will be attached to the jail and 

 *  run by the child. The parent process will receive the process ID of the child.

 */

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;

}

/*

 * I can't remember how the hell you document a class, but that will go here.

 */

void

Init_bsdjail( void ) {

	rbjail_mBSD = rb_define_module( "BSD" );

	rbjail_cBSDJail = rb_define_class_under( rbjail_mBSD, "Jail" );

	/* Class methods */

	rb_define_alloc_function( rbjail_cBSDJail, rbjail_jail_s_allocate );

	rb_define_singleton_method( rbjail_cBSDJail, "jail", rbjail_jail_s_jail, 0 );

	rb_define_singleton_method( rbjail_cBSDJail, "list", rbjail_jail_s_list, 0 );

	/* Instance methods */

	rb_define_method( rbjail_cBSDJail, "initialize", rbjail_jail_initialize, 3 );

	rb_define_method( rbjail_cBSDJail, "attach", rbjail_jail_attach, -1 );

	rb_define_method( rbjail_cBSDJail, "hostname", rbjail_jail_hostname, 0 );

	rb_define_method( rbjail_cBSDJail, "path", rbjail_jail_path, 0 );

	rb_define_method( rbjail_cBSDJail, "ip", rbjail_jail_ip, 0 );

	rb_define_method( rbjail_cBSDJail, "jid", rbjail_jail_jid, 0 );

}