.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/sys@v0.0.0-20210124154548-22da62e12c0c/unix/pledge_openbsd.go

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package unix
   6
   7 import (
   8         "errors"
   9         "fmt"
  10         "strconv"
  11         "syscall"
  12         "unsafe"
  13 )
  14
  15 // Pledge implements the pledge syscall.
  16 //
  17 // The pledge syscall does not accept execpromises on OpenBSD releases
  18 // before 6.3.
  19 //
  20 // execpromises must be empty when Pledge is called on OpenBSD
  21 // releases predating 6.3, otherwise an error will be returned.
  22 //
  23 // For more information see pledge(2).
  24 func Pledge(promises, execpromises string) error {
  25         maj, min, err := majmin()
  26         if err != nil {
  27                 return err
  28         }
  29
  30         err = pledgeAvailable(maj, min, execpromises)
  31         if err != nil {
  32                 return err
  33         }
  34
  35         pptr, err := syscall.BytePtrFromString(promises)
  36         if err != nil {
  37                 return err
  38         }
  39
  40         // This variable will hold either a nil unsafe.Pointer or
  41         // an unsafe.Pointer to a string (execpromises).
  42         var expr unsafe.Pointer
  43
  44         // If we're running on OpenBSD > 6.2, pass execpromises to the syscall.
  45         if maj > 6 || (maj == 6 && min > 2) {
  46                 exptr, err := syscall.BytePtrFromString(execpromises)
  47                 if err != nil {
  48                         return err
  49                 }
  50                 expr = unsafe.Pointer(exptr)
  51         }
  52
  53         _, _, e := syscall.Syscall(SYS_PLEDGE, uintptr(unsafe.Pointer(pptr)), uintptr(expr), 0)
  54         if e != 0 {
  55                 return e
  56         }
  57
  58         return nil
  59 }
  60
  61 // PledgePromises implements the pledge syscall.
  62 //
  63 // This changes the promises and leaves the execpromises untouched.
  64 //
  65 // For more information see pledge(2).
  66 func PledgePromises(promises string) error {
  67         maj, min, err := majmin()
  68         if err != nil {
  69                 return err
  70         }
  71
  72         err = pledgeAvailable(maj, min, "")
  73         if err != nil {
  74                 return err
  75         }
  76
  77         // This variable holds the execpromises and is always nil.
  78         var expr unsafe.Pointer
  79
  80         pptr, err := syscall.BytePtrFromString(promises)
  81         if err != nil {
  82                 return err
  83         }
  84
  85         _, _, e := syscall.Syscall(SYS_PLEDGE, uintptr(unsafe.Pointer(pptr)), uintptr(expr), 0)
  86         if e != 0 {
  87                 return e
  88         }
  89
  90         return nil
  91 }
  92
  93 // PledgeExecpromises implements the pledge syscall.
  94 //
  95 // This changes the execpromises and leaves the promises untouched.
  96 //
  97 // For more information see pledge(2).
  98 func PledgeExecpromises(execpromises string) error {
  99         maj, min, err := majmin()
 100         if err != nil {
 101                 return err
 102         }
 103
 104         err = pledgeAvailable(maj, min, execpromises)
 105         if err != nil {
 106                 return err
 107         }
 108
 109         // This variable holds the promises and is always nil.
 110         var pptr unsafe.Pointer
 111
 112         exptr, err := syscall.BytePtrFromString(execpromises)
 113         if err != nil {
 114                 return err
 115         }
 116
 117         _, _, e := syscall.Syscall(SYS_PLEDGE, uintptr(pptr), uintptr(unsafe.Pointer(exptr)), 0)
 118         if e != 0 {
 119                 return e
 120         }
 121
 122         return nil
 123 }
 124
 125 // majmin returns major and minor version number for an OpenBSD system.
 126 func majmin() (major int, minor int, err error) {
 127         var v Utsname
 128         err = Uname(&v)
 129         if err != nil {
 130                 return
 131         }
 132
 133         major, err = strconv.Atoi(string(v.Release[0]))
 134         if err != nil {
 135                 err = errors.New("cannot parse major version number returned by uname")
 136                 return
 137         }
 138
 139         minor, err = strconv.Atoi(string(v.Release[2]))
 140         if err != nil {
 141                 err = errors.New("cannot parse minor version number returned by uname")
 142                 return
 143         }
 144
 145         return
 146 }
 147
 148 // pledgeAvailable checks for availability of the pledge(2) syscall
 149 // based on the running OpenBSD version.
 150 func pledgeAvailable(maj, min int, execpromises string) error {
 151         // If OpenBSD <= 5.9, pledge is not available.
 152         if (maj == 5 && min != 9) || maj < 5 {
 153                 return fmt.Errorf("pledge syscall is not available on OpenBSD %d.%d", maj, min)
 154         }
 155
 156         // If OpenBSD <= 6.2 and execpromises is not empty,
 157         // return an error - execpromises is not available before 6.3
 158         if (maj < 6 || (maj == 6 && min <= 2)) && execpromises != "" {
 159                 return fmt.Errorf("cannot use execpromises on OpenBSD %d.%d", maj, min)
 160         }
 161
 162         return nil
 163 }