Add Devfs_ruleset property to reflect generated RS

README.md

@@ -4,8 +4,9 @@ GoCage
 Jail management tool for FreeBSD, written in Go.  
 Support iocage jails, so they can coexist.  
 Gocage is meant to be a complete jail management tool with network, snapshots, jail cloning support and a web interface. This is the hypothetic future.  
+Gocage can handle multiple datastores, so you can have jails on HDD storage and jails on SSD storage.  
+
 
-At present time, it list and stops jails.  
 
 List jails
 ----------
@@ -80,7 +81,110 @@ gocage list -f Config.Boot=1,Running=true -o JID,Name,Running,Config.Boot
 +-----+----------+---------+-------------+
 </pre></code>
 
+Sort jails  
+----------
+Use -s switch followed by sort criteria. Criteria is a field name, prefixed with + or - for sort order (increase/decrease):  
+<pre><code>
+gocage list -f Config.Boot=1,Running=true -o JID,Name,Running,Config.Boot -s +JID
++=====+==========+=========+=============+
+| JID | Name     | Running | Config.Boot |
++=====+==========+=========+=============+
+| 22  | srv-dns1 | true    | 1           |
++-----+----------+---------+-------------+
+| 29  | bdd-tst  | true    | 1           |
++-----+----------+---------+-------------+
+| 183 | test     | true    | 1           |
++-----+----------+---------+-------------+
+</pre></code>
+
+You can use up to 3 criteria, delimited with comma.  
+As an example, you want to list boot priorities of automatically starting jails:  
+<pre><code>
+gocage list -o JID,Name,Config.Ip4_addr,Config.Priority,Config.Boot,Running -s -Config.Priority,-Config.Boot -f Running=true
++=====+==============+=======================+=================+=============+=========+
+| JID | Name         | Config.Ip4_addr       | Config.Priority | Config.Boot | Running |
++=====+==============+=======================+=================+=============+=========+
+| 1   | srv-dhcp     | vnet0|192.168.1.2/24  | 99              | 1           | true    |
++-----+--------------+-----------------------+-----------------+-------------+---------+
+| 8   | srv-dns      | vnet0|192.168.1.1/24  | 80              | 1           | true    |
++-----+--------------+-----------------------+-----------------+-------------+---------+
+| 7   | srv-random   | vnet0|192.168.1.12/24 | 20              | 1           | true    |
++-----+--------------+-----------------------+-----------------+-------------+---------+
+| 4   | coincoin     | vnet0|192.168.1.9/24  | 20              | 0           | true    |
++-----+--------------+-----------------------+-----------------+-------------+---------+
+</pre></code>
+
+
 Stop jails
 ----------
 `gocage stop test`
 
+
+Multi datastore  
+----------
+A datastore is a ZFS dataset mounted. It should be declared in gocage.conf.yml, specifying its ZFS mountpoint :
+<pre><code>
+datastore:
+  - /iocage
+  - /fastiocage
+</pre></code>
+
+In gocage commands, datastore name is the mountpoint without its "/" prefix.  
+
+### List datastores
+<pre><code>
+gocage datastore list 
++============+=============+============+===========+==========+============+
+| Name       | Mountpoint  | ZFSDataset | Available | Used     | Referenced |
++============+=============+============+===========+==========+============+
+| iocage     | /iocage     | hdd/iocage | 1.6 TB    | 414.9 GB | 27.5 KB    |
++------------+-------------+------------+-----------+----------+------------+
+| fastiocage | /fastiocage | ssd/iocage | 1.5 TB    | 65.3 KB  | 34.6 KB    |
++------------+-------------+------------+-----------+----------+------------+
+</pre></code>
+
+### Filter datastores  
+As with jails and snapshots, you can filter by name:  
+<pre><code>
+gocage datastore list iocage
++============+=============+============+===========+==========+============+
+| Name       | Mountpoint  | ZFSDataset | Available | Used     | Referenced |
++============+=============+============+===========+==========+============+
+| iocage     | /iocage     | hdd/iocage | 1.6 TB    | 414.9 GB | 27.5 KB    |
++------------+-------------+------------+-----------+----------+------------+
+</pre></code>
+
+### Sort datastores  
+You can sort datastores:  
+<pre><code>
+gocage datastore list -s -Available
++============+=============+============+===========+==========+============+
+| Name       | Mountpoint  | ZFSDataset | Available | Used     | Referenced |
++============+=============+============+===========+==========+============+
+| iocage     | /iocage     | hdd/iocage | 1.6 TB    | 415.0 GB | 27.5 KB    |
++------------+-------------+------------+-----------+----------+------------+
+| fastiocage | /fastiocage | ssd/iocage | 1.5 TB    | 65.3 KB  | 34.6 KB    |
++------------+-------------+------------+-----------+----------+------------+
+</pre></code>
+
+See [cmd/struct.go](https://git.nosd.in/yo/gocage/src/branch/master/cmd/struct.go) for field names.
+
+Migrating jails  
+----------
+With multi datastore comes the need to migrate a jail between datastores.  
+Migration can be done with a minimal downtime, using zfs differential send/receive.  
+Source jail datasets are sent to the destination datastore, jail is stopped and a last differential sync is done before starting jail on new datastore.  
+
+### Warning 
+Be aware the moment you migrate a jail to another datastore than /iocage default, you lose compatibility with iocage.  
+Then you need to disable iocage service, and enable gocage so the jails will start automatically at boot.  
+Also make sure, if you don't destroy source jail, that it won't have the "boot" property set or you will have the 2 jails up at boot.  
+
+<pre><code>
+gocage migrate -d fastiocage srv-random
+Snapshot data/iocage/jails/srv-random: Done
+Snapshot data/iocage/jails/srv-random/root: Done
+Migrate jail config dataset to fastdata/iocage/jails/srv-random: Done
+Migrate jail filesystem dataset to fastdata/iocage/jails/srv-random/root: Done
+</pre></code>
+

cmd/console.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"os"
+	"fmt"
+	"log"
+	"errors"
+	"strconv"
+	"syscall"
+)
+
+func ShellJail(args []string) error {
+	// We cant shell more than one jail bc we replace gocage execution with jexec, so there wont be no return to gocage
+	if len(args) > 0 {
+		cj, err := getJailFromArray(args[0], gJails)
+		if err != nil {
+			fmt.Printf("Error getting jail %s: %v\n", args[0], err)
+			return err
+		}
+		if err := shellJail(cj); err != nil {
+			fmt.Printf("%v\n", err)
+			return err
+		}
+	}
+	
+	return nil
+}
+
+func shellJail(jail *Jail) error {
+	if false == jail.Running {
+		return errors.New("Jail is not running")
+	}
+	
+	jid := strconv.Itoa(jail.JID)
+
+	//err := syscall.Exec("/usr/sbin/jexec", []string{"jexec", jid, "/bin/csh"}, os.Environ())
+	err := syscall.Exec("/usr/sbin/jexec", []string{"jexec", jid, "login", "-f", "root"}, os.Environ())
+
+	// We should never get here, as syscall.Exec replace the gocage binary execution with jexec
+	// This means the moment syscall.Exec fires, gocage execution halt.
+	if err != nil {
+		log.Printf("Exec returned %v\n", err)
+	}
+	
+	return nil
+}

cmd/datastore.go

@@ -0,0 +1,108 @@
+package cmd
+
+import (
+	"fmt"
+	"errors"
+	"reflect"
+	"strconv"
+	"strings"
+) 
+
+func ListDatastores(args []string, display bool) error {
+	/***************************************************************
+	/   Filter datastores by names given on command line
+	/**************************************************************/
+	for _, d := range args {
+		cmd := fmt.Sprintf("zfs list -p -H -o name,used,available,referenced %s", d)
+		out, err := executeCommand(cmd)
+		if err != nil {
+			if strings.HasSuffix(err.Error(), "No such file or directory") {
+				return errors.New(fmt.Sprintf("Datastore does not exist: %s", d))
+			} else {
+				return errors.New(fmt.Sprintf("Error executing command %s: %v; command returned: %s\n", cmd, err, out))
+			}
+		}
+		
+		fields := strings.Fields(out)
+		if len(fields) < 4 {
+			return errors.New(fmt.Sprintf("Error parsing output of \"%s\": Not enough fields", cmd))
+		}
+		u, _ := strconv.ParseUint(fields[1], 10, 64)
+		a, _ := strconv.ParseUint(fields[2], 10, 64)
+		r, _ := strconv.ParseUint(fields[3], 10, 64)
+		ds := Datastore{Name: d[1:], Mountpoint: d, ZFSDataset: fields[0], Used: u, Referenced: r, Available: a}
+		
+		err = loadDefaultsForDatastore(&ds)
+		if err != nil {
+			return err
+		}
+		
+		gDatastores = append(gDatastores, ds)
+	}
+	
+	fields := strings.Split(gDisplayDColumns, ",")
+
+	if true == display {
+		/***************************************************************
+		/   Sort datastores
+		/     We support 3 sort criteria max
+		/**************************************************************/
+		if len(gSortDSFields) > 0 && gSortDSFields != "none" {		
+			ds := initDatastoreSortStruct()
+
+			// The way we manage criteria quantity is not very elegant...
+			var fct1, fct2, fct3 *reflect.Value
+			for i, c := range strings.Split(gSortDSFields, ",") {
+				var fctName string
+				if strings.HasPrefix(c, "-") {
+					fctName = fmt.Sprintf("%sDec", strings.Replace(c, "-", "", 1))
+				} else { // Par defaut (pas de prefix +/-) on considere un tri incremental
+					fctName = fmt.Sprintf("%sInc", strings.Replace(c, "+", "", 1))
+				}
+
+				// Get function by its name
+				fct, _, err := getStructFieldValue(ds, fctName)
+				
+				if err != nil {
+					fieldName := strings.Replace(strings.Replace(c, "-", "", 1), "+", "", 1)
+					return errors.New(fmt.Sprintf("ERROR getting DatastoreSort struct field %s. Please check the field name: %s\n", fctName, fieldName))
+				}
+				switch i + 1 {
+				case 1:
+					fct1 = fct
+				case 2:
+					fct2 = fct
+				case 3:
+					fct3 = fct
+				}
+			}
+
+			switch len(strings.Split(gSortDSFields, ",")) {
+			case 1:
+				DatastoresOrderedBy(fct1.Interface().(datastoreLessFunc)).Sort(gDatastores)
+			case 2:
+				DatastoresOrderedBy(fct1.Interface().(datastoreLessFunc), fct2.Interface().(datastoreLessFunc)).Sort(gDatastores)
+			case 3:
+				DatastoresOrderedBy(fct1.Interface().(datastoreLessFunc), fct2.Interface().(datastoreLessFunc), fct3.Interface().(datastoreLessFunc)).Sort(gDatastores)
+			}
+		}
+		displayDatastoresFields(gDatastores, fields)
+	}
+	
+	return nil
+}
+
+/********************************************************************************
+ * Load jails default config from $datastore/defaults.json
+ *******************************************************************************/
+func loadDefaultsForDatastore(ds *Datastore) error {
+	jc, err := getJailConfig(fmt.Sprintf("%s/defaults.json", ds.Mountpoint))
+	if err != nil {
+		return err
+	}
+
+	ds.DefaultJailConfig = jc
+	//gDefaultConfig = append(gDefaultConfig, jc)
+
+	return nil
+}

cmd/jailhost.go

@@ -0,0 +1,229 @@
+package cmd
+
+import (
+	"fmt"
+	"net"
+	"regexp"
+	"strconv"
+	"strings"
+	"io/ioutil"
+	"golang.org/x/net/route"
+)
+
+var defaultRoute4 = [4]byte{0, 0, 0, 0}
+var defaultRoute6 = [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+var local6 = [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
+
+func Inet4AddrToString(ip4 route.Inet4Addr) string {
+	return fmt.Sprintf("%v.%v.%v.%v", ip4.IP[0], ip4.IP[1], ip4.IP[2], ip4.IP[3])
+}
+
+func Inet6AddrToString(ip6 route.Inet6Addr) string {
+	return fmt.Sprintf("%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
+		ip6.IP[0], ip6.IP[1], ip6.IP[2], ip6.IP[3], ip6.IP[4], ip6.IP[5], ip6.IP[6], ip6.IP[7],
+		ip6.IP[8], ip6.IP[9], ip6.IP[10], ip6.IP[11], ip6.IP[12], ip6.IP[13], ip6.IP[14], ip6.IP[15])
+}
+
+/*****************************************************************************
+* Initialize default_interface, default_gatway4, default_gateway6
+*****************************************************************************/
+func (jh *JailHost) InitNetworkProperties() {
+	rib, _ := route.FetchRIB(0, route.RIBTypeRoute, 0)
+	messages, err := route.ParseRIB(route.RIBTypeRoute, rib)
+	if err != nil {
+		panic(err)
+	}
+
+	for _, message := range messages {
+		route_message := message.(*route.RouteMessage)
+		addresses := route_message.Addrs
+		card_index := route_message.Index
+
+		if addresses[0].Family() == 2 {
+			var destination4, gateway4 *route.Inet4Addr
+			ok := false
+
+			if destination4, ok = addresses[0].(*route.Inet4Addr); !ok {
+				continue
+			}
+
+			if gateway4, ok = addresses[1].(*route.Inet4Addr); !ok {
+				continue
+			}
+
+			if destination4 == nil || gateway4 == nil {
+				continue
+			}
+
+			if destination4.IP == defaultRoute4 {
+				card, _ := net.InterfaceByIndex(card_index)
+				//fmt.Printf("Default IPv4 gateway is %v on card %s\n", Inet4AddrToString(*gateway4), card.Name)
+				jh.default_interface = card.Name
+				jh.default_gateway4 = Inet4AddrToString(*gateway4)
+			}
+		} else if addresses[0].Family() == 28 {
+			var destination6, gateway6 *route.Inet6Addr
+			ok := false
+
+			if destination6, ok = addresses[0].(*route.Inet6Addr); !ok {
+				continue
+			}
+
+			if gateway6, ok = addresses[1].(*route.Inet6Addr); !ok {
+				continue
+			}
+
+			if destination6 == nil || gateway6 == nil {
+				continue
+			}
+
+			if destination6.IP == defaultRoute6 && gateway6.IP != local6 {
+				card, _ := net.InterfaceByIndex(card_index)
+				//fmt.Printf("Default IPv6 gateway is %v on card %s\n", Inet6AddrToString(*gateway6), card.Name)
+				jh.default_interface = card.Name
+				jh.default_gateway6 = Inet6AddrToString(*gateway6)
+			}
+		}
+	}
+}
+
+func (jh *JailHost) GetDefaultInterface() string {
+	if len(jh.default_interface) == 0 {
+		jh.InitNetworkProperties()
+	}
+	return jh.default_interface
+}
+
+func (jh *JailHost) GetDefaultGateway4() string {
+	if len(jh.default_gateway4) == 0 {
+		jh.InitNetworkProperties()
+	}
+	return jh.default_gateway4
+}
+
+func (jh *JailHost) GetDefaultGateway6() string {
+	if len(jh.default_gateway6) == 0 {
+		jh.InitNetworkProperties()
+	}
+	return jh.default_gateway6
+}
+
+/*****************************************************************************
+ * Get all network interfaces
+ ****************************************************************************/
+func (jh *JailHost) GetInterfaces() ([]string, error) {
+	var names []string
+	
+	interfaces, err := net.Interfaces()
+	if err != nil {
+		return names, fmt.Errorf("Error listing network interfaces: %v", err)
+	}
+	for _, n := range interfaces {
+		names = append(names, n.Name)
+	}
+	
+	return names, nil
+}
+
+func (jh *JailHost) GetBridgeMTU(bridgeName string) (int, error) {
+	bridge, err := net.InterfaceByName(bridgeName)
+	if err != nil {
+		return 0, err
+	}
+	
+	return bridge.MTU, nil
+}
+
+/*****************************************************************************
+ * Get all IPv4 currently in use on host
+ ****************************************************************************/
+func getHostInUseIPv4() ([]string, error) {
+	var ips []string
+
+	re := regexp.MustCompile(ifconfigipv4re)
+
+	out, err := executeCommand("/sbin/ifconfig")
+	if err != nil {
+		return ips, fmt.Errorf("Error executing \"/sbin/ifconfig\": %s", err)
+	}
+
+	for _, line := range strings.Split(out, "\n") {
+		if re.MatchString(line) {
+			ips = append(ips, re.FindStringSubmatch(line)[1])
+		}
+	}
+
+	return ips, nil
+}
+
+func getHostname() (string, error) {
+	out, err := executeCommand("/bin/hostname")
+	if err != nil {
+		return "", fmt.Errorf("Error executing \"/bin/hostname\": %v", err)
+	}
+	
+	return strings.Split(out, "\n")[0], nil
+}
+
+func getHostId() (string, error) {
+	var content []byte
+	var err     error
+	// return empty string if file does not exist
+	if content, err = ioutil.ReadFile("/etc/hostid"); err != nil {
+		if strings.HasSuffix(err.Error(), "no such file or directory") {
+			return "", nil
+		}
+		return "", err
+	}
+	
+	return strings.Split(string(content), "\n")[0], nil
+}
+
+func getFreeBSDVersion() (FreeBSDVersion, error) {
+	var version FreeBSDVersion
+	regex := `([0-9]{1,2})(\.)?([0-9]{1,2})?\-([^\-]*)(\-)?(p[0-9]{1,2})?`
+	
+	re := regexp.MustCompile(regex)
+	
+	out, err := executeCommand("/bin/freebsd-version")
+	if err != nil {
+		return version, fmt.Errorf("Error executing \"/bin/freebsd-version\": %v", err)
+	}
+	
+	if re.MatchString(out) {
+		version.major, err = strconv.Atoi(re.FindStringSubmatch(out)[1])
+		if err != nil {
+			return version, err
+		}
+		version.minor, err = strconv.Atoi(re.FindStringSubmatch(out)[3])
+		if err != nil {
+			return version, err
+		}
+		version.flavor = strings.Trim(re.FindStringSubmatch(out)[4], "\n")
+		
+		// Skip the 'p' starting patch level
+		if len(re.FindStringSubmatch(out)[6]) > 0 {
+			version.patchLevel, err = strconv.Atoi(re.FindStringSubmatch(out)[6][1:])
+			if err != nil {
+				return version, err
+			}
+		}
+	}
+	return version, nil
+}
+
+func NewJailHost() (JailHost, error) {
+	var jh  JailHost
+	var err error
+	
+	if jh.hostname, err = getHostname(); err != nil {
+		return jh, err
+	}
+	if jh.hostid, err = getHostId(); err != nil {
+		return jh, err
+	}
+	if jh.version, err = getFreeBSDVersion(); err != nil {
+		return jh, err
+	}
+	return jh, nil
+}

cmd/list.go

@@ -1,315 +1,121 @@
 package cmd
 
 import (
-	"os"
+	"encoding/json"
 	"fmt"
+	"gocage/jail"
+	"io/ioutil"
 	"log"
-	"errors"
+	"os"
 	"reflect"
 	"strings"
-	"io/ioutil"
-	"gocage/jail"
-	"encoding/json"
-	"github.com/spf13/viper"
 )
 
-
+/********************************************************************************
-// Recurse into structure, returning reflect.Value of wanted field.
+ * List all properties a jail have, with their internal name
-//  Nested fields are named with a dot (ex "MyStruct.MyField")
+ * Only print properties name. To get name & values, use GetJailProperties()
-func getStructFieldValue(parentStruct interface{}, fieldName string) (reflect.Value, string, error) {
+ *******************************************************************************/
-	v := reflect.ValueOf(parentStruct)
+func ListJailsProps(args []string) {
-
+	var conf Jail
-	if v.Kind() == reflect.Ptr {
+	var result []string
-		v = v.Elem()
+	// Mandatory constructor to init default values
-	}
+	jailconf, err := NewJailConfig()
-
+	if err != nil {
-	if false {
+		fmt.Printf("Error allocating JailConfig: %s\n", err.Error())
-		for i := 0 ; i < v.NumField(); i++ {
-			f := v.Field(i)
-			if f.Kind() == reflect.String {
-				fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface())
-			}
-		}
-	}
-
-	if strings.Contains(fieldName, ".") {
-		fs := strings.Split(fieldName, ".")
-		f := v.FieldByName(fs[0])
-		if f.Kind() == reflect.Struct {
-			return getStructFieldValue(f.Interface(), strings.Join(fs[1:], "."))
-		} else {
-			log.Fatalln(fmt.Sprintf("%s is not a struct: %s\n", fs[0], f.Kind().String()))
-		}
-	} else {
-		f := v.FieldByName(fieldName)
-		if f.IsValid() {
-			return f, fieldName, nil
-		} else {
-			return v, fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName))
-		}
-	}
-
-	return v, fieldName, nil
-}
-
-
-// TODO : Replace by getStructFieldValue
-// Recurse into structure, returning reflect.Value of wanted field.
-//  Nested fields are named with a dot (ex "MyStruct.MyField")
-func getStructField(parentStruct interface{}, fieldName string) (reflect.Value, string) {
-	v := reflect.ValueOf(parentStruct)
-
-	if v.Kind() == reflect.Ptr {
-		v = v.Elem()
-	}
-
-	if false {
-		for i := 0 ; i < v.NumField(); i++ {
-			f := v.Field(i)
-			if f.Kind() == reflect.String {
-				fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface())
-			}
-		}
-	}
-
-	if strings.Contains(fieldName, ".") {
-		fs := strings.Split(fieldName, ".")
-		f := v.FieldByName(fs[0])
-		if f.Kind() == reflect.Struct {
-			return getStructField(f.Interface(), strings.Join(fs[1:], "."))
-		} else {
-			log.Fatalln(fmt.Sprintf("%s is not a struct: %s\n", fs[0], f.Kind().String()))
-		}
-	}
-
-	return v, fieldName
-}
-
-
-/* Pretty display of jails field
-   Fields to show are given in a string array parameter
-   Ex. : displayJails(["Name", "JID", "RootPath"])
-*/
-func displayStructFields(jails []Jail, valsToDisplay []string) {
-	/* A line is defined by :
-		Nr of fields
-		For each field :
-			Its name
-			Its max length
-			Its value
-	*/
-	type Field struct {
-		Name	string
-		MaxLen	int
-		Value	string
-	}
-
-	type Line []Field
-
-	type Output []Line
-	var out Output
-
-	//fmt.Printf("%d fields in a %d items structure\n", len(valsToDisplay), len(jails))
-
-	// Browse structure to get max length and values
-	for _, j := range jails {
-		// Have to use a pointer, else reflect.Value.Elem() will panic : https://pkg.go.dev/reflect#Value.Elem
-		tj := &j
-		
-		line := make([]Field, len(valsToDisplay))
-		for i, f := range valsToDisplay {
-			a, f := getStructField(tj, f)
-
-			field := Field {
-				Name: f,
-			}
-			if a.FieldByName(f).IsValid() {
-				// For now this just contains this item length, will adjust later
-				//  We need to divide length by number of items in string fields (because we can have more than 1 ip4_addr)
-				if reflect.TypeOf(a.FieldByName(f).Interface()).Kind() == reflect.String {
-					itnr := len(strings.Split(string(a.FieldByName(f).Interface().(string)), ","))
-					field.MaxLen = len(fmt.Sprintf("%v", a.FieldByName(f).Interface())) / itnr
-				} else {
-					field.MaxLen = len(fmt.Sprintf("%v", a.FieldByName(f).Interface()))
-				}
-				field.Value = fmt.Sprintf("%v", a.FieldByName(f).Interface())
-			} else {
-				fmt.Printf("Invalid field name: %s\n", f)
-			}
-			line[i] = field
-			
-		}
-		out = append(out, line)
-	}
-
-	if len(out) == 0 {
-		fmt.Printf("Nothing to see here!\n")
 		return
 	}
 
-	// Get real maximum length
+	conf.Config = jailconf
-	maxlen := make([]int, len(valsToDisplay))
-	for i := 0; i< len(valsToDisplay); i++ {
-		maxlen[i] = len(valsToDisplay[i])
-	}
-	for _, l := range out {
-		for i, f := range l {
-			if f.MaxLen > maxlen[i] {
-				maxlen[i] = f.MaxLen
-			}
-		}
-	}
 
-	// Align maxlen to the real maximum length
+	result = getStructFieldNames(conf, result, "")
-	for io, l := range out {
-		for ii, _ := range l {
-			// We need to access slice by index if we want to modify content
-			out[io][ii].MaxLen = maxlen[ii]
-		}
-	}
 
-	totalLen := 0
+	for _, f := range result {
-	// For each field, add separator and 2 blank spaces 
+		fmt.Printf("%s\n", f)
-	for _, f := range out[0] {
-		totalLen += f.MaxLen + 3
 	}
-	// Then add starting delimiter 
+}
-	totalLen += 1
 
-	Debug := false
+/********************************************************************************
-	if Debug == true {
+ * Get Jails from datastores. Store config and running metadata
-		for _, f := range out[0] {
+ *   into gJails global var
-			fmt.Printf("%s max length : %d\n", f.Name, f.MaxLen)
+ *******************************************************************************/
-		}
+func ListJails(args []string, display bool) {
+	type uniqueJailName struct {
+		jail       string
+		unique     bool
+		uniqueName bool
 	}
-
+	var nameChecked []*uniqueJailName
-	// Lets draw things on the screen!
+	var curCheck *uniqueJailName
-	// First, headers: 1st separator line
+	var found bool
-	for i, f := range out[0] {
+	var skip bool
-		if i == 0 {	fmt.Printf("+")	}
+	
-		for i := 0 ; i < f.MaxLen+2 ; i++ {	fmt.Printf("=")	}
+	for _, ds := range gDatastores {
-		fmt.Printf("+")
+		listJailsFromDatastore(ds, args, display)
 	}
-	fmt.Printf("\n")
+	
-
+	// Only when displaying jails, we accept to process multiple same name jails
-
+	if false == display {
-	//  Column names
+		for _, j := range gJails {
-	for i, f := range out[0] {
+			// If already checked and was using distinctive name, skip this occurence
-		if i == 0 {
+			for i, n := range nameChecked {
-			fmt.Printf("|")
+				if strings.EqualFold(n.jail, j.Name) {
-		}
+					found = true
-		/* Use vlsToDisplay to get real name (with "Config.")
+					if false == n.unique && true == n.uniqueName {
-		fmt.Printf(" %s", f.Name)
+						skip = true
-		for i := len(f.Name)+1 ; i < f.MaxLen+1 ; i++ {  */
-		fmt.Printf(" %s", valsToDisplay[i])
-		for i := len(valsToDisplay[i])+1 ; i < f.MaxLen+1 ; i++ {
-			fmt.Printf(" ")
-		}
-		fmt.Printf(" |")
-	}
-	//  Finally separator line
-	fmt.Printf("\n")
-	for i, f := range out[0] {
-		if i == 0 {	fmt.Printf("+")	}
-		for i := 0 ; i < f.MaxLen+2 ; i++ {	fmt.Printf("=")	}
-		fmt.Printf("+")
-	}
-	fmt.Printf("\n")
-
-	// Then display data
-	//  Loop through lines
-	for _, l := range out {
-		
-		// Loop through fields
-		//  In case we need to add a line for a 2nd IP, or whatever object
-		var supplines = make(map[string]string)
-		for i, f := range l {
-			if i == 0 {
-				fmt.Printf("|")
-			}
-			// Special cases of value displaying
-			if f.Name == "JID" && f.Value == "0" {
-				fmt.Printf("  ")
-			} else if f.Name == "Ip4_addr" {
-				ia := strings.Split(f.Value, ",")
-				// If we have more than 1 value we need to finish this line, and store value for writing at the end of line loop
-				for i, inter := range ia {
-					if i > 0 {
-						supplines[f.Name] = inter
 					} else {
-						fmt.Printf(" %s", inter)
+						curCheck = nameChecked[i]
+					}
+					break
+				}
+			}
+			
+			if true == skip {
+				continue
+			}
+			
+			// Initialize if not found in nameChecked
+			if false == found {
+				curCheck = &uniqueJailName{jail: j.Name,
+									unique: true,
+									uniqueName: false}
+			} else {
+				found = false
+			}
+			
+			if countOfJailsWithThisName(j.Name) > 1 {
+				//fmt.Printf("DEBUG: Jail %s exist multiple times, now checking if specified with full name\n", j.Name)
+				curCheck.unique = false
+				
+				for _, a := range args {
+					//fmt.Printf("DEBUG: comparing %s/%s with %s\n", j.Datastore, j.Name, a)
+					if strings.EqualFold(a, fmt.Sprintf("%s/%s", j.Datastore, j.Name)) {
+						//fmt.Printf("DEBUG: Was specified with full name, GG!\n")
+						curCheck.uniqueName = true
 					}
 				}
-				//fmt.Printf(" %s", strings.Split(strings.Split(f.Value, "|")[1], "/")[0])
-			} else {
-				fmt.Printf(" %s", f.Value)
 			}
-			// Complete with spaces to the max length
+			nameChecked = append(nameChecked, curCheck)
-			for i := len(f.Value)+1 ; i < f.MaxLen+1 ; i++ {
-				fmt.Printf(" ")
-			}
-			fmt.Printf(" |")
 		}
-		// Draw supplementary lines
+		
-		if len(supplines) > 0 {
+		// Now check
-			for i, f := range l {
+		for _, a := range args {
-				if i == 0 {
+			for _, n := range nameChecked {
-					fmt.Printf("\n|")
+				if strings.EqualFold(n.jail, a) && false == n.unique && false == n.uniqueName {
+					fmt.Printf("There is more than one jail named \"%s\", please use datastore/jail format\n", n.jail)
+					os.Exit(1)
 				}
-				// Overwrite value in this scope
-				v, exists := supplines[f.Name]
-				if exists {
-					fmt.Printf(" %s", v)
-				} else {
-					// 1st option : Do not redisplay precedent line values
-					fmt.Printf(" ")
-					// 2nd option : Redisplay precedenet line values
-					//fmt.Printf(" %s", f.Value)
-				}
-				// Complete with spaces to the max length
-				for i := len(v)+1 ; i < f.MaxLen+1 ; i++ {
-					fmt.Printf(" ")
-				}
-				fmt.Printf(" |")
 			}
 		}
-		// Draw line separator between jails
-		if !gNoLineSep {
-			fmt.Printf("\n")
-			for i, f := range out[0] {
-				if i == 0 {	fmt.Printf("+")	}
-				for i := 0 ; i < f.MaxLen+2 ; i++ {	fmt.Printf("-")	}
-				fmt.Printf("+")
-			}
-		}
-		fmt.Printf("\n")
-	}
-	if gNoLineSep {
-		for i, f := range out[0] {
-			if i == 0 {	fmt.Printf("+")	}
-			for i := 0 ; i < f.MaxLen+2 ; i++ {	fmt.Printf("-")	}
-			fmt.Printf("+")
-		}
 	}
 	
-	fmt.Printf("\n")
+	fields := strings.Split(gDisplayJColumns, ",")
-}
+	
-
-
-/* Get Jails from datastores. Store config and running metadata into gJails global var */
-func ListJails(args []string, display bool) {
-	fields := strings.Split(gDisplayColumns, ",")
-
-	for _, d := range viper.GetStringSlice("datastore") {
-		listJailsFromDatastore(d)
-	}
-
 	// This is the structure we will filter, then display
 	var jails []Jail
 
-	/************************************************************************************
+	/***************************************************************
 	/   Filter jails with "filter" options
-	/***********************************************************************************/
+	/**************************************************************/
 	if len(gFilterJails) > 0 && gFilterJails != "none" {
 		flts := make(map[string]string)
 		for _, flt := range strings.Split(gFilterJails, ",") {
@@ -340,40 +146,38 @@ func ListJails(args []string, display bool) {
 		jails = gJails
 	}
 
-
+	/***************************************************************
-	/************************************************************************************
 	/   Filter jails by names given on command line
-	/***********************************************************************************/
+	/**************************************************************/
 	if len(args) > 0 {
 		var js []Jail
 		for _, a := range args {
 			for _, j := range jails {
 				if j.Name == a {
 					js = append(js, j)
-					break
 				}
 			}
 		}
 		jails = js
 	}
 
-	/************************************************************************************
+	/***************************************************************
 	/   Sort jails
 	/     We support 3 sort criteria max
-	/***********************************************************************************/
+	/**************************************************************/
-	if len(gSortFields) > 0 {
+	if len(gSortJailFields) > 0 && gSortJailFields != "none" {
-		js := initSortStruct()
+		js := initJailSortStruct()
 
 		// The way we manage criteria quantity is not very elegant...
-		var fct1, fct2, fct3 reflect.Value
+		var fct1, fct2, fct3 *reflect.Value
-		for i, c := range strings.Split(gSortFields, ",") {
+		for i, c := range strings.Split(gSortJailFields, ",") {
 			var fctName string
 			if strings.HasPrefix(c, "-") {
 				fctName = fmt.Sprintf("%sDec", strings.Replace(c, "-", "", 1))
-			} else {	// Par defaut (pas de prefix +/-) on considere un tri incremental	
+			} else { // Par defaut (pas de prefix +/-) on considere un tri incremental
 				fctName = fmt.Sprintf("%sInc", strings.Replace(c, "+", "", 1))
 			}
-			
+
 			// Get function by its name
 			fct, _, err := getStructFieldValue(js, fctName)
 			if err != nil {
@@ -381,82 +185,101 @@ func ListJails(args []string, display bool) {
 				fmt.Printf("ERROR getting JailSort struct field %s. Please check the field name: %s\n", fctName, fieldName)
 				return
 			}
-			switch i+1 {
+			switch i + 1 {
-				case 1:	fct1 = fct
+			case 1:
-				case 2: fct2 = fct
+				fct1 = fct
-				case 3: fct3 = fct
+			case 2:
+				fct2 = fct
+			case 3:
+				fct3 = fct
 			}
 		}
 
-		switch len(strings.Split(gSortFields, ",")) {
+		switch len(strings.Split(gSortJailFields, ",")) {
-			case 1:
+		case 1:
-				OrderedBy(fct1.Interface().(lessFunc)).Sort(jails)
+			JailsOrderedBy(fct1.Interface().(jailLessFunc)).Sort(jails)
-			case 2:
+		case 2:
-				OrderedBy(fct1.Interface().(lessFunc), fct2.Interface().(lessFunc)).Sort(jails)
+			JailsOrderedBy(fct1.Interface().(jailLessFunc), fct2.Interface().(jailLessFunc)).Sort(jails)
-			case 3:
+		case 3:
-				OrderedBy(fct1.Interface().(lessFunc), fct2.Interface().(lessFunc), fct3.Interface().(lessFunc)).Sort(jails)
+			JailsOrderedBy(fct1.Interface().(jailLessFunc), fct2.Interface().(jailLessFunc), fct3.Interface().(jailLessFunc)).Sort(jails)
 		}
 	}
 
-	/************************************************************************************
+	/***************************************************************
 	/   Finally, display jails
-	/***********************************************************************************/
+	/**************************************************************/
 	if display {
-		displayStructFields(jails, fields)
+		displayJailsFields(jails, fields)
 	}
 }
 
-
+func listJailsFromDatastore(ds Datastore, args []string, accept_multiple bool) {
-func listJailsFromDatastore(datastore string) {
+	
-	fileInfo, err := os.Stat(datastore)
+	fileInfo, err := os.Stat(ds.Mountpoint)
-	if err != nil { log.Fatalln(fmt.Sprintf("Unable to access %s, check path and/or rights", datastore)) }
+	if err != nil {
-	if fileInfo.IsDir() == false { log.Fatalln(fmt.Sprintf("%s is not a directory", datastore)) }
+		log.Fatalln(fmt.Sprintf("Unable to access %s, check path and/or rights", ds.Mountpoint))
+	}
+	if fileInfo.IsDir() == false {
+		log.Fatalln(fmt.Sprintf("%s is not a directory", ds.Mountpoint))
+	}
 
 	// A datastore have to contain a "jails" directory
-	jailsDir := fmt.Sprintf("%s/jails", datastore)
+	jailsDir := fmt.Sprintf("%s/jails", ds.Mountpoint)
 	fileInfo, err = os.Stat(jailsDir)
-	if err != nil { log.Fatalln(fmt.Sprintf("Unable to access %s, check path and/or rights", jailsDir)) }
+	if err != nil {
-	if fileInfo.IsDir() == false { log.Fatalln(fmt.Sprintf("%s is not a directory", jailsDir)) }
+		log.Fatalln(fmt.Sprintf("Unable to access %s, check path and/or rights", jailsDir))
+	}
+	if fileInfo.IsDir() == false {
+		log.Fatalln(fmt.Sprintf("%s is not a directory", jailsDir))
+	}
 
-	listJailsFromDirectory(jailsDir)
+	listJailsFromDirectory(jailsDir, ds.Name)
 }
 
-
+func listJailsFromDirectory(dir string, dsname string) ([]Jail, error) {
-func listJailsFromDirectory(dir string) ([]Jail) {
 	files, err := ioutil.ReadDir(dir)
-	if err != nil { log.Fatalln(fmt.Sprintf("Unable to browse %s, check path and/or rights", dir)) }
+	if err != nil {
+		log.Fatalln(fmt.Sprintf("Unable to browse %s, check path and/or rights", dir))
+	}
 
 	for _, fi := range files {
 		if fi.IsDir() == true {
 
-		// 1. Get conf from config.json
+			// 1. Get conf from config.json
 			jailConfPath := fmt.Sprintf("%s/%s/%s", dir, fi.Name(), "config.json")
 			jailConf, err := getJailConfig(jailConfPath)
-			if err != nil { log.Println("ERROR reading jail config for %s", jailConfPath) }
+			if err != nil {
-	
+				log.Println("ERROR reading jail config for %s", jailConfPath)
-		// 2. Build jail object from config
-			jailRootPath := fmt.Sprintf("%s/%s/%s", dir, fi.Name(), "root")
-			j := Jail{
-				Name: jailConf.Host_hostname,
-				Config: jailConf,
-				ConfigPath: jailConfPath,
-				RootPath: jailRootPath,
-				Running: false,
 			}
 
-		// 3. Add current running informations
+			// 2. Build jail object from config
+			jailRootPath := fmt.Sprintf("%s/%s/%s", dir, fi.Name(), "root")
+			j := Jail{
+				Name:       jailConf.Host_hostuuid,
+				Config:     jailConf,
+				ConfigPath: jailConfPath,
+				Datastore:  dsname,
+				RootPath:   jailRootPath,
+				Running:    false,
+			}
+
+			// 3. Add current running informations
 			rjails, err := jail.GetJails()
-			if err != nil { log.Fatalln("Unable to list running jails") }
+			if err != nil {
+				log.Fatalln("Unable to list running jails")
+			}
 			for _, rj := range rjails {
 				if rj.Path == j.RootPath {
 					j.JID = rj.Jid
 					j.Running = true
 					j.InternalName = rj.Name
+					j.Devfs_ruleset = rj.Devfs_ruleset
 					break
 				}
 			}
-	
+
-/* This op take some 600ms for ~40 jails :^( */
+			// 4. Get Zpool
+			/* This op take some 600ms for ~40 jails :^( */
 			out, err := executeCommand(fmt.Sprintf("zfs list -H -o name %s", j.RootPath))
 			if err != nil {
 				fmt.Printf("ERROR getting dataset from %s: %s\n", j.RootPath, err.Error())
@@ -464,21 +287,40 @@ func listJailsFromDirectory(dir string) ([]Jail) {
 				j.Zpool = strings.Split(strings.TrimSuffix(out, "\n"), "/")[0]
 			}
 
+			// Check if jail with the same name already exist on another DS
+			for _, jj := range gJails {
+				if strings.EqualFold(jj.Name, j.Name) {
+					/*fmt.Printf("Warning: A jail with name %s exist on datastore %s, use full name to interact!\n", j.Name, jj.Datastore)
+					fmt.Printf("(Ex: gocage start %s/%s)\n", jj.Datastore, j.Name)*/
+					// Add Datastore  to avoid confusion
+					if false == strings.Contains(gDisplayJColumns, "Datastore") {
+						gDisplayJColumns += ",Datastore"
+					}
+				}
+			}
+			
 			gJails = append(gJails, j)
 		}
 	}
 
-	return gJails
+	return gJails, nil
 }
 
-
 func getJailConfig(jailConfigPath string) (JailConfig, error) {
 	content, err := ioutil.ReadFile(jailConfigPath)
-	if err != nil { log.Fatalln(fmt.Sprintf("Unable to read %s, check path and/or rights", jailConfigPath)) }
+	if err != nil {
+		log.Fatalln(fmt.Sprintf("Unable to read %s, check path and/or rights", jailConfigPath))
+	}
 
-	var jc JailConfig
+	// Mandatory constructor to init default values
+	jc, err := NewJailConfig()
+	if err != nil {
+		return jc, err
+	}
 	err = json.Unmarshal([]byte(content), &jc)
-	if err != nil { log.Fatalln(fmt.Sprintf("Error occured during unmarshaling %s: %s", jailConfigPath, err.Error())) }
+	if err != nil {
+		log.Fatalln(fmt.Sprintf("Error occured during unmarshaling %s: %s", jailConfigPath, err.Error()))
+	}
 
 	return jc, err
 }

cmd/migrate.go

@@ -0,0 +1,224 @@
+package cmd
+
+import (
+	"os"
+	"fmt"
+	"bufio"
+	"errors"
+	"strings"
+)
+
+const (
+	// 1MB
+	BUFFER_SIZE = 512
+)
+
+/********************************************************************************
+ * Migrate jail to another zfs pool
+ *******************************************************************************/
+func MigrateJail(args []string) {
+	var jailNames []string
+
+	if len(args) > 0 {
+		for _, a := range args {
+			jailNames = append(jailNames, a)
+		}
+	}
+
+	for _, jn := range jailNames {
+		cj, err := getJailFromArray(jn, gJails)
+		if cj == nil {
+			fmt.Printf("Error getting jail %s: Not found\n", jn)
+			return
+		}
+		
+		// Check if destination datastore exist & get current DS
+		destDS, err := getDatastoreFromArray(gMigrateDestDatastore, gDatastores)
+		if err != nil {
+			fmt.Printf("Error getting datastore \"%s\": %v\n", gMigrateDestDatastore, err)
+			return
+		}
+		curDS, err := getDatastoreFromArray(cj.Datastore, gDatastores)
+		if err != nil {
+			fmt.Printf("Error getting datastore \"%s\": %v\n", gMigrateDestDatastore, err)
+			return
+		}
+		
+		if cj.Running == true && gYesToAll == false {
+			fmt.Printf("WARNING: Jail %s is running\n", cj.Name)
+			fmt.Printf("Migration will stop it for data sync before starting on the new pool. You will be prompted for shutdown.\n")
+			fmt.Printf("Continue? (y/n) ")
+			scanr := bufio.NewScanner(os.Stdin)
+			scanr.Scan()
+			if false == strings.EqualFold(scanr.Text(), "y") {
+				fmt.Printf("Migration aborted\n")
+				return
+			}
+		}
+
+		/* TODO : Check dest pool (gMigrateDestDatastore) existence
+				zfs snapshot /iocage/jails/$jail@gocage_mig_first_snap
+				zfs snapshot /iocage/jails/$jail/root@gocage_mig_first_snap
+				zfs send jail@gocage_mig_first_snap | zfs receive destpool/jails/jail_name
+				zfs send jail/root@gocage_mig_first_snap | zfs receive destpool/jails/jail_name/root
+				shutdown jail if needed
+				if jail was shutdown
+					zfs snapshot /iocage/jails/$jail@gocage_mig_last_snap to get last data
+					zfs send -i jail@gocage_mig_first_snap jail/root@gocage_mig_last_snap | zfs receive -F destpool/jails/jail_name
+					start jail on new dest
+					zfs destroy destpool/jails/jail_name@gocage_mig_first_snap
+					zfs destroy destpool/jails/jail_name/root@gocage_mig_first_snap
+		*/
+
+		// Snapshot config
+		dsconf := strings.Join([]string{curDS.ZFSDataset, "jails", jn}, "/")
+		fmt.Printf("Snapshot %s: ", dsconf)
+		if err = zfsSnapshot(dsconf, "gocage_mig_init"); err != nil {
+			fmt.Printf("Error: %v\n", err)
+			return
+		}
+		fmt.Printf("Done\n")
+		
+		// Snapshot filesystem
+		dsdata := strings.Join([]string{curDS.ZFSDataset, "jails", jn, "root"}, "/")
+		fmt.Printf("Snapshot %s: ", dsdata)
+		if err := zfsSnapshot(dsdata, "gocage_mig_init"); err != nil {
+			fmt.Printf("Error: %v\n", err)
+			return
+		}
+		fmt.Printf("Done\n")
+		
+		
+		// TODO: Browse jailed ZFS dataset to migrate them (see poudriere for example)
+		// zfs send -R src/poudriere@init | zfs receive -Fu dest/poudriere
+		
+		dsconfdest := strings.Join([]string{destDS.ZFSDataset, "jails", jn}, "/")
+		fmt.Printf("Migrate jail config dataset to %s: ", dsconfdest)
+		if err := zfsCopy(fmt.Sprintf("%s@gocage_mig_init", dsconf), dsconfdest); err != nil {
+			fmt.Printf("Error: %v\n", err)
+		}
+		fmt.Printf("Done\n")
+		
+		dsdatadest := strings.Join([]string{destDS.ZFSDataset, "jails", jn, "root"}, "/")
+		fmt.Printf("Migrate jail filesystem dataset to %s: ", dsdatadest)
+		if err := zfsCopy(fmt.Sprintf("%s@gocage_mig_init", dsdata), dsdatadest); err != nil {
+			fmt.Printf("Error: %v\n", err)
+		}
+		fmt.Printf("Done\n")
+		
+		// Running jail needs a last snapshot for an incremental send/recv after shutting down.
+		if cj.Running == true {
+			fmt.Printf("Shutdown jail %s for last data sync, this could take some time.\n", cj.Name)
+			if gYesToAll == false {
+				fmt.Printf("Continue? (y/n) ")
+				scanr := bufio.NewScanner(os.Stdin)
+				scanr.Scan()
+				if false == strings.EqualFold(scanr.Text(), "y") {
+					fmt.Printf("Migration aborted. Now cleaning destination pool.\n")
+					if err := CleanMigrateMess([]string{cj.Name}); err != nil {
+						fmt.Printf("Error: %v\n", err)
+					}
+					// TODO : Remove destination datasets, or handle the cas at the beginning of current function
+					// (when snapshot already exist on source and dest)
+					return
+				}
+			}
+			
+			StopJail([]string{cj.Name})
+			
+			fmt.Printf("Snapshot %s: ", dsconf)
+			if err = zfsSnapshot(dsconf, "gocage_mig_last_sync"); err != nil {
+				fmt.Printf("Error: %v\n", err)
+				return
+			}
+			fmt.Printf("Done\n")
+			fmt.Printf("Snapshot %s: ", dsdata)
+			if err := zfsSnapshot(dsdata, "gocage_mig_last_sync"); err != nil {
+				fmt.Printf("Error: %v\n", err)
+				return
+			}
+			fmt.Printf("Done\n")
+			
+			fmt.Printf("Synchronize jail config to %s: ", dsconfdest)
+			if err := zfsCopyIncremental(fmt.Sprintf("%s@gocage_mig_init", dsconf), 
+										fmt.Sprintf("%s@gocage_mig_last_sync", dsconf),  
+										 dsconfdest); err != nil {
+				fmt.Printf("Error: %v\n", err)
+				return
+			}
+			fmt.Printf("Done\n")
+			
+			fmt.Printf("Synchronize jail filesystem dataset to %s: ", dsdatadest)
+			if err := zfsCopyIncremental(fmt.Sprintf("%s@gocage_mig_init", dsdata), 
+										fmt.Sprintf("%s@gocage_mig_last_sync", dsdata),  
+										dsdatadest); err != nil {
+				return
+				fmt.Printf("Error: %v\n", err)
+			}
+			fmt.Printf("Done\n")
+			
+			// TODO : Start jail on new datastore (! Currently ListJails won't support 2 jails with same name !)
+			
+			// TODO : zfs destroy destpool/jails/jail_name@gocage_mig_first_snap
+			// TODO : zfs destroy destpool/jails/jail_name/root@gocage_mig_first_snap
+			// TODO : zfs destroy -r srcpool/iocage/jails/$jail
+		}
+	}
+}
+
+// Clean snapshots from an aborted migration
+func CleanMigrateMess(args []string) error {
+	var jailNames []string
+
+	if len(args) > 0 {
+		for _, a := range args {
+			jailNames = append(jailNames, a)
+		}
+	}
+
+	for _, jn := range jailNames {
+		cj, err := getJailFromArray(jn, gJails)
+		if cj == nil {
+			return errors.New(fmt.Sprintf("Error getting jail %s: Not found\n", jn))
+		}
+		curDS, err := getDatastoreFromArray(cj.Datastore, gDatastores)
+		if err != nil {
+			return errors.New(fmt.Sprintf("Error getting datastore \"%s\": %v\n", cj.Datastore, err))
+		}
+		
+		cmd := fmt.Sprintf("zfs destroy %s@gocage_mig_init", strings.Join([]string{curDS.ZFSDataset, "jails", jn}, "/"))
+		out, err := executeCommand(cmd)
+		if err != nil {
+			if false == strings.HasSuffix(out, "could not find any snapshots to destroy; check snapshot names.\n") {
+				fmt.Printf("Error executing command %s: %v; command returned: %s\n", cmd, err, out)
+				return errors.New(fmt.Sprintf("Error executing command %s: %v; command returned: %s\n", cmd, err, out))
+			}
+		}
+		cmd = fmt.Sprintf("zfs destroy %s@gocage_mig_init", strings.Join([]string{curDS.ZFSDataset, "jails", jn, "root"}, "/"))
+		out, err = executeCommand(cmd)
+		if err != nil {
+			if false == strings.HasSuffix(out, "could not find any snapshots to destroy; check snapshot names.\n") {
+				fmt.Printf("Error executing command %s: %v; command returned: %s\n", cmd, err, out)
+				return errors.New(fmt.Sprintf("Error executing command %s: %v; command returned: %s\n", cmd, err, out))
+			}
+		}
+		cmd = fmt.Sprintf("zfs destroy %s@gocage_mig_last_sync", strings.Join([]string{curDS.ZFSDataset, "jails", jn}, "/"))
+		out, err = executeCommand(cmd)
+		if err != nil {
+			if false == strings.HasSuffix(out, "could not find any snapshots to destroy; check snapshot names.\n") {
+				fmt.Printf("Error executing command %s: %v; command returned: %s\n", cmd, err, out)
+				return errors.New(fmt.Sprintf("Error executing command %s: %v; command returned: %s\n", cmd, err, out))
+			}
+		}
+		cmd = fmt.Sprintf("zfs destroy %s@gocage_mig_last_sync", strings.Join([]string{curDS.ZFSDataset, "jails", jn, "root"}, "/"))
+		out, err = executeCommand(cmd)
+		if err != nil {
+			if false == strings.HasSuffix(out, "could not find any snapshots to destroy; check snapshot names.\n") {
+				fmt.Printf("Error executing command %s: %v; command returned: %s\n", cmd, err, out)
+				return errors.New(fmt.Sprintf("Error executing command %s: %v; command returned: %s\n", cmd, err, out))
+			}
+		}
+	}
+
+	return nil
+}

cmd/properties.go

@@ -0,0 +1,123 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+func GetJailProperties(args []string) {
+	var props []string
+	var jail *Jail
+	var err error
+
+	if len(args) > 0 {
+		for i, a := range args {
+			// Last arg is the jail name
+			if i == len(args)-1 {
+				jail, err = getJailFromArray(a, gJails)
+				if err != nil {
+					fmt.Printf("Error: %s\n", err.Error())
+					return
+				}
+			} else {
+				props = append(props, a)
+			}
+		}
+	}
+
+	if len(jail.Name) == 0 || len(args) == 0 {
+		// TODO : Show help
+		fmt.Printf("Error\n")
+		return
+	}
+	
+	if isStringInArray(props, "all") {
+		var result []string
+		result = getStructFieldNames(*jail, result, "")
+		props = result
+	}
+
+	for _, p := range props {
+		v, err := getJailProperty(jail, p)
+		if err != nil {
+			fmt.Printf("Error: %s\n", err.Error())
+			return
+		} else {
+			fmt.Printf("%s = %s\n", p, v)
+		}
+	}
+}
+
+func getJailProperty(jail *Jail, propName string) (string, error) {
+	val, _, err := getStructFieldValue(jail, propName)
+	if err != nil {
+		return "", err
+	}
+
+	switch val.Kind() {
+	case reflect.String:
+		return val.String(), nil
+	case reflect.Int:
+		return strconv.FormatInt(val.Int(), 10), nil
+	case reflect.Bool:
+		return strconv.FormatBool(val.Bool()), nil
+	default:
+		return "", errors.New(fmt.Sprintf("Error: Unknown type for property %s: %s\n", propName, val.Kind()))
+	}
+
+	return "", errors.New("Unknown error in getJailProperty")
+}
+
+func SetJailProperties(args []string) {
+	type properties struct {
+		name  string
+		value string
+	}
+
+	var jail Jail
+	var props []properties
+
+	if len(args) > 0 {
+		for i, a := range args {
+			// This is the jail name
+			if i == len(args)-1 {
+				jail.Name = a
+			} else {
+				kv := strings.Split(a, "=")
+				if len(kv) != 2 {
+					// TODO : Show help
+					fmt.Printf("Error parsing args: %s\n", a)
+					return
+				} else {
+					p := properties{name: kv[0], value: kv[1]}
+					props = append(props, p)
+				}
+			}
+		}
+	}
+
+	if len(jail.Name) == 0 || len(args) == 0 {
+		// TODO : Show help
+		fmt.Printf("Error\n")
+		return
+	}
+
+	// Get jail by index to modify it
+	for i, _ := range gJails {
+		if gJails[i].Name == jail.Name {
+			for _, p := range props {
+				err := setStructFieldValue(&gJails[i], p.name, p.value)
+				if err != nil {
+					fmt.Printf("Error: %s\n", err.Error())
+					return
+				} else {
+					fmt.Printf("%s: %s set to %s\n", gJails[i].Name, p.name, p.value)
+					gJails[i].ConfigUpdated = true
+				}
+			}
+		}
+	}
+}

cmd/root.go

@@ -1,92 +1,373 @@
 package cmd
 
 import (
-	"os"
+	"encoding/json"
 	"fmt"
+	"io/ioutil"
+	"os"
 	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	// TODO : Use log
+	log "github.com/sirupsen/logrus"
 )
 
 const (
-	version = "0.02"
+	gVersion = "0.31"
+	
+	// TODO : Get from $jail_zpool/defaults.json
+	MIN_DYN_DEVFS_RULESET = 1000
 )
 
 var (
-	gJails			[]Jail
+	gJailHost   JailHost
+	gJails      []Jail
+	gDatastores []Datastore
 
-	gUseSudo		bool
+	gUseSudo bool
+	gForce   bool
+	gDebug   bool
 
-	gConfigFile		string
+	gConfigFile      string
-	gDisplayColumns	string
+	gDisplayJColumns string
-	gFilterJails	string
+	gDisplaySColumns string
-	gSortFields		string
+	gDisplayDColumns string
-	gNoLineSep		bool
+	gFilterJails     string
+	gFilterSnaps     string
+	gFilterDS        string
+	gSortJailFields  string
+	gSortSnapFields  string
+	gSortDSFields    string
+	gNoJailLineSep   bool
+	gNoSnapLineSep   bool
+	gNoDSLineSep     bool
 
+	gHostVersion float64
 
-	rootCmd = & cobra.Command{
+	gTimeZone     string
-    	Use:    "gocage",
+	gSnapshotName string
-	    Short:  "GoCage is a FreeBSD Jail management tool",
+
-	    Long:   `GoCage is a jail management tool. It support VNET, host-only, NAT networks. Provides snapshots and cloning.
+	gMigrateDestDatastore string
+	gYesToAll             bool
+
+	rootCmd = &cobra.Command{
+		Use:   "gocage",
+		Short: "GoCage is a FreeBSD Jail management tool",
+		Long: `GoCage is a jail management tool. It support VNET, host-only, NAT networks. Provides snapshots and cloning.
 It support iocage jails and can coexist with iocage.`,
-
+		Run: func(cmd *cobra.Command, args []string) {
-	    Run: func(cmd *cobra.Command, args []string) {
+			fv, _ := getFreeBSDVersion()
-	        fmt.Println("Here we are in the Run")
+			fmt.Printf("GoCage v.%s on FreeBSD %d.%d-%s\n", gVersion, fv.major, fv.minor, fv.flavor)
-	    },
+			fmt.Printf("Use -h flag to display help\n")
+		},
 	}
 
 	versionCmd = &cobra.Command{
-	    Use:   "version",
+		Use:   "version",
-	    Short: "Print the version number of GoCage",
+		Short: "Print the version number of GoCage",
-	    Long:  `Let this show you how much fail I had to get this *cough* perfect`,
+		Long:  `Let this show you how much fail I had to get this *cough* perfect`,
-	    Run: func(cmd *cobra.Command, args []string) {
+		Run: func(cmd *cobra.Command, args []string) {
-	        fmt.Printf("GoCage v.%s\n", version)
+			fv, _ := getFreeBSDVersion()
-	    },
+			fmt.Printf("GoCage v.%s on FreeBSD %d.%d-%s\n", gVersion, fv.major, fv.minor, fv.flavor)
+		},
 	}
 
 	listCmd = &cobra.Command{
 		Use:   "list",
 		Short: "Print jails",
-		Long:  `Display jails, their IP and OS.
+		Long: `Display jails, their IP and OS.
 Jail list can be restricted by adding name on command line
 ex: gocage list srv-db srv-web`,
 		Run: func(cmd *cobra.Command, args []string) {
 			ListJails(args, true)
 		},
 	}
+
+	listPropsCmd = &cobra.Command{
+		Use:   "properties",
+		Short: "Print jails properties",
+		Long:  "Display jails properties. You can use properties to filter, get or set them.",
+		Run: func(cmd *cobra.Command, args []string) {
+			ListJailsProps(args)
+		},
+	}
 	
+/*	destroyCmd = &cobra.Command{
+		Use:   "destroy",
+		Short: "destroy jails",
+		Long: `Destroy jail filesystem, snapshots and configuration file.`,
+		Run: func(cmd *cobra.Command, args []string) {
+			ListJails(args, false)
+			DestroyJails(args)
+		},
+	}
+*/
 	stopCmd = &cobra.Command{
 		Use:   "stop",
 		Short: "stop jail",
-		Long:  `shutdown jail`,
+		Long:  "shutdown jail",
 		Run: func(cmd *cobra.Command, args []string) {
-			// Get the inventory
+			// Load inventory
+			ListJails(args, false)
+			if len(args) == 0 {
+				StopAllRunningJails()
+			} else {
+				StopJail(args)
+			}
+		},
+	}
+
+	startCmd = &cobra.Command{
+		Use:   "start",
+		Short: "start jail",
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			if len(args) == 0 {
+				StartJailsAtBoot()
+			} else {
+				StartJail(args)
+			}
+			WriteConfigToDisk(false)
+		},
+	}
+	
+	
+	
+	restartCmd = &cobra.Command{
+		Use:   "restart",
+		Short: "restart jail",
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
 			ListJails(args, false)
 			StopJail(args)
+			StartJail(args)
+			WriteConfigToDisk(false)
+		},
+	}
+	
+	shellCmd = &cobra.Command {
+		Use:   "console",
+		Short: "Execute shell on jail",
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			ShellJail(args)
+		},
+	}
+	
+	setCmd = &cobra.Command{
+		Use:   "set",
+		Short: "Set a jail property",
+		Long: `Set jail property value. Specify property=value, end command with jail name.
+Multiples properties can be specified, separated with space (Ex: gocage set allow_mlock=1 boot=1 myjail)`,
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			SetJailProperties(args)
+			WriteConfigToDisk(true)
+		},
+	}
+
+	getCmd = &cobra.Command{
+		Use:   "get",
+		Short: "Get a jail property",
+		Long: `Get jail property value. Specify property, end command with jail name.
+Multiples properties can be specified, separated with space (Ex: gocage get allow_mlock boot myjail)
+For all properties specify "all" (Ex: gocage get all myjail)`,
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			GetJailProperties(args)
+		},
+	}
+
+	snapshotCmd = &cobra.Command{
+		Use:   "snapshot",
+		Short: "snapshot jail",
+		Long:  "Commands to manage jail snapshots. If no arguments given, ",
+		Run: func(cmd *cobra.Command, args []string) {
+
+		},
+	}
+
+	snapshotListCmd = &cobra.Command{
+		Use:   "list",
+		Short: "list snapshots",
+		Long: `List snapshots of a jail by specifying its name. 
+List all snapshots if no jail name specified.
+You can specify multiple jails.`,
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			ListJailsSnapshots(args)
+		},
+	}
+
+	snapshotCreateCmd = &cobra.Command{
+		Use:   "create",
+		Short: "create snapshots",
+		Long:  `Create snapshot of a jail by specifying snapshot name and jail name.`,
+		//		You can specify multiple jails.`,
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			CreateJailSnapshot(args)
+		},
+	}
+
+	snapshotRollbackCmd = &cobra.Command{
+		Use:   "rollback",
+		Short: "Rollback snapshots",
+		Long:  `Rollback jail to specifyed snapshot.`,
+		//		You can specify multiple jails.`,
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			RollbackJailSnapshot(args)
+		},
+	}
+
+	snapshotDeleteCmd = &cobra.Command{
+		Use:   "destroy",
+		Short: "destroy snapshots",
+		Long:  `Destroy snapshot of a jail by specifying snapshot name and jail name.
+				You can specify multiple snapshots separated by comma.`,
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			DeleteJailSnapshot(args)
+		},
+	}
+
+	migrateCmd = &cobra.Command{
+		Use:   "migrate",
+		Short: "Migrate jail to another datastore",
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			MigrateJail(args)
+			WriteConfigToDisk(false)
+		},
+	}
+
+	migrateCleanCmd = &cobra.Command{
+		Use:   "clean",
+		Short: "Clean previous aborted/in error jail migration",
+		Run: func(cmd *cobra.Command, args []string) {
+			// Load inventory
+			ListJails(args, false)
+			err := CleanMigrateMess(args)
+			if err != nil {
+				fmt.Printf("%v", err)
+			}
+		},
+	}
+	
+	datastoreCmd = &cobra.Command{
+		Use:   "datastore",
+		Short: "list datastores",
+		Long:  "Commands to manage datastores. If no arguments given, list them.",
+		Run: func(cmd *cobra.Command, args []string) {
+			ListDatastores(args, true)
+		},
+	}
+	
+	datastoreListCmd = &cobra.Command{
+		Use:   "list",
+		Short: "list datastores",
+		Long: `List datastore by specifying its name. 
+List all datastores if no name specified.
+You can specify multiple datastores.`,
+		Run: func(cmd *cobra.Command, args []string) {
+			ListDatastores(args, true)
+		},
+	}
+	
+	testCmd = &cobra.Command{
+		Use:   "test",
+		Short: "temporary command to test some code snippet",
+		Run: func(cmd *cobra.Command, args []string) {
+			fmt.Printf("Nope\n")
 		},
 	}
 )
 
-
+// TODO : Init log level and log output
-
 func init() {
-    cobra.OnInitialize(initConfig)
+	var err error
+	
+	cobra.OnInitialize(initConfig)
 
-// Global switches
+	// Global switches
-    rootCmd.PersistentFlags().StringVarP(&gConfigFile, "config", "c", "/usr/local/etc/gocage.conf.yml", "GoCage configuration file")
+	rootCmd.PersistentFlags().StringVarP(&gConfigFile, "config", "c", "/usr/local/etc/gocage.conf.yml", "GoCage configuration file")
-    rootCmd.PersistentFlags().BoolVarP(&gUseSudo, "sudo", "u", false, "Use sudo to run commands")
+	rootCmd.PersistentFlags().BoolVarP(&gUseSudo, "sudo", "u", false, "Use sudo to run commands")
+	rootCmd.PersistentFlags().StringVarP(&gTimeZone, "timezone", "t", "", "Specify timezone. Will get from /var/db/zoneinfo if not set.")
+	rootCmd.PersistentFlags().BoolVarP(&gDebug, "debug", "d", false, "Debug mode")
 
-// Command dependant switches
+	// Command dependant switches
-    listCmd.PersistentFlags().StringVarP(&gDisplayColumns, "outcol", "o", "JID,Name,Config.Release,Config.Ip4_addr,Running", "Show these columns in output")
+
-    listCmd.PersistentFlags().BoolVarP(&gNoLineSep, "nolinesep", "l", false, "Do not display line separator between jails")
+	// We reuse these flags in "gocage snapshot list myjail" and 'gocage datastore list" commands
-    listCmd.PersistentFlags().StringVarP(&gFilterJails, "filter", "f", "none", "Only display jails with these values. Ex: \"gocage list -f Config.Boot=1\" will only list started on boot jails")
+	listCmd.Flags().StringVarP(&gDisplayJColumns, "outcol", "o", "JID,Name,Config.Release,Config.Ip4_addr,Running", "Show these columns in output")
-    listCmd.PersistentFlags().StringVarP(&gSortFields, "sort", "s", "none", "Display jails sorted by field values. Ex: \"gocage list -s +Name,-Config.Priority\" will sort jails by their decreasing name, then increasing start priority. 3 critera max supported.")
+	listCmd.Flags().BoolVarP(&gNoJailLineSep, "nolinesep", "l", false, "Do not display line separator between jails")
-    
+	listCmd.Flags().StringVarP(&gFilterJails, "filter", "f", "none", "Only display jails with these values. Ex: \"gocage list -f Config.Boot=1\" will only list started on boot jails")
-// Now declare commands
+	listCmd.Flags().StringVarP(&gSortJailFields, "sort", "s", "none", "Display jails sorted by field values. Ex: \"gocage list -s +Name,-Config.Priority\" will sort jails by their decreasing name, then increasing start priority. 3 critera max supported.")
-    rootCmd.AddCommand(versionCmd)
+	
-    rootCmd.AddCommand(listCmd)
+//	destroyCmd.Flags().BoolVarP(&gForce, "force", "f", false, "Force stop jail if running")
-    rootCmd.AddCommand(stopCmd)
+
+	snapshotListCmd.Flags().StringVarP(&gDisplaySColumns, "outcol", "o", "Jailname,Name,Creation,Referenced,Used", "Show these columns in output")
+	snapshotListCmd.Flags().BoolVarP(&gNoSnapLineSep, "nolinesep", "l", false, "Do not display line separator between snapshots")
+	snapshotListCmd.Flags().StringVarP(&gFilterSnaps, "filter", "f", "none", "Only display snapshots with these values. Ex: \"gocage snapshot list -f Config.Boot=1\" will only list started on boot jails")
+	snapshotListCmd.Flags().StringVarP(&gSortSnapFields, "sort", "s", "none", "Display snapshots sorted by field values. Ex: \"gocage snapshot list -s +Jailname,-Used\" will sort snapshots by jail decreasing name, then increasing used space. 3 critera max supported.")
+	
+	datastoreListCmd.Flags().StringVarP(&gDisplayDColumns, "outcol", "o", "Name,Mountpoint,ZFSDataset,Available,Used,Referenced", "Show these columns in output")
+	datastoreListCmd.Flags().BoolVarP(&gNoDSLineSep, "nolinesep", "l", false, "Do not display line separator between datastores")
+	datastoreListCmd.Flags().StringVarP(&gFilterDS, "filter", "f", "none", "Only display datastores with these values. Ex: \"gocage datastore list -f Config.Boot=1\" will only list started on boot jails")
+	datastoreListCmd.Flags().StringVarP(&gSortDSFields, "sort", "s", "none", "Display datastores sorted by field values. Ex: \"gocage datastore list -s +Jailname,-Used\" will sort snapshots by jail decreasing name, then increasing used space. 3 critera max supported.")
+	
+	// This is local flag : Only available to gocage snapshot create command
+	snapshotCreateCmd.Flags().StringVarP(&gSnapshotName, "snapname", "n", "", "Name of the snapshot to create")
+	snapshotCreateCmd.MarkFlagRequired("snapname")
+	snapshotDeleteCmd.Flags().StringVarP(&gSnapshotName, "snapname", "n", "", "Name of the snapshot to destroy")
+	snapshotDeleteCmd.MarkFlagRequired("snapname")
+	snapshotRollbackCmd.Flags().StringVarP(&gSnapshotName, "snapname", "n", "", "Name of the snapshot to rollback to")
+	snapshotRollbackCmd.MarkFlagRequired("snapname")
+
+	migrateCmd.Flags().StringVarP(&gMigrateDestDatastore, "datastore", "d", "", "Path of destination datastore for jail (Ex: \"/iocage\")")
+	migrateCmd.Flags().BoolVarP(&gYesToAll, "yes", "y", false, "Answer yes to all questions")
+	migrateCmd.MarkFlagRequired("datastore")
+
+	// Now declare commands
+	rootCmd.AddCommand(versionCmd)
+	rootCmd.AddCommand(listCmd)
+	listCmd.AddCommand(listPropsCmd)
+	rootCmd.AddCommand(stopCmd)
+	rootCmd.AddCommand(startCmd)
+	rootCmd.AddCommand(restartCmd)
+//	rootCmd.AddCommand(destroyCmd)
+	rootCmd.AddCommand(shellCmd)
+	rootCmd.AddCommand(getCmd)
+	rootCmd.AddCommand(setCmd)
+	rootCmd.AddCommand(snapshotCmd)
+	rootCmd.AddCommand(migrateCmd)
+	rootCmd.AddCommand(datastoreCmd)
+	
+	rootCmd.AddCommand(testCmd)
+	
+	snapshotCmd.AddCommand(snapshotListCmd)
+	snapshotCmd.AddCommand(snapshotCreateCmd)
+	snapshotCmd.AddCommand(snapshotDeleteCmd)
+	snapshotCmd.AddCommand(snapshotRollbackCmd)
+	migrateCmd.AddCommand(migrateCleanCmd)
+	datastoreCmd.AddCommand(datastoreListCmd)
+
+	// Get FreeBSD version, hostname, hostid
+	gJailHost, err = NewJailHost()
+	if err != nil {
+		fmt.Printf("Error initializing JailHost properties: %v\n", err)
+		os.Exit(1)
+	}
 }
 
 func initConfig() {
@@ -95,46 +376,121 @@ func initConfig() {
 		os.Exit(1)
 	}
 
-//	fmt.Printf("We are in initConfig(), with config file %s\n", gConfigFile)
-
 	viper.SetConfigFile(gConfigFile)
 
 	if err := viper.ReadInConfig(); err != nil {
 		fmt.Printf("ERROR reading config file %s : %s\n", gConfigFile, err.Error())
 		os.Exit(1)
 	}
-
-//	fmt.Println("Using config file:", viper.ConfigFileUsed())
-//	fmt.Printf("datastore in config : %s\n", viper.GetStringSlice("datastore"))
-//	fmt.Printf("datastore.0 in config : %s\n", viper.GetStringSlice("datastore.0"))
 	
+	// Load default configs from datastores
+	err := ListDatastores(viper.GetStringSlice("datastore"), false)
+	if err != nil {
+		fmt.Printf("ERROR: error checking datastores: %v\n", err)
+		os.Exit(1)
+	}
+
+	//	fmt.Println("Using config file:", viper.ConfigFileUsed())
+	//	fmt.Printf("datastore in config : %s\n", viper.GetStringSlice("datastore"))
+	//	fmt.Printf("datastore.0 in config : %s\n", viper.GetStringSlice("datastore.0"))
+
 	// Command line flags have priority on config file
 	if rootCmd.Flags().Lookup("sudo") != nil && false == rootCmd.Flags().Lookup("sudo").Changed {
 		gUseSudo = viper.GetBool("sudo")
 	}
+	if rootCmd.Flags().Lookup("timezone") != nil && false == rootCmd.Flags().Lookup("timezone").Changed {
+		gTimeZone = viper.GetString("timezone")
+	}
+	// If neither on cmdline nor config file, get from /var/db/zoneinfo
+	if len(gTimeZone) == 0 {
+		tz, err := ioutil.ReadFile("/var/db/zoneinfo")
+		if err != nil {
+			fmt.Println("Error reading /var/db/zoneinfo: %s\n", err.Error())
+			os.Exit(1)
+		}
+		gTimeZone = strings.Trim(string(tz), "\n")
+	}
 	if listCmd.Flags().Lookup("outcol") != nil && false == listCmd.Flags().Lookup("outcol").Changed {
-		gDisplayColumns = viper.GetString("outcol")
+		gDisplayJColumns = viper.GetString("outcol")
 	}
 	if listCmd.Flags().Lookup("nolinesep") != nil && false == listCmd.Flags().Lookup("nolinesep").Changed {
-		gNoLineSep = viper.GetBool("nolinesep")
+		gNoJailLineSep = viper.GetBool("nolinesep")
 	}
 	if listCmd.Flags().Lookup("filter") != nil && false == listCmd.Flags().Lookup("filter").Changed {
 		gFilterJails = viper.GetString("filter")
 	}
 	if listCmd.Flags().Lookup("sort") != nil && false == listCmd.Flags().Lookup("sort").Changed {
-		gSortFields = viper.GetString("sort")
+		gSortJailFields = viper.GetString("sort")
 	}
-	if len(strings.Split(gSortFields, ",")) > 3 {
+	if len(strings.Split(gSortJailFields, ",")) > 3 {
-		fmt.Printf("More than 3 sort criteria, this is not supported!\n")
+		fmt.Printf("More than 3 sort criteria is not supported!\n")
 		os.Exit(1)
 	}
+	
+	
+	if gDebug {
+		log.SetLevel(log.DebugLevel)
+		log.Debugf("Debug mode enabled\n")
+	}
+}
+
+/********************************************************************************
+ * Write jails config which been updated to disk.
+ * If changeauto not set, values which are in "auto" mode on disk
+ *  won't be overwritten (p.ex defaultrouter wont be overwritten with current
+ *  default route, so if route change on jailhost this will reflect on jail next
+ *  start)
+ *******************************************************************************/
+func WriteConfigToDisk(changeauto bool) {
+	for _, j := range gJails {
+		if j.ConfigUpdated {
+			//log.Debug("%s config has changed, write changes to disk\n", j.Name)
+
+			// we will manipulate properties so get a copy
+			jc := j.Config
+
+			if changeauto == false {
+				// Overwrite "auto" properties
+				ondiskjc, err := getJailConfig(j.ConfigPath)
+				if err != nil {
+					panic(err)
+				}
+				// TODO : List all fields, then call getStructFieldValue to compare value with "auto"
+				// If "auto" then keep it that way before writing ondiskjc to disk
+				var properties []string
+				properties = getStructFieldNames(ondiskjc, properties, "")
+
+				for _, p := range properties {
+					v, _, err := getStructFieldValue(ondiskjc, p)
+					if err != nil {
+						panic(err)
+					}
+					if v.String() == "auto" {
+						err = setStructFieldValue(&jc, p, "auto")
+						if err != nil {
+							fmt.Printf("ERROR sanitizing config: %s\n", err.Error())
+							os.Exit(1)
+						}
+					}
+				}
+			}
+
+			marshaled, err := json.MarshalIndent(jc, "", "    ")
+			if err != nil {
+				fmt.Printf("ERROR marshaling config: %s\n", err.Error())
+			}
+			//fmt.Printf(string(marshaled))
+			if os.WriteFile(j.ConfigPath, []byte(marshaled), 0644); err != nil {
+				fmt.Printf("Error writing config file %s: %v\n", j.ConfigPath, err)
+				os.Exit(1)
+			}
+		}
+	}
 }
 
 func Execute() {
-    if err := rootCmd.Execute(); err != nil {
+	if err := rootCmd.Execute(); err != nil {
-        fmt.Fprintln(os.Stderr, err)
+		fmt.Fprintln(os.Stderr, err)
-        os.Exit(1)
+		os.Exit(1)
-    }
+	}
 }
-
-

cmd/snapshots.go

@@ -0,0 +1,330 @@
+package cmd
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"reflect"
+	"time"
+)
+
+/********************************************************************************
+ * List all snapshots jails have
+ *******************************************************************************/
+func ListJailsSnapshots(args []string) {
+	var jailNames []string
+	var snapshots []Snapshot
+
+	/***************************************************************
+	/   Filter snapshots by jailname
+	/**************************************************************/
+	if len(args) > 0 {
+		for _, a := range args {
+			/*if countOfJailsWithThisName(a) > 1 {
+				fmt.Printf("Nope")
+				return
+			}*/
+			jailNames = append(jailNames, a)
+		}
+	}
+
+	if len(jailNames) == 0 || len(args) == 0 {
+		for _, j := range gJails {
+			snapshots = append(snapshots, listJailSnapshots(j)...)
+		}
+	} else {
+		for _, cj := range gJails {
+			for _, jn := range jailNames {
+				if strings.EqualFold(cj.Name, jn) {
+					snapshots = append(snapshots, listJailSnapshots(cj)...)
+				}
+			}
+		}
+	}
+	
+	fields := strings.Split(gDisplaySColumns, ",")
+	
+	/***************************************************************
+	/   Sort snapshots
+	/     We support 3 sort criteria max
+	/**************************************************************/
+	if len(gSortSnapFields) > 0 && gSortSnapFields != "none" {		
+		ss := initSnapshotSortStruct()
+
+		// The way we manage criteria quantity is not very elegant...
+		var fct1, fct2, fct3 *reflect.Value
+		for i, c := range strings.Split(gSortSnapFields, ",") {
+			var fctName string
+			if strings.HasPrefix(c, "-") {
+				fctName = fmt.Sprintf("%sDec", strings.Replace(c, "-", "", 1))
+			} else { // Par defaut (pas de prefix +/-) on considere un tri incremental
+				fctName = fmt.Sprintf("%sInc", strings.Replace(c, "+", "", 1))
+			}
+
+			// Get function by its name
+			fct, _, err := getStructFieldValue(ss, fctName)
+			
+			if err != nil {
+				fieldName := strings.Replace(strings.Replace(c, "-", "", 1), "+", "", 1)
+				fmt.Printf("ERROR getting SnapshotSort struct field %s. Please check the field name: %s\n", fctName, fieldName)
+				return
+			}
+			switch i + 1 {
+			case 1:
+				fct1 = fct
+			case 2:
+				fct2 = fct
+			case 3:
+				fct3 = fct
+			}
+		}
+
+		switch len(strings.Split(gSortSnapFields, ",")) {
+		case 1:
+			SnapshotsOrderedBy(fct1.Interface().(snapshotLessFunc)).Sort(snapshots)
+		case 2:
+			SnapshotsOrderedBy(fct1.Interface().(snapshotLessFunc), fct2.Interface().(snapshotLessFunc)).Sort(snapshots)
+		case 3:
+			SnapshotsOrderedBy(fct1.Interface().(snapshotLessFunc), fct2.Interface().(snapshotLessFunc), fct3.Interface().(snapshotLessFunc)).Sort(snapshots)
+		}
+	}
+	
+	displaySnapshotsFields(snapshots, fields)
+}
+
+/********************************************************************************
+ * List all snapshots a jail have
+ *******************************************************************************/
+func listJailSnapshots(jail Jail) []Snapshot {
+	var snapshots []Snapshot
+
+	// 1. List all datasets
+	// TODO : Include mounted filesystems?
+	
+	curDS, err := getDatastoreFromArray(jail.Datastore, gDatastores)
+	if err != nil {
+		fmt.Printf("Error getting datastore \"%s\": %v\n", jail.Datastore, err)
+		return snapshots
+	}
+	
+	rootDataset := fmt.Sprintf("%s/%s/%s", curDS.ZFSDataset, "jails", jail.Name)
+	cmd := fmt.Sprintf("zfs list -p -r -H -o name,mountpoint,used,referenced,creation -t snapshot %s", rootDataset)
+	out, err := executeCommand(cmd)
+	if err != nil {
+		fmt.Printf("Error: %s\n", err.Error())
+		return snapshots
+	}
+	
+	for _, line := range strings.Split(out, "\n") {
+		if len(line) > 0 {
+			ls := strings.Split(line, "\t")
+			// Parse creation date so we can use it to sort snapshots
+			//creationts, err := time.ParseInLocation(dateLayout, ls[4], loc)
+			creationts, err := strconv.ParseInt(ls[4], 10, 64)
+			if err != nil {
+				fmt.Println("Error while parsing date %s:", ls[4], err)
+				return snapshots
+			}
+			// Get subdir to append to snapshot name
+			subdir := strings.Replace(strings.Split(ls[0], "@")[0], rootDataset, "", 1)
+
+			u, _ := strconv.ParseUint(ls[2], 10, 64)
+			r, _ := strconv.ParseUint(ls[3], 10, 64)
+			snapshots = append(snapshots, Snapshot{Datastore: curDS.Name,
+				Name:       fmt.Sprintf("%s%s", strings.Split(ls[0], "@")[1], subdir),
+				Jailname:   jail.Name,
+				Mountpoint: ls[1],
+				Used:       u,
+				Referenced: r,
+				Creation:   time.Unix(creationts, 0)})
+		}
+	}
+
+	// Sort snapshots by creation date
+	ss := initSnapshotSortStruct()
+	SnapshotsOrderedBy(ss.CreationInc).Sort(snapshots)
+
+	return snapshots
+}
+
+/********************************************************************************
+ * Create snapshot for jail(s)
+ *******************************************************************************/
+func CreateJailSnapshot(args []string) {
+	var jailNames []string
+
+	if len(args) > 0 {
+		for _, a := range args {
+			jailNames = append(jailNames, a)
+		}
+	}
+
+	for _, cj := range gJails {
+		for _, jn := range jailNames {
+			if strings.EqualFold(cj.Name, jn) {
+				createJailSnapshot(cj)
+			}
+		}
+	}
+}
+
+/********************************************************************************
+ * Create snapshot for a jail
+ *******************************************************************************/
+func createJailSnapshot(jail Jail) error {
+	curDS, _ := getDatastoreFromArray(jail.Datastore, gDatastores)
+	rootDataset := fmt.Sprintf("%s/%s/%s", curDS.ZFSDataset, "jails", jail.Name)
+	cmd := fmt.Sprintf("zfs snapshot -r %s@%s", rootDataset, gSnapshotName)
+
+	_, err := executeCommand(cmd)
+	if err != nil {
+		fmt.Printf("Error creating snapshot %s@%s: %s\n", rootDataset, gSnapshotName, err.Error())
+		return err
+	}
+	fmt.Printf("Snapshot %s@%s created\n", rootDataset, gSnapshotName)
+
+	return nil
+}
+
+/********************************************************************************
+ * Delete snapshot for jail(s)
+ *******************************************************************************/
+func DeleteJailSnapshot(args []string) {
+	var jailNames []string
+
+	if len(args) > 0 {
+		for _, a := range args {
+			jailNames = append(jailNames, a)
+		}
+	}
+
+	for _, cj := range gJails {
+		for _, jn := range jailNames {
+			if strings.EqualFold(cj.Name, jn) {
+				deleteJailSnapshot(cj)
+			}
+		}
+	}
+}
+
+/********************************************************************************
+ * Delete snapshot for a jail
+ *******************************************************************************/
+func deleteJailSnapshot(jail Jail) error {
+	var snaptodel []string
+
+	// Get all recursive snapshots
+	curDS, _ := getDatastoreFromArray(jail.Datastore, gDatastores)
+	rootDataset := fmt.Sprintf("%s/%s/%s", curDS.ZFSDataset, "jails", jail.Name)
+	cmd := fmt.Sprintf("zfs list -r -H -o name -t snapshot %s", rootDataset)
+	out, err := executeCommand(cmd)
+	if err != nil {
+		fmt.Printf("Error: listing snapshots: %s\n", err.Error())
+		return nil
+	}
+
+	for _, line := range strings.Split(out, "\n") {
+		if len(line) > 0 {
+			ls := strings.Split(line, "@")
+			for _, sn := range strings.Split(gSnapshotName, ",") {
+				matched, _ := regexp.Match(fmt.Sprintf("^%s(\\/.*)?$", sn), []byte(ls[1]))
+				if matched {
+					snaptodel = append(snaptodel, strings.Join(ls, "@"))
+				}
+			}
+		}
+	}
+
+	for _, s := range snaptodel {
+		cmd := fmt.Sprintf("zfs destroy %s", s)
+		_, err := executeCommand(cmd)
+		if err != nil {
+			fmt.Printf("Error deleting snapshot %s: %s\n", s, err.Error())
+			return nil
+		}
+		fmt.Printf("Snapshot %s deleted\n", s)
+	}
+
+	return nil
+}
+
+func RollbackJailSnapshot(args []string) error {
+	var jailNames []string
+
+	if len(args) > 0 {
+		for _, a := range args {
+			jailNames = append(jailNames, a)
+		}
+	}
+
+	for _, cj := range gJails {
+		for _, jn := range jailNames {
+			if strings.EqualFold(cj.Name, jn) {
+				rollbackJailSnapshot(cj)
+			}
+		}
+	}
+
+	return nil
+}
+
+/********************************************************************************
+ * rollback jail to snapshot gSnapshotName, destroy this snapshots and more
+ *   recents snapshots and bookmarks
+ *******************************************************************************/
+func rollbackJailSnapshot(jail Jail) error {
+	var snaptorb []string
+
+	if jail.Running {
+		fmt.Printf("Jail should be stoped to rollback, should we stop and rollback? (y/n)\n")
+		scanr := bufio.NewScanner(os.Stdin)
+		if scanr.Scan() {
+			if !strings.EqualFold(scanr.Text(), "y") {
+				return errors.New("Jail is running")
+			} else {
+				err := stopJail(&jail)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	// We need to rollback parent and childs
+	// Get all recursive snapshots
+	curDS, _ := getDatastoreFromArray(jail.Datastore, gDatastores)
+	rootDataset := fmt.Sprintf("%s/%s/%s", curDS.ZFSDataset, "jails", jail.Name)
+	cmd := fmt.Sprintf("zfs list -r -H -o name -t snapshot %s", rootDataset)
+	out, err := executeCommand(cmd)
+	if err != nil {
+		fmt.Printf("Error: listing snapshots: %s\n", err.Error())
+		return err
+	}
+
+	for _, line := range strings.Split(out, "\n") {
+		if len(line) > 0 {
+			ls := strings.Split(line, "@")
+
+			matched, _ := regexp.Match(fmt.Sprintf("^%s(\\/.*)?$", gSnapshotName), []byte(ls[1]))
+			if matched {
+				snaptorb = append(snaptorb, strings.Join(ls, "@"))
+			}
+		}
+	}
+
+	for _, s := range snaptorb {
+		cmd := fmt.Sprintf("zfs rollback -r %s", s)
+		_, err := executeCommand(cmd)
+		if err != nil {
+			fmt.Printf("Error rolling back snapshot %s: %s\n", s, err.Error())
+			return err
+		}
+	}
+	fmt.Printf("Jail is back to %s\n", gSnapshotName)
+
+	return nil
+}

cmd/stop.go

@@ -3,12 +3,15 @@ package cmd
 import (
 	"os"
 	"fmt"
-//	"log"
+	//"log"
 	"errors"
 	"regexp"
 	"os/exec"
-//	"reflect"
+	//"reflect"
+	"strconv"
 	"strings"
+	
+	log "github.com/sirupsen/logrus"
 )
 
 // TODO : Use SYS_RCTL_GET_RACCT syscall
@@ -38,7 +41,6 @@ func removeRctlRules(jail string, rules []string) error {
 	return nil
 }
 
-
 // TODO: Validate with  >1 dataset
 func umountAndUnjailZFS(jail *Jail) error {
 	var ds []string
@@ -75,16 +77,16 @@ func umountAndUnjailZFS(jail *Jail) error {
 		fmt.Printf("ERROR unjailing %s/%s: %s\n", jail.Zpool, ds[len(ds)-1], err.Error())
 		return err
 	}
-	
+
 	return nil
 }
 
-
 func destroyVNetInterfaces(jail *Jail) error {
 	for _, i := range strings.Split(jail.Config.Ip4_addr, ",") {
 		iname := fmt.Sprintf("%s.%d", strings.Split(i, "|")[0], jail.JID)
 		fmt.Printf("%s: ", iname)
 		_, err := executeCommand(fmt.Sprintf("ifconfig %s destroy", iname))
+		//_, err := executeScript(fmt.Sprintf("ifconfig %s destroy >/dev/null 2>&1", iname))
 		if err != nil {
 			return err
 		} else {
@@ -95,17 +97,23 @@ func destroyVNetInterfaces(jail *Jail) error {
 	return nil
 }
 
-
+// Jails copy the ruleset referenced as "devfs_ruleset" when starting, getting a new devsf_ruleset ID.
-func deleteDevfsRuleset(jail *Jail) error {
+// This new ID can be obtained with 'jls -j $JID devfs_ruleset'
+// This is the ID which needs to be removed. Original ID referenced is json should not be deleted
+//  or else it will require a restart of "devfs" service.
+// But, stoppign the jail already removes this >1000 ID.
+// So no need to call this function.
+func deleteDevfsRuleset(ruleset int) error {
 	cmd := "devfs rule showsets"
 	out, err := executeCommand(cmd)
 	if err != nil {
 		return errors.New(fmt.Sprintf("ERROR listing rulesets: %s", err.Error()))
 	}
-
+	
+	rs := strconv.Itoa(ruleset)
 	for _, r := range strings.Split(out, "\n") {
-		if r == jail.Config.Devfs_ruleset {
+		if r == rs {
-			cmd := fmt.Sprintf("devfs rule -s %s delset", jail.Config.Devfs_ruleset)
+			cmd := fmt.Sprintf("devfs rule -s %d delset", ruleset)
 			_, err := executeCommand(cmd)
 			return err
 		}
@@ -114,7 +122,6 @@ func deleteDevfsRuleset(jail *Jail) error {
 	return nil
 }
 
-
 func umountJailFsFromHost(jail *Jail, mountpoint string) error {
 	cmd := "mount -p"
 	out, err := executeCommand(cmd)
@@ -130,7 +137,7 @@ func umountJailFsFromHost(jail *Jail, mountpoint string) error {
 				cmd = fmt.Sprintf("umount %s%s", jail.RootPath, mountpoint)
 				_, err := executeCommand(cmd)
 				if err != nil {
-					return errors.New(fmt.Sprintf("Error umounting %s/%s: %s", jail.RootPath, mountpoint, err.Error()))
+					return errors.New(fmt.Sprintf("Error umounting %s%s: %s", jail.RootPath, mountpoint, err.Error()))
 				}
 				return nil
 			}
@@ -140,7 +147,6 @@ func umountJailFsFromHost(jail *Jail, mountpoint string) error {
 	return nil
 }
 
-
 // Internal usage only
 func stopJail(jail *Jail) error {
 	cmd := "jail -q"
@@ -162,6 +168,33 @@ func stopJail(jail *Jail) error {
 	return nil
 }
 
+// Stop all running jails by reverse priority
+func StopAllRunningJails() {
+	var stopList []Jail
+	
+	// Get boot enabled jails
+	for _, j := range gJails {
+		if j.Running == true {
+			stopList = append(stopList, j)
+		}
+	}
+	
+	// Order by priority
+	js := initJailSortStruct()
+	fct, _, err := getStructFieldValue(js, "Config.PriorityDec")
+	if err != nil {
+		log.Errorf("ERROR getting JailSort struct field \"Config.PriorityDec\"\n")
+		return
+	}
+	JailsOrderedBy(fct.Interface().(jailLessFunc)).Sort(stopList)
+	
+	for _, j := range stopList {
+		jFullName := fmt.Sprintf("%s/%s", j.Datastore, j.Name)
+		log.Debugf("Stopping %s with priority %s\n", jFullName, j.Config.Priority)
+		StopJail([]string{jFullName})
+	}
+}
+
 /*
 	Stop jail:
 		Remove rctl rules
@@ -186,25 +219,23 @@ func stopJail(jail *Jail) error {
 func StopJail(args []string) {
 	// Current jail were stopping
 	var cj *Jail
+	var err error
 
-	for _, j := range args {
+	for _, a := range args {
-		fmt.Printf("> Stopping jail %s\n", j)
+		// Check if jail exist and is distinctly named
-
+		cj, err = getJailFromArray(a, gJails)
-		for _, rj := range gJails {
+		if err != nil {
-			if rj.Name == j {
+			fmt.Printf("Error getting jail: %s\n", err)
-				cj = &rj
-				break
-			}
-		}
-		if cj == nil {
-			fmt.Printf("Jail not found: %s\n", j)
 			continue
 		}
+		
 		if cj.Running == false {
 			fmt.Printf("Jail %s is not running!\n", cj.Name)
 			continue
 		}
-
+		
+		fmt.Printf("> Stopping jail %s\n", a)
+		
 		out, err := executeCommand(fmt.Sprintf("rctl jail:%s", cj.InternalName))
 		if err == nil && len(out) > 0 {
 			fmt.Printf("  > Remove RCTL rules:\n")
@@ -216,17 +247,17 @@ func StopJail(args []string) {
 			}
 		}
 
-		if len (cj.Config.Exec_prestop) > 0 {
+		if len(cj.Config.Exec_prestop) > 0 {
-			fmt.Printf("  > Execute prestop:\n")
+			fmt.Printf("  > Execute pre-stop:\n")
 			_, err := executeCommand(cj.Config.Exec_prestop)
 			if err != nil {
 				fmt.Printf("ERROR: %s\n", err.Error())
 			} else {
-				fmt.Printf("  > Execute prestop: OK\n")
+				fmt.Printf("  > Execute pre-stop: OK\n")
 			}
 		}
-		
+
-		if len (cj.Config.Exec_stop) > 0 {
+		if len(cj.Config.Exec_stop) > 0 {
 			fmt.Printf("  > Execute stop:\n")
 			_, err := executeCommandInJail(cj, cj.Config.Exec_stop)
 			if err != nil {
@@ -255,15 +286,15 @@ func StopJail(args []string) {
 				fmt.Printf("  > Destroy VNet interfaces: OK\n")
 			}
 		}
-		
+
-		fmt.Printf("  > Remove devfsruleset %s:\n", cj.Config.Devfs_ruleset)
+		fmt.Printf("  > Remove devfs ruleset %d: \n", cj.Devfs_ruleset)
-		err = deleteDevfsRuleset(cj)
+		err = deleteDevfsRuleset(cj.Devfs_ruleset)
 		if err != nil {
 			fmt.Printf("ERROR: %s\n", err.Error())
 		} else {
-			fmt.Printf("  > Remove devfsruleset %s: OK\n", cj.Config.Devfs_ruleset)
+			fmt.Printf("  > Remove devfsruleset %d: OK\n", cj.Devfs_ruleset)
 		}
-		
+
 		fmt.Printf("  > Stop jail %s:\n", cj.Name)
 		err = stopJail(cj)
 		if err != nil {
@@ -292,15 +323,16 @@ func StopJail(args []string) {
 			}
 		}
 
-		if cj.Config.Mount_fdescfs > 0 {
+		// FIXME: /dev/fd is mounted even with Mount_fdescfs = 0 ?!
+		//if cj.Config.Mount_fdescfs > 0 {
 			fmt.Printf("  > Umount fdescfs:\n")
-			err := umountJailFsFromHost(cj, "/dev/fd")
+			err = umountJailFsFromHost(cj, "/dev/fd")
 			if err != nil {
 				fmt.Printf("ERROR: %s\n", err.Error())
 			} else {
 				fmt.Printf("  > Umount fdescfs: OK\n")
 			}
-		}
+		//}
 
 		if cj.Config.Mount_devfs > 0 {
 			fmt.Printf("  > Umount devfs:\n")
@@ -311,6 +343,61 @@ func StopJail(args []string) {
 				fmt.Printf("  > Umount devfs: OK\n")
 			}
 		}
+
+		// Remove local mounts from $JAIL/fstab
+		fstab := strings.Replace(cj.ConfigPath, "config.json", "fstab", 1)
+		mounts, err := getFstab(fstab)
+		if err != nil {
+			fmt.Printf("ERROR: %s\n", err.Error())
+		}
+		if len(mounts) > 0 {
+			fmt.Printf("  > Umount mountpoints from %s\n", fstab)
+			errs := 0
+			for _, m := range mounts {
+				err = umountJailFsFromHost(cj, m.Mountpoint)
+				if err != nil {
+					fmt.Printf("ERROR: %s\n", err.Error())
+					errs += 1
+				}
+			}
+			if errs == 0 {
+				fmt.Printf("  > Umount mountpoints from %s: OK\n", fstab)
+			}
+		}
+		
+		// TODO: Execute poststop
+		if len(cj.Config.Exec_poststop) > 0 {
+			fmt.Printf("  > Execute post-stop:\n")
+			_, err := executeCommand(cj.Config.Exec_poststop)
+			if err != nil {
+				fmt.Printf("ERROR: %s\n", err.Error())
+			} else {
+				fmt.Printf("  > Execute post-stop: OK\n")
+			}
+		}
+		
+		// Remove parameter file
+		pfile := fmt.Sprintf("/var/run/jail.%s.conf", cj.InternalName)
+		if err = os.Remove(pfile); err != nil {
+			fmt.Printf("Error deleting parameter file %s\n", pfile)
+		}
+		
+		// We need this to get a reference to cj.Running (bc cj.Running is just a copy of value in the scope of StopJail())
+		for i, j := range gJails {
+			if strings.EqualFold(j.Name, cj.Name) && strings.EqualFold(j.Datastore, cj.Datastore) {
+				if err = setStructFieldValue(&gJails[i], "Running", "false"); err != nil {
+					fmt.Printf("ERROR: setting Running property to false: %s\n", err.Error())
+				}
+				if err = setStructFieldValue(&gJails[i], "JID", "0"); err != nil {
+					fmt.Printf("ERROR: setting JID property to 0: %s\n", err.Error())
+				}
+				if err = setStructFieldValue(&gJails[i], "InternalName", ""); err != nil {
+					fmt.Printf("ERROR: clearing InternalName property: %s\n", err.Error())
+				}
+				if err = setStructFieldValue(&gJails[i], "Devfs_ruleset", "0"); err != nil {
+					fmt.Printf("ERROR: setting Devfs_ruleset property to 0: %s\n", err.Error())
+				}
+			}
+		}
 	}
 }
-

cmd/struct.go

@@ -1,18 +1,35 @@
 package cmd
 
+import (
+	"time"
+)
+
+const (
+	IPv4 = 0
+	IPv6 = 1
+)
+
+type NatDesc struct {
+	Proto    string
+	JailPort string
+	HostPort string
+}
 
 // To allow sorting, just duplicate fields in JailSort below
 type Jail struct {
-	Name					string
+	Name          string
-	InternalName			string
+	InternalName  string
-	JID						int
+	JID           int
-	Config					JailConfig
+	Config        JailConfig
-	RootPath				string
+	RootPath      string
-	ConfigPath				string
+	ConfigPath    string
-	Running					bool
+	ConfigUpdated bool
+	Running       bool
 	// No need, Config.Release always represent what is running (plus it know release for non-running jails)
 	//Release					string
-	Zpool					string
+	Devfs_ruleset int	// The effective devfs ruleset generated at runtime
+	Zpool         string
+	Datastore     string
 }
 
 // iocage struct as stored in config.json
@@ -20,444 +37,526 @@ type Jail struct {
 //
 // Fields in this struct are acquired by their name using reflection
 //  So these char are forbidden for field name: -+.
+// Array should be forbidden, or else you'll need to rewrite setJailProperty()
 //
 // To allow sorting, just duplicate fields in JailConfigSort below
 type JailConfig struct {
-	Config_version			string	`json:"CONFIG_VERSION"`
+	Config_version        string `json:"CONFIG_VERSION"`
-	Allow_chflags			int		`json:"allow_chflags"`
+	Allow_chflags         int    `json:"allow_chflags"`
-	Allow_mlock				int		`json:"allow_mlock"`
+	Allow_mlock           int    `json:"allow_mlock"`
-	Allow_mount				int		`json:"allow_mount"`
+	Allow_mount           int    `json:"allow_mount"`
-	Allow_mount_devfs		int		`json:"allow_mount_devfs"`
+	Allow_mount_devfs     int    `json:"allow_mount_devfs"`
-	Allow_mount_fusefs		int		`json:"allow_mount_fusefs"`
+	Allow_mount_fusefs    int    `json:"allow_mount_fusefs"`
-	Allow_mount_nullfs		int		`json:"allow_mount_nullfs"`
+	Allow_mount_nullfs    int    `json:"allow_mount_nullfs"`
-	Allow_mount_procfs		int		`json:"allow_mount_procfs"`
+	Allow_mount_procfs    int    `json:"allow_mount_procfs"`
-	Allow_mount_tmpfs		int		`json:"allow_mount_tmpfs"`
+	Allow_mount_tmpfs     int    `json:"allow_mount_tmpfs"`
-	Allow_mount_zfs			int		`json:"allow_mount_zfs"`
+	Allow_mount_zfs       int    `json:"allow_mount_zfs"`
-	Allow_quotas			int		`json:"allow_quotas"`
+	Allow_quotas          int    `json:"allow_quotas"`
-	Allow_raw_sockets		int		`json:"allow_raw_sockets"`
+	Allow_raw_sockets     int    `json:"allow_raw_sockets"`
-	Allow_set_hostname		int		`json:"allow_set_hostname"`
+	Allow_set_hostname    int    `json:"allow_set_hostname"`
-	Allow_socket_af			int		`json:"allow_socket_af"`
+	Allow_socket_af       int    `json:"allow_socket_af"`
-	Allow_sysvipc			int		`json:"allow_sysvipc"`
+	Allow_sysvipc         int    `json:"allow_sysvipc"`
-	Allow_tun				int		`json:"allow_tun"`
+	Allow_tun             int    `json:"allow_tun"`
-	Allow_vmm				int		`json:"allow_vmm"`
+	Allow_vmm             int    `json:"allow_vmm"`
-	Assign_localhost		int		`json:"assign_localhost"`
+	Assign_localhost      int    `json:"assign_localhost"`
-	Available				string	`json:"available"`
+	Available             string `json:"available"`
-	Basejail				int		`json:"basejail"`
+	Basejail              int    `json:"basejail"`
-	Boot					int		`json:"boot"`
+	Boot                  int    `json:"boot"`
-	Bpf						int		`json:"bpf"`
+	Bpf                   int    `json:"bpf"`
-	Children_max			string	`json:"children_max"`
+	Children_max          string `json:"children_max"`
-	Cloned_release			string	`json:"cloned_release"`
+	Cloned_release        string `json:"cloned_release"`
-	Comment					string	`json:"comment"`
+	Comment               string `json:"comment"`
-	Compression				string	`json:"compression"`
+	Compression           string `json:"compression"`
-	Compressratio			string	`json:"compressratio"`
+	Compressratio         string `json:"compressratio"`
-	Coredumpsize			string	`json:"coredumpsize"`
+	Coredumpsize          string `json:"coredumpsize"`
-	Count					string	`json:"count"`
+	Count                 string `json:"count"`
-	Cpuset					string	`json:"cpuset"`
+	Cpuset                string `json:"cpuset"`
-	Cputime					string	`json:"cputime"`
+	Cputime               string `json:"cputime"`
-	Datasize				string	`json:"datasize"`
+	Datasize              string `json:"datasize"`
-	Dedup					string	`json:"dedup"`
+	Dedup                 string `json:"dedup"`
-	Defaultrouter			string	`json:"defaultrouter"`
+	Defaultrouter         string `json:"defaultrouter"`
-	Defaultrouter6			string	`json:"defaultrouter6"`
+	Defaultrouter6        string `json:"defaultrouter6"`
-	Depends					string	`json:"depends"`
+	Depends               string `json:"depends"`
-	Devfs_ruleset			string	`json:"devfs_ruleset"`
+	Devfs_ruleset         string `json:"devfs_ruleset"`
-	Dhcp					int		`json:"dhcp"`
+	Dhcp                  int    `json:"dhcp"`
-	Enforce_statfs			string	`json:"enforce_statfs"`
+	Enforce_statfs        string `json:"enforce_statfs"`
-	Exec_clean				int		`json:"exec_clean"`
+	Exec_clean            int    `json:"exec_clean"`
-	Exec_created			string	`json:"exec_created"`
+	Exec_created          string `json:"exec_created"`
-	Exec_fib				string	`json:"exec_fib"`
+	Exec_fib              string `json:"exec_fib"`
-	Exec_jail_user			string	`json:"exec_jail_user"`
+	Exec_jail_user        string `json:"exec_jail_user"`
-	Exec_poststart			string	`json:"exec_poststart"`
+	Exec_poststart        string `json:"exec_poststart"`
-	Exec_poststop			string	`json:"exec_poststop"`
+	Exec_poststop         string `json:"exec_poststop"`
-	Exec_prestart			string	`json:"exec_prestart"`
+	Exec_prestart         string `json:"exec_prestart"`
-	Exec_prestop			string	`json:"exec_prestop"`
+	Exec_prestop          string `json:"exec_prestop"`
-	Exec_start				string	`json:"exec_start"`
+	Exec_start            string `json:"exec_start"`
-	Exec_stop				string	`json:"exec_stop"`
+	Exec_stop             string `json:"exec_stop"`
-	Exec_system_jail_user	string	`json:"exec_system_jail_user"`
+	Exec_system_jail_user string `json:"exec_system_jail_user"`
-	Exec_system_user		string	`json:"exec_system_user"`
+	Exec_system_user      string `json:"exec_system_user"`
-	Exec_timeout			string	`json:"exec_timeout"`
+	Exec_timeout          string `json:"exec_timeout"`
-	Host_domainname			string	`json:"host_domainname"`
+	Host_domainname       string `json:"host_domainname"`
-	Host_hostname			string	`json:"host_hostname"`
+	Host_hostname         string `json:"host_hostname"`
-	Host_hostuuid			string	`json:"host_hostuuid"`
+	Host_hostuuid         string `json:"host_hostuuid"`
-	Host_time				int		`json:"host_time"`
+	Host_time             int    `json:"host_time"`
-	Hostid					string	`json:"hostid"`
+	Hostid                string `json:"hostid"`
-	Hostid_strict_check		int		`json:"hostid_strict_check"`
+	Hostid_strict_check   int    `json:"hostid_strict_check"`
-	Interfaces				string	`json:"interfaces"`
+// Specify multiple net cards with "vnet0:bridge0,vnet1:bridge1"
-	Ip4						string	`json:"ip4"`
+	Interfaces            string `json:"interfaces"`
-	Ip4_addr				string	`json:"ip4_addr"`
+	Ip4                   string `json:"ip4"`
-	Ip4_saddrsel			string	`json:"ip4_saddrsel"`
+// Specify multiples IP with "vnet0|192.168.1.42,vnet1|10.0.0.3"
-	Ip6						string	`json:"ip6"`
+	Ip4_addr              string `json:"ip4_addr"`
-	Ip6_addr				string	`json:"ip6_addr"`
+	Ip4_saddrsel          string `json:"ip4_saddrsel"`
-	Ip6_saddrsel			string	`json:"ip4_saddrsel"`
+	Ip6                   string `json:"ip6"`
-	Ip_hostname				int		`json:"ip_hostname"`
+	Ip6_addr              string `json:"ip6_addr"`
-	Jail_zfs				int		`json:"jail_zfs"`
+	Ip6_saddrsel          string `json:"ip4_saddrsel"`
-	Jail_zfs_dataset		string	`json:"jail_zfs_dataset"`
+	Ip_hostname           int    `json:"ip_hostname"`
-	Jail_zfs_mountpoint		string	`json:"jail_zfs_mountpoint"`
+	Jail_zfs              int    `json:"jail_zfs"`
-	Last_started			string	`json:"last_started"`
+	Jail_zfs_dataset      string `json:"jail_zfs_dataset"`
-	Localhost_ip			string	`json:"localhost_ip"`
+	Jail_zfs_mountpoint   string `json:"jail_zfs_mountpoint"`
-	Login_flags				string	`json:"login_flags"`
+	Last_started          string `json:"last_started"`
-	Mac_prefix				string	`json:"mac_prefix"`
+	Localhost_ip          string `json:"localhost_ip"`
-	Maxproc					string	`json:"maxproc"`
+	Login_flags           string `json:"login_flags"`
-	Memorylocked			string	`json:"memorylocked"`
+	Mac_prefix            string `json:"mac_prefix"`
-	Memoryuse				string	`json:"memoryuse"`
+	Maxproc               string `json:"maxproc"`
-	Min_dyn_devfs_ruleset	string	`json:"min_dyn_devfs_ruleset"`
+	Memorylocked          string `json:"memorylocked"`
-	Mount_devfs				int		`json:"mount_devfs"`
+	Memoryuse             string `json:"memoryuse"`
-	Mount_fdescfs			int		`json:"mount_fdescfs"`
+	Min_dyn_devfs_ruleset string `json:"min_dyn_devfs_ruleset"`
-	Mount_linprocfs			int		`json:"mount_linprocfs"`
+	Mount_devfs           int    `json:"mount_devfs"`
-	Mount_procfs			int		`json:"mount_procfs"`
+	Mount_fdescfs         int    `json:"mount_fdescfs"`
-	Mountpoint				string	`json:"mountpoint"`
+	Mount_linprocfs       int    `json:"mount_linprocfs"`
-	Msgqqueued				string	`json:"msgqqueued"`
+	Mount_procfs          int    `json:"mount_procfs"`
-	Msgqsize				string	`json:"msgqsize"`
+	Mountpoint            string `json:"mountpoint"`
-	Nat						int		`json:"nat"`
+	Msgqqueued            string `json:"msgqqueued"`
-	Nat_backend				string	`json:"nat_backend"`
+	Msgqsize              string `json:"msgqsize"`
-	Nat_forwards			string	`json:"nat_forwards"`
+	Nat                   int    `json:"nat"`
-	Nat_interface			string	`json:"nat_interface"`
+	Nat_backend           string `json:"nat_backend"`
-	Nat_prefix				string	`json:"nat_prefix"`
+	Nat_forwards          string `json:"nat_forwards"`
-	Nmsgq					string	`json:"nmsgq"`
+	Nat_interface         string `json:"nat_interface"`
-	Notes					string	`json:"notes"`
+	Nat_prefix            string `json:"nat_prefix"`
-	Nsem					string	`json:"nsem"`
+	Nmsgq                 string `json:"nmsgq"`
-	Nsemop					string	`json:"nsemop"`
+	Notes                 string `json:"notes"`
-	Nshm					string	`json:"nshm"`
+	Nsem                  string `json:"nsem"`
-	Nthr					string	`json:"nthr"`
+	Nsemop                string `json:"nsemop"`
-	Openfiles				string	`json:"openfiles"`
+	Nshm                  string `json:"nshm"`
-	Origin					string	`json:"origin"`
+	Nthr                  string `json:"nthr"`
-	Owner					string	`json:"owner"`
+	Openfiles             string `json:"openfiles"`
-	Pcpu					string	`json:"pcpu"`
+	Origin                string `json:"origin"`
-	Plugin_name				string	`json:"plugin_name"`
+	Owner                 string `json:"owner"`
-	Plugin_repository		string	`json:"plugin_repository"`
+	Pcpu                  string `json:"pcpu"`
-	Priority				string	`json:"priority"`
+	Plugin_name           string `json:"plugin_name"`
-	Pseudoterminals			string	`json:"pseudoterminals"`
+	Plugin_repository     string `json:"plugin_repository"`
-	Quota					string	`json:"quota"`
+	Priority              string `json:"priority"`
-	Readbps					string	`json:"readbps"`
+	Pseudoterminals       string `json:"pseudoterminals"`
-	Readiops				string	`json:"readiops"`
+	Quota                 string `json:"quota"`
-	Release					string	`json:"release"`
+	Readbps               string `json:"readbps"`
-	Reservation				string	`json:"reservation"`
+	Readiops              string `json:"readiops"`
-	Resolver				string	`json:"resolver"`
+	Release               string `json:"release"`
-	Rlimits					string	`json:"rlimits"`
+	Reservation           string `json:"reservation"`
-	Rtsold					int		`json:"rtsold"`
+	Resolver              string `json:"resolver"`
-	Securelevel				string	`json:"securelevel"`
+	Rlimits               string `json:"rlimits"`
-	Shmsize					string	`json:"shmsize"`
+	Rtsold                int    `json:"rtsold"`
-	Stacksize				string	`json:"stacksize"`
+	Securelevel           string `json:"securelevel"`
-	Stop_timeout			string	`json:"stop_timeout"`
+	Shmsize               string `json:"shmsize"`
-	Swapuse					string	`json:"swapuse"`
+	Stacksize             string `json:"stacksize"`
-	Sync_state				string	`json:"sync_state"`
+	Stop_timeout          string `json:"stop_timeout"`
-	Sync_target				string	`json:"sync_target"`
+	Swapuse               string `json:"swapuse"`
-	Sync_tgt_zpool			string	`json:"sync_tgt_zpool"`
+	Sync_state            string `json:"sync_state"`
-	Sysvmsg					string	`json:"sysvmsg"`
+	Sync_target           string `json:"sync_target"`
-	Sysvsem					string	`json:"sysvsem"`
+	Sync_tgt_zpool        string `json:"sync_tgt_zpool"`
-	Sysvshm					string	`json:"sysvshm"`
+	Sysvmsg               string `json:"sysvmsg"`
-	Template				int		`json:"template"`
+	Sysvsem               string `json:"sysvsem"`
+	Sysvshm               string `json:"sysvshm"`
+	Template              int    `json:"template"`
 	// Go don't like a variable named "type" (And i dont care about finding a cleaner way)
-	Jailtype				string	`json:"type"`
+	Jailtype               string `json:"type"`
-	Used					string	`json:"used"`
+	Used                   string `json:"used"`
-	Vmemoryuse				string	`json:"vmemoryuse"`
+	Vmemoryuse             string `json:"vmemoryuse"`
-	Vnet					int		`json:"vnet"`
+	Vnet                   int    `json:"vnet"`
-	Vnet0_mac				string	`json:"vnet0_mac"`
+	Vnet0_mac              string `json:"vnet0_mac"`
-	Vnet1_mac				string	`json:"vnet1_mac"`
+	Vnet1_mac              string `json:"vnet1_mac"`
-	Vnet2_mac				string	`json:"vnet2_mac"`
+	Vnet2_mac              string `json:"vnet2_mac"`
-	Vnet3_mac				string	`json:"vnet3_mac"`
+	Vnet3_mac              string `json:"vnet3_mac"`
-	Vnet_default_interface	string	`json:"vnet_default_interface"`
+	Vnet_default_interface string `json:"vnet_default_interface"`
-	Vnet_interfaces			string	`json:"vnet_interfaces"`
+	Vnet_interfaces        string `json:"vnet_interfaces"`
-	Wallclock				string	`json:"wallclock"`
+	Wallclock              string `json:"wallclock"`
-	Writebps				string	`json:"writebps"`
+	Writebps               string `json:"writebps"`
-	Writeiops				string	`json:"writeiops"`
+	Writeiops              string `json:"writeiops"`
 }
 
-// This struct hold "sort by jail fields" functions
+// Represent an fstab line
-type lessFunc func(j1 *Jail, j2 *Jail) bool
+type Mount struct {
+	Device     string
+	Mountpoint string
+	Type       string
+	Options    []string
+	Fs_Freq    int
+	Fs_Passno  int
+}
+
+type Snapshot struct {
+	// snapshot name is stored after '@' in dataset name
+	Name       string
+	Datastore  string
+	Jailname   string
+	Mountpoint string
+	Used       uint64
+	Referenced uint64
+	Creation   time.Time
+}
+
+type FreeBSDVersion struct {
+	major      int
+	minor      int
+	flavor     string
+	patchLevel int
+}
+
+type JailHost struct {
+	hostname          string
+	hostid            string
+	default_gateway4  string
+	default_gateway6  string
+	default_interface string
+	version           FreeBSDVersion
+}
+
+type Datastore struct {
+	Name              string
+	Mountpoint        string
+	ZFSDataset        string
+	DefaultJailConfig JailConfig
+	Used              uint64
+	Referenced        uint64
+	Available         uint64
+}
 
 // Fields in this struct are acquired by their name using reflection
 //  So these char are forbidden for field name: -+.
-//
 type JailSort struct {
-    NameInc					lessFunc
+	NameInc         jailLessFunc
-	NameDec					lessFunc
+	NameDec         jailLessFunc
-    InternalNameInc			lessFunc
+	InternalNameInc jailLessFunc
-    InternalNameDec			lessFunc
+	InternalNameDec jailLessFunc
-    JIDInc					lessFunc 
+	JIDInc          jailLessFunc
-    JIDDec					lessFunc 
+	JIDDec          jailLessFunc
-    RootPathInc				lessFunc
+	RootPathInc     jailLessFunc
-    RootPathDec				lessFunc
+	RootPathDec     jailLessFunc
-	ConfigPathInc			lessFunc
+	ConfigPathInc   jailLessFunc
-	ConfigPathDec			lessFunc
+	ConfigPathDec   jailLessFunc
-    RunningInc				lessFunc
+	RunningInc      jailLessFunc
-    RunningDec				lessFunc
+	RunningDec      jailLessFunc
-    ZpoolInc				lessFunc
+	DatastoreInc    jailLessFunc
-    ZpoolDec				lessFunc
+	DatastoreDec    jailLessFunc
-	Config					JailConfigSort
+	ZpoolInc        jailLessFunc
+	ZpoolDec        jailLessFunc
+	Devfs_rulesetInc jailLessFunc
+	Devfs_rulesetDec jailLessFunc
+	Config          JailConfigSort
 }
 
-
 type JailConfigSort struct {
-	Config_versionInc		lessFunc
+	Config_versionInc         jailLessFunc
-	Config_versionDec		lessFunc
+	Config_versionDec         jailLessFunc
-	Allow_chflagsInc		lessFunc
+	Allow_chflagsInc          jailLessFunc
-	Allow_chflagsDec		lessFunc
+	Allow_chflagsDec          jailLessFunc
-	Allow_mlockInc			lessFunc
+	Allow_mlockInc            jailLessFunc
-	Allow_mlockDec			lessFunc
+	Allow_mlockDec            jailLessFunc
-	Allow_mountInc			lessFunc
+	Allow_mountInc            jailLessFunc
-	Allow_mountDec			lessFunc
+	Allow_mountDec            jailLessFunc
-	Allow_mount_devfsInc	lessFunc
+	Allow_mount_devfsInc      jailLessFunc
-	Allow_mount_devfsDec	lessFunc
+	Allow_mount_devfsDec      jailLessFunc
-	Allow_mount_fusefsInc	lessFunc
+	Allow_mount_fusefsInc     jailLessFunc
-	Allow_mount_fusefsDec	lessFunc
+	Allow_mount_fusefsDec     jailLessFunc
-	Allow_mount_nullfsInc	lessFunc
+	Allow_mount_nullfsInc     jailLessFunc
-	Allow_mount_nullfsDec	lessFunc
+	Allow_mount_nullfsDec     jailLessFunc
-	Allow_mount_procfsInc	lessFunc
+	Allow_mount_procfsInc     jailLessFunc
-	Allow_mount_procfsDec	lessFunc
+	Allow_mount_procfsDec     jailLessFunc
-	Allow_mount_tmpfsInc	lessFunc
+	Allow_mount_tmpfsInc      jailLessFunc
-	Allow_mount_tmpfsDec	lessFunc
+	Allow_mount_tmpfsDec      jailLessFunc
-	Allow_mount_zfsInc		lessFunc
+	Allow_mount_zfsInc        jailLessFunc
-	Allow_mount_zfsDec		lessFunc
+	Allow_mount_zfsDec        jailLessFunc
-	Allow_quotasInc			lessFunc
+	Allow_quotasInc           jailLessFunc
-	Allow_quotasDec			lessFunc
+	Allow_quotasDec           jailLessFunc
-	Allow_raw_socketsInc	lessFunc
+	Allow_raw_socketsInc      jailLessFunc
-	Allow_raw_socketsDec	lessFunc
+	Allow_raw_socketsDec      jailLessFunc
-	Allow_set_hostnameInc	lessFunc
+	Allow_set_hostnameInc     jailLessFunc
-	Allow_set_hostnameDec	lessFunc
+	Allow_set_hostnameDec     jailLessFunc
-	Allow_socket_afInc		lessFunc
+	Allow_socket_afInc        jailLessFunc
-	Allow_socket_afDec		lessFunc
+	Allow_socket_afDec        jailLessFunc
-	Allow_sysvipcInc		lessFunc
+	Allow_sysvipcInc          jailLessFunc
-	Allow_sysvipcDec		lessFunc
+	Allow_sysvipcDec          jailLessFunc
-	Allow_tunInc			lessFunc
+	Allow_tunInc              jailLessFunc
-	Allow_tunDec			lessFunc
+	Allow_tunDec              jailLessFunc
-	Allow_vmmInc			lessFunc
+	Allow_vmmInc              jailLessFunc
-	Allow_vmmDec			lessFunc
+	Allow_vmmDec              jailLessFunc
-	Assign_localhostInc		lessFunc
+	Assign_localhostInc       jailLessFunc
-	Assign_localhostDec		lessFunc
+	Assign_localhostDec       jailLessFunc
-	AvailableInc			lessFunc
+	AvailableInc              jailLessFunc
-	AvailableDec			lessFunc
+	AvailableDec              jailLessFunc
-	BasejailInc				lessFunc
+	BasejailInc               jailLessFunc
-	BasejailDec				lessFunc
+	BasejailDec               jailLessFunc
-	BootInc					lessFunc
+	BootInc                   jailLessFunc
-	BootDec					lessFunc
+	BootDec                   jailLessFunc
-	BpfInc					lessFunc
+	BpfInc                    jailLessFunc
-	BpfDec					lessFunc
+	BpfDec                    jailLessFunc
-	Children_maxInc			lessFunc
+	Children_maxInc           jailLessFunc
-	Children_maxDec			lessFunc
+	Children_maxDec           jailLessFunc
-	Cloned_releaseInc		lessFunc
+	Cloned_releaseInc         jailLessFunc
-	Cloned_releaseDec		lessFunc
+	Cloned_releaseDec         jailLessFunc
-	CommentInc				lessFunc
+	CommentInc                jailLessFunc
-	CommentDec				lessFunc
+	CommentDec                jailLessFunc
-	CompressionInc			lessFunc
+	CompressionInc            jailLessFunc
-	CompressionDec			lessFunc
+	CompressionDec            jailLessFunc
-	CompressratioInc		lessFunc
+	CompressratioInc          jailLessFunc
-	CompressratioDec		lessFunc
+	CompressratioDec          jailLessFunc
-	CoredumpsizeInc			lessFunc
+	CoredumpsizeInc           jailLessFunc
-	CoredumpsizeDec			lessFunc
+	CoredumpsizeDec           jailLessFunc
-	CountInc				lessFunc
+	CountInc                  jailLessFunc
-	CountDec				lessFunc
+	CountDec                  jailLessFunc
-	CpusetInc				lessFunc
+	CpusetInc                 jailLessFunc
-	CpusetDec				lessFunc
+	CpusetDec                 jailLessFunc
-	CputimeInc				lessFunc
+	CputimeInc                jailLessFunc
-	CputimeDec				lessFunc
+	CputimeDec                jailLessFunc
-	DatasizeInc				lessFunc
+	DatasizeInc               jailLessFunc
-	DatasizeDec				lessFunc
+	DatasizeDec               jailLessFunc
-	DedupInc				lessFunc
+	DedupInc                  jailLessFunc
-	DedupDec				lessFunc
+	DedupDec                  jailLessFunc
-	DefaultrouterInc		lessFunc
+	DefaultrouterInc          jailLessFunc
-	DefaultrouterDec		lessFunc
+	DefaultrouterDec          jailLessFunc
-	Defaultrouter6Inc		lessFunc
+	Defaultrouter6Inc         jailLessFunc
-	Defaultrouter6Dec		lessFunc
+	Defaultrouter6Dec         jailLessFunc
-	DependsInc				lessFunc
+	DependsInc                jailLessFunc
-	DependsDec				lessFunc
+	DependsDec                jailLessFunc
-	Devfs_rulesetInc		lessFunc
+	Devfs_rulesetInc          jailLessFunc
-	Devfs_rulesetDec		lessFunc
+	Devfs_rulesetDec          jailLessFunc
-	DhcpInc					lessFunc
+	DhcpInc                   jailLessFunc
-	DhcpDec					lessFunc
+	DhcpDec                   jailLessFunc
-	Enforce_statfsInc		lessFunc
+	Enforce_statfsInc         jailLessFunc
-	Enforce_statfsDec		lessFunc
+	Enforce_statfsDec         jailLessFunc
-	Exec_cleanInc			lessFunc
+	Exec_cleanInc             jailLessFunc
-	Exec_cleanDec			lessFunc
+	Exec_cleanDec             jailLessFunc
-	Exec_createdInc			lessFunc
+	Exec_createdInc           jailLessFunc
-	Exec_createdDec			lessFunc
+	Exec_createdDec           jailLessFunc
-	Exec_fibInc				lessFunc
+	Exec_fibInc               jailLessFunc
-	Exec_fibDec				lessFunc
+	Exec_fibDec               jailLessFunc
-	Exec_jail_userInc		lessFunc
+	Exec_jail_userInc         jailLessFunc
-	Exec_jail_userDec		lessFunc
+	Exec_jail_userDec         jailLessFunc
-	Exec_poststartInc		lessFunc
+	Exec_poststartInc         jailLessFunc
-	Exec_poststartDec		lessFunc
+	Exec_poststartDec         jailLessFunc
-	Exec_poststopInc		lessFunc
+	Exec_poststopInc          jailLessFunc
-	Exec_poststopDec		lessFunc
+	Exec_poststopDec          jailLessFunc
-	Exec_prestartInc		lessFunc
+	Exec_prestartInc          jailLessFunc
-	Exec_prestartDec		lessFunc
+	Exec_prestartDec          jailLessFunc
-	Exec_prestopInc			lessFunc
+	Exec_prestopInc           jailLessFunc
-	Exec_prestopDec			lessFunc
+	Exec_prestopDec           jailLessFunc
-	Exec_startInc			lessFunc
+	Exec_startInc             jailLessFunc
-	Exec_startDec			lessFunc
+	Exec_startDec             jailLessFunc
-	Exec_stopInc			lessFunc
+	Exec_stopInc              jailLessFunc
-	Exec_stopDec			lessFunc
+	Exec_stopDec              jailLessFunc
-	Exec_system_jail_userInc	lessFunc
+	Exec_system_jail_userInc  jailLessFunc
-	Exec_system_jail_userDec	lessFunc
+	Exec_system_jail_userDec  jailLessFunc
-	Exec_system_userInc		lessFunc
+	Exec_system_userInc       jailLessFunc
-	Exec_system_userDec		lessFunc
+	Exec_system_userDec       jailLessFunc
-	Exec_timeoutInc			lessFunc
+	Exec_timeoutInc           jailLessFunc
-	Exec_timeoutDec			lessFunc
+	Exec_timeoutDec           jailLessFunc
-	Host_domainnameInc		lessFunc
+	Host_domainnameInc        jailLessFunc
-	Host_domainnameDec		lessFunc
+	Host_domainnameDec        jailLessFunc
-	Host_hostnameInc		lessFunc
+	Host_hostnameInc          jailLessFunc
-	Host_hostnameDec		lessFunc
+	Host_hostnameDec          jailLessFunc
-	Host_hostuuidInc		lessFunc
+	Host_hostuuidInc          jailLessFunc
-	Host_hostuuidDec		lessFunc
+	Host_hostuuidDec          jailLessFunc
-	Host_timeInc			lessFunc
+	Host_timeInc              jailLessFunc
-	Host_timeDec			lessFunc
+	Host_timeDec              jailLessFunc
-	HostidInc				lessFunc
+	HostidInc                 jailLessFunc
-	HostidDec				lessFunc
+	HostidDec                 jailLessFunc
-	Hostid_strict_checkInc	lessFunc
+	Hostid_strict_checkInc    jailLessFunc
-	Hostid_strict_checkDec	lessFunc
+	Hostid_strict_checkDec    jailLessFunc
-	InterfacesInc			lessFunc
+	InterfacesInc             jailLessFunc
-	InterfacesDec			lessFunc
+	InterfacesDec             jailLessFunc
-	Ip4Inc					lessFunc
+	Ip4Inc                    jailLessFunc
-	Ip4Dec					lessFunc
+	Ip4Dec                    jailLessFunc
-	Ip4_addrInc				lessFunc
+	Ip4_addrInc               jailLessFunc
-	Ip4_addrDec				lessFunc
+	Ip4_addrDec               jailLessFunc
-	Ip4_saddrselInc			lessFunc
+	Ip4_saddrselInc           jailLessFunc
-	Ip4_saddrselDec			lessFunc
+	Ip4_saddrselDec           jailLessFunc
-	Ip6Inc					lessFunc
+	Ip6Inc                    jailLessFunc
-	Ip6Dec					lessFunc
+	Ip6Dec                    jailLessFunc
-	Ip6_addrInc				lessFunc
+	Ip6_addrInc               jailLessFunc
-	Ip6_addrDec				lessFunc
+	Ip6_addrDec               jailLessFunc
-	Ip6_saddrselInc			lessFunc
+	Ip6_saddrselInc           jailLessFunc
-	Ip6_saddrselDec			lessFunc
+	Ip6_saddrselDec           jailLessFunc
-	Ip_hostnameInc			lessFunc
+	Ip_hostnameInc            jailLessFunc
-	Ip_hostnameDec			lessFunc
+	Ip_hostnameDec            jailLessFunc
-	Jail_zfsInc				lessFunc
+	Jail_zfsInc               jailLessFunc
-	Jail_zfsDec				lessFunc
+	Jail_zfsDec               jailLessFunc
-	Jail_zfs_datasetInc		lessFunc
+	Jail_zfs_datasetInc       jailLessFunc
-	Jail_zfs_datasetDec		lessFunc
+	Jail_zfs_datasetDec       jailLessFunc
-	Jail_zfs_mountpointInc	lessFunc
+	Jail_zfs_mountpointInc    jailLessFunc
-	Jail_zfs_mountpointDec	lessFunc
+	Jail_zfs_mountpointDec    jailLessFunc
-	Last_startedInc			lessFunc
+	Last_startedInc           jailLessFunc
-	Last_startedDec			lessFunc
+	Last_startedDec           jailLessFunc
-	Localhost_ipInc			lessFunc
+	Localhost_ipInc           jailLessFunc
-	Localhost_ipDec			lessFunc
+	Localhost_ipDec           jailLessFunc
-	Login_flagsInc			lessFunc
+	Login_flagsInc            jailLessFunc
-	Login_flagsDec			lessFunc
+	Login_flagsDec            jailLessFunc
-	Mac_prefixInc			lessFunc
+	Mac_prefixInc             jailLessFunc
-	Mac_prefixDec			lessFunc
+	Mac_prefixDec             jailLessFunc
-	MaxprocInc				lessFunc
+	MaxprocInc                jailLessFunc
-	MaxprocDec				lessFunc
+	MaxprocDec                jailLessFunc
-	MemorylockedInc			lessFunc
+	MemorylockedInc           jailLessFunc
-	MemorylockedDec			lessFunc
+	MemorylockedDec           jailLessFunc
-	MemoryuseInc			lessFunc
+	MemoryuseInc              jailLessFunc
-	MemoryuseDec			lessFunc
+	MemoryuseDec              jailLessFunc
-	Min_dyn_devfs_rulesetInc	lessFunc
+	Min_dyn_devfs_rulesetInc  jailLessFunc
-	Min_dyn_devfs_rulesetDec	lessFunc
+	Min_dyn_devfs_rulesetDec  jailLessFunc
-	Mount_devfsInc			lessFunc
+	Mount_devfsInc            jailLessFunc
-	Mount_devfsDec			lessFunc
+	Mount_devfsDec            jailLessFunc
-	Mount_fdescfsInc		lessFunc
+	Mount_fdescfsInc          jailLessFunc
-	Mount_fdescfsDec		lessFunc
+	Mount_fdescfsDec          jailLessFunc
-	Mount_linprocfsInc		lessFunc
+	Mount_linprocfsInc        jailLessFunc
-	Mount_linprocfsDec		lessFunc
+	Mount_linprocfsDec        jailLessFunc
-	Mount_procfsInc			lessFunc
+	Mount_procfsInc           jailLessFunc
-	Mount_procfsDec			lessFunc
+	Mount_procfsDec           jailLessFunc
-	MountpointInc			lessFunc
+	MountpointInc             jailLessFunc
-	MountpointDec			lessFunc
+	MountpointDec             jailLessFunc
-	MsgqqueuedInc			lessFunc
+	MsgqqueuedInc             jailLessFunc
-	MsgqqueuedDec			lessFunc
+	MsgqqueuedDec             jailLessFunc
-	MsgqsizeInc				lessFunc
+	MsgqsizeInc               jailLessFunc
-	MsgqsizeDec				lessFunc
+	MsgqsizeDec               jailLessFunc
-	NatInc					lessFunc
+	NatInc                    jailLessFunc
-	NatDec					lessFunc
+	NatDec                    jailLessFunc
-	Nat_backendInc			lessFunc
+	Nat_backendInc            jailLessFunc
-	Nat_backendDec			lessFunc
+	Nat_backendDec            jailLessFunc
-	Nat_forwardsInc			lessFunc
+	Nat_forwardsInc           jailLessFunc
-	Nat_forwardsDec			lessFunc
+	Nat_forwardsDec           jailLessFunc
-	Nat_interfaceInc		lessFunc
+	Nat_interfaceInc          jailLessFunc
-	Nat_interfaceDec		lessFunc
+	Nat_interfaceDec          jailLessFunc
-	Nat_prefixInc			lessFunc
+	Nat_prefixInc             jailLessFunc
-	Nat_prefixDec			lessFunc
+	Nat_prefixDec             jailLessFunc
-	NmsgqInc				lessFunc
+	NmsgqInc                  jailLessFunc
-	NmsgqDec				lessFunc
+	NmsgqDec                  jailLessFunc
-	NotesInc				lessFunc
+	NotesInc                  jailLessFunc
-	NotesDec				lessFunc
+	NotesDec                  jailLessFunc
-	NsemInc					lessFunc
+	NsemInc                   jailLessFunc
-	NsemDec					lessFunc
+	NsemDec                   jailLessFunc
-	NsemopInc				lessFunc
+	NsemopInc                 jailLessFunc
-	NsemopDec				lessFunc
+	NsemopDec                 jailLessFunc
-	NshmInc					lessFunc
+	NshmInc                   jailLessFunc
-	NshmDec					lessFunc
+	NshmDec                   jailLessFunc
-	NthrInc					lessFunc
+	NthrInc                   jailLessFunc
-	NthrDec					lessFunc
+	NthrDec                   jailLessFunc
-	OpenfilesInc			lessFunc
+	OpenfilesInc              jailLessFunc
-	OpenfilesDec			lessFunc
+	OpenfilesDec              jailLessFunc
-	OriginInc				lessFunc
+	OriginInc                 jailLessFunc
-	OriginDec				lessFunc
+	OriginDec                 jailLessFunc
-	OwnerInc				lessFunc
+	OwnerInc                  jailLessFunc
-	OwnerDec				lessFunc
+	OwnerDec                  jailLessFunc
-	PcpuInc					lessFunc
+	PcpuInc                   jailLessFunc
-	PcpuDec					lessFunc
+	PcpuDec                   jailLessFunc
-	Plugin_nameInc			lessFunc
+	Plugin_nameInc            jailLessFunc
-	Plugin_nameDec			lessFunc
+	Plugin_nameDec            jailLessFunc
-	Plugin_repositoryInc	lessFunc
+	Plugin_repositoryInc      jailLessFunc
-	Plugin_repositoryDec	lessFunc
+	Plugin_repositoryDec      jailLessFunc
-	PriorityInc				lessFunc
+	PriorityInc               jailLessFunc
-	PriorityDec				lessFunc
+	PriorityDec               jailLessFunc
-	PseudoterminalsInc		lessFunc
+	PseudoterminalsInc        jailLessFunc
-	PseudoterminalsDec		lessFunc
+	PseudoterminalsDec        jailLessFunc
-	QuotaInc				lessFunc
+	QuotaInc                  jailLessFunc
-	QuotaDec				lessFunc
+	QuotaDec                  jailLessFunc
-	ReadbpsInc				lessFunc
+	ReadbpsInc                jailLessFunc
-	ReadbpsDec				lessFunc
+	ReadbpsDec                jailLessFunc
-	ReadiopsInc				lessFunc
+	ReadiopsInc               jailLessFunc
-	ReadiopsDec				lessFunc
+	ReadiopsDec               jailLessFunc
-	ReleaseInc				lessFunc
+	ReleaseInc                jailLessFunc
-	ReleaseDec				lessFunc
+	ReleaseDec                jailLessFunc
-	ReservationInc			lessFunc
+	ReservationInc            jailLessFunc
-	ReservationDec			lessFunc
+	ReservationDec            jailLessFunc
-	ResolverInc				lessFunc
+	ResolverInc               jailLessFunc
-	ResolverDec				lessFunc
+	ResolverDec               jailLessFunc
-	RlimitsInc				lessFunc
+	RlimitsInc                jailLessFunc
-	RlimitsDec				lessFunc
+	RlimitsDec                jailLessFunc
-	RtsoldInc				lessFunc
+	RtsoldInc                 jailLessFunc
-	RtsoldDec				lessFunc
+	RtsoldDec                 jailLessFunc
-	SecurelevelInc			lessFunc	
+	SecurelevelInc            jailLessFunc
-	SecurelevelDec			lessFunc	
+	SecurelevelDec            jailLessFunc
-	ShmsizeInc				lessFunc	
+	ShmsizeInc                jailLessFunc
-	ShmsizeDec				lessFunc	
+	ShmsizeDec                jailLessFunc
-	StacksizeInc			lessFunc
+	StacksizeInc              jailLessFunc
-	StacksizeDec			lessFunc
+	StacksizeDec              jailLessFunc
-	Stop_timeoutInc			lessFunc
+	Stop_timeoutInc           jailLessFunc
-	Stop_timeoutDec			lessFunc
+	Stop_timeoutDec           jailLessFunc
-	SwapuseInc				lessFunc
+	SwapuseInc                jailLessFunc
-	SwapuseDec				lessFunc
+	SwapuseDec                jailLessFunc
-	Sync_stateInc			lessFunc
+	Sync_stateInc             jailLessFunc
-	Sync_stateDec			lessFunc
+	Sync_stateDec             jailLessFunc
-	Sync_targetInc			lessFunc
+	Sync_targetInc            jailLessFunc
-	Sync_targetDec			lessFunc
+	Sync_targetDec            jailLessFunc
-	Sync_tgt_zpoolInc		lessFunc
+	Sync_tgt_zpoolInc         jailLessFunc
-	Sync_tgt_zpoolDec		lessFunc
+	Sync_tgt_zpoolDec         jailLessFunc
-	SysvmsgInc				lessFunc
+	SysvmsgInc                jailLessFunc
-	SysvmsgDec				lessFunc
+	SysvmsgDec                jailLessFunc
-	SysvsemInc				lessFunc	
+	SysvsemInc                jailLessFunc
-	SysvsemDec				lessFunc	
+	SysvsemDec                jailLessFunc
-	SysvshmInc				lessFunc	
+	SysvshmInc                jailLessFunc
-	SysvshmDec				lessFunc	
+	SysvshmDec                jailLessFunc
-	TemplateInc				lessFunc
+	TemplateInc               jailLessFunc
-	TemplateDec				lessFunc
+	TemplateDec               jailLessFunc
-	JailtypeInc				lessFunc
+	JailtypeInc               jailLessFunc
-	JailtypeDec				lessFunc
+	JailtypeDec               jailLessFunc
-	UsedInc					lessFunc
+	UsedInc                   jailLessFunc
-	UsedDec					lessFunc
+	UsedDec                   jailLessFunc
-	VmemoryuseInc			lessFunc
+	VmemoryuseInc             jailLessFunc
-	VmemoryuseDec			lessFunc
+	VmemoryuseDec             jailLessFunc
-	VnetInc					lessFunc
+	VnetInc                   jailLessFunc
-	VnetDec					lessFunc
+	VnetDec                   jailLessFunc
-	Vnet0_macInc			lessFunc
+	Vnet0_macInc              jailLessFunc
-	Vnet0_macDec			lessFunc
+	Vnet0_macDec              jailLessFunc
-	Vnet1_macInc			lessFunc
+	Vnet1_macInc              jailLessFunc
-	Vnet1_macDec			lessFunc
+	Vnet1_macDec              jailLessFunc
-	Vnet2_macInc			lessFunc
+	Vnet2_macInc              jailLessFunc
-	Vnet2_macDec			lessFunc
+	Vnet2_macDec              jailLessFunc
-	Vnet3_macInc			lessFunc
+	Vnet3_macInc              jailLessFunc
-	Vnet3_macDec			lessFunc
+	Vnet3_macDec              jailLessFunc
-	Vnet_default_interfaceInc	lessFunc
+	Vnet_default_interfaceInc jailLessFunc
-	Vnet_default_interfaceDec	lessFunc
+	Vnet_default_interfaceDec jailLessFunc
-	Vnet_interfacesInc		lessFunc
+	Vnet_interfacesInc        jailLessFunc
-	Vnet_interfacesDec		lessFunc
+	Vnet_interfacesDec        jailLessFunc
-	WallclockInc			lessFunc
+	WallclockInc              jailLessFunc
-	WallclockDec			lessFunc
+	WallclockDec              jailLessFunc
-	WritebpsInc				lessFunc
+	WritebpsInc               jailLessFunc
-	WritebpsDec				lessFunc
+	WritebpsDec               jailLessFunc
-	WriteiopsInc			lessFunc
+	WriteiopsInc              jailLessFunc
-	WriteiopsDec			lessFunc
+	WriteiopsDec              jailLessFunc
 }
+
+type SnapshotSort struct {
+	NameInc       snapshotLessFunc
+	NameDec       snapshotLessFunc
+	DatastoreInc  snapshotLessFunc
+	DatastoreDec  snapshotLessFunc
+	JailnameInc   snapshotLessFunc
+	JailnameDec   snapshotLessFunc
+	MountpointInc snapshotLessFunc
+	MountpointDec snapshotLessFunc
+	UsedInc       snapshotLessFunc
+	UsedDec       snapshotLessFunc
+	ReferencedInc snapshotLessFunc
+	ReferencedDec snapshotLessFunc
+	CreationInc   snapshotLessFunc
+	CreationDec   snapshotLessFunc
+}
+
+type DatastoreSort struct {
+	NameInc       datastoreLessFunc
+	NameDec       datastoreLessFunc
+	MountpointInc datastoreLessFunc
+	MountpointDec datastoreLessFunc
+	ZFSDatasetInc datastoreLessFunc
+	ZFSDatasetDec datastoreLessFunc
+	UsedInc       datastoreLessFunc
+	UsedDec       datastoreLessFunc
+	ReferencedInc datastoreLessFunc
+	ReferencedDec datastoreLessFunc
+	AvailableInc  datastoreLessFunc
+	AvailableDec  datastoreLessFunc
+}
+

go.mod

@@ -3,8 +3,13 @@ module gocage
 go 1.17
 
 require (
+	github.com/c-robinson/iplib v1.0.3
+	github.com/c2h5oh/datasize v0.0.0-20220606134207-859f65c6625b
+	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
+	github.com/sirupsen/logrus v1.8.1
 	github.com/spf13/cobra v1.2.1
 	github.com/spf13/viper v1.9.0
+	golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
 )
 
 require (

gocage.conf.yml

@@ -1,11 +1,12 @@
-# List datastore root directory (the one containing jails/ and defaults.json)
+# List datastore(s) root directory (the one containing jails/ and defaults.json)
 datastore:
     - /iocage
 
+# Prefix all commands with sudo
 sudo: false
 
 # Columns to display when "gocage list". Column names are struct fields, see cmd/struct.go
 outcol: 'JID,Name,Config.Release,Config.Ip4_addr,Running'
 
-# Do not add line separator between jails
+# Do not add line separator between jails
 nolinesep: false

jail/main.go

@@ -14,16 +14,17 @@ package jail
 */
 import "C"
 import (
-	"strconv"
+    "strconv"
 //    "syscall"
     "unsafe"
 )
 
 
 type Jail struct {
-    Name	string
+    Name          string
-    Jid		int
+    Jid           int
-	Path	string
+    Path          string
+    Devfs_ruleset int
 }
 
 
@@ -33,8 +34,8 @@ func GetJails() ([]Jail, error) {
     var jl Jail
     var err error
 
-	// Make "params" a list of 4 jails parameters
+	// Make "params" a list of 5 jails parameters
-    params := make([]C.struct_jailparam, 4)
+    params := make([]C.struct_jailparam, 5)
 
     // initialize parameter names
     csname := C.CString("name")
@@ -43,27 +44,31 @@ func GetJails() ([]Jail, error) {
     defer C.free(unsafe.Pointer(csjid))
     cspath := C.CString("path")
     defer C.free(unsafe.Pointer(cspath))
+	csdevfsrs := C.CString("devfs_ruleset")
+	defer C.free(unsafe.Pointer(csdevfsrs))
     cslastjid := C.CString("lastjid")
     defer C.free(unsafe.Pointer(cslastjid))
+	
 
     // initialize params struct with parameter names
     C.jailparam_init(&params[0], csname)
     C.jailparam_init(&params[1], csjid)
     C.jailparam_init(&params[2], cspath)
+	C.jailparam_init(&params[3], csdevfsrs)
 
     // The key to retrieve jail. lastjid = 0 returns first jail and its jid as jailparam_get return value
-    C.jailparam_init(&params[3], cslastjid)
+    C.jailparam_init(&params[4], cslastjid)
 
     lastjailid := 0
     cslastjidval := C.CString(strconv.Itoa(lastjailid))
     defer C.free(unsafe.Pointer(cslastjidval))
 
-    C.jailparam_import(&params[3], cslastjidval)
+    C.jailparam_import(&params[4], cslastjidval)
 
     // loop on existing jails
     for lastjailid >= 0 {
         // get parameter values
-        lastjailid = int(C.jailparam_get(&params[0], 4, 0))
+        lastjailid = int(C.jailparam_get(&params[0], 5, 0))
         if lastjailid > 0 {
             nametmp := C.jailparam_export(&params[0])
             jl.Name = C.GoString(nametmp)
@@ -75,23 +80,28 @@ func GetJails() ([]Jail, error) {
             // Memory mgmt : Non gere par Go
             C.free(unsafe.Pointer(jidtmp))
             
-			pathtmp := C.jailparam_export(&params[2])
+            pathtmp := C.jailparam_export(&params[2])
             jl.Path = C.GoString(pathtmp)
             // Memory mgmt : Non gere par Go
             C.free(unsafe.Pointer(pathtmp))
 
+            drstmp := C.jailparam_export(&params[3])
+            jl.Devfs_ruleset, _ = strconv.Atoi(C.GoString(drstmp))
+            // Memory mgmt : Non gere par Go
+            C.free(unsafe.Pointer(drstmp))
+
             jls = append(jls, jl)
             //log.Debug("Got jid " + strconv.Itoa(jl.jid) + " with name " + jl.name)
 
             // Prepare next loop iteration
             cslastjidval := C.CString(strconv.Itoa(lastjailid))
             defer C.free(unsafe.Pointer(cslastjidval))
-            C.jailparam_import(&params[3], cslastjidval)
+            C.jailparam_import(&params[4], cslastjidval)
         }
     }
 
-	// Free 4 items of params list
+	// Free 5 items of params list
-    C.jailparam_free(&params[0], 4)
+    C.jailparam_free(&params[0], 5)
 
     return jls, err
 }

main.go

@@ -1,10 +1,9 @@
 package main
 
 import (
-    "gocage/cmd"
+	"gocage/cmd"
 )
 
-func main () {
+func main() {
-    cmd.Execute()
+	cmd.Execute()
 }
-

service/gocage

@@ -0,0 +1,43 @@
+#!/bin/sh
+#
+# $FreeBSD$
+#
+
+# PROVIDE: gocage
+# REQUIRE: LOGIN cleanvar
+# KEYWORD: shutdown
+
+# Add the following lines to /etc/rc.conf to enable :
+#
+# gocage_enable="YES"
+#
+# gocage_conf="/usr/local/etc/gocage.conf.yml"
+#
+
+. /etc/rc.subr
+
+name="gocage"
+rcvar=gocage_enable
+
+# read configuration and set defaults
+load_rc_config "$name"
+
+: ${gocage_enable:="NO"}
+: ${gocage_conf="/usr/local/etc/gocage.conf.yml"}
+
+start_cmd=${name}_start
+stop_cmd=${name}_stop
+
+gocage_start()
+{
+    echo "Gocage starting jails... "
+    /usr/local/bin/gocage -c ${gocage_conf} start
+}
+
+gocage_stop()
+{
+    echo "Gocage stopping jails... "
+    /usr/local/bin/gocage  -c ${gocage_conf} stop
+}
+
+run_rc_command "$1"