prison 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 283161d70dc2f82c2e1408eaf7669d4bbd29fce3
+  data.tar.gz: 943c7451b3eeb0ffdc76698b903029a37e402a19
+SHA512:
+  metadata.gz: 5b186b38021ffef0348541f2f6285b31fb3f445f6f8779440d6c35bc66d63b5abc9f4d1bfb2550809153073a5d66c13a1c815aed29d0fa7f5c0b6084be83adb1
+  data.tar.gz: 71678b11330fbf2bb87059942e4650577feb3b91e2487215fd3a17a870309a1d9adb36705a9cbb28669e81b7bc518b0f61a4a978ff6df89242e61edaf0f9c4ae

data/.gitignore

@@ -0,0 +1,23 @@
+.build.sh
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in prison.gemspec
+gemspec
+gem "rake-compiler"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,33 @@
+# Prison
+
+FreeBSD jail wrapper.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'prison'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install prison
+
+## Usage
+
+prison list
+
+prison create
+
+prison config
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/prison/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "prison" do |ext|
+	ext.lib_dir = "lib/prison"
+end
+

data/bin/prison

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require "jail"
+require "prison/prison"
+require "pp"
+
+argv = ARGV.dup
+
+if argv.include?("-v") || argv.include?("--version")
+	require "prison/version"
+	puts "Prison #{Prison::VERSION}"
+end
+
+#if argv.include?("create")
+#
+#end
+
+if argv.include?("list")
+	prison = Prison.new
+	list = prison.list
+
+	list.each do |i|
+		puts "#{i.jp_name} : #{i.jp_value}"
+	end
+
+end

data/build.sh

@@ -0,0 +1 @@
+gem build prison.gemspec && gem uninstall prison && gem install ./prison-0.0.1.gem && rbenv rehash

data/ext/prison/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+$LDFLAGS += " -ljail"
+create_makefile('prison/prison')
+$CFLAGS = " -g "

data/ext/prison/prison.c

@@ -0,0 +1,338 @@
+#include "prison.h"
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+#include <arpa/inet.h>
+#include <sys/jail.h>
+
+#include <err.h>
+#include <errno.h>
+
+#include <sys/sysctl.h>
+#include <limits.h>
+
+#define	JP_USER		0x01000000
+#define	JP_OPT		0x02000000
+
+#define PRINT_DEFAULT 0x01
+#define PRINT_HEADER  0x02
+#define PRINT_NAMEVAL 0x04
+#define PRINT_QUOTED  0x08
+#define PRINT_SKIP  0x10
+#define PRINT_VERBOSE 0x20
+#define PRINT_JAIL_NAME 0x40
+
+static struct jailparam *params;
+static int *param_parent;
+static int nparams;
+static int add_param(const char *name, void *value, size_t valuelen,
+		struct jailparam *source, unsigned flags);
+static int sort_param(const void *a, const void *b);
+static int print_jail(int pflags, int jflags, VALUE *rb_jailparams);
+static void quoted_print(char *str);
+
+VALUE cPrison;
+
+VALUE list_func(VALUE self);
+
+VALUE list_func(VALUE self){
+
+	int i, jflags, jid, lastjid, pflags;
+
+	char *dot, *ep, *jname;
+	i = pflags = jflags = jid = 0;
+
+	pflags = (pflags & ~(PRINT_HEADER | PRINT_VERBOSE)) |
+		PRINT_NAMEVAL | PRINT_QUOTED | PRINT_SKIP;
+
+#ifdef INET6
+	ip6_ok = feature_present("inet6");
+#endif
+#ifdef INET
+	ip4_ok = feature_present("inet");
+#endif
+
+	/* Add the parameters to print. */
+	if (pflags & (PRINT_HEADER | PRINT_NAMEVAL))
+		add_param("all", NULL, (size_t)0, NULL, JP_USER);
+	else if (pflags & PRINT_VERBOSE) {
+		add_param("jid", NULL, (size_t)0, NULL, JP_USER);
+		add_param("host.hostname", NULL, (size_t)0, NULL,
+				JP_USER);
+		add_param("path", NULL, (size_t)0, NULL, JP_USER);
+		add_param("name", NULL, (size_t)0, NULL, JP_USER);
+		add_param("dying", NULL, (size_t)0, NULL, JP_USER);
+		add_param("cpuset.id", NULL, (size_t)0, NULL, JP_USER);
+#ifdef INET
+		if (ip4_ok)
+			add_param("ip4.addr", NULL, (size_t)0, NULL,
+					JP_USER);
+#endif
+#ifdef INET6
+		if (ip6_ok)
+			add_param("ip6.addr", NULL, (size_t)0, NULL,
+					JP_USER | JP_OPT);
+#endif
+	} else {
+		pflags |= PRINT_DEFAULT;
+		if (pflags & PRINT_JAIL_NAME)
+			add_param("name", NULL, (size_t)0, NULL, JP_USER);
+		else
+			add_param("jid", NULL, (size_t)0, NULL, JP_USER);
+#ifdef INET
+		if (ip4_ok)
+			add_param("ip4.addr", NULL, (size_t)0, NULL,
+					JP_USER);
+#endif
+		add_param("host.hostname", NULL, (size_t)0, NULL,
+				JP_USER);
+		add_param("path", NULL, (size_t)0, NULL, JP_USER);
+	}
+
+	if (pflags & PRINT_SKIP) {
+		/* Check for parameters with jailsys parents. */
+		for (i = 0; i < nparams; i++) {
+			if ((params[i].jp_flags & JP_USER) &&
+					(dot = strchr(params[i].jp_name, '.'))) {
+				*dot = 0;
+				param_parent[i] = add_param(params[i].jp_name,
+						NULL, (size_t)0, NULL, JP_OPT);
+				*dot = '.';
+			}
+		}
+	}
+
+	/* Add the index key parameters. */
+	if (jid != 0)
+		add_param("jid", &jid, sizeof(jid), NULL, 0);
+	else if (jname != NULL)
+		add_param("name", jname, strlen(jname), NULL, 0);
+	else
+		add_param("lastjid", &lastjid, sizeof(lastjid), NULL, 0);
+
+
+	VALUE rb_jailparams = rb_ary_new();
+	for (lastjid = 0; (lastjid = print_jail(pflags, jflags, &rb_jailparams)) >= 0; );
+
+	return rb_jailparams;
+}
+
+void Init_prison(){
+	cPrison = rb_define_class("Prison", rb_cObject);
+	rb_define_method(cPrison, "list", RUBY_METHOD_FUNC(list_func),0);
+}
+
+
+static int
+add_param(const char *name, void *value, size_t valuelen,
+		struct jailparam *source, unsigned flags)
+{
+	struct jailparam *param, *tparams;
+	int i, tnparams;
+
+	static int paramlistsize;
+
+	/* The pseudo-parameter "all" scans the list of available parameters. */
+	if (!strcmp(name, "all")) {
+		tnparams = jailparam_all(&tparams);
+		if (tnparams < 0)
+			errx(1, "%s", jail_errmsg);
+		qsort(tparams, (size_t)tnparams, sizeof(struct jailparam),
+				sort_param);
+		for (i = 0; i < tnparams; i++)
+			add_param(tparams[i].jp_name, NULL, (size_t)0,
+					tparams + i, flags);
+		free(tparams);
+		return -1;
+	}
+
+	/* Check for repeat parameters. */
+	for (i = 0; i < nparams; i++)
+		if (!strcmp(name, params[i].jp_name)) {
+			if (value != NULL && jailparam_import_raw(params + i,
+						value, valuelen) < 0)
+				errx(1, "%s", jail_errmsg);
+			params[i].jp_flags |= flags;
+			if (source != NULL)
+				jailparam_free(source, 1);
+			return i;
+		}
+
+	/* Make sure there is room for the new param record. */
+	if (!nparams) {
+		paramlistsize = 32;
+		params = malloc(paramlistsize * sizeof(*params));
+		param_parent = malloc(paramlistsize * sizeof(*param_parent));
+		if (params == NULL || param_parent == NULL)
+			err(1, "malloc");
+	} else if (nparams >= paramlistsize) {
+		paramlistsize *= 2;
+		params = realloc(params, paramlistsize * sizeof(*params));
+		param_parent = realloc(param_parent,
+				paramlistsize * sizeof(*param_parent));
+		if (params == NULL || param_parent == NULL)
+			err(1, "realloc");
+	}
+
+	/* Look up the parameter. */
+	param_parent[nparams] = -1;
+	param = params + nparams++;
+	if (source != NULL) {
+		*param = *source;
+		param->jp_flags |= flags;
+		return param - params;
+	}
+	if (jailparam_init(param, name) < 0)
+		errx(1, "%s", jail_errmsg);
+	param->jp_flags = flags;
+	if ((value != NULL ? jailparam_import_raw(param, value, valuelen)
+				: jailparam_import(param, value)) < 0) {
+		if (flags & JP_OPT) {
+			nparams--;
+			return (-1);
+		}
+		errx(1, "%s", jail_errmsg);
+	}
+	return param - params;
+}
+
+
+static int
+sort_param(const void *a, const void *b)
+{
+	const struct jailparam *parama, *paramb;
+	char *ap, *bp;
+
+	/* Put top-level parameters first. */
+	parama = a;
+	paramb = b;
+	ap = strchr(parama->jp_name, '.');
+	bp = strchr(paramb->jp_name, '.');
+	if (ap && !bp)
+		return (1);
+	if (bp && !ap)
+		return (-1);
+	return (strcmp(parama->jp_name, paramb->jp_name));
+}
+
+
+static int
+print_jail(int pflags, int jflags, VALUE *rb_jailparams)
+{
+	char *nname;
+	char **param_values;
+	int i, ai, jid, count, n, spc;
+	char ipbuf[INET6_ADDRSTRLEN];
+
+	jid = jailparam_get(params, nparams, jflags);
+
+	if (jid < 0)
+		return jid;
+	else {
+
+		ID class_id = rb_intern("Jailparam");
+		VALUE class = rb_const_get(rb_cObject, class_id);
+		VALUE name;
+		VALUE val;
+
+		param_values = alloca(nparams * sizeof(*param_values));
+		for (i = 0; i < nparams; i++) {
+			if (!(params[i].jp_flags & JP_USER))
+				continue;
+			param_values[i] = jailparam_export(params + i);
+			if (param_values[i] == NULL)
+				errx(1, "%s", jail_errmsg);
+		}
+		for (i = spc = 0; i < nparams; i++) {
+			if (!(params[i].jp_flags & JP_USER))
+				continue;
+			if ((pflags & PRINT_SKIP) &&
+					((!(params[i].jp_ctltype &
+							(CTLFLAG_WR | CTLFLAG_TUN))) ||
+					 (param_parent[i] >= 0 &&
+						*(int *)params[param_parent[i]].jp_value !=
+						JAIL_SYS_NEW)))
+				continue;
+			if (spc)
+				putchar(' ');
+			else
+				spc = 1;
+			if (pflags & PRINT_NAMEVAL) {
+				/*
+				 * * Generally "name=value", but for booleans
+				 * * either "name" or "noname".
+				 * */
+				if (params[i].jp_flags &
+						(JP_BOOL | JP_NOBOOL)) {
+					if (*(int *)params[i].jp_value){
+						name = rb_str_new2(params[i].jp_name);
+						printf("%s", params[i].jp_name);
+					} else {
+						nname = (params[i].jp_flags &
+								JP_NOBOOL) ?
+							nononame(params[i].jp_name)
+							: noname(params[i].jp_name);
+						name = rb_str_new2(nname);
+						printf("%s", nname);
+						free(nname);
+					}
+
+					continue;
+				}
+				name = rb_str_new2(params[i].jp_name);
+				printf("%s=", params[i].jp_name);
+			}
+			if (params[i].jp_valuelen == 0) {
+				if (pflags & PRINT_QUOTED)
+					printf("\"\"");
+				else if (!(pflags & PRINT_NAMEVAL))
+					printf('-');
+			} else {
+				val = rb_str_new2(param_values[i]);
+				quoted_print(param_values[i]);
+			}
+		  VALUE argv[] = {name, val};
+			int argc = sizeof argv / sizeof argv[0];
+			VALUE new_jp = rb_class_new_instance(argc, argv, class);
+			rb_ary_push(*rb_jailparams, new_jp);
+		}
+		putchar('\n');
+		for (i = 0; i < nparams; i++)
+			if (params[i].jp_flags & JP_USER)
+				free(param_values[i]);
+	}
+
+	return (jid);
+}
+
+
+static void
+quoted_print(char *str)
+{
+	int c, qc;
+	char *p = str;
+
+	/* An empty string needs quoting. */
+	if (!*p) {
+		fputs("\"\"", stdout);
+		return;
+	}
+
+	/*
+	 * * The value will be surrounded by quotes if it contains spaces
+	 * * or quotes.
+	 * */
+	qc = strchr(p, '\'') ? '"'
+		: strchr(p, '"') ? '\''
+		: strchr(p, ' ') || strchr(p, '\t') ? '"'
+		: 0;
+	if (qc)
+		putchar(qc);
+	while ((c = *p++)) {
+		if (c == '\\' || c == qc)
+			putchar('\\');
+		putchar(c);
+	}
+	if (qc)
+		putchar(qc);
+}
+

data/ext/prison/prison.h

@@ -0,0 +1,6 @@
+#include <stdio.h>
+#include <ruby.h>
+#include <sys/param.h>
+#include <sys/jail.h>
+#include <jail.h>
+#include <sys/uio.h>

data/lib/jail.rb

@@ -0,0 +1,14 @@
+#require "prison/version"
+
+class Jailparam
+	attr_accessor :jp_name, :jp_value
+
+	def initialize(jp_name, jp_value)
+		@jp_name, @jp_value = jp_name, jp_value
+	end
+
+	def to_s
+		"#{jp_name} = #{jp_value}"
+	end
+
+end

data/lib/prison/version.rb

@@ -0,0 +1,3 @@
+module Prison
+  VERSION = "0.0.2"
+end

data/prison.gemspec

@@ -0,0 +1,59 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'prison/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "prison"
+  spec.version       = Prison::VERSION
+  spec.authors       = ["kazuhide maeda"]
+  spec.email         = ["kzhd15med3pub@gmail.com"]
+  spec.summary       = %q{FreeBSD jail wrapper.}
+  spec.description   = %q{The easiest way to management FreeBSD jail.}
+  spec.homepage      = "https://github.com/kzhd15med3gh/prison"
+  spec.license       = "MIT"
+  spec.extensions    = %w[ext/prison/extconf.rb]
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  # spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = %w(prison)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  #added to realize that prison can use on the shell.
+
+  root_path      = File.dirname(__FILE__)
+  all_files      = Dir.chdir(root_path) { Dir.glob("**/{*,.*}") }
+  all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
+  all_files.reject! { |file| file.start_with?("website/") }
+  gitignore_path = File.join(root_path, ".gitignore")
+  gitignore      = File.readlines(gitignore_path)
+  gitignore.map!    { |line| line.chomp.strip }
+  gitignore.reject! { |line| line.empty? || line =~ /^(#|!)/ }
+
+  unignored_files = all_files.reject do |file|
+    # Ignore any directories, the gemspec only cares about files
+    next true if File.directory?(file)
+
+    # Ignore any paths that match anything in the gitignore. We do
+    # two tests here:
+    #
+    #   - First, test to see if the entire path matches the gitignore.
+    #   - Second, match if the basename does, this makes it so that things
+    #     like '.DS_Store' will match sub-directories too (same behavior
+    #     as git).
+    #
+    gitignore.any? do |ignore|
+      File.fnmatch(ignore, file, File::FNM_PATHNAME) ||
+        File.fnmatch(ignore, File.basename(file), File::FNM_PATHNAME)
+    end
+  end
+
+
+  spec.files         = unignored_files
+  # spec.executables   = unignored_files.map { |f| f[/^bin\/(.*)/, 1] }.compact
+  spec.require_path  = 'lib'
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: prison
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- kazuhide maeda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: The easiest way to management FreeBSD jail.
+email:
+- kzhd15med3pub@gmail.com
+executables:
+- prison
+extensions:
+- ext/prison/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/prison
+- build.sh
+- ext/prison/extconf.rb
+- ext/prison/prison.c
+- ext/prison/prison.h
+- lib/jail.rb
+- lib/prison/version.rb
+- prison.gemspec
+homepage: https://github.com/kzhd15med3gh/prison
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: FreeBSD jail wrapper.
+test_files: []