*  jail.c - Ruby jParallel

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

 * Utility functions

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

			rb_obj_classname( self ));

 * Attach to a running jail and chdir to the root.

 */

static int

rbjail_do_attach( int jid )

{

	int attach_status = jail_attach(jid);

	if ( attach_status == -1 )

		rb_sys_fail( "jail_attach" );

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

	return attach_status;

}

/*

 * Attach to a running jail from within a block, forking first

 * and returning the child pid.

 */

static VALUE

rbjail_attach_block( int jid )

{

	int pid;

	int status;

	if ( ! rb_block_given_p() ) return Qnil;

	rb_secure(2);

	fflush(stdout);

	fflush(stderr);

	switch ( pid = fork() ) {

		case 0:

			rb_thread_atfork();

			rbjail_do_attach( jid );

			rb_protect( rb_yield, Qundef, &status );

			rb_exit( status );

			return Qnil;

		case -1:

			rb_sys_fail( "fork(2)" );

			return Qnil;

		default:

			return INT2FIX( pid );

	}

}

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

 * Memory-management functions

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

/*

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

 * Class methods

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

 *  call-seq:

 *     BSD::Jail.new( ip, path, host )   => jail_id

 *

 *  Create a new BSD::Jail object from required +ip+, +path+, and +host+

 *  arguments.  You can optionally pass a +securelevel+ fourth argument.

 *

 *  Returns the +id+ of the newly created jail.

rbjail_jail( int argc, VALUE *argv, VALUE self )

{

	VALUE ip, path, host, sec_level;

	int securelevel = -1;

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

	if ( sec_level != Qnil ) securelevel = FIX2INT( sec_level );

	if ( securelevel > -1 && securelevel < 4 ) {

		debugMsg(( "Setting securelevel to: %d", securelevel ));

		if ( sysctlbyname("kern.securelevel", NULL, 0, &securelevel, sizeof(securelevel)) )

			rb_sys_fail( "securelevel" );

	}

 *  call-seq:

 *     BSD::Jail.find_by_jid( jid ) => BSD::Jail

 *

 *  Iterate over the currently instantiated jails, returning a jail

 *  object that matches the given +jid+, or nil if no jail is found.

 *

 */

static VALUE

rbjail_find_by_jid( VALUE self, VALUE jid )

{

	VALUE args[0];

	if ( TYPE(jid) != T_FIXNUM )

		rb_raise( rb_eTypeError, "invalid argument to find_by_jid(): %s",

			RSTRING_PTR( rb_inspect(jid)) );

	args[0] = jid;

	return rbjail_find( 1, args, self );

}

/*

 *  call-seq:

 *     BSD::Jail.search( id )                      => BSD::Jail

 *     BSD::Jail.search( hostname )                => [ BSD::Jail, ... ]

 *     BSD::Jail.search( IPAddr.new('127.0.0.1') ) => [ BSD::Jail, ... ]

 *     BSD::Jail.search( Pathname.new('/tmp') )    => [ BSD::Jail, ... ]

 *     BSD::Jail.search                            => [ BSD::Jail, BSD::Jail, ... ]

 *     BSD::Jail.search { |obj| block }            => obj

 *

 *  Iterate over the currently instantiated jails, returning a jail

 *  object that matches the given argument. 

 *

 *  If the argument is an integer, it is assumed to be a JID.

 *  Otherwise, it is converted to a string, and compared against

 *  IP addresses, hostnames, and paths.  JIDs are unique, so there is

 *  only one object that can match.  Only the matching object (or nil)

 *  is returned in that event.  IPs, hostnames, and paths can be

 *  shared between jails, so searching on those return an array populated

 *  with matched jail objects -- or if there are no valid matches, an empty array.

 *

 *  Without an argument, return an array of all jails as objects.

 *

 */

			// find by IP/hostname/path

			//

				rb_raise( rb_eTypeError, "invalid argument: %s",

						RSTRING_PTR( rb_inspect(arg)) );

	// No arguments to find() -- yield each successive jail,

	// and return an array of all jail objects.

			rbjail = rbjail_alloc( self, xp );

			if ( rb_block_given_p() ) rb_yield( rbjail );

	// with each current jail.  Return all matches.

				   ( strcmp( str, xp->pr_host )   == 0 ) ||

				   ( strcmp( str, xp->pr_path )   == 0 ))

			// If the user already knows the JID, there can only be

			// one match.  Return it immediately.

			//

			if ( compare == 0 ) {

				free( sxp );

				return rbjail_alloc( self, xp );

			}

			// If searching for anything other than JID, the argument

			// isn't unique.  Put matching jails into an array.

			//

			rb_ary_push( jails, rbjail_alloc( self, xp ) );

			xp++;

	if ( compare == 0 && rb_ary_shift( jails ) == Qnil )

		return Qnil;

	return jails;

/*

 *  call-seq:

 *     BSD::Jail.attach( id )       => true

 *     BSD::Jail.attach( hostname ) => true

 *

 *  Attach to a currently running jail instance directly.

 *  Operates under the same rules as BSD::Jail#search -- you may

 *  specify a jail by IP Address, hostname, or jid.

 *

 *  Please note that attaching your process into a jail is a one way

 *  operation that requires root privileges.  You must fork() if

 *  your process needs to continue in the host environment.

 *

 */

rbjail_class_attach( VALUE self, VALUE arg )

	int jid = 0;

	VALUE jails;

	VALUE find_args [0];

	switch ( TYPE(arg) ) {

		// The user knows the JID already, attach directly.

		//

		case T_FIXNUM:

			jid = FIX2INT( arg );

			rbjail_do_attach( jid );

			break;

		// Find the JID to attach to.  First match wins.

		//

		case T_OBJECT:

		case T_DATA:

		case T_STRING:

			find_args[0] = arg;

			jails = rbjail_find( 1, find_args, self );

			jid = FIX2INT( rbjail_get_jid( rb_ary_shift(jails) ));

			rbjail_do_attach( jid );

			break;

			rb_raise( rb_eTypeError, "invalid argument to attach(): %s",

						RSTRING_PTR( rb_inspect(arg)) );

	return Qtrue;

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

 * Instance methods

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

/*

 *  call-seq:

 *     BSD::Jail <=> BSD::Jail

 *

 *  Interface for Comparable.

 *

 */

rbjail_compare( VALUE self, VALUE other )

	debugMsg(("self id: %s, other id: %s",

				RSTRING_PTR(rb_inspect( self )),

				RSTRING_PTR(rb_inspect( other ))));

	return rb_funcall( 

		rbjail_get_jid( self ),

		rb_intern("<=>"),

		1,

		rbjail_get_jid( other )

	);

}

/*

 * Fetch the configured IP address for the jail.

 * Returns an IPAddr object.

 *

 */