/*

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

/*

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_jail_gc_free( ptr )

	jail *ptr;

{

	if ( ptr ) {

		ptr->path		= NULL;

		ptr->hostname	= NULL;

		xfree( ptr );

	}

	else {

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

	}

}

/*

 * Object validity checker. Returns the data pointer.

 */

static rlink_SENTENCE *

check_sentence( self )

	 VALUE	self;

{

	debugMsg(( "Checking a LinkParser::Sentence object (%d).", self ));

	Check_Type( self, T_DATA );

    if ( !IsSentence(self) ) {

		rb_raise( rb_eTypeError, "wrong argument type %s (expected LinkParser::Sentence)",

				  rb_class2name(CLASS_OF( self )) );

    }

	return DATA_PTR( self );

}

/*

 * Fetch the data pointer and check it for sanity.

 */

static rlink_SENTENCE *

get_sentence( self )

	 VALUE self;

{

	rlink_SENTENCE *ptr = check_sentence( self );

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

	if ( !ptr )

		rb_raise( rb_eRuntimeError, "uninitialized Sentence" );

	return ptr;

}

/*

 * Publicly-usable sentence-fetcher

 */

rlink_SENTENCE *

rlink_get_sentence( self )

	VALUE self;

{

	return get_sentence( self );

}

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;

}

static VALUE

	rbjail_list( VALUE self )

{

	struct kinfo_prison *sxp, *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( kinfo_prison, 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);

	printf("   JID  IP Address      Hostname                      Path\n");

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

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

		printf("%6d  %-15.15s %-29.29s %.74s\n",

			xp->pr_id, inet_ntoa(in), xp->pr_host, xp->pr_path);

		xp++;

	}

	free(sxp);

	exit(0);

}

void

Init_bsdjail( void )

{

	rbjail_mBSD = rb_define_module( "BSD" );

	rbjail_cBSDJail = rb_define_class_under( rbjail_mBSD, "Jail" );

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

	rb_define_alloc_function( rbjail_cBSDJail, )

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

}