yo/gocage
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

WIP on start, go fmt on *

Browse Source
This commit is contained in:
yo 2022-04-24 16:49:54 +02:00
parent dbd9153513
commit 43f26d099f
12 changed files with 1498 additions and 1169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
cmd/jailhost.go
View File

@ -2,8 +2,8 @@ package cmd
import ( import (
"fmt" "fmt"
"net"
"golang.org/x/net/route" "golang.org/x/net/route"
"net"
) )
var defaultRoute4 = [4]byte{0, 0, 0, 0} var defaultRoute4 = [4]byte{0, 0, 0, 0}
@ -16,8 +16,8 @@ func Inet4AddrToString(ip4 route.Inet4Addr) string {
func Inet6AddrToString(ip6 route.Inet6Addr) string { 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", 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[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]) ip6.IP[8], ip6.IP[9], ip6.IP[10], ip6.IP[11], ip6.IP[12], ip6.IP[13], ip6.IP[14], ip6.IP[15])
} }
/***************************************************************************** /*****************************************************************************
@ -83,7 +83,6 @@ func (jh *JailHost) InitNetworkProperties() {
} }
} }
func (jh *JailHost) GetDefaultInterface() string { func (jh *JailHost) GetDefaultInterface() string {
if len(jh.default_interface) == 0 { if len(jh.default_interface) == 0 {
jh.InitNetworkProperties() jh.InitNetworkProperties()
@ -91,7 +90,6 @@ func (jh *JailHost) GetDefaultInterface() string {
return jh.default_interface return jh.default_interface
} }
func (jh *JailHost) GetDefaultGateway4() string { func (jh *JailHost) GetDefaultGateway4() string {
if len(jh.default_gateway4) == 0 { if len(jh.default_gateway4) == 0 {
jh.InitNetworkProperties() jh.InitNetworkProperties()
@ -99,11 +97,9 @@ func (jh *JailHost) GetDefaultGateway4() string {
return jh.default_gateway4 return jh.default_gateway4
} }
func (jh *JailHost) GetDefaultGateway6() string {
func(jh *JailHost) GetDefaultGateway6() string {
if len(jh.default_gateway6) == 0 { if len(jh.default_gateway6) == 0 {
jh.InitNetworkProperties() jh.InitNetworkProperties()
} }
return jh.default_gateway6 return jh.default_gateway6
} }

101
cmd/list.go
View File

@ -1,15 +1,15 @@
package cmd package cmd
import ( import (
"os" "encoding/json"
"fmt" "fmt"
"github.com/spf13/viper"
"gocage/jail"
"io/ioutil"
"log" "log"
"os"
"reflect" "reflect"
"strings" "strings"
"io/ioutil"
"gocage/jail"
"encoding/json"
"github.com/spf13/viper"
) )
/******************************************************************************** /********************************************************************************
@ -82,7 +82,6 @@ func ListJails(args []string, display bool) {
jails = gJails jails = gJails
} }
/*************************************************************** /***************************************************************
/ Filter jails by names given on command line / Filter jails by names given on command line
/**************************************************************/ /**************************************************************/
@ -112,7 +111,7 @@ func ListJails(args []string, display bool) {
var fctName string var fctName string
if strings.HasPrefix(c, "-") { if strings.HasPrefix(c, "-") {
fctName = fmt.Sprintf("%sDec", strings.Replace(c, "-", "", 1)) 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)) fctName = fmt.Sprintf("%sInc", strings.Replace(c, "+", "", 1))
} }
@ -123,20 +122,23 @@ func ListJails(args []string, display bool) {
fmt.Printf("ERROR getting JailSort struct field %s. Please check the field name: %s\n", fctName, fieldName) fmt.Printf("ERROR getting JailSort struct field %s. Please check the field name: %s\n", fctName, fieldName)
return 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(gSortFields, ",")) {
case 1: case 1:
JailsOrderedBy(fct1.Interface().(jailLessFunc)).Sort(jails) JailsOrderedBy(fct1.Interface().(jailLessFunc)).Sort(jails)
case 2: case 2:
JailsOrderedBy(fct1.Interface().(jailLessFunc), fct2.Interface().(jailLessFunc)).Sort(jails) JailsOrderedBy(fct1.Interface().(jailLessFunc), fct2.Interface().(jailLessFunc)).Sort(jails)
case 3: case 3:
JailsOrderedBy(fct1.Interface().(jailLessFunc), fct2.Interface().(jailLessFunc), fct3.Interface().(jailLessFunc)).Sort(jails) JailsOrderedBy(fct1.Interface().(jailLessFunc), fct2.Interface().(jailLessFunc), fct3.Interface().(jailLessFunc)).Sort(jails)
} }
} }
@ -148,47 +150,59 @@ func ListJails(args []string, display bool) {
} }
} }
func listJailsFromDatastore(datastore string) { func listJailsFromDatastore(datastore string) {
fileInfo, err := os.Stat(datastore) fileInfo, err := os.Stat(datastore)
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", datastore))
}
if fileInfo.IsDir() == false {
log.Fatalln(fmt.Sprintf("%s is not a directory", datastore))
}
// A datastore have to contain a "jails" directory // A datastore have to contain a "jails" directory
jailsDir := fmt.Sprintf("%s/jails", datastore) jailsDir := fmt.Sprintf("%s/jails", datastore)
fileInfo, err = os.Stat(jailsDir) 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)
} }
func listJailsFromDirectory(dir string) []Jail {
func listJailsFromDirectory(dir string) ([]Jail) {
files, err := ioutil.ReadDir(dir) 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 { for _, fi := range files {
if fi.IsDir() == true { 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") jailConfPath := fmt.Sprintf("%s/%s/%s", dir, fi.Name(), "config.json")
jailConf, err := getJailConfig(jailConfPath) 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_hostname,
Config: jailConf,
ConfigPath: jailConfPath,
RootPath: jailRootPath,
Running: false,
}
// 3. Add current running informations
rjails, err := jail.GetJails() 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 { for _, rj := range rjails {
if rj.Path == j.RootPath { if rj.Path == j.RootPath {
j.JID = rj.Jid j.JID = rj.Jid
@ -198,7 +212,7 @@ func listJailsFromDirectory(dir string) ([]Jail) {
} }
} }
/* This op take some 600ms for ~40 jails :^( */ /* This op take some 600ms for ~40 jails :^( */
out, err := executeCommand(fmt.Sprintf("zfs list -H -o name %s", j.RootPath)) out, err := executeCommand(fmt.Sprintf("zfs list -H -o name %s", j.RootPath))
if err != nil { if err != nil {
fmt.Printf("ERROR getting dataset from %s: %s\n", j.RootPath, err.Error()) fmt.Printf("ERROR getting dataset from %s: %s\n", j.RootPath, err.Error())
@ -213,10 +227,11 @@ func listJailsFromDirectory(dir string) ([]Jail) {
return gJails return gJails
} }
func getJailConfig(jailConfigPath string) (JailConfig, error) { func getJailConfig(jailConfigPath string) (JailConfig, error) {
content, err := ioutil.ReadFile(jailConfigPath) 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))
}
// Mandatory constructor to init default values // Mandatory constructor to init default values
jc, err := NewJailConfig() jc, err := NewJailConfig()
@ -224,7 +239,9 @@ func getJailConfig(jailConfigPath string) (JailConfig, error) {
return jc, err return jc, err
} }
err = json.Unmarshal([]byte(content), &jc) 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 return jc, err
} }

26
cmd/properties.go
View File

@ -1,11 +1,11 @@
package cmd package cmd
import ( import (
"fmt"
"errors" "errors"
"fmt"
"reflect" "reflect"
"strings"
"strconv" "strconv"
"strings"
) )
func GetJailProperties(args []string) { func GetJailProperties(args []string) {
@ -55,14 +55,14 @@ func getJailProperty(jail *Jail, propName string) (string, error) {
} }
switch val.Kind() { switch val.Kind() {
case reflect.String: case reflect.String:
return val.String(), nil return val.String(), nil
case reflect.Int: case reflect.Int:
return strconv.FormatInt(val.Int(), 10), nil return strconv.FormatInt(val.Int(), 10), nil
case reflect.Bool: case reflect.Bool:
return strconv.FormatBool(val.Bool()), nil return strconv.FormatBool(val.Bool()), nil
default: default:
return "", errors.New(fmt.Sprintf("Error: Unknown type for property %s: %s\n", propName, val.Kind())) return "", errors.New(fmt.Sprintf("Error: Unknown type for property %s: %s\n", propName, val.Kind()))
} }
} }
} }
@ -72,8 +72,8 @@ func getJailProperty(jail *Jail, propName string) (string, error) {
func SetJailProperties(args []string) { func SetJailProperties(args []string) {
type properties struct { type properties struct {
name string name string
value string value string
} }
var jail Jail var jail Jail
@ -120,5 +120,3 @@ func SetJailProperties(args []string) {
} }
} }
} }

122
cmd/root.go
View File

@ -1,41 +1,43 @@
package cmd package cmd
import ( import (
"os" "encoding/json"
"fmt" "fmt"
"io/ioutil"
"os"
"strconv" "strconv"
"strings" "strings"
"io/ioutil"
"encoding/json"
"github.com/spf13/cobra" "github.com/spf13/cobra"
"github.com/spf13/viper" "github.com/spf13/viper"
// TODO : Use log
//log "github.com/sirupsen/logrus"
) )
const ( const (
gVersion = "0.25" gVersion = "0.26a"
) )
var ( var (
gJails []Jail gJails []Jail
gUseSudo bool gUseSudo bool
gConfigFile string gConfigFile string
gDisplayColumns string gDisplayColumns string
gFilterJails string gFilterJails string
gSortFields string gSortFields string
gNoLineSep bool gNoLineSep bool
gHostVersion float64 gHostVersion float64
gTimeZone string gTimeZone string
gSnapshotName string gSnapshotName string
rootCmd = & cobra.Command { rootCmd = &cobra.Command{
Use: "gocage", Use: "gocage",
Short: "GoCage is a FreeBSD Jail management tool", 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. 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.`, It support iocage jails and can coexist with iocage.`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("GoCage v.%s on FreeBSD %.1f\n", gVersion, gHostVersion) fmt.Printf("GoCage v.%s on FreeBSD %.1f\n", gVersion, gHostVersion)
@ -43,19 +45,19 @@ It support iocage jails and can coexist with iocage.`,
}, },
} }
versionCmd = &cobra.Command { 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 on FreeBSD %.1f\n", gVersion, gHostVersion) fmt.Printf("GoCage v.%s on FreeBSD %.1f\n", gVersion, gHostVersion)
}, },
} }
listCmd = &cobra.Command { listCmd = &cobra.Command{
Use: "list", Use: "list",
Short: "Print jails", 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 Jail list can be restricted by adding name on command line
ex: gocage list srv-db srv-web`, ex: gocage list srv-db srv-web`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
@ -63,7 +65,7 @@ ex: gocage list srv-db srv-web`,
}, },
} }
listPropsCmd = &cobra.Command { listPropsCmd = &cobra.Command{
Use: "properties", Use: "properties",
Short: "Print jails properties", Short: "Print jails properties",
Long: "Display jails properties. You can use properties to filter, get or set them.", Long: "Display jails properties. You can use properties to filter, get or set them.",
@ -72,7 +74,7 @@ ex: gocage list srv-db srv-web`,
}, },
} }
stopCmd = &cobra.Command { stopCmd = &cobra.Command{
Use: "stop", Use: "stop",
Short: "stop jail", Short: "stop jail",
Long: "shutdown jail", Long: "shutdown jail",
@ -83,7 +85,7 @@ ex: gocage list srv-db srv-web`,
}, },
} }
startCmd = &cobra.Command { startCmd = &cobra.Command{
Use: "start", Use: "start",
Short: "start jail", Short: "start jail",
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
@ -94,20 +96,20 @@ ex: gocage list srv-db srv-web`,
}, },
} }
/* shellCmd = &cobra.Command { /* shellCmd = &cobra.Command {
Use: "console", Use: "console",
Short: "Execute shell on jail", Short: "Execute shell on jail",
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
// Load inventory // Load inventory
ListJails(args, false) ListJails(args, false)
ShellJail(args) ShellJail(args)
}, },
} }
*/ */
setCmd = &cobra.Command { setCmd = &cobra.Command{
Use: "set", Use: "set",
Short: "Set a jail property", Short: "Set a jail property",
Long: `Set jail property value. Specify property=value, end command with jail name. 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)`, Multiples properties can be specified, separated with space (Ex: gocage set allow_mlock=1 boot=1 myjail)`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
// Load inventory // Load inventory
@ -117,10 +119,10 @@ Multiples properties can be specified, separated with space (Ex: gocage set allo
}, },
} }
getCmd = &cobra.Command { getCmd = &cobra.Command{
Use: "get", Use: "get",
Short: "Get a jail property", Short: "Get a jail property",
Long: `Get jail property value. Specify property, end command with jail name. 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) 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)`, For all properties specify "all" (Ex: gocage get all myjail)`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
@ -130,7 +132,7 @@ For all properties specify "all" (Ex: gocage get all myjail)`,
}, },
} }
snapshotCmd = &cobra.Command { snapshotCmd = &cobra.Command{
Use: "snapshot", Use: "snapshot",
Short: "snapshot jail", Short: "snapshot jail",
Long: "Commands to manage jail snapshots. If no arguments given, ", Long: "Commands to manage jail snapshots. If no arguments given, ",
@ -139,10 +141,10 @@ For all properties specify "all" (Ex: gocage get all myjail)`,
}, },
} }
snapshotListCmd = &cobra.Command { snapshotListCmd = &cobra.Command{
Use: "list", Use: "list",
Short: "list snapshots", Short: "list snapshots",
Long: `List snapshots of a jail by specifying its name. Long: `List snapshots of a jail by specifying its name.
List all snapshots if no jail name specified. List all snapshots if no jail name specified.
You can specify multiple jails.`, You can specify multiple jails.`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
@ -152,11 +154,11 @@ You can specify multiple jails.`,
}, },
} }
snapshotCreateCmd = &cobra.Command { snapshotCreateCmd = &cobra.Command{
Use: "create", Use: "create",
Short: "create snapshots", Short: "create snapshots",
Long: `Create snapshot of a jail by specifying snapshot name and jail name.`, Long: `Create snapshot of a jail by specifying snapshot name and jail name.`,
// You can specify multiple jails.`, // You can specify multiple jails.`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
// Load inventory // Load inventory
ListJails(args, false) ListJails(args, false)
@ -164,11 +166,11 @@ You can specify multiple jails.`,
}, },
} }
snapshotRollbackCmd = &cobra.Command { snapshotRollbackCmd = &cobra.Command{
Use: "rollback", Use: "rollback",
Short: "Rollback snapshots", Short: "Rollback snapshots",
Long: `Rollback jail to specifyed snapshot.`, Long: `Rollback jail to specifyed snapshot.`,
// You can specify multiple jails.`, // You can specify multiple jails.`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
// Load inventory // Load inventory
ListJails(args, false) ListJails(args, false)
@ -176,7 +178,7 @@ You can specify multiple jails.`,
}, },
} }
snapshotDeleteCmd = &cobra.Command { snapshotDeleteCmd = &cobra.Command{
Use: "destroy", Use: "destroy",
Short: "destroy snapshots", Short: "destroy snapshots",
Long: `Destroy snapshot of a jail by specifying snapshot name and jail name.`, Long: `Destroy snapshot of a jail by specifying snapshot name and jail name.`,
@ -189,17 +191,16 @@ You can specify multiple jails.`,
} }
) )
// TODO : Init log level and log output
func init() { func init() {
cobra.OnInitialize(initConfig) 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().StringVarP(&gTimeZone, "timezone", "t", "", "Specify timezone. Will get from /var/db/zoneinfo if not set.")
// Command dependant switches // Command dependant switches
// These are persistent so we can reuse them in "gocage list snapshot myjail" command (TODO) // These are persistent so we can reuse them in "gocage list snapshot myjail" command (TODO)
listCmd.PersistentFlags().StringVarP(&gDisplayColumns, "outcol", "o", "JID,Name,Config.Release,Config.Ip4_addr,Running", "Show these columns in output") listCmd.PersistentFlags().StringVarP(&gDisplayColumns, "outcol", "o", "JID,Name,Config.Release,Config.Ip4_addr,Running", "Show these columns in output")
@ -215,7 +216,7 @@ func init() {
snapshotRollbackCmd.Flags().StringVarP(&gSnapshotName, "snapname", "n", "", "Name of the snapshot to rollback to") snapshotRollbackCmd.Flags().StringVarP(&gSnapshotName, "snapname", "n", "", "Name of the snapshot to rollback to")
snapshotRollbackCmd.MarkFlagRequired("snapname") snapshotRollbackCmd.MarkFlagRequired("snapname")
// Now declare commands // Now declare commands
rootCmd.AddCommand(versionCmd) rootCmd.AddCommand(versionCmd)
rootCmd.AddCommand(listCmd) rootCmd.AddCommand(listCmd)
listCmd.AddCommand(listPropsCmd) listCmd.AddCommand(listPropsCmd)
@ -245,7 +246,7 @@ func initConfig() {
os.Exit(1) os.Exit(1)
} }
// fmt.Printf("We are in initConfig(), with config file %s\n", gConfigFile) // fmt.Printf("We are in initConfig(), with config file %s\n", gConfigFile)
viper.SetConfigFile(gConfigFile) viper.SetConfigFile(gConfigFile)
@ -254,9 +255,9 @@ func initConfig() {
os.Exit(1) os.Exit(1)
} }
// fmt.Println("Using config file:", viper.ConfigFileUsed()) // fmt.Println("Using config file:", viper.ConfigFileUsed())
// fmt.Printf("datastore in config : %s\n", viper.GetStringSlice("datastore")) // fmt.Printf("datastore in config : %s\n", viper.GetStringSlice("datastore"))
// fmt.Printf("datastore.0 in config : %s\n", viper.GetStringSlice("datastore.0")) // fmt.Printf("datastore.0 in config : %s\n", viper.GetStringSlice("datastore.0"))
// Command line flags have priority on config file // Command line flags have priority on config file
if rootCmd.Flags().Lookup("sudo") != nil && false == rootCmd.Flags().Lookup("sudo").Changed { if rootCmd.Flags().Lookup("sudo") != nil && false == rootCmd.Flags().Lookup("sudo").Changed {
@ -292,7 +293,6 @@ func initConfig() {
} }
} }
/******************************************************************************** /********************************************************************************
* Write jails config which been updated to disk. * Write jails config which been updated to disk.
* If changeauto not set, values which are in "auto" mode on disk * If changeauto not set, values which are in "auto" mode on disk
@ -352,5 +352,3 @@ func Execute() {
os.Exit(1) os.Exit(1)
} }
} }

18
cmd/snapshots.go
View File

@ -1,13 +1,13 @@
package cmd package cmd
import ( import (
"os"
"fmt"
"time"
"bufio" "bufio"
"errors" "errors"
"fmt"
"os"
"regexp" "regexp"
"strings" "strings"
"time"
) )
/******************************************************************************** /********************************************************************************
@ -36,10 +36,9 @@ func ListJailsSnapshots(args []string) {
} }
} }
} }
displaySnapshotsFields(snapshots, []string{"Jailname","Name","Creation","Referenced","Used"}) displaySnapshotsFields(snapshots, []string{"Jailname", "Name", "Creation", "Referenced", "Used"})
} }
/******************************************************************************** /********************************************************************************
* List all snapshots a jail have * List all snapshots a jail have
*******************************************************************************/ *******************************************************************************/
@ -73,12 +72,12 @@ func listJailSnapshots(jail Jail) []Snapshot {
subdir := strings.Replace(strings.Split(ls[0], "@")[0], rootDataset, "", 1) subdir := strings.Replace(strings.Split(ls[0], "@")[0], rootDataset, "", 1)
snapshots = append(snapshots, Snapshot{Dsname: ls[0], snapshots = append(snapshots, Snapshot{Dsname: ls[0],
Name: fmt.Sprintf("%s%s", strings.Split(ls[0], "@")[1], subdir), Name: fmt.Sprintf("%s%s", strings.Split(ls[0], "@")[1], subdir),
Jailname: jail.Name, Jailname: jail.Name,
Mountpoint: ls[1], Mountpoint: ls[1],
Used: ls[2], Used: ls[2],
Referenced: ls[3], Referenced: ls[3],
Creation: creationts}) Creation: creationts})
} }
} }
@ -89,7 +88,6 @@ func listJailSnapshots(jail Jail) []Snapshot {
return snapshots return snapshots
} }
/******************************************************************************** /********************************************************************************
* Create snapshot for jail(s) * Create snapshot for jail(s)
*******************************************************************************/ *******************************************************************************/

470
cmd/start.go
View File

@ -1,13 +1,16 @@
package cmd package cmd
import ( import (
"os"
"fmt"
"errors" "errors"
"regexp" "fmt"
"strings" "github.com/c-robinson/iplib"
"strconv" log "github.com/sirupsen/logrus"
"io/ioutil" "io/ioutil"
"net"
"os"
"regexp"
"strconv"
"strings"
) )
// FIXME : Do not work?! // FIXME : Do not work?!
@ -93,22 +96,22 @@ func mountAllJailFsFromHost(jail *Jail) error {
devfsFound := false devfsFound := false
fdescfsFound := false fdescfsFound := false
cmd := "mount -p" cmd := "mount -p"
out, err := executeCommand(cmd) out, err := executeCommand(cmd)
if err != nil { if err != nil {
return errors.New(fmt.Sprintf("Error executing mount: %s", err.Error())) return errors.New(fmt.Sprintf("Error executing mount: %s", err.Error()))
} }
var outclean []string var outclean []string
remSpPtrn := regexp.MustCompile(`\s+`) remSpPtrn := regexp.MustCompile(`\s+`)
for _, l := range strings.Split(out, "\n") { for _, l := range strings.Split(out, "\n") {
outclean = append(outclean, remSpPtrn.ReplaceAllString(l, " ")) outclean = append(outclean, remSpPtrn.ReplaceAllString(l, " "))
} }
// Check if these FS are already mounted // Check if these FS are already mounted
for _, l := range outclean { for _, l := range outclean {
f := strings.Split(l, " ") f := strings.Split(l, " ")
if len(f) > 2 { if len(f) > 2 {
if strings.EqualFold(f[1], fmt.Sprintf("%s/proc", jail.RootPath)) { if strings.EqualFold(f[1], fmt.Sprintf("%s/proc", jail.RootPath)) {
procfsFound = true procfsFound = true
@ -128,22 +131,22 @@ func mountAllJailFsFromHost(jail *Jail) error {
// Mount wanted FS // Mount wanted FS
if jail.Config.Mount_procfs > 0 && procfsFound == false { if jail.Config.Mount_procfs > 0 && procfsFound == false {
err := mountProcFs(jail) err := mountProcFs(jail)
if err != nil { if err != nil {
return err return err
} }
} }
if jail.Config.Mount_linprocfs > 0 && linProcfsFound == false { if jail.Config.Mount_linprocfs > 0 && linProcfsFound == false {
err = mountLinProcFs(jail) err = mountLinProcFs(jail)
if err != nil { if err != nil {
return err return err
} }
} }
if jail.Config.Mount_devfs > 0 && devfsFound == false { if jail.Config.Mount_devfs > 0 && devfsFound == false {
err := mountDevFs(jail) err := mountDevFs(jail)
if err != nil { if err != nil {
return err return err
} }
} }
if jail.Config.Mount_fdescfs > 0 && fdescfsFound == false { if jail.Config.Mount_fdescfs > 0 && fdescfsFound == false {
@ -153,7 +156,6 @@ func mountAllJailFsFromHost(jail *Jail) error {
} }
} }
// Ces montages doivent-ils etre effectués une fois le jail démarré? // Ces montages doivent-ils etre effectués une fois le jail démarré?
// FreeBSD <= 9.3 do not support fdescfs // FreeBSD <= 9.3 do not support fdescfs
@ -186,10 +188,9 @@ func mountAllJailFsFromHost(jail *Jail) error {
} }
} }
return nil return nil
} }
// TODO // TODO
func prepareJailedZfsDatasets(jail *Jail) error { func prepareJailedZfsDatasets(jail *Jail) error {
if jail.Config.Jail_zfs > 0 { if jail.Config.Jail_zfs > 0 {
@ -229,9 +230,9 @@ func prepareJailedZfsDatasets(jail *Jail) error {
} }
type NatDesc struct { type NatDesc struct {
Proto string Proto string
JailPort string JailPort string
HostPort string HostPort string
} }
// tcp(80:8080),tcp(3300-3310:33060-33070) // tcp(80:8080),tcp(3300-3310:33060-33070)
@ -262,7 +263,7 @@ func getNatForwardsArray(nat_forwards string, decompose_range bool) ([]NatDesc,
if (ejrange - sjrange) != (ehrange - shrange) { if (ejrange - sjrange) != (ehrange - shrange) {
return res, errors.New(fmt.Sprintf("Invalid port range in nat_forwards: %s", match[0])) return res, errors.New(fmt.Sprintf("Invalid port range in nat_forwards: %s", match[0]))
} }
for i := sjrange ; i <= ejrange ; i++ { for i := sjrange; i <= ejrange; i++ {
nd := NatDesc{Proto: match[1], nd := NatDesc{Proto: match[1],
JailPort: strconv.Itoa(i), JailPort: strconv.Itoa(i),
HostPort: strconv.Itoa(shrange + (i - sjrange)), HostPort: strconv.Itoa(shrange + (i - sjrange)),
@ -271,8 +272,8 @@ func getNatForwardsArray(nat_forwards string, decompose_range bool) ([]NatDesc,
} }
} else { } else {
nd := NatDesc{Proto: match[1], nd := NatDesc{Proto: match[1],
JailPort: match[2], JailPort: match[2],
HostPort: match[3], HostPort: match[3],
} }
res = append(res, nd) res = append(res, nd)
} }
@ -281,6 +282,216 @@ func getNatForwardsArray(nat_forwards string, decompose_range bool) ([]NatDesc,
return res, nil return res, nil
} }
func enableRcKeyValue(rcconfpath string, key string, value string) error {
cmd := fmt.Sprintf("/usr/sbin/sysrc -f %s %s=%s", rcconfpath, key, value)
_, err := executeCommand(cmd)
if err != nil {
return err
}
return nil
}
func disableRcKey(rcconfpath string, key string) error {
cmd := fmt.Sprintf("/usr/sbin/sysrc -f %s -x %s", rcconfpath, key)
_, err := executeCommand(cmd)
if err != nil {
return err
}
return nil
}
/*****************************************************************************
* Enable or disables DHCP or accept_rtadv for interfaces declared with this
* option
****************************************************************************/
func configureDhcpOrAcceptRtadv(jail *Jail, ipproto int, enable bool) error {
var nics []string
// Iocage legacy behavior to enable on all interfaces if Config.Dhcp is set...
if ipproto == IPv4 && jail.Config.Dhcp > 0 || enable == false {
nic_list := strings.Split(jail.Config.Interfaces, ",")
for _, n := range nic_list {
nics = append(nics, strings.Split(n, ":")[0])
}
// ...else enable for selected interface in Config.IpX_addr
} else {
if ipproto == IPv4 {
for _, i := range strings.Split(jail.Config.Ip4_addr, ",") {
if strings.EqualFold(strings.ToLower(strings.Split(i, "|")[1]), "dhcp") {
nics = append(nics, i)
}
}
} else {
for _, i := range strings.Split(jail.Config.Ip6_addr, ",") {
if strings.EqualFold(strings.ToLower(strings.Split(i, "|")[1]), "accept_rtadv") {
nics = append(nics, i)
}
}
}
}
for _, n := range nics {
// vnet0 is epair0b inside jail
if strings.Contains(n, "vnet") {
n = fmt.Sprintf("%sb", strings.Replace(n, "vnet", "epair", 1))
}
key := fmt.Sprintf("ifconfig_%s", n)
value := "SYNCDHCP"
if ipproto == IPv6 {
key = fmt.Sprintf("%s_ipv6", key)
value = "inet6 auto_linklocal accept_rtadv autoconf"
}
if enable == true {
err := enableRcKeyValue(jail.ConfigPath, key, value)
if err != nil {
return fmt.Errorf("ERROR setting %s=%s with sysrc for jail %s: %s\n", key, value, jail.Name, err)
}
} else {
err := disableRcKey(jail.ConfigPath, key)
if err != nil {
return fmt.Errorf("ERROR deleting %s with sysrc for jail %s: %s\n", key, value, jail.Name, err)
}
}
}
return nil
}
func checkRtsold(jail *Jail) error {
if strings.Contains(jail.Config.Ip6_addr, "accept_rtadv") == false {
return fmt.Errorf("Must set at least one ip6_addr to accept_rtadv!\n")
}
err := enableRcKeyValue(jail.ConfigPath, "rtsold_enable", "yes")
if err != nil {
return fmt.Errorf("ERROR setting rtsold_enable=YES with sysrc for jail %s: %s\n", jail.Name, err)
}
return nil
}
func checkNat(backend string) error {
cmd := "/sbin/sysctl -q net.inet.ip.forwarding=1"
_, err := executeCommand(cmd)
if err != nil {
return fmt.Errorf("ERROR executing \"/sbin/sysctl -q net.inet.ip.forwarding=1\": %s", err)
}
if strings.EqualFold(backend, "pf") {
// Load module and enable pf
out, err := executeCommand("/sbin/kldload -n pf")
if err != nil {
if false == strings.Contains(out, "module already loaded or in kernel") {
return fmt.Errorf("ERROR executing \"/sbin/kldload pf\": %s", err)
}
}
out, err = executeCommand("/sbin/pfctl -e")
if err != nil {
if false == strings.Contains(out, "pf already enabled") {
return fmt.Errorf("ERROR executing \"/sbin/pfctl -e\": %s", err)
}
}
} else if strings.EqualFold(backend, "ipwf") {
// Check if module loaded
out, err := executeCommand("/sbin/sysctl net.inet.ip.fw.enable=1")
if err != nil {
if false == strings.Contains(out, "unknown oid 'net.inet.ip.fw.enable'") {
return fmt.Errorf("ERROR executing \"/sbin/sysctl net.inet.ip.fw.enable=1\": %s", err)
}
}
_, _ = executeCommand("/bin/kenv net.inet.ip.fw.default_to_accept=1")
_, _ = executeCommand("/sbin/kldload -n ipfw")
_, _ = executeCommand("/sbin/kldload -n ipfw_nat")
_, err = executeCommand("/sbin/sysctl -q net.inet.ip.fw.enable=1")
if err != nil {
return fmt.Errorf("ERROR executing \"/sbin/sysctl -q net.inet.ip.fw.enable=1\": %s", err)
}
}
return nil
}
func getJailsInUseIPv4() ([]string, error) {
var ips []string
re := regexp.MustCompile(ifconfigipv4re)
for _, j := range gJails {
out, err := executeCommandInJail(&j, "/sbin/ifconfig")
if err != nil {
return ips, fmt.Errorf("ERROR executing \"/sbin/ifconfig\" in jail %s: %s", j.Name, err)
}
for _, line := range strings.Split(out, "\n") {
if re.MatchString(line) {
ips = append(ips, re.FindStringSubmatch(line)[1])
}
}
}
return ips, nil
}
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 genNatIpv4(jail *Jail) ([]string, error) {
var ippair []string
// Get all IP in use, host and jails
inuseip4, err := getHostInUseIPv4()
if err != nil {
return ippair, err
}
ij, err := getJailsInUseIPv4()
if err != nil {
return ippair, err
}
inuseip4 = append(inuseip4, ij...)
// TODO : Voir https://github.com/iocage/iocage/blob/e94863d4c54f02523fb09e62e48be7db9ac92eda/iocage_lib/ioc_common.py#L1026
for i := 0; i < 256; i++ {
for j := 0; j < 256; j += 4 {
n := iplib.NewNet4(net.ParseIP(fmt.Sprintf("172.16.%d.%d", i, j)), 30)
for _, ip := range n.Enumerate(0, 0) {
ippair = append(ippair, ip.String())
}
found := false
for _, ip := range inuseip4 {
for _, ipn := range ippair {
if ip == ipn {
found = true
}
}
}
if found == false {
return ippair, nil
}
}
}
return ippair, nil
}
/* /*
Start jail: Start jail:
Check jail fstab? Check jail fstab?
@ -309,6 +520,7 @@ func getNatForwardsArray(nat_forwards string, decompose_range bool) ([]NatDesc,
func StartJail(args []string) { func StartJail(args []string) {
// jail we have to start // jail we have to start
var cj *Jail var cj *Jail
var err error
for _, j := range args { for _, j := range args {
fmt.Printf("> Starting jail %s\n", j) fmt.Printf("> Starting jail %s\n", j)
@ -344,8 +556,8 @@ func StartJail(args []string) {
} }
var props_missing []string var props_missing []string
// DHCP can also be set with "DHCP" value in ip4_addr // DHCP can also be set with "dhcp" value in ip4_addr (Eg: "vnet0|dhcp")
if cj.Config.Dhcp > 0 || strings.EqualFold(cj.Config.Ip4_addr, "DHCP") == true { if cj.Config.Dhcp > 0 || strings.Contains(strings.ToLower(cj.Config.Ip4_addr), "dhcp") == true {
if cj.Config.Bpf == 0 { if cj.Config.Bpf == 0 {
props_missing = append(props_missing, fmt.Sprintf("%s: dhcp requires bpf", cj.Name)) props_missing = append(props_missing, fmt.Sprintf("%s: dhcp requires bpf", cj.Name))
} }
@ -376,7 +588,7 @@ func StartJail(args []string) {
for _, cjn := range cjnd { for _, cjn := range cjnd {
if jn == cjn { if jn == cjn {
fmt.Printf("nat_forwards rule \"%s\" is in conflict with jail %s, won't start\n", fmt.Printf("nat_forwards rule \"%s\" is in conflict with jail %s, won't start\n",
fmt.Sprintf("%s(%s:%s)", cjn.Proto, cjn.JailPort, cjn.HostPort), j.Name) fmt.Sprintf("%s(%s:%s)", cjn.Proto, cjn.JailPort, cjn.HostPort), j.Name)
return return
} }
} }
@ -403,7 +615,48 @@ func StartJail(args []string) {
// "auto" default Gateway should not be updated to support jailhost route change // "auto" default Gateway should not be updated to support jailhost route change
} }
// Continue here if strings.EqualFold(cj.Config.Ip6_addr, "accept_rtadv") && cj.Config.Vnet == 0 {
props_missing = append(props_missing, fmt.Sprintf("%s: accept_rtadv requires vnet", cj.Name))
}
if cj.Config.Bpf > 0 && cj.Config.Vnet == 0 {
props_missing = append(props_missing, fmt.Sprintf("%s: bpf requires vnet", cj.Name))
}
if len(props_missing) > 0 {
for _, m := range props_missing {
fmt.Printf("%s\n", m)
}
return
}
if cj.Config.Dhcp > 0 || strings.Contains(strings.ToLower(cj.Config.Ip4_addr), "dhcp") == true {
err = configureDhcpOrAcceptRtadv(cj, IPv4, true)
} else {
err = configureDhcpOrAcceptRtadv(cj, IPv4, false)
}
if err != nil {
fmt.Printf(err.Error())
return
}
if cj.Config.Rtsold > 0 {
err = checkRtsold(cj)
}
if err != nil {
fmt.Printf(err.Error())
return
}
if strings.Contains(strings.ToLower(cj.Config.Ip6_addr), "accept_rtadv") == true {
err = configureDhcpOrAcceptRtadv(cj, IPv6, true)
} else {
err = configureDhcpOrAcceptRtadv(cj, IPv6, false)
}
if err != nil {
fmt.Printf(err.Error())
return
}
fmt.Printf(" > Mount special filesystems:\n") fmt.Printf(" > Mount special filesystems:\n")
err := mountAllJailFsFromHost(cj) err := mountAllJailFsFromHost(cj)
@ -423,76 +676,115 @@ func StartJail(args []string) {
} }
} }
// TODO : Check capabilites relative to FreeBSD Version when executing jail with all parameters
// See l.335 of https://github.com/iocage/iocage/blob/e94863d4c54f02523fb09e62e48be7db9ac92eda/iocage_lib/ioc_start.py
//checkCapabilities(cj)
/* // Check NAT backend
out, err := executeCommand(fmt.Sprintf("rctl jail:%s", cj.InternalName)) if cj.Config.Nat > 0 {
if err == nil && len(out) > 0 { log.Debug("Check NAT backend %s\n", cj.Config.Nat_backend)
fmt.Printf(" > Remove RCTL rules:\n") err = checkNat(cj.Config.Nat_backend)
err := removeRctlRules(cj.InternalName, []string{""})
if err != nil { if err != nil {
fmt.Printf("ERROR: %s\n", err.Error()) fmt.Printf(err.Error())
return
}
if cj.Config.Vnet == 0 {
log.Debug("Generate NAT IPv4 without VNet")
ip4, err := genNatIpv4(cj)
if err != nil {
fmt.Printf("%s\n", err.Error())
return
}
log.Debug("Configuring NAT : Set ip4_addr to %s", ip4[0])
// This IP should not be saved into json
cj.Config.Ip4_addr = fmt.Sprintf("%s|%s", cj.Config.Nat_interface, ip4[0])
} else { } else {
fmt.Printf(" > Remove RCTL rules: OK\n") log.Debug("Generate NAT IPv4 with VNet")
ip4, err := genNatIpv4(cj)
if err != nil {
fmt.Printf("%s\n", err.Error())
return
}
log.Debug("Configuring NAT : Set ip4_addr to %s, defaultrouter to %s", ip4[1], ip4[0])
// This IP should not be saved into json
cj.Config.Ip4_addr = fmt.Sprintf("vnet0|%s", ip4[1])
cj.Config.Defaultrouter = ip4[0]
} }
} }
if len (cj.Config.Exec_prestop) > 0 { // CONTINUE HERE
fmt.Printf(" > Execute prestop:\n") // See https://github.com/iocage/iocage/blob/e94863d4c54f02523fb09e62e48be7db9ac92eda/iocage_lib/ioc_start.py:401
_, err := executeCommand(cj.Config.Exec_prestop)
/*
out, err := executeCommand(fmt.Sprintf("rctl jail:%s", cj.InternalName))
if err == nil && len(out) > 0 {
fmt.Printf(" > Remove RCTL rules:\n")
err := removeRctlRules(cj.InternalName, []string{""})
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Remove RCTL rules: OK\n")
}
}
if len (cj.Config.Exec_prestop) > 0 {
fmt.Printf(" > Execute prestop:\n")
_, err := executeCommand(cj.Config.Exec_prestop)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Execute prestop: OK\n")
}
}
if len (cj.Config.Exec_stop) > 0 {
fmt.Printf(" > Execute stop:\n")
_, err := executeCommandInJail(cj, cj.Config.Exec_stop)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Execute stop: OK\n")
}
}
if cj.Config.Jail_zfs > 0 {
fmt.Printf(" > Umount jailed ZFS:\n")
err := umountAndUnjailZFS(cj)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Umount jailed ZFS: OK\n")
}
}
if cj.Config.Vnet > 0 && len(cj.Config.Ip4_addr) > 0 {
fmt.Printf(" > Destroy VNet interfaces:\n")
err := destroyVNetInterfaces(cj)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Destroy VNet interfaces: OK\n")
}
}
fmt.Printf(" > Remove devfsruleset %s:\n", cj.Config.Devfs_ruleset)
err = deleteDevfsRuleset(cj)
if err != nil { if err != nil {
fmt.Printf("ERROR: %s\n", err.Error()) fmt.Printf("ERROR: %s\n", err.Error())
} else { } else {
fmt.Printf(" > Execute prestop: OK\n") fmt.Printf(" > Remove devfsruleset %s: OK\n", cj.Config.Devfs_ruleset)
} }
}
if len (cj.Config.Exec_stop) > 0 { fmt.Printf(" > Stop jail %s:\n", cj.Name)
fmt.Printf(" > Execute stop:\n") err = stopJail(cj)
_, err := executeCommandInJail(cj, cj.Config.Exec_stop)
if err != nil { if err != nil {
fmt.Printf("ERROR: %s\n", err.Error()) fmt.Printf("ERROR: %s\n", err.Error())
} else { } else {
fmt.Printf(" > Execute stop: OK\n") fmt.Printf(" > Stop jail %s: OK\n", cj.Name)
} }
} */
if cj.Config.Jail_zfs > 0 {
fmt.Printf(" > Umount jailed ZFS:\n")
err := umountAndUnjailZFS(cj)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Umount jailed ZFS: OK\n")
}
}
if cj.Config.Vnet > 0 && len(cj.Config.Ip4_addr) > 0 {
fmt.Printf(" > Destroy VNet interfaces:\n")
err := destroyVNetInterfaces(cj)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Destroy VNet interfaces: OK\n")
}
}
fmt.Printf(" > Remove devfsruleset %s:\n", cj.Config.Devfs_ruleset)
err = deleteDevfsRuleset(cj)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Remove devfsruleset %s: OK\n", cj.Config.Devfs_ruleset)
}
fmt.Printf(" > Stop jail %s:\n", cj.Name)
err = stopJail(cj)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Stop jail %s: OK\n", cj.Name)
}
*/
} }
} }

17
cmd/stop.go
View File

@ -1,13 +1,13 @@
package cmd package cmd
import ( import (
"os"
"fmt" "fmt"
// "log" "os"
// "log"
"errors" "errors"
"regexp"
"os/exec" "os/exec"
// "reflect" "regexp"
// "reflect"
"strings" "strings"
) )
@ -38,7 +38,6 @@ func removeRctlRules(jail string, rules []string) error {
return nil return nil
} }
// TODO: Validate with >1 dataset // TODO: Validate with >1 dataset
func umountAndUnjailZFS(jail *Jail) error { func umountAndUnjailZFS(jail *Jail) error {
var ds []string var ds []string
@ -79,7 +78,6 @@ func umountAndUnjailZFS(jail *Jail) error {
return nil return nil
} }
func destroyVNetInterfaces(jail *Jail) error { func destroyVNetInterfaces(jail *Jail) error {
for _, i := range strings.Split(jail.Config.Ip4_addr, ",") { for _, i := range strings.Split(jail.Config.Ip4_addr, ",") {
iname := fmt.Sprintf("%s.%d", strings.Split(i, "|")[0], jail.JID) iname := fmt.Sprintf("%s.%d", strings.Split(i, "|")[0], jail.JID)
@ -119,7 +117,6 @@ func deleteDevfsRuleset(jail *Jail) error {
return nil return nil
} }
func umountJailFsFromHost(jail *Jail, mountpoint string) error { func umountJailFsFromHost(jail *Jail, mountpoint string) error {
cmd := "mount -p" cmd := "mount -p"
out, err := executeCommand(cmd) out, err := executeCommand(cmd)
@ -145,7 +142,6 @@ func umountJailFsFromHost(jail *Jail, mountpoint string) error {
return nil return nil
} }
// Internal usage only // Internal usage only
func stopJail(jail *Jail) error { func stopJail(jail *Jail) error {
cmd := "jail -q" cmd := "jail -q"
@ -221,7 +217,7 @@ 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 prestop:\n")
_, err := executeCommand(cj.Config.Exec_prestop) _, err := executeCommand(cj.Config.Exec_prestop)
if err != nil { if err != nil {
@ -231,7 +227,7 @@ func StopJail(args []string) {
} }
} }
if len (cj.Config.Exec_stop) > 0 { if len(cj.Config.Exec_stop) > 0 {
fmt.Printf(" > Execute stop:\n") fmt.Printf(" > Execute stop:\n")
_, err := executeCommandInJail(cj, cj.Config.Exec_stop) _, err := executeCommandInJail(cj, cj.Config.Exec_stop)
if err != nil { if err != nil {
@ -340,4 +336,3 @@ func StopJail(args []string) {
} }
} }
} }

933
cmd/struct.go
View File

@ -4,19 +4,24 @@ import (
"time" "time"
) )
const (
IPv4 = 0
IPv6 = 1
)
// To allow sorting, just duplicate fields in JailSort below // To allow sorting, just duplicate fields in JailSort below
type Jail struct { 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
ConfigUpdated bool ConfigUpdated bool
Running bool Running bool
// No need, Config.Release always represent what is running (plus it know release for non-running jails) // No need, Config.Release always represent what is running (plus it know release for non-running jails)
//Release string //Release string
Zpool string Zpool string
} }
// iocage struct as stored in config.json // iocage struct as stored in config.json
@ -28,483 +33,483 @@ type Jail struct {
// //
// To allow sorting, just duplicate fields in JailConfigSort below // To allow sorting, just duplicate fields in JailConfigSort below
type JailConfig struct { 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"` Interfaces string `json:"interfaces"`
Ip4 string `json:"ip4"` Ip4 string `json:"ip4"`
Ip4_addr string `json:"ip4_addr"` Ip4_addr string `json:"ip4_addr"`
Ip4_saddrsel string `json:"ip4_saddrsel"` Ip4_saddrsel string `json:"ip4_saddrsel"`
Ip6 string `json:"ip6"` Ip6 string `json:"ip6"`
Ip6_addr string `json:"ip6_addr"` Ip6_addr string `json:"ip6_addr"`
Ip6_saddrsel string `json:"ip4_saddrsel"` Ip6_saddrsel string `json:"ip4_saddrsel"`
Ip_hostname int `json:"ip_hostname"` Ip_hostname int `json:"ip_hostname"`
Jail_zfs int `json:"jail_zfs"` Jail_zfs int `json:"jail_zfs"`
Jail_zfs_dataset string `json:"jail_zfs_dataset"` Jail_zfs_dataset string `json:"jail_zfs_dataset"`
Jail_zfs_mountpoint string `json:"jail_zfs_mountpoint"` Jail_zfs_mountpoint string `json:"jail_zfs_mountpoint"`
Last_started string `json:"last_started"` Last_started string `json:"last_started"`
Localhost_ip string `json:"localhost_ip"` Localhost_ip string `json:"localhost_ip"`
Login_flags string `json:"login_flags"` Login_flags string `json:"login_flags"`
Mac_prefix string `json:"mac_prefix"` Mac_prefix string `json:"mac_prefix"`
Maxproc string `json:"maxproc"` Maxproc string `json:"maxproc"`
Memorylocked string `json:"memorylocked"` Memorylocked string `json:"memorylocked"`
Memoryuse string `json:"memoryuse"` Memoryuse string `json:"memoryuse"`
Min_dyn_devfs_ruleset string `json:"min_dyn_devfs_ruleset"` Min_dyn_devfs_ruleset string `json:"min_dyn_devfs_ruleset"`
Mount_devfs int `json:"mount_devfs"` Mount_devfs int `json:"mount_devfs"`
Mount_fdescfs int `json:"mount_fdescfs"` Mount_fdescfs int `json:"mount_fdescfs"`
Mount_linprocfs int `json:"mount_linprocfs"` Mount_linprocfs int `json:"mount_linprocfs"`
Mount_procfs int `json:"mount_procfs"` Mount_procfs int `json:"mount_procfs"`
Mountpoint string `json:"mountpoint"` Mountpoint string `json:"mountpoint"`
Msgqqueued string `json:"msgqqueued"` Msgqqueued string `json:"msgqqueued"`
Msgqsize string `json:"msgqsize"` Msgqsize string `json:"msgqsize"`
Nat int `json:"nat"` Nat int `json:"nat"`
Nat_backend string `json:"nat_backend"` Nat_backend string `json:"nat_backend"`
Nat_forwards string `json:"nat_forwards"` Nat_forwards string `json:"nat_forwards"`
Nat_interface string `json:"nat_interface"` Nat_interface string `json:"nat_interface"`
Nat_prefix string `json:"nat_prefix"` Nat_prefix string `json:"nat_prefix"`
Nmsgq string `json:"nmsgq"` Nmsgq string `json:"nmsgq"`
Notes string `json:"notes"` Notes string `json:"notes"`
Nsem string `json:"nsem"` Nsem string `json:"nsem"`
Nsemop string `json:"nsemop"` Nsemop string `json:"nsemop"`
Nshm string `json:"nshm"` Nshm string `json:"nshm"`
Nthr string `json:"nthr"` Nthr string `json:"nthr"`
Openfiles string `json:"openfiles"` Openfiles string `json:"openfiles"`
Origin string `json:"origin"` Origin string `json:"origin"`
Owner string `json:"owner"` Owner string `json:"owner"`
Pcpu string `json:"pcpu"` Pcpu string `json:"pcpu"`
Plugin_name string `json:"plugin_name"` Plugin_name string `json:"plugin_name"`
Plugin_repository string `json:"plugin_repository"` Plugin_repository string `json:"plugin_repository"`
Priority string `json:"priority"` Priority string `json:"priority"`
Pseudoterminals string `json:"pseudoterminals"` Pseudoterminals string `json:"pseudoterminals"`
Quota string `json:"quota"` Quota string `json:"quota"`
Readbps string `json:"readbps"` Readbps string `json:"readbps"`
Readiops string `json:"readiops"` Readiops string `json:"readiops"`
Release string `json:"release"` Release string `json:"release"`
Reservation string `json:"reservation"` Reservation string `json:"reservation"`
Resolver string `json:"resolver"` Resolver string `json:"resolver"`
Rlimits string `json:"rlimits"` Rlimits string `json:"rlimits"`
Rtsold int `json:"rtsold"` Rtsold int `json:"rtsold"`
Securelevel string `json:"securelevel"` Securelevel string `json:"securelevel"`
Shmsize string `json:"shmsize"` Shmsize string `json:"shmsize"`
Stacksize string `json:"stacksize"` Stacksize string `json:"stacksize"`
Stop_timeout string `json:"stop_timeout"` Stop_timeout string `json:"stop_timeout"`
Swapuse string `json:"swapuse"` Swapuse string `json:"swapuse"`
Sync_state string `json:"sync_state"` Sync_state string `json:"sync_state"`
Sync_target string `json:"sync_target"` Sync_target string `json:"sync_target"`
Sync_tgt_zpool string `json:"sync_tgt_zpool"` Sync_tgt_zpool string `json:"sync_tgt_zpool"`
Sysvmsg string `json:"sysvmsg"` Sysvmsg string `json:"sysvmsg"`
Sysvsem string `json:"sysvsem"` Sysvsem string `json:"sysvsem"`
Sysvshm string `json:"sysvshm"` Sysvshm string `json:"sysvshm"`
Template int `json:"template"` Template int `json:"template"`
// Go don't like a variable named "type" (And i dont care about finding a cleaner way) // 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"`
} }
// Represent an fstab line // Represent an fstab line
type Mount struct { type Mount struct {
Device string Device string
Mountpoint string Mountpoint string
Type string Type string
Options []string Options []string
Fs_Freq int Fs_Freq int
Fs_Passno int Fs_Passno int
} }
type Snapshot struct { type Snapshot struct {
// snapshot name is stored after '@' in dataset name // snapshot name is stored after '@' in dataset name
Name string Name string
Dsname string Dsname string
Jailname string Jailname string
Mountpoint string Mountpoint string
Used string Used string
Referenced string Referenced string
Creation time.Time Creation time.Time
} }
// Fields in this struct are acquired by their name using reflection // Fields in this struct are acquired by their name using reflection
// So these char are forbidden for field name: -+. // So these char are forbidden for field name: -+.
// //
type JailSort struct { type JailSort struct {
NameInc jailLessFunc NameInc jailLessFunc
NameDec jailLessFunc NameDec jailLessFunc
InternalNameInc jailLessFunc InternalNameInc jailLessFunc
InternalNameDec jailLessFunc InternalNameDec jailLessFunc
JIDInc jailLessFunc JIDInc jailLessFunc
JIDDec jailLessFunc JIDDec jailLessFunc
RootPathInc jailLessFunc RootPathInc jailLessFunc
RootPathDec jailLessFunc RootPathDec jailLessFunc
ConfigPathInc jailLessFunc ConfigPathInc jailLessFunc
ConfigPathDec jailLessFunc ConfigPathDec jailLessFunc
RunningInc jailLessFunc RunningInc jailLessFunc
RunningDec jailLessFunc RunningDec jailLessFunc
ZpoolInc jailLessFunc ZpoolInc jailLessFunc
ZpoolDec jailLessFunc ZpoolDec jailLessFunc
Config JailConfigSort Config JailConfigSort
} }
type JailConfigSort struct { type JailConfigSort struct {
Config_versionInc jailLessFunc Config_versionInc jailLessFunc
Config_versionDec jailLessFunc Config_versionDec jailLessFunc
Allow_chflagsInc jailLessFunc Allow_chflagsInc jailLessFunc
Allow_chflagsDec jailLessFunc Allow_chflagsDec jailLessFunc
Allow_mlockInc jailLessFunc Allow_mlockInc jailLessFunc
Allow_mlockDec jailLessFunc Allow_mlockDec jailLessFunc
Allow_mountInc jailLessFunc Allow_mountInc jailLessFunc
Allow_mountDec jailLessFunc Allow_mountDec jailLessFunc
Allow_mount_devfsInc jailLessFunc Allow_mount_devfsInc jailLessFunc
Allow_mount_devfsDec jailLessFunc Allow_mount_devfsDec jailLessFunc
Allow_mount_fusefsInc jailLessFunc Allow_mount_fusefsInc jailLessFunc
Allow_mount_fusefsDec jailLessFunc Allow_mount_fusefsDec jailLessFunc
Allow_mount_nullfsInc jailLessFunc Allow_mount_nullfsInc jailLessFunc
Allow_mount_nullfsDec jailLessFunc Allow_mount_nullfsDec jailLessFunc
Allow_mount_procfsInc jailLessFunc Allow_mount_procfsInc jailLessFunc
Allow_mount_procfsDec jailLessFunc Allow_mount_procfsDec jailLessFunc
Allow_mount_tmpfsInc jailLessFunc Allow_mount_tmpfsInc jailLessFunc
Allow_mount_tmpfsDec jailLessFunc Allow_mount_tmpfsDec jailLessFunc
Allow_mount_zfsInc jailLessFunc Allow_mount_zfsInc jailLessFunc
Allow_mount_zfsDec jailLessFunc Allow_mount_zfsDec jailLessFunc
Allow_quotasInc jailLessFunc Allow_quotasInc jailLessFunc
Allow_quotasDec jailLessFunc Allow_quotasDec jailLessFunc
Allow_raw_socketsInc jailLessFunc Allow_raw_socketsInc jailLessFunc
Allow_raw_socketsDec jailLessFunc Allow_raw_socketsDec jailLessFunc
Allow_set_hostnameInc jailLessFunc Allow_set_hostnameInc jailLessFunc
Allow_set_hostnameDec jailLessFunc Allow_set_hostnameDec jailLessFunc
Allow_socket_afInc jailLessFunc Allow_socket_afInc jailLessFunc
Allow_socket_afDec jailLessFunc Allow_socket_afDec jailLessFunc
Allow_sysvipcInc jailLessFunc Allow_sysvipcInc jailLessFunc
Allow_sysvipcDec jailLessFunc Allow_sysvipcDec jailLessFunc
Allow_tunInc jailLessFunc Allow_tunInc jailLessFunc
Allow_tunDec jailLessFunc Allow_tunDec jailLessFunc
Allow_vmmInc jailLessFunc Allow_vmmInc jailLessFunc
Allow_vmmDec jailLessFunc Allow_vmmDec jailLessFunc
Assign_localhostInc jailLessFunc Assign_localhostInc jailLessFunc
Assign_localhostDec jailLessFunc Assign_localhostDec jailLessFunc
AvailableInc jailLessFunc AvailableInc jailLessFunc
AvailableDec jailLessFunc AvailableDec jailLessFunc
BasejailInc jailLessFunc BasejailInc jailLessFunc
BasejailDec jailLessFunc BasejailDec jailLessFunc
BootInc jailLessFunc BootInc jailLessFunc
BootDec jailLessFunc BootDec jailLessFunc
BpfInc jailLessFunc BpfInc jailLessFunc
BpfDec jailLessFunc BpfDec jailLessFunc
Children_maxInc jailLessFunc Children_maxInc jailLessFunc
Children_maxDec jailLessFunc Children_maxDec jailLessFunc
Cloned_releaseInc jailLessFunc Cloned_releaseInc jailLessFunc
Cloned_releaseDec jailLessFunc Cloned_releaseDec jailLessFunc
CommentInc jailLessFunc CommentInc jailLessFunc
CommentDec jailLessFunc CommentDec jailLessFunc
CompressionInc jailLessFunc CompressionInc jailLessFunc
CompressionDec jailLessFunc CompressionDec jailLessFunc
CompressratioInc jailLessFunc CompressratioInc jailLessFunc
CompressratioDec jailLessFunc CompressratioDec jailLessFunc
CoredumpsizeInc jailLessFunc CoredumpsizeInc jailLessFunc
CoredumpsizeDec jailLessFunc CoredumpsizeDec jailLessFunc
CountInc jailLessFunc CountInc jailLessFunc
CountDec jailLessFunc CountDec jailLessFunc
CpusetInc jailLessFunc CpusetInc jailLessFunc
CpusetDec jailLessFunc CpusetDec jailLessFunc
CputimeInc jailLessFunc CputimeInc jailLessFunc
CputimeDec jailLessFunc CputimeDec jailLessFunc
DatasizeInc jailLessFunc DatasizeInc jailLessFunc
DatasizeDec jailLessFunc DatasizeDec jailLessFunc
DedupInc jailLessFunc DedupInc jailLessFunc
DedupDec jailLessFunc DedupDec jailLessFunc
DefaultrouterInc jailLessFunc DefaultrouterInc jailLessFunc
DefaultrouterDec jailLessFunc DefaultrouterDec jailLessFunc
Defaultrouter6Inc jailLessFunc Defaultrouter6Inc jailLessFunc
Defaultrouter6Dec jailLessFunc Defaultrouter6Dec jailLessFunc
DependsInc jailLessFunc DependsInc jailLessFunc
DependsDec jailLessFunc DependsDec jailLessFunc
Devfs_rulesetInc jailLessFunc Devfs_rulesetInc jailLessFunc
Devfs_rulesetDec jailLessFunc Devfs_rulesetDec jailLessFunc
DhcpInc jailLessFunc DhcpInc jailLessFunc
DhcpDec jailLessFunc DhcpDec jailLessFunc
Enforce_statfsInc jailLessFunc Enforce_statfsInc jailLessFunc
Enforce_statfsDec jailLessFunc Enforce_statfsDec jailLessFunc
Exec_cleanInc jailLessFunc Exec_cleanInc jailLessFunc
Exec_cleanDec jailLessFunc Exec_cleanDec jailLessFunc
Exec_createdInc jailLessFunc Exec_createdInc jailLessFunc
Exec_createdDec jailLessFunc Exec_createdDec jailLessFunc
Exec_fibInc jailLessFunc Exec_fibInc jailLessFunc
Exec_fibDec jailLessFunc Exec_fibDec jailLessFunc
Exec_jail_userInc jailLessFunc Exec_jail_userInc jailLessFunc
Exec_jail_userDec jailLessFunc Exec_jail_userDec jailLessFunc
Exec_poststartInc jailLessFunc Exec_poststartInc jailLessFunc
Exec_poststartDec jailLessFunc Exec_poststartDec jailLessFunc
Exec_poststopInc jailLessFunc Exec_poststopInc jailLessFunc
Exec_poststopDec jailLessFunc Exec_poststopDec jailLessFunc
Exec_prestartInc jailLessFunc Exec_prestartInc jailLessFunc
Exec_prestartDec jailLessFunc Exec_prestartDec jailLessFunc
Exec_prestopInc jailLessFunc Exec_prestopInc jailLessFunc
Exec_prestopDec jailLessFunc Exec_prestopDec jailLessFunc
Exec_startInc jailLessFunc Exec_startInc jailLessFunc
Exec_startDec jailLessFunc Exec_startDec jailLessFunc
Exec_stopInc jailLessFunc Exec_stopInc jailLessFunc
Exec_stopDec jailLessFunc Exec_stopDec jailLessFunc
Exec_system_jail_userInc jailLessFunc Exec_system_jail_userInc jailLessFunc
Exec_system_jail_userDec jailLessFunc Exec_system_jail_userDec jailLessFunc
Exec_system_userInc jailLessFunc Exec_system_userInc jailLessFunc
Exec_system_userDec jailLessFunc Exec_system_userDec jailLessFunc
Exec_timeoutInc jailLessFunc Exec_timeoutInc jailLessFunc
Exec_timeoutDec jailLessFunc Exec_timeoutDec jailLessFunc
Host_domainnameInc jailLessFunc Host_domainnameInc jailLessFunc
Host_domainnameDec jailLessFunc Host_domainnameDec jailLessFunc
Host_hostnameInc jailLessFunc Host_hostnameInc jailLessFunc
Host_hostnameDec jailLessFunc Host_hostnameDec jailLessFunc
Host_hostuuidInc jailLessFunc Host_hostuuidInc jailLessFunc
Host_hostuuidDec jailLessFunc Host_hostuuidDec jailLessFunc
Host_timeInc jailLessFunc Host_timeInc jailLessFunc
Host_timeDec jailLessFunc Host_timeDec jailLessFunc
HostidInc jailLessFunc HostidInc jailLessFunc
HostidDec jailLessFunc HostidDec jailLessFunc
Hostid_strict_checkInc jailLessFunc Hostid_strict_checkInc jailLessFunc
Hostid_strict_checkDec jailLessFunc Hostid_strict_checkDec jailLessFunc
InterfacesInc jailLessFunc InterfacesInc jailLessFunc
InterfacesDec jailLessFunc InterfacesDec jailLessFunc
Ip4Inc jailLessFunc Ip4Inc jailLessFunc
Ip4Dec jailLessFunc Ip4Dec jailLessFunc
Ip4_addrInc jailLessFunc Ip4_addrInc jailLessFunc
Ip4_addrDec jailLessFunc Ip4_addrDec jailLessFunc
Ip4_saddrselInc jailLessFunc Ip4_saddrselInc jailLessFunc
Ip4_saddrselDec jailLessFunc Ip4_saddrselDec jailLessFunc
Ip6Inc jailLessFunc Ip6Inc jailLessFunc
Ip6Dec jailLessFunc Ip6Dec jailLessFunc
Ip6_addrInc jailLessFunc Ip6_addrInc jailLessFunc
Ip6_addrDec jailLessFunc Ip6_addrDec jailLessFunc
Ip6_saddrselInc jailLessFunc Ip6_saddrselInc jailLessFunc
Ip6_saddrselDec jailLessFunc Ip6_saddrselDec jailLessFunc
Ip_hostnameInc jailLessFunc Ip_hostnameInc jailLessFunc
Ip_hostnameDec jailLessFunc Ip_hostnameDec jailLessFunc
Jail_zfsInc jailLessFunc Jail_zfsInc jailLessFunc
Jail_zfsDec jailLessFunc Jail_zfsDec jailLessFunc
Jail_zfs_datasetInc jailLessFunc Jail_zfs_datasetInc jailLessFunc
Jail_zfs_datasetDec jailLessFunc Jail_zfs_datasetDec jailLessFunc
Jail_zfs_mountpointInc jailLessFunc Jail_zfs_mountpointInc jailLessFunc
Jail_zfs_mountpointDec jailLessFunc Jail_zfs_mountpointDec jailLessFunc
Last_startedInc jailLessFunc Last_startedInc jailLessFunc
Last_startedDec jailLessFunc Last_startedDec jailLessFunc
Localhost_ipInc jailLessFunc Localhost_ipInc jailLessFunc
Localhost_ipDec jailLessFunc Localhost_ipDec jailLessFunc
Login_flagsInc jailLessFunc Login_flagsInc jailLessFunc
Login_flagsDec jailLessFunc Login_flagsDec jailLessFunc
Mac_prefixInc jailLessFunc Mac_prefixInc jailLessFunc
Mac_prefixDec jailLessFunc Mac_prefixDec jailLessFunc
MaxprocInc jailLessFunc MaxprocInc jailLessFunc
MaxprocDec jailLessFunc MaxprocDec jailLessFunc
MemorylockedInc jailLessFunc MemorylockedInc jailLessFunc
MemorylockedDec jailLessFunc MemorylockedDec jailLessFunc
MemoryuseInc jailLessFunc MemoryuseInc jailLessFunc
MemoryuseDec jailLessFunc MemoryuseDec jailLessFunc
Min_dyn_devfs_rulesetInc jailLessFunc Min_dyn_devfs_rulesetInc jailLessFunc
Min_dyn_devfs_rulesetDec jailLessFunc Min_dyn_devfs_rulesetDec jailLessFunc
Mount_devfsInc jailLessFunc Mount_devfsInc jailLessFunc
Mount_devfsDec jailLessFunc Mount_devfsDec jailLessFunc
Mount_fdescfsInc jailLessFunc Mount_fdescfsInc jailLessFunc
Mount_fdescfsDec jailLessFunc Mount_fdescfsDec jailLessFunc
Mount_linprocfsInc jailLessFunc Mount_linprocfsInc jailLessFunc
Mount_linprocfsDec jailLessFunc Mount_linprocfsDec jailLessFunc
Mount_procfsInc jailLessFunc Mount_procfsInc jailLessFunc
Mount_procfsDec jailLessFunc Mount_procfsDec jailLessFunc
MountpointInc jailLessFunc MountpointInc jailLessFunc
MountpointDec jailLessFunc MountpointDec jailLessFunc
MsgqqueuedInc jailLessFunc MsgqqueuedInc jailLessFunc
MsgqqueuedDec jailLessFunc MsgqqueuedDec jailLessFunc
MsgqsizeInc jailLessFunc MsgqsizeInc jailLessFunc
MsgqsizeDec jailLessFunc MsgqsizeDec jailLessFunc
NatInc jailLessFunc NatInc jailLessFunc
NatDec jailLessFunc NatDec jailLessFunc
Nat_backendInc jailLessFunc Nat_backendInc jailLessFunc
Nat_backendDec jailLessFunc Nat_backendDec jailLessFunc
Nat_forwardsInc jailLessFunc Nat_forwardsInc jailLessFunc
Nat_forwardsDec jailLessFunc Nat_forwardsDec jailLessFunc
Nat_interfaceInc jailLessFunc Nat_interfaceInc jailLessFunc
Nat_interfaceDec jailLessFunc Nat_interfaceDec jailLessFunc
Nat_prefixInc jailLessFunc Nat_prefixInc jailLessFunc
Nat_prefixDec jailLessFunc Nat_prefixDec jailLessFunc
NmsgqInc jailLessFunc NmsgqInc jailLessFunc
NmsgqDec jailLessFunc NmsgqDec jailLessFunc
NotesInc jailLessFunc NotesInc jailLessFunc
NotesDec jailLessFunc NotesDec jailLessFunc
NsemInc jailLessFunc NsemInc jailLessFunc
NsemDec jailLessFunc NsemDec jailLessFunc
NsemopInc jailLessFunc NsemopInc jailLessFunc
NsemopDec jailLessFunc NsemopDec jailLessFunc
NshmInc jailLessFunc NshmInc jailLessFunc
NshmDec jailLessFunc NshmDec jailLessFunc
NthrInc jailLessFunc NthrInc jailLessFunc
NthrDec jailLessFunc NthrDec jailLessFunc
OpenfilesInc jailLessFunc OpenfilesInc jailLessFunc
OpenfilesDec jailLessFunc OpenfilesDec jailLessFunc
OriginInc jailLessFunc OriginInc jailLessFunc
OriginDec jailLessFunc OriginDec jailLessFunc
OwnerInc jailLessFunc OwnerInc jailLessFunc
OwnerDec jailLessFunc OwnerDec jailLessFunc
PcpuInc jailLessFunc PcpuInc jailLessFunc
PcpuDec jailLessFunc PcpuDec jailLessFunc
Plugin_nameInc jailLessFunc Plugin_nameInc jailLessFunc
Plugin_nameDec jailLessFunc Plugin_nameDec jailLessFunc
Plugin_repositoryInc jailLessFunc Plugin_repositoryInc jailLessFunc
Plugin_repositoryDec jailLessFunc Plugin_repositoryDec jailLessFunc
PriorityInc jailLessFunc PriorityInc jailLessFunc
PriorityDec jailLessFunc PriorityDec jailLessFunc
PseudoterminalsInc jailLessFunc PseudoterminalsInc jailLessFunc
PseudoterminalsDec jailLessFunc PseudoterminalsDec jailLessFunc
QuotaInc jailLessFunc QuotaInc jailLessFunc
QuotaDec jailLessFunc QuotaDec jailLessFunc
ReadbpsInc jailLessFunc ReadbpsInc jailLessFunc
ReadbpsDec jailLessFunc ReadbpsDec jailLessFunc
ReadiopsInc jailLessFunc ReadiopsInc jailLessFunc
ReadiopsDec jailLessFunc ReadiopsDec jailLessFunc
ReleaseInc jailLessFunc ReleaseInc jailLessFunc
ReleaseDec jailLessFunc ReleaseDec jailLessFunc
ReservationInc jailLessFunc ReservationInc jailLessFunc
ReservationDec jailLessFunc ReservationDec jailLessFunc
ResolverInc jailLessFunc ResolverInc jailLessFunc
ResolverDec jailLessFunc ResolverDec jailLessFunc
RlimitsInc jailLessFunc RlimitsInc jailLessFunc
RlimitsDec jailLessFunc RlimitsDec jailLessFunc
RtsoldInc jailLessFunc RtsoldInc jailLessFunc
RtsoldDec jailLessFunc RtsoldDec jailLessFunc
SecurelevelInc jailLessFunc SecurelevelInc jailLessFunc
SecurelevelDec jailLessFunc SecurelevelDec jailLessFunc
ShmsizeInc jailLessFunc ShmsizeInc jailLessFunc
ShmsizeDec jailLessFunc ShmsizeDec jailLessFunc
StacksizeInc jailLessFunc StacksizeInc jailLessFunc
StacksizeDec jailLessFunc StacksizeDec jailLessFunc
Stop_timeoutInc jailLessFunc Stop_timeoutInc jailLessFunc
Stop_timeoutDec jailLessFunc Stop_timeoutDec jailLessFunc
SwapuseInc jailLessFunc SwapuseInc jailLessFunc
SwapuseDec jailLessFunc SwapuseDec jailLessFunc
Sync_stateInc jailLessFunc Sync_stateInc jailLessFunc
Sync_stateDec jailLessFunc Sync_stateDec jailLessFunc
Sync_targetInc jailLessFunc Sync_targetInc jailLessFunc
Sync_targetDec jailLessFunc Sync_targetDec jailLessFunc
Sync_tgt_zpoolInc jailLessFunc Sync_tgt_zpoolInc jailLessFunc
Sync_tgt_zpoolDec jailLessFunc Sync_tgt_zpoolDec jailLessFunc
SysvmsgInc jailLessFunc SysvmsgInc jailLessFunc
SysvmsgDec jailLessFunc SysvmsgDec jailLessFunc
SysvsemInc jailLessFunc SysvsemInc jailLessFunc
SysvsemDec jailLessFunc SysvsemDec jailLessFunc
SysvshmInc jailLessFunc SysvshmInc jailLessFunc
SysvshmDec jailLessFunc SysvshmDec jailLessFunc
TemplateInc jailLessFunc TemplateInc jailLessFunc
TemplateDec jailLessFunc TemplateDec jailLessFunc
JailtypeInc jailLessFunc JailtypeInc jailLessFunc
JailtypeDec jailLessFunc JailtypeDec jailLessFunc
UsedInc jailLessFunc UsedInc jailLessFunc
UsedDec jailLessFunc UsedDec jailLessFunc
VmemoryuseInc jailLessFunc VmemoryuseInc jailLessFunc
VmemoryuseDec jailLessFunc VmemoryuseDec jailLessFunc
VnetInc jailLessFunc VnetInc jailLessFunc
VnetDec jailLessFunc VnetDec jailLessFunc
Vnet0_macInc jailLessFunc Vnet0_macInc jailLessFunc
Vnet0_macDec jailLessFunc Vnet0_macDec jailLessFunc
Vnet1_macInc jailLessFunc Vnet1_macInc jailLessFunc
Vnet1_macDec jailLessFunc Vnet1_macDec jailLessFunc
Vnet2_macInc jailLessFunc Vnet2_macInc jailLessFunc
Vnet2_macDec jailLessFunc Vnet2_macDec jailLessFunc
Vnet3_macInc jailLessFunc Vnet3_macInc jailLessFunc
Vnet3_macDec jailLessFunc Vnet3_macDec jailLessFunc
Vnet_default_interfaceInc jailLessFunc Vnet_default_interfaceInc jailLessFunc
Vnet_default_interfaceDec jailLessFunc Vnet_default_interfaceDec jailLessFunc
Vnet_interfacesInc jailLessFunc Vnet_interfacesInc jailLessFunc
Vnet_interfacesDec jailLessFunc Vnet_interfacesDec jailLessFunc
WallclockInc jailLessFunc WallclockInc jailLessFunc
WallclockDec jailLessFunc WallclockDec jailLessFunc
WritebpsInc jailLessFunc WritebpsInc jailLessFunc
WritebpsDec jailLessFunc WritebpsDec jailLessFunc
WriteiopsInc jailLessFunc WriteiopsInc jailLessFunc
WriteiopsDec jailLessFunc WriteiopsDec jailLessFunc
} }
type SnapshotSort struct { type SnapshotSort struct {
NameInc snapshotLessFunc NameInc snapshotLessFunc
NameDec snapshotLessFunc NameDec snapshotLessFunc
DsnameInc snapshotLessFunc DsnameInc snapshotLessFunc
DsnameDec snapshotLessFunc DsnameDec snapshotLessFunc
JailnameInc snapshotLessFunc JailnameInc snapshotLessFunc
JailnameDec snapshotLessFunc JailnameDec snapshotLessFunc
MountpointInc snapshotLessFunc MountpointInc snapshotLessFunc
MountpointDec snapshotLessFunc MountpointDec snapshotLessFunc
UsedInc snapshotLessFunc UsedInc snapshotLessFunc
UsedDec snapshotLessFunc UsedDec snapshotLessFunc
ReferencedInc snapshotLessFunc ReferencedInc snapshotLessFunc
ReferencedDec snapshotLessFunc ReferencedDec snapshotLessFunc
CreationInc snapshotLessFunc CreationInc snapshotLessFunc
CreationDec snapshotLessFunc CreationDec snapshotLessFunc
} }
type JailHost struct { type JailHost struct {
hostname string hostname string
hostid string hostid string
default_gateway4 string default_gateway4 string
default_gateway6 string default_gateway6 string
default_interface string default_interface string
} }

599
cmd/utils.go
View File

@ -1,19 +1,23 @@
package cmd package cmd
import ( import (
"os"
"fmt"
"log"
"sort"
"bufio" "bufio"
"errors" "errors"
"fmt"
"io/ioutil"
"log"
"os"
"os/exec" "os/exec"
"reflect" "reflect"
"strings" "sort"
"strconv" "strconv"
"io/ioutil" "strings"
) )
const (
ipv4re = `[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}`
ifconfigipv4re = `inet[[:space:]](` + ipv4re + `)`
)
/***************************************************************************** /*****************************************************************************
* Mandatory constructor for JailConfig type. It set default values * Mandatory constructor for JailConfig type. It set default values
@ -28,134 +32,134 @@ func NewJailConfig() (JailConfig, error) {
hostid = []byte(strings.Replace(string(hostid), "\n", "", -1)) hostid = []byte(strings.Replace(string(hostid), "\n", "", -1))
} }
jc.Allow_chflags = 0 jc.Allow_chflags = 0
jc.Allow_mlock = 0 jc.Allow_mlock = 0
jc.Allow_mount = 0 jc.Allow_mount = 0
jc.Allow_mount_devfs = 0 jc.Allow_mount_devfs = 0
jc.Allow_mount_fusefs = 0 jc.Allow_mount_fusefs = 0
jc.Allow_mount_nullfs = 0 jc.Allow_mount_nullfs = 0
jc.Allow_mount_procfs = 0 jc.Allow_mount_procfs = 0
jc.Allow_mount_tmpfs = 0 jc.Allow_mount_tmpfs = 0
jc.Allow_mount_zfs = 0 jc.Allow_mount_zfs = 0
jc.Allow_quotas = 0 jc.Allow_quotas = 0
jc.Allow_raw_sockets = 0 jc.Allow_raw_sockets = 0
jc.Allow_socket_af = 0 jc.Allow_socket_af = 0
jc.Allow_set_hostname = 1 jc.Allow_set_hostname = 1
jc.Allow_sysvipc = 0 jc.Allow_sysvipc = 0
jc.Allow_tun = 0 jc.Allow_tun = 0
jc.Allow_vmm = 0 jc.Allow_vmm = 0
jc.Assign_localhost = 0 jc.Assign_localhost = 0
jc.Available = "readonly" jc.Available = "readonly"
jc.Basejail = 0 jc.Basejail = 0
jc.Bpf = 0 jc.Bpf = 0
jc.Boot = 0 jc.Boot = 0
jc.Children_max = "0" jc.Children_max = "0"
jc.Comment = "none" jc.Comment = "none"
jc.Compression = "lz4" jc.Compression = "lz4"
jc.Compressratio = "readonly" jc.Compressratio = "readonly"
jc.Coredumpsize = "off" jc.Coredumpsize = "off"
jc.Count = "1" jc.Count = "1"
jc.Cpuset = "off" jc.Cpuset = "off"
jc.Cputime = "off" jc.Cputime = "off"
jc.Datasize = "off" jc.Datasize = "off"
jc.Dedup = "off" jc.Dedup = "off"
jc.Defaultrouter = "auto" jc.Defaultrouter = "auto"
jc.Defaultrouter6 = "auto" jc.Defaultrouter6 = "auto"
jc.Depends = "none" jc.Depends = "none"
jc.Devfs_ruleset = "4" jc.Devfs_ruleset = "4"
jc.Dhcp = 0 jc.Dhcp = 0
jc.Enforce_statfs = "2" jc.Enforce_statfs = "2"
jc.Exec_clean = 1 jc.Exec_clean = 1
jc.Exec_created = "/usr/bin/true" jc.Exec_created = "/usr/bin/true"
jc.Exec_jail_user = "root" jc.Exec_jail_user = "root"
jc.Exec_fib = "0" jc.Exec_fib = "0"
jc.Exec_poststart = "/usr/bin/true" jc.Exec_poststart = "/usr/bin/true"
jc.Exec_poststop = "/usr/bin/true" jc.Exec_poststop = "/usr/bin/true"
jc.Exec_prestart = "/usr/bin/true" jc.Exec_prestart = "/usr/bin/true"
jc.Exec_prestop = "/usr/bin/true" jc.Exec_prestop = "/usr/bin/true"
jc.Exec_system_jail_user = "0" jc.Exec_system_jail_user = "0"
jc.Exec_system_user = "root" jc.Exec_system_user = "root"
jc.Exec_start = "/bin/sh /etc/rc" jc.Exec_start = "/bin/sh /etc/rc"
jc.Exec_stop = "/bin/sh /etc/rc.shutdown" jc.Exec_stop = "/bin/sh /etc/rc.shutdown"
jc.Exec_timeout = "60" jc.Exec_timeout = "60"
jc.Hostid = string(hostid) jc.Hostid = string(hostid)
jc.Hostid_strict_check = 0 jc.Hostid_strict_check = 0
jc.Host_time = 1 jc.Host_time = 1
jc.Interfaces = "vnet0:bridge0" jc.Interfaces = "vnet0:bridge0"
jc.Ip4_addr = "none" jc.Ip4_addr = "none"
jc.Ip4_saddrsel = "1" jc.Ip4_saddrsel = "1"
jc.Ip4 = "new" jc.Ip4 = "new"
jc.Ip6_addr = "none" jc.Ip6_addr = "none"
jc.Ip6_saddrsel = "1" jc.Ip6_saddrsel = "1"
jc.Ip6 = "new" jc.Ip6 = "new"
jc.Ip_hostname = 0 jc.Ip_hostname = 0
jc.Jailtype = "jail" jc.Jailtype = "jail"
jc.Jail_zfs = 0 jc.Jail_zfs = 0
jc.Jail_zfs_mountpoint = "none" jc.Jail_zfs_mountpoint = "none"
jc.Last_started = "none" jc.Last_started = "none"
jc.Localhost_ip = "none" jc.Localhost_ip = "none"
jc.Login_flags = "-f root" jc.Login_flags = "-f root"
jc.Maxproc = "off" jc.Maxproc = "off"
jc.Min_dyn_devfs_ruleset = "1000" jc.Min_dyn_devfs_ruleset = "1000"
jc.Memoryuse = "off" jc.Memoryuse = "off"
jc.Memorylocked = "off" jc.Memorylocked = "off"
jc.Mountpoint = "readonly" jc.Mountpoint = "readonly"
jc.Mount_devfs = 1 jc.Mount_devfs = 1
jc.Mount_fdescfs = 1 jc.Mount_fdescfs = 1
jc.Mount_procfs = 0 jc.Mount_procfs = 0
jc.Mount_linprocfs = 0 jc.Mount_linprocfs = 0
jc.Msgqqueued = "off" jc.Msgqqueued = "off"
jc.Msgqsize = "off" jc.Msgqsize = "off"
jc.Nat = 0 jc.Nat = 0
jc.Nat_backend = "ipfw" jc.Nat_backend = "ipfw"
jc.Nat_forwards = "none" jc.Nat_forwards = "none"
jc.Nat_interface = "none" jc.Nat_interface = "none"
jc.Nat_prefix = "172.16" jc.Nat_prefix = "172.16"
jc.Nmsgq = "off" jc.Nmsgq = "off"
jc.Notes = "none" jc.Notes = "none"
jc.Nsem = "off" jc.Nsem = "off"
jc.Nsemop = "off" jc.Nsemop = "off"
jc.Nshm = "off" jc.Nshm = "off"
jc.Nthr = "off" jc.Nthr = "off"
jc.Openfiles = "off" jc.Openfiles = "off"
jc.Origin = "readonly" jc.Origin = "readonly"
jc.Owner = "root" jc.Owner = "root"
jc.Pcpu = "off" jc.Pcpu = "off"
jc.Plugin_name = "none" jc.Plugin_name = "none"
jc.Plugin_repository = "none" jc.Plugin_repository = "none"
jc.Priority = "99" jc.Priority = "99"
jc.Pseudoterminals = "off" jc.Pseudoterminals = "off"
jc.Quota = "none" jc.Quota = "none"
jc.Readbps = "off" jc.Readbps = "off"
jc.Readiops = "off" jc.Readiops = "off"
jc.Reservation = "none" jc.Reservation = "none"
jc.Resolver = "/etc/resolv.conf" jc.Resolver = "/etc/resolv.conf"
jc.Rlimits = "off" jc.Rlimits = "off"
jc.Rtsold = 0 jc.Rtsold = 0
jc.Securelevel = "2" jc.Securelevel = "2"
jc.Shmsize = "off" jc.Shmsize = "off"
jc.Stacksize = "off" jc.Stacksize = "off"
jc.Stop_timeout = "30" jc.Stop_timeout = "30"
jc.Sync_state = "none" jc.Sync_state = "none"
jc.Sync_target = "none" jc.Sync_target = "none"
jc.Sync_tgt_zpool = "none" jc.Sync_tgt_zpool = "none"
jc.Sysvmsg = "new" jc.Sysvmsg = "new"
jc.Sysvsem = "new" jc.Sysvsem = "new"
jc.Sysvshm = "new" jc.Sysvshm = "new"
jc.Swapuse = "off" jc.Swapuse = "off"
jc.Template = 0 jc.Template = 0
jc.Used = "readonly" jc.Used = "readonly"
jc.Vmemoryuse = "off" jc.Vmemoryuse = "off"
jc.Vnet = 0 jc.Vnet = 0
jc.Vnet0_mac = "none" jc.Vnet0_mac = "none"
jc.Vnet1_mac = "none" jc.Vnet1_mac = "none"
jc.Vnet2_mac = "none" jc.Vnet2_mac = "none"
jc.Vnet3_mac = "none" jc.Vnet3_mac = "none"
jc.Vnet_default_interface = "auto" jc.Vnet_default_interface = "auto"
jc.Vnet_interfaces = "none" jc.Vnet_interfaces = "none"
jc.Wallclock = "off" jc.Wallclock = "off"
jc.Writebps = "off" jc.Writebps = "off"
jc.Writeiops = "off" jc.Writeiops = "off"
return jc, nil return jc, nil
} }
@ -166,49 +170,48 @@ func NewJailConfig() (JailConfig, error) {
* *
*****************************************************************************/ *****************************************************************************/
func executeCommand(cmdline string) (string, error) { func executeCommand(cmdline string) (string, error) {
var cmd []string var cmd []string
var out []byte var out []byte
var err error var err error
if gUseSudo { if gUseSudo {
cmd = append(cmd, "sudo") cmd = append(cmd, "sudo")
} }
cs := strings.Split(cmdline, " ") cs := strings.Split(cmdline, " ")
cmd = append(cmd, cs...) cmd = append(cmd, cs...)
if len (cmd) > 1 { if len(cmd) > 1 {
out, err = exec.Command(cmd[0], cmd[1:]...).Output() out, err = exec.Command(cmd[0], cmd[1:]...).Output()
} else { } else {
out, err = exec.Command(cmd[0]).Output() out, err = exec.Command(cmd[0]).Output()
} }
return string(out), err return string(out), err
} }
func executeCommandInJail(jail *Jail, cmdline string) (string, error) { func executeCommandInJail(jail *Jail, cmdline string) (string, error) {
var cmd []string var cmd []string
if gUseSudo { if gUseSudo {
cmd = append(cmd, "sudo") cmd = append(cmd, "sudo")
} }
cmd = append(cmd, "setfib") cmd = append(cmd, "setfib")
if len(jail.Config.Exec_fib) > 0 { if len(jail.Config.Exec_fib) > 0 {
cmd = append(cmd, jail.Config.Exec_fib) cmd = append(cmd, jail.Config.Exec_fib)
} else { } else {
cmd = append(cmd, "0") cmd = append(cmd, "0")
} }
cmd = append(cmd, "jexec", jail.InternalName) cmd = append(cmd, "jexec", jail.InternalName)
cs := strings.Split(cmdline, " ") cs := strings.Split(cmdline, " ")
cmd = append(cmd, cs...) cmd = append(cmd, cs...)
out, err := exec.Command(cmd[0], cmd[1:]...).Output() out, err := exec.Command(cmd[0], cmd[1:]...).Output()
return string(out), err return string(out), err
} }
/***************************************************************************** /*****************************************************************************
@ -238,12 +241,12 @@ func getFstab(path string) ([]Mount, error) {
return mounts, fmt.Errorf("Incorrect format for fstab line %s: Pass is not an integer\n", scan.Text()) return mounts, fmt.Errorf("Incorrect format for fstab line %s: Pass is not an integer\n", scan.Text())
} }
m := Mount{ m := Mount{
Device : res[0], Device: res[0],
Mountpoint : res[1], Mountpoint: res[1],
Type : res[2], Type: res[2],
Options : strings.Split(res[3], ","), Options: strings.Split(res[3], ","),
Fs_Freq : freq, Fs_Freq: freq,
Fs_Passno : pass, Fs_Passno: pass,
} }
mounts = append(mounts, m) mounts = append(mounts, m)
} }
@ -251,7 +254,6 @@ func getFstab(path string) ([]Mount, error) {
return mounts, nil return mounts, nil
} }
/******************************************************************************** /********************************************************************************
* Get a specific jail source reference, to update properties after a range loop * Get a specific jail source reference, to update properties after a range loop
*******************************************************************************/ *******************************************************************************/
@ -269,40 +271,40 @@ func getJailFromArray(internalName string, jarray []Jail) (*Jail, error) {
* Nested fields are named with a dot (ex "MyStruct.MyField") * Nested fields are named with a dot (ex "MyStruct.MyField")
*******************************************************************************/ *******************************************************************************/
func getStructFieldKind(parentStruct interface{}, fieldName string) (reflect.Kind, string, error) { func getStructFieldKind(parentStruct interface{}, fieldName string) (reflect.Kind, string, error) {
v := reflect.ValueOf(parentStruct) v := reflect.ValueOf(parentStruct)
if v.Kind() == reflect.Ptr { if v.Kind() == reflect.Ptr {
v = v.Elem() v = v.Elem()
} }
// For debugging // For debugging
if false { if false {
for i := 0 ; i < v.NumField(); i++ { for i := 0; i < v.NumField(); i++ {
f := v.Field(i) f := v.Field(i)
if f.Kind() == reflect.String { if f.Kind() == reflect.String {
fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface()) fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface())
} }
} }
} }
if strings.Contains(fieldName, ".") { if strings.Contains(fieldName, ".") {
fs := strings.Split(fieldName, ".") fs := strings.Split(fieldName, ".")
f := v.FieldByName(fs[0]) f := v.FieldByName(fs[0])
if f.Kind() == reflect.Struct { if f.Kind() == reflect.Struct {
return getStructFieldKind(f.Interface(), strings.Join(fs[1:], ".")) return getStructFieldKind(f.Interface(), strings.Join(fs[1:], "."))
} else { } else {
return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("%s is not a struct: %s\n", fs[0], f.Kind().String())) return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("%s is not a struct: %s\n", fs[0], f.Kind().String()))
} }
} else { } else {
f := v.FieldByName(fieldName) f := v.FieldByName(fieldName)
if f.IsValid() { if f.IsValid() {
return f.Kind(), fieldName, nil return f.Kind(), fieldName, nil
} else { } else {
return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName)) return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName))
} }
} }
return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName)) return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName))
} }
/******************************************************************************** /********************************************************************************
@ -313,7 +315,7 @@ func getStructFieldKind(parentStruct interface{}, fieldName string) (reflect.Kin
func getStructFieldNames(parentStruct interface{}, result []string, prefix string) []string { func getStructFieldNames(parentStruct interface{}, result []string, prefix string) []string {
v := reflect.ValueOf(parentStruct) v := reflect.ValueOf(parentStruct)
for i := 0 ; i < v.NumField() ; i++ { for i := 0; i < v.NumField(); i++ {
if v.Type().Field(i).Type.Kind() == reflect.Struct { if v.Type().Field(i).Type.Kind() == reflect.Struct {
result = getStructFieldNames(v.Field(i).Interface(), result, v.Type().Field(i).Name) result = getStructFieldNames(v.Field(i).Interface(), result, v.Type().Field(i).Name)
} else { } else {
@ -337,7 +339,8 @@ func getStructFieldValue(parentStruct interface{}, fieldName string) (*reflect.V
v := reflect.ValueOf(parentStruct) v := reflect.ValueOf(parentStruct)
// Get value while we're dealing with pointers // Get value while we're dealing with pointers
for ; v.Kind() == reflect.Ptr ; v = v.Elem() {} for ; v.Kind() == reflect.Ptr; v = v.Elem() {
}
if v.Kind() != reflect.Struct { if v.Kind() != reflect.Struct {
return &v, fieldName, errors.New(fmt.Sprintf("parentStruct is not a struct! Kind: %s", v.Kind().String())) return &v, fieldName, errors.New(fmt.Sprintf("parentStruct is not a struct! Kind: %s", v.Kind().String()))
@ -346,7 +349,7 @@ func getStructFieldValue(parentStruct interface{}, fieldName string) (*reflect.V
typeOfV := v.Type() typeOfV := v.Type()
if false { if false {
for i := 0 ; i < v.NumField(); i++ { for i := 0; i < v.NumField(); i++ {
f := v.Field(i) f := v.Field(i)
if f.Kind() == reflect.String { if f.Kind() == reflect.String {
fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface()) fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface())
@ -361,7 +364,7 @@ func getStructFieldValue(parentStruct interface{}, fieldName string) (*reflect.V
// Loop through properties // Loop through properties
for i, curF := range fs { for i, curF := range fs {
found = false found = false
for j := 0 ; j < v.NumField() ; j++ { for j := 0; j < v.NumField(); j++ {
if typeOfV.Field(j).Name == curF { if typeOfV.Field(j).Name == curF {
f = v.Field(j) f = v.Field(j)
found = true found = true
@ -372,7 +375,8 @@ func getStructFieldValue(parentStruct interface{}, fieldName string) (*reflect.V
return &v, fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName)) return &v, fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName))
} }
for ; f.Kind() == reflect.Ptr ; f = f.Elem() {} for ; f.Kind() == reflect.Ptr; f = f.Elem() {
}
/*fmt.Printf("v.kind() = %v\n", v.Kind().String()) /*fmt.Printf("v.kind() = %v\n", v.Kind().String())
fmt.Printf("v = %v\n", v) fmt.Printf("v = %v\n", v)
@ -397,7 +401,6 @@ func getStructFieldValue(parentStruct interface{}, fieldName string) (*reflect.V
return &v, fieldName, nil return &v, fieldName, nil
} }
/******************************************************************************** /********************************************************************************
* TODO : Replace by getStructFieldValue * TODO : Replace by getStructFieldValue
* Recurse into structure, returning reflect.Value of wanted field. * Recurse into structure, returning reflect.Value of wanted field.
@ -411,7 +414,7 @@ func getStructField(parentStruct interface{}, fieldName string) (reflect.Value,
} }
if false { if false {
for i := 0 ; i < v.NumField(); i++ { for i := 0; i < v.NumField(); i++ {
f := v.Field(i) f := v.Field(i)
if f.Kind() == reflect.String { if f.Kind() == reflect.String {
fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface()) fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface())
@ -442,22 +445,22 @@ func setStructFieldValue(parentStruct interface{}, propName string, propValue st
if val.CanSet() { if val.CanSet() {
switch val.Kind() { switch val.Kind() {
case reflect.String: case reflect.String:
val.SetString(propValue) val.SetString(propValue)
case reflect.Int: case reflect.Int:
ival, err := strconv.ParseInt(propValue, 10, 64) ival, err := strconv.ParseInt(propValue, 10, 64)
if err != nil { if err != nil {
return err return err
} }
val.SetInt(ival) val.SetInt(ival)
case reflect.Bool: case reflect.Bool:
bval, err := strconv.ParseBool(propValue) bval, err := strconv.ParseBool(propValue)
if err != nil { if err != nil {
return err return err
} }
val.SetBool(bval) val.SetBool(bval)
default: default:
return errors.New(fmt.Sprintf("Field is an unkown type: %s: %s", propName, val.Kind().String())) return errors.New(fmt.Sprintf("Field is an unkown type: %s: %s", propName, val.Kind().String()))
} }
} else { } else {
return errors.New(fmt.Sprintf("Field is not writable : %s", propName)) return errors.New(fmt.Sprintf("Field is not writable : %s", propName))
@ -480,9 +483,9 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
* Its value * Its value
*/ */
type Field struct { type Field struct {
Name string Name string
MaxLen int MaxLen int
Value string Value string
} }
type Line []Field type Line []Field
@ -501,7 +504,7 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
for i, f := range valsToDisplay { for i, f := range valsToDisplay {
a, f := getStructField(tj, f) a, f := getStructField(tj, f)
field := Field { field := Field{
Name: f, Name: f,
} }
if a.FieldByName(f).IsValid() { if a.FieldByName(f).IsValid() {
@ -530,7 +533,7 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
// Get real maximum length // Get real maximum length
maxlen := make([]int, len(valsToDisplay)) maxlen := make([]int, len(valsToDisplay))
for i := 0; i< len(valsToDisplay); i++ { for i := 0; i < len(valsToDisplay); i++ {
maxlen[i] = len(valsToDisplay[i]) maxlen[i] = len(valsToDisplay[i])
} }
for _, l := range out { for _, l := range out {
@ -567,13 +570,16 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
// Lets draw things on the screen! // Lets draw things on the screen!
// First, headers: 1st separator line // First, headers: 1st separator line
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { fmt.Printf("+") } if i == 0 {
for i := 0 ; i < f.MaxLen+2 ; i++ { fmt.Printf("=") } fmt.Printf("+")
}
for i := 0; i < f.MaxLen+2; i++ {
fmt.Printf("=")
}
fmt.Printf("+") fmt.Printf("+")
} }
fmt.Printf("\n") fmt.Printf("\n")
// Column names // Column names
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { if i == 0 {
@ -583,7 +589,7 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
* fmt.Printf(" %s", f.Name) * fmt.Printf(" %s", f.Name)
* for i := len(f.Name)+1 ; i < f.MaxLen+1 ; i++ { */ * for i := len(f.Name)+1 ; i < f.MaxLen+1 ; i++ { */
fmt.Printf(" %s", valsToDisplay[i]) fmt.Printf(" %s", valsToDisplay[i])
for i := len(valsToDisplay[i])+1 ; i < f.MaxLen+1 ; i++ { for i := len(valsToDisplay[i]) + 1; i < f.MaxLen+1; i++ {
fmt.Printf(" ") fmt.Printf(" ")
} }
fmt.Printf(" |") fmt.Printf(" |")
@ -591,8 +597,12 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
// Finally separator line // Finally separator line
fmt.Printf("\n") fmt.Printf("\n")
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { fmt.Printf("+") } if i == 0 {
for i := 0 ; i < f.MaxLen+2 ; i++ { fmt.Printf("=") } fmt.Printf("+")
}
for i := 0; i < f.MaxLen+2; i++ {
fmt.Printf("=")
}
fmt.Printf("+") fmt.Printf("+")
} }
fmt.Printf("\n") fmt.Printf("\n")
@ -626,7 +636,7 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
fmt.Printf(" %s", f.Value) fmt.Printf(" %s", f.Value)
} }
// Complete with spaces to the max length // Complete with spaces to the max length
for i := len(f.Value)+1 ; i < f.MaxLen+1 ; i++ { for i := len(f.Value) + 1; i < f.MaxLen+1; i++ {
fmt.Printf(" ") fmt.Printf(" ")
} }
fmt.Printf(" |") fmt.Printf(" |")
@ -648,7 +658,7 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
//fmt.Printf(" %s", f.Value) //fmt.Printf(" %s", f.Value)
} }
// Complete with spaces to the max length // Complete with spaces to the max length
for i := len(v)+1 ; i < f.MaxLen+1 ; i++ { for i := len(v) + 1; i < f.MaxLen+1; i++ {
fmt.Printf(" ") fmt.Printf(" ")
} }
fmt.Printf(" |") fmt.Printf(" |")
@ -658,8 +668,12 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
if !gNoLineSep { if !gNoLineSep {
fmt.Printf("\n") fmt.Printf("\n")
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { fmt.Printf("+") } if i == 0 {
for i := 0 ; i < f.MaxLen+2 ; i++ { fmt.Printf("-") } fmt.Printf("+")
}
for i := 0; i < f.MaxLen+2; i++ {
fmt.Printf("-")
}
fmt.Printf("+") fmt.Printf("+")
} }
} }
@ -667,8 +681,12 @@ func displayJailsFields(jails []Jail, valsToDisplay []string) {
} }
if gNoLineSep { if gNoLineSep {
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { fmt.Printf("+") } if i == 0 {
for i := 0 ; i < f.MaxLen+2 ; i++ { fmt.Printf("-") } fmt.Printf("+")
}
for i := 0; i < f.MaxLen+2; i++ {
fmt.Printf("-")
}
fmt.Printf("+") fmt.Printf("+")
} }
} }
@ -690,9 +708,9 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
* Its value * Its value
*/ */
type Field struct { type Field struct {
Name string Name string
MaxLen int MaxLen int
Value string Value string
} }
type Line []Field type Line []Field
@ -711,7 +729,7 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
for i, f := range valsToDisplay { for i, f := range valsToDisplay {
a, f := getStructField(tj, f) a, f := getStructField(tj, f)
field := Field { field := Field{
Name: f, Name: f,
} }
if a.FieldByName(f).IsValid() { if a.FieldByName(f).IsValid() {
@ -740,7 +758,7 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
// Get real maximum length // Get real maximum length
maxlen := make([]int, len(valsToDisplay)) maxlen := make([]int, len(valsToDisplay))
for i := 0; i< len(valsToDisplay); i++ { for i := 0; i < len(valsToDisplay); i++ {
maxlen[i] = len(valsToDisplay[i]) maxlen[i] = len(valsToDisplay[i])
} }
for _, l := range out { for _, l := range out {
@ -777,13 +795,16 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
// Lets draw things on the screen! // Lets draw things on the screen!
// First, headers: 1st separator line // First, headers: 1st separator line
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { fmt.Printf("+") } if i == 0 {
for i := 0 ; i < f.MaxLen+2 ; i++ { fmt.Printf("=") } fmt.Printf("+")
}
for i := 0; i < f.MaxLen+2; i++ {
fmt.Printf("=")
}
fmt.Printf("+") fmt.Printf("+")
} }
fmt.Printf("\n") fmt.Printf("\n")
// Column names // Column names
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { if i == 0 {
@ -793,7 +814,7 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
* fmt.Printf(" %s", f.Name) * fmt.Printf(" %s", f.Name)
* for i := len(f.Name)+1 ; i < f.MaxLen+1 ; i++ { */ * for i := len(f.Name)+1 ; i < f.MaxLen+1 ; i++ { */
fmt.Printf(" %s", valsToDisplay[i]) fmt.Printf(" %s", valsToDisplay[i])
for i := len(valsToDisplay[i])+1 ; i < f.MaxLen+1 ; i++ { for i := len(valsToDisplay[i]) + 1; i < f.MaxLen+1; i++ {
fmt.Printf(" ") fmt.Printf(" ")
} }
fmt.Printf(" |") fmt.Printf(" |")
@ -801,8 +822,12 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
// Finally separator line // Finally separator line
fmt.Printf("\n") fmt.Printf("\n")
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { fmt.Printf("+") } if i == 0 {
for i := 0 ; i < f.MaxLen+2 ; i++ { fmt.Printf("=") } fmt.Printf("+")
}
for i := 0; i < f.MaxLen+2; i++ {
fmt.Printf("=")
}
fmt.Printf("+") fmt.Printf("+")
} }
fmt.Printf("\n") fmt.Printf("\n")
@ -819,24 +844,24 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
fmt.Printf("|") fmt.Printf("|")
} }
// Special cases of value displaying // Special cases of value displaying
/* if f.Name == "JID" && f.Value == "0" { /* if f.Name == "JID" && f.Value == "0" {
fmt.Printf(" ") fmt.Printf(" ")
} else if f.Name == "Ip4_addr" { } else if f.Name == "Ip4_addr" {
ia := strings.Split(f.Value, ",") 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 // 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 { for i, inter := range ia {
if i > 0 { if i > 0 {
supplines[f.Name] = inter supplines[f.Name] = inter
} else { } else {
fmt.Printf(" %s", inter) fmt.Printf(" %s", inter)
} }
} }
//fmt.Printf(" %s", strings.Split(strings.Split(f.Value, "|")[1], "/")[0]) //fmt.Printf(" %s", strings.Split(strings.Split(f.Value, "|")[1], "/")[0])
} else {*/ } else {*/
fmt.Printf(" %s", f.Value) fmt.Printf(" %s", f.Value)
/*}*/ /*}*/
// Complete with spaces to the max length // Complete with spaces to the max length
for i := len(f.Value)+1 ; i < f.MaxLen+1 ; i++ { for i := len(f.Value) + 1; i < f.MaxLen+1; i++ {
fmt.Printf(" ") fmt.Printf(" ")
} }
fmt.Printf(" |") fmt.Printf(" |")
@ -858,7 +883,7 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
//fmt.Printf(" %s", f.Value) //fmt.Printf(" %s", f.Value)
} }
// Complete with spaces to the max length // Complete with spaces to the max length
for i := len(v)+1 ; i < f.MaxLen+1 ; i++ { for i := len(v) + 1; i < f.MaxLen+1; i++ {
fmt.Printf(" ") fmt.Printf(" ")
} }
fmt.Printf(" |") fmt.Printf(" |")
@ -868,8 +893,12 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
if !gNoLineSep { if !gNoLineSep {
fmt.Printf("\n") fmt.Printf("\n")
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { fmt.Printf("+") } if i == 0 {
for i := 0 ; i < f.MaxLen+2 ; i++ { fmt.Printf("-") } fmt.Printf("+")
}
for i := 0; i < f.MaxLen+2; i++ {
fmt.Printf("-")
}
fmt.Printf("+") fmt.Printf("+")
} }
} }
@ -877,8 +906,12 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
} }
if gNoLineSep { if gNoLineSep {
for i, f := range out[0] { for i, f := range out[0] {
if i == 0 { fmt.Printf("+") } if i == 0 {
for i := 0 ; i < f.MaxLen+2 ; i++ { fmt.Printf("-") } fmt.Printf("+")
}
for i := 0; i < f.MaxLen+2; i++ {
fmt.Printf("-")
}
fmt.Printf("+") fmt.Printf("+")
} }
} }
@ -886,7 +919,6 @@ func displaySnapshotsFields(snaps []Snapshot, valsToDisplay []string) {
fmt.Printf("\n") fmt.Printf("\n")
} }
/***************************************************************************** /*****************************************************************************
* *
* Sorting jails * Sorting jails
@ -1767,8 +1799,8 @@ func initJailSortStruct() JailSort {
// jailSorter implements the Sort interface, sorting the jails within. // jailSorter implements the Sort interface, sorting the jails within.
type jailSorter struct { type jailSorter struct {
jails []Jail jails []Jail
less []jailLessFunc less []jailLessFunc
} }
// Sort sorts the argument slice according to the less functions passed to JailsOrderedBy. // Sort sorts the argument slice according to the less functions passed to JailsOrderedBy.
@ -1822,7 +1854,6 @@ func (js *jailSorter) Less(i, j int) bool {
return js.less[k](p, q) return js.less[k](p, q)
} }
/***************************************************************************** /*****************************************************************************
* *
* Sorting snapshots * Sorting snapshots
@ -1882,8 +1913,8 @@ func initSnapshotSortStruct() SnapshotSort {
// snapshotSorter implements the Sort interface, sorting the jails within. // snapshotSorter implements the Sort interface, sorting the jails within.
type snapshotSorter struct { type snapshotSorter struct {
snapshots []Snapshot snapshots []Snapshot
less []snapshotLessFunc less []snapshotLessFunc
} }
// Sort sorts the argument slice according to the less functions passed to OrderedBy. // Sort sorts the argument slice according to the less functions passed to OrderedBy.
@ -1923,12 +1954,12 @@ func (ss *snapshotSorter) Less(i, j int) bool {
for k = 0; k < len(ss.less)-1; k++ { for k = 0; k < len(ss.less)-1; k++ {
less := ss.less[k] less := ss.less[k]
switch { switch {
case less(p, q): case less(p, q):
// p < q, so we have a decision. // p < q, so we have a decision.
return true return true
case less(q, p): case less(q, p):
// p > q, so we have a decision. // p > q, so we have a decision.
return false return false
} }
// p == q; try the next comparison. // p == q; try the next comparison.
} }
@ -1937,7 +1968,6 @@ func (ss *snapshotSorter) Less(i, j int) bool {
return ss.less[k](p, q) return ss.less[k](p, q)
} }
/***************************************************************************** /*****************************************************************************
* *
* Generic utilities * Generic utilities
@ -1951,4 +1981,3 @@ func isStringInArray(strarr []string, searched string) bool {
} }
return false return false
} }

2
go.mod
View File

@ -3,6 +3,8 @@ module gocage
go 1.17 go 1.17
require ( require (
github.com/c-robinson/iplib v1.0.3
github.com/sirupsen/logrus v1.8.1
github.com/spf13/cobra v1.2.1 github.com/spf13/cobra v1.2.1
github.com/spf13/viper v1.9.0 github.com/spf13/viper v1.9.0
golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420 golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420

7
main.go
View File

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