// runtimeArchitecture gets the name of the current architecture (x86, x86_64, …)
func runtimeArchitecture() (string, error) {
	utsname := &syscall.Utsname{}
	if err := syscall.Uname(utsname); err != nil {
		return "", err
	}
	return charsToString(utsname.Machine), nil
}
Beispiel #2
0
func main() {
	flag.Usage = usage
	flag.Parse()
	var err error
	switch flag.NArg() {
	case 0:
		var uts syscall.Utsname
		err = syscall.Uname(&uts)
		if err == nil {
			name := ""
			for _, r := range uts.Domainname {
				if r == 0 {
					break
				}
				name += string(r)
			}
			fmt.Println(name)
		}
	case 1:
		name := []byte(flag.Arg(0))
		err = syscall.Setdomainname(name)
	default:
		usage()
	}

	if err != nil {
		fmt.Fprintln(os.Stderr, "domainname:", err)
		os.Exit(1)
	}
}
// FIXME: Move this to utils package
func getKernelVersion() (*utils.KernelVersionInfo, error) {
	var (
		uts                  syscall.Utsname
		flavor               string
		kernel, major, minor int
		err                  error
	)

	if err := syscall.Uname(&uts); err != nil {
		return nil, err
	}

	release := make([]byte, len(uts.Release))

	i := 0
	for _, c := range uts.Release {
		release[i] = byte(c)
		i++
	}

	// Remove the \x00 from the release for Atoi to parse correctly
	release = release[:bytes.IndexByte(release, 0)]

	tmp := strings.SplitN(string(release), "-", 2)
	tmp2 := strings.SplitN(tmp[0], ".", 3)

	if len(tmp2) > 0 {
		kernel, err = strconv.Atoi(tmp2[0])
		if err != nil {
			return nil, err
		}
	}

	if len(tmp2) > 1 {
		major, err = strconv.Atoi(tmp2[1])
		if err != nil {
			return nil, err
		}
	}

	if len(tmp2) > 2 {
		minor, err = strconv.Atoi(tmp2[2])
		if err != nil {
			return nil, err
		}
	}

	if len(tmp) == 2 {
		flavor = tmp[1]
	} else {
		flavor = ""
	}

	return &utils.KernelVersionInfo{
		Kernel: kernel,
		Major:  major,
		Minor:  minor,
		Flavor: flavor,
	}, nil
}
Beispiel #4
0
func checkForUpdates(dockerVersion string, network string) {
	newVersion.Store("")

	handleResponse := func(r *checkpoint.CheckResponse, err error) {
		if err != nil {
			Log.Printf("Error checking version: %v", err)
			return
		}
		if r.Outdated {
			newVersion.Store(r.CurrentVersion)
			Log.Printf("Weave version %s is available; please update at %s",
				r.CurrentVersion, r.CurrentDownloadURL)
		}
	}

	var uts syscall.Utsname
	syscall.Uname(&uts)
	flags := map[string]string{
		"docker-version": dockerVersion,
		"kernel-version": charsToString(uts.Release[:]),
	}
	if network != "" {
		flags["network"] = network
	}

	// Start background version checking
	params := checkpoint.CheckParams{
		Product:       "weave-net",
		Version:       version,
		SignatureFile: "",
		Flags:         flags,
	}
	checker = checkpoint.CheckInterval(&params, updateCheckPeriod, handleResponse)
}
Beispiel #5
0
func getUname() (*Utsname, error) {
	u := syscall.Utsname{}
	if err := syscall.Uname(&u); err != nil {
		return nil, err
	}

	toString := func(f [65]int8) string {
		out := make([]byte, 0, 64)
		for _, v := range f[:] {
			if v == 0 {
				break
			}
			out = append(out, uint8(v))
		}
		return string(out)
	}

	uname := Utsname{
		Sysname:    toString(u.Sysname),
		Nodename:   toString(u.Nodename),
		Release:    toString(u.Release),
		Version:    toString(u.Version),
		Machine:    toString(u.Machine),
		Domainname: toString(u.Domainname),
	}

	return &uname, nil

}
Beispiel #6
0
// uname does a uname and returns a uroot.Utsname
func Uname() (*Utsname, error) {
	var u syscall.Utsname
	if err := syscall.Uname(&u); err != nil {
		return nil, err
	}
	return &Utsname{Sysname: toString(u.Sysname[:]), Nodename: toString(u.Nodename[:]), Release: toString(u.Release[:]), Version: toString(u.Version[:]), Machine: toString(u.Machine[:]), Domainname: toString(u.Domainname[:])}, nil
}
Beispiel #7
0
// osVersion returns the OS version.
func osVersion() string {
	buf := &syscall.Utsname{}
	err := syscall.Uname(buf)
	if err != nil {
		return "0.0"
	}
	return charsToString(buf.Release)
}
Beispiel #8
0
// osName returns the name of the OS.
func osName() string {
	buf := &syscall.Utsname{}
	err := syscall.Uname(buf)
	if err != nil {
		return runtime.GOOS
	}
	return charsToString(buf.Sysname)
}
Beispiel #9
0
func GetString() (string, error) {
	var uts syscall.Utsname
	err := syscall.Uname(&uts)
	if err != nil {
		return "", errors.New(fmt.Sprintf("Error calling system function 'uname': %s", err))
	}
	return fmt.Sprintf("%s", int8SliceToString(uts.Release[:])), nil
}
func uname() (*syscall.Utsname, error) {
	uts := &syscall.Utsname{}

	if err := syscall.Uname(uts); err != nil {
		return nil, err
	}
	return uts, nil
}
Beispiel #11
0
func Platform() (platform string) {
	var buf syscall.Utsname
	err := syscall.Uname(&buf)
	if err != nil {
		log.Fatal(err)
	}
	s := []string{charsToString(buf.Sysname[:]), charsToString(buf.Release[:]), charsToString(buf.Version[:])}
	platform = strings.Join(s, "-")
	return
}
Beispiel #12
0
func genInfo() (*info, error) {
	var name syscall.Utsname
	err := syscall.Uname(&name)
	return &info{
		sysname:  intToString(name.Sysname),
		nodename: intToString(name.Nodename),
		release:  intToString(name.Release),
		version:  intToString(name.Version),
		machine:  intToString(name.Machine),
	}, err
}
Beispiel #13
0
func GenInfo() *info {
	_ = syscall.Uname(&name)
	return &info{
		kname:     IntToString(name.Sysname),
		node:      IntToString(name.Nodename),
		release:   IntToString(name.Release),
		kversion:  IntToString(name.Version),
		machine:   IntToString(name.Machine),
		processor: Proc(),
		os:        GOOS,
	}
}
Beispiel #14
0
func uname() string {
	var uts syscall.Utsname
	ck(syscall.Uname(&uts))

	b := make([]byte, len(uts.Release))
	for i := range b {
		b[i] = byte(uts.Release[i])
		if b[i] == 0 {
			break
		}
	}
	return strings.TrimRight(string(b), "\x00")
}
Beispiel #15
0
func getKernelVersion() (major, minor int, err error) {
	var u syscall.Utsname
	if err = syscall.Uname(&u); err != nil {
		return
	}

	// Kernel versions are not always a semver, so we have to do minimal parsing.
	release := marshal.FromUtsname(u.Release)
	if n, err := fmt.Sscanf(release, "%d.%d", &major, &minor); err != nil || n != 2 {
		return 0, 0, fmt.Errorf("Malformed version: %s", release)
	}
	return
}
Beispiel #16
0
// s390/s390x changes
func getMachineArch() (string, error) {
	uname := syscall.Utsname{}
	err := syscall.Uname(&uname)
	if err != nil {
		return "", err
	}

	var arch string
	for _, val := range uname.Machine {
		arch += string(int(val))
	}

	return arch, nil
}
Beispiel #17
0
// Version returns our version, os and Go runtime info.
func Version() (os string, rt string) {
	var osinfo syscall.Utsname
	if err := syscall.Uname(&osinfo); err == nil {
		os = fmt.Sprintf("%s %s %s", Atos(osinfo.Sysname),
			Atos(osinfo.Release), Atos(osinfo.Machine))
	}
	if lsb, err := exec.Command("lsb_release", "-ds").Output(); err == nil {
		os = fmt.Sprintf("%s %s %s", strings.Trim(string(lsb), "\"\n"), Atos(osinfo.Release),
			Atos(osinfo.Machine))
	}

	rt = fmt.Sprintf("%s %s/%s", runtime.Version(), runtime.GOOS, runtime.GOARCH)
	return os, BOTVERSION + " (" + rt + ")"
}
Beispiel #18
0
func hostname() (name string, err error) {
	var u syscall.Utsname
	if errno := syscall.Uname(&u); errno != nil {
		return "", NewSyscallError("uname", errno)
	}
	b := make([]byte, len(u.Nodename))
	i := 0
	for ; i < len(u.Nodename); i++ {
		if u.Nodename[i] == 0 {
			break
		}
		b[i] = byte(u.Nodename[i])
	}
	return string(b[:i]), nil
}
Beispiel #19
0
func Sysinfo() Systeminfo {
	var uts syscall.Utsname
	syscall.Uname(&uts)
	sysname := charToStr(uts.Sysname)
	nodename := charToStr(uts.Nodename)
	release := charToStr(uts.Release)
	version := charToStr(uts.Version)
	machine := charToStr(uts.Machine)
	model := cpuModel()
	numCPU := runtime.NumCPU()
	memInfo, _ := getMemInfo()
	memory := float64(memInfo.MemTotal) / (1024 * 1024)
	memstr := strconv.FormatFloat(memory, 'f', 2, 64) + "GB"
	return Systeminfo{sysname, nodename, release, version, machine, model, numCPU, memstr}
}
Beispiel #20
0
func GetPlatform() Platform {
	var uname syscall.Utsname

	err := syscall.Uname(&uname)

	if err != nil {
		panic("Unable to provide a uname call for this platform")
	}

	return Platform{
		OSName:       charsToString(uname.Sysname[:]),
		Release:      charsToString(uname.Release[:]),
		Architecture: charsToString(uname.Machine[:]),
	}
}
Beispiel #21
0
func machineArch() string {
	utsname := syscall.Utsname{}
	err := syscall.Uname(&utsname)
	if err != nil {
		log.Fatal("Can't get uname:", err)
	}

	s := ""
	for _, v := range utsname.Machine {
		if v > 0 {
			s += string(rune(v))
		}
	}
	return s
}
Beispiel #22
0
func getArch() (string, error) {
	var uname syscall.Utsname
	err := syscall.Uname(&uname)
	if err != nil {
		return "", err
	}
	var arch [65]byte
	for i, c := range uname.Machine {
		if c == 0 {
			return string(arch[:i]), nil
		}
		arch[i] = byte(c)
	}
	return string(arch[:]), nil
}
Beispiel #23
0
// getSystemInfo returns a sysinfo struct containing system information.
func getSystemInfo() *sysinfo {
	var utsname syscall.Utsname
	_ = syscall.Uname(&utsname)
	sys := sysinfo{
		name:      utsnameToString(utsname.Sysname),
		node:      utsnameToString(utsname.Nodename),
		release:   utsnameToString(utsname.Release),
		version:   utsnameToString(utsname.Version),
		machine:   utsnameToString(utsname.Machine),
		domain:    utsnameToString(utsname.Domainname),
		os:        getOS(),
		processor: getProcessorName(),
	}
	return &sys
}
Beispiel #24
0
// FIXME: this doens't build on Darwin
func GetKernelVersion() (*KernelVersionInfo, error) {
	var uts syscall.Utsname

	if err := syscall.Uname(&uts); err != nil {
		return nil, err
	}

	release := make([]byte, len(uts.Release))

	i := 0
	for _, c := range uts.Release {
		release[i] = byte(c)
		i++
	}

	tmp := strings.SplitN(string(release), "-", 2)
	if len(tmp) != 2 {
		return nil, fmt.Errorf("Unrecognized kernel version")
	}
	tmp2 := strings.SplitN(tmp[0], ".", 3)
	if len(tmp2) != 3 {
		return nil, fmt.Errorf("Unrecognized kernel version")
	}

	kernel, err := strconv.Atoi(tmp2[0])
	if err != nil {
		return nil, err
	}

	major, err := strconv.Atoi(tmp2[1])
	if err != nil {
		return nil, err
	}

	minor, err := strconv.Atoi(tmp2[2])
	if err != nil {
		return nil, err
	}

	flavor := tmp[1]

	return &KernelVersionInfo{
		Kernel: kernel,
		Major:  major,
		Minor:  minor,
		Flavor: flavor,
	}, nil
}
Beispiel #25
0
func ArchitectureGetLocal() (string, error) {
	uname := syscall.Utsname{}
	if err := syscall.Uname(&uname); err != nil {
		return ArchitectureDefault, err
	}

	architectureName := ""
	for _, c := range uname.Machine {
		if c == 0 {
			break
		}
		architectureName += string(byte(c))
	}

	return architectureName, nil
}
func (c unameCollector) Update(ch chan<- prometheus.Metric) error {
	var uname syscall.Utsname
	if err := syscall.Uname(&uname); err != nil {
		return err
	}

	ch <- prometheus.MustNewConstMetric(unameDesc, prometheus.GaugeValue, 1,
		unameToString(uname.Sysname),
		unameToString(uname.Release),
		unameToString(uname.Version),
		unameToString(uname.Machine),
		unameToString(uname.Nodename),
		unameToString(uname.Domainname),
	)
	return nil
}
Beispiel #27
0
func main() {
	log.SetFlags(0)
	flag.Usage = usage
	flag.Parse()

	flags := false
	flag.Visit(func(*flag.Flag) {
		flags = true
	})
	if !flags {
		*kernel = true
	}

	var uts syscall.Utsname
	err := syscall.Uname(&uts)
	if err != nil {
		log.Fatal(err)
	}
	buf := new(bytes.Buffer)

	if *all || *kernel {
		xprint(buf, uts.Sysname[:])
	}

	if *all || *node {
		xprint(buf, uts.Nodename[:])
	}

	if *all || *release {
		xprint(buf, uts.Release[:])
	}

	if *all || *version {
		xprint(buf, uts.Version[:])
	}

	if *all || *machine {
		xprint(buf, uts.Machine[:])
	}

	if *all || *domain {
		xprint(buf, uts.Domainname[:])
	}

	str := buf.String()
	fmt.Println(str[:len(str)-1])
}
Beispiel #28
0
func getKernelVersion() string {
	uname := &syscall.Utsname{}

	if err := syscall.Uname(uname); err != nil {
		return "Unknown"
	}

	release := make([]byte, len(uname.Release))
	i := 0
	for _, c := range uname.Release {
		release[i] = byte(c)
		i++
	}
	release = release[:bytes.IndexByte(release, 0)]

	return string(release)
}
Beispiel #29
0
// Write an event into the Wtmp file. An error is returned if the event
// cannot be appended to the Wtmp file.
func WriteWtmp(user, id string, pid int32, utype int16, line string) error {

	u := new(Utmp)
	u.Time.GetTimeOfDay()
	u.Pid = pid
	u.Type = utype
	_ = copy(u.User[:], []byte(user))
	_ = copy(u.Id[:], []byte(id))
	_ = copy(u.Line[:], []byte(line))

	name := new(syscall.Utsname)
	if err := syscall.Uname(name); err == nil {
		_ = copy(u.Host[:], general.Int8ToByte(name.Release[:]))
	}

	return u.UpdWtmp(WtmpFile)
}
Beispiel #30
0
func newSystemInfo() SystemInfo {
	var sysInfo SystemInfo
	var unameInfo syscall.Utsname

	if err := syscall.Uname(&unameInfo); err != nil {
		return sysInfo
	}

	sysInfo.Sysname = nativeCharsToString(unameInfo.Sysname)
	sysInfo.Nodename = nativeCharsToString(unameInfo.Nodename)
	sysInfo.Release = nativeCharsToString(unameInfo.Release)
	sysInfo.Version = nativeCharsToString(unameInfo.Version)
	sysInfo.Machine = nativeCharsToString(unameInfo.Machine)
	sysInfo.Domainname = nativeCharsToString(unameInfo.Domainname)

	return sysInfo
}