// ValidateContextDirectory checks if all the contents of the directory // can be read and returns an error if some files can't be read // symlinks which point to non-existing files don't trigger an error func ValidateContextDirectory(srcPath string) error { var finalError error filepath.Walk(filepath.Join(srcPath, "."), func(filePath string, f os.FileInfo, err error) error { // skip this directory/file if it's not in the path, it won't get added to the context _, err = filepath.Rel(srcPath, filePath) if err != nil && os.IsPermission(err) { return nil } if _, err := os.Stat(filePath); err != nil && os.IsPermission(err) { finalError = fmt.Errorf("can't stat '%s'", filePath) return err } // skip checking if symlinks point to non-existing files, such symlinks can be useful lstat, _ := os.Lstat(filePath) if lstat.Mode()&os.ModeSymlink == os.ModeSymlink { return err } if !f.IsDir() { currentFile, err := os.Open(filePath) if err != nil && os.IsPermission(err) { finalError = fmt.Errorf("no permission to read from '%s'", filePath) return err } else { currentFile.Close() } } return nil }) return finalError }
func checkWriteable(dir string) error { _, err := os.Stat(dir) if err == nil { // dir exists, make sure we can write to it testfile := path.Join(dir, "test") fi, err := os.Create(testfile) if err != nil { if os.IsPermission(err) { return fmt.Errorf("%s is not writeable by the current user", dir) } return fmt.Errorf("unexpected error while checking writeablility of repo root: %s", err) } fi.Close() return os.Remove(testfile) } if os.IsNotExist(err) { // dir doesnt exist, check that we can create it return os.Mkdir(dir, 0775) } if os.IsPermission(err) { return fmt.Errorf("cannot write to %s, incorrect permissions", err) } return err }
// ServeHTTP determines if the request is for this plugin, and if all prerequisites are met. // If so, control is handed over to ServeListing. func (b Browse) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) { var bc *Config // See if there's a browse configuration to match the path for i := range b.Configs { if httpserver.Path(r.URL.Path).Matches(b.Configs[i].PathScope) { bc = &b.Configs[i] goto inScope } } return b.Next.ServeHTTP(w, r) inScope: // Browse works on existing directories; delegate everything else requestedFilepath, err := bc.Root.Open(r.URL.Path) if err != nil { switch { case os.IsPermission(err): return http.StatusForbidden, err case os.IsExist(err): return http.StatusNotFound, err default: return b.Next.ServeHTTP(w, r) } } defer requestedFilepath.Close() info, err := requestedFilepath.Stat() if err != nil { switch { case os.IsPermission(err): return http.StatusForbidden, err case os.IsExist(err): return http.StatusGone, err default: return b.Next.ServeHTTP(w, r) } } if !info.IsDir() { return b.Next.ServeHTTP(w, r) } // Do not reply to anything else because it might be nonsensical switch r.Method { case http.MethodGet, http.MethodHead: // proceed, noop case "PROPFIND", http.MethodOptions: return http.StatusNotImplemented, nil default: return b.Next.ServeHTTP(w, r) } // Browsing navigation gets messed up if browsing a directory // that doesn't end in "/" (which it should, anyway) if !strings.HasSuffix(r.URL.Path, "/") { staticfiles.Redirect(w, r, r.URL.Path+"/", http.StatusTemporaryRedirect) return 0, nil } return b.ServeListing(w, r, requestedFilepath, bc) }
// deleteFile - delete file path if its empty. func deleteFile(basePath, deletePath string) error { if basePath == deletePath { return nil } // Verify if the path exists. pathSt, err := os.Stat(preparePath(deletePath)) if err != nil { if os.IsNotExist(err) { return errFileNotFound } else if os.IsPermission(err) { return errFileAccessDenied } return err } if pathSt.IsDir() && !isDirEmpty(deletePath) { // Verify if directory is empty. return nil } // Attempt to remove path. if err := os.Remove(preparePath(deletePath)); err != nil { if os.IsNotExist(err) { return errFileNotFound } else if os.IsPermission(err) { return errFileAccessDenied } return err } // Recursively go down the next path and delete again. if err := deleteFile(basePath, slashpath.Dir(deletePath)); err != nil { return err } return nil }
// fsStat - wrapper function to get file stat. func (f *fsClient) fsStat() (os.FileInfo, *probe.Error) { fpath := f.PathURL.Path // Golang strips trailing / if you clean(..) or // EvalSymlinks(..). Adding '.' prevents it from doing so. if strings.HasSuffix(fpath, string(f.PathURL.Separator)) { fpath = fpath + "." } fpath, e := filepath.EvalSymlinks(fpath) if e != nil { if os.IsPermission(e) { if runtime.GOOS == "windows" { return f.handleWindowsSymlinks(f.PathURL.Path) } return nil, probe.NewError(client.PathInsufficientPermission{Path: f.PathURL.Path}) } err := f.toClientError(e, f.PathURL.Path) return nil, err.Trace(fpath) } st, e := os.Stat(fpath) if e != nil { if os.IsPermission(e) { if runtime.GOOS == "windows" { return f.handleWindowsSymlinks(fpath) } return nil, probe.NewError(client.PathInsufficientPermission{Path: f.PathURL.Path}) } if os.IsNotExist(e) { return nil, probe.NewError(client.PathNotFound{Path: f.PathURL.Path}) } return nil, probe.NewError(e) } return st, nil }
func (ad *ArchDiff) DiffRepoFile() FileList { if ad.diffRepoFile == nil { ad.diffRepoFile = make(FileList) for _, file := range ad.RepoFile() { realpath := filepath.Join(ad.Root, file.Name) repopath := filepath.Join(ad.Repo, file.Name) realhash, err := filehash(realpath) if err != nil && !os.IsNotExist(err) { if os.IsPermission(err) { if !ad.Silent { log.Printf("Skipping file: %s", err) } continue } log.Fatalf("Error looking for modified repo files (real): %s", err) } repohash, err := filehash(repopath) if err != nil && !os.IsNotExist(err) { if os.IsPermission(err) { if !ad.Silent { log.Printf("Skipping file: %s", err) } continue } log.Fatalf("Error looking for modified repo files (repo): %s", err) } if realhash != repohash { ad.diffRepoFile.Add(file) } } } return ad.diffRepoFile }
func (f *fsClient) listRecursiveInRoutine(contentCh chan client.ContentOnChannel) { defer close(contentCh) visitFS := func(fp string, fi os.FileInfo, err error) error { // fp also sends back itself with visitFS, ignore it we don't need it if fp == f.path { return nil } if err != nil { if strings.Contains(err.Error(), "operation not permitted") { contentCh <- client.ContentOnChannel{ Content: nil, Err: probe.NewError(err), } return nil } if os.IsPermission(err) { contentCh <- client.ContentOnChannel{ Content: nil, Err: probe.NewError(err), } return nil } return err } if fi.Mode()&os.ModeSymlink == os.ModeSymlink { fi, err = os.Stat(fp) if err != nil { if os.IsNotExist(err) || os.IsPermission(err) { // ignore broken symlinks and permission denied contentCh <- client.ContentOnChannel{ Content: nil, Err: probe.NewError(err), } return nil } return err } } if fi.Mode().IsRegular() || fi.Mode().IsDir() { content := &client.Content{ Name: f.delimited(fp), Time: fi.ModTime(), Size: fi.Size(), Type: fi.Mode(), } contentCh <- client.ContentOnChannel{ Content: content, Err: nil, } } return nil } err := filepath.Walk(f.path, visitFS) if err != nil { contentCh <- client.ContentOnChannel{ Content: nil, Err: probe.NewError(err), } } }
// return a list of available virtual go environments for the user func (e *EnvironmentsList) getEnvironments() ([]string, []string, error) { envs_path := filepath.Join("~", ".VenGO", "*") files, err := filepath.Glob(cache.ExpandUser(envs_path)) if err != nil { fmt.Println("while getting list of environments:", err) return nil, nil, err } available, invalid := []string{}, []string{} for _, file := range files { var vengoenv string filename := path.Base(file) stat, err := os.Stat(file) if err != nil { fmt.Println("while getting list of environments:", err) return nil, nil, err } if stat.IsDir() && filename != "bin" && filename != "scripts" { _, err := os.Open(filepath.Join(file, "bin", "activate")) if err != nil { if os.IsNotExist(err) || os.IsPermission(err) { invalid = append(invalid, filename) } continue } if r, err := os.Readlink(filepath.Join(file, "lib")); err != nil { if os.IsNotExist(err) || os.IsPermission(err) { invalid = append(invalid, filename) } continue } else { if e.DisplayAs == Text { vengoenv = fmt.Sprintf("%-22s%-8s", filename, path.Base(r)) } else { vengoenv = filename } if _, err := os.Stat(r); err != nil { if os.IsNotExist(err) || os.IsPermission(err) { invalid = append(invalid, vengoenv) } continue } } available = append(available, vengoenv) } } return available, invalid, nil }
func checkUserNS(t *testing.T) { if _, err := os.Stat("/proc/self/ns/user"); err != nil { if os.IsNotExist(err) { t.Skip("kernel doesn't support user namespaces") } if os.IsPermission(err) { t.Skip("unable to test user namespaces due to permissions") } t.Fatalf("Failed to stat /proc/self/ns/user: %v", err) } if isChrooted(t) { // create_user_ns in the kernel (see // https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/kernel/user_namespace.c) // forbids the creation of user namespaces when chrooted. t.Skip("cannot create user namespaces when chrooted") } // On some systems, there is a sysctl setting. if os.Getuid() != 0 { data, errRead := ioutil.ReadFile("/proc/sys/kernel/unprivileged_userns_clone") if errRead == nil && data[0] == '0' { t.Skip("kernel prohibits user namespace in unprivileged process") } } // When running under the Go continuous build, skip tests for // now when under Kubernetes. (where things are root but not quite) // Both of these are our own environment variables. // See Issue 12815. if os.Getenv("GO_BUILDER_NAME") != "" && os.Getenv("IN_KUBERNETES") == "1" { t.Skip("skipping test on Kubernetes-based builders; see Issue 12815") } }
func Locked(confdir string) (bool, error) { log.Debugf("Checking lock") if !util.FileExists(path.Join(confdir, LockFile)) { log.Debugf("File doesn't exist: %s", path.Join(confdir, LockFile)) return false, nil } if lk, err := Lock(confdir); err != nil { // EAGAIN == someone else has the lock if err == syscall.EAGAIN { log.Debugf("Someone else has the lock: %s", path.Join(confdir, LockFile)) return true, nil } if strings.Contains(err.Error(), "can't Lock file") { log.Debugf("Can't lock file: %s.\n reason: %s", path.Join(confdir, LockFile), err.Error()) return true, nil } // lock fails on permissions error if os.IsPermission(err) { log.Debugf("Lock fails on permissions error") return false, errPerm(confdir) } if isLockCreatePermFail(err) { log.Debugf("Lock fails on permissions error") return false, errPerm(confdir) } // otherwise, we cant guarantee anything, error out return false, err } else { log.Debugf("No one has a lock") lk.Close() return false, nil } }
func statusCheckFile(absPath string, file *entities.File, report *StatusReport) error { log.Infof(2, "%v: checking file status.", absPath) stat, err := os.Stat(file.Path()) if err != nil { switch { case os.IsNotExist(err): log.Infof(2, "%v: file is missing.", absPath) report.AddRow(Row{absPath, MISSING}) return nil case os.IsPermission(err): log.Warnf("%v: permission denied.", absPath) case strings.Contains(err.Error(), "not a directory"): //TODO improve report.AddRow(Row{file.Path(), MISSING}) return nil default: return fmt.Errorf("%v: could not stat: %v", file.Path(), err) } } else { if stat.Size() != file.Size || !stat.ModTime().UTC().Equal(file.ModTime) { log.Infof(2, "%v: file is modified.", absPath) report.AddRow(Row{absPath, MODIFIED}) } else { log.Infof(2, "%v: file is unchanged.", absPath) report.AddRow(Row{absPath, TAGGED}) } } return nil }
func (v *Volume) load(alsoLoadIndex bool, createDatIfMissing bool) error { var e error fileName := v.FileName() if exists, canRead, canWrite, _ := checkFile(fileName + ".dat"); exists { if !canRead { return fmt.Errorf("cannot read Volume Data file %s.dat", fileName) } if canWrite { v.dataFile, e = os.OpenFile(fileName+".dat", os.O_RDWR|os.O_CREATE, 0644) } else { glog.V(0).Infoln("opening " + fileName + ".dat in READONLY mode") v.dataFile, e = os.Open(fileName + ".dat") v.readOnly = true } } else { if createDatIfMissing { v.dataFile, e = os.OpenFile(fileName+".dat", os.O_RDWR|os.O_CREATE, 0644) } else { return fmt.Errorf("Volume Data file %s.dat does not exist.", fileName) } } if e != nil { if !os.IsPermission(e) { return fmt.Errorf("cannot load Volume Data %s.dat: %s", fileName, e.Error()) } } if v.ReplicaPlacement == nil { e = v.readSuperBlock() } else { e = v.maybeWriteSuperBlock() } if e == nil && alsoLoadIndex { if v.readOnly { if v.ensureConvertIdxToCdb(fileName) { v.nm, e = OpenCdbMap(fileName + ".cdb") return e } } var indexFile *os.File if v.readOnly { glog.V(1).Infoln("open to read file", fileName+".idx") if indexFile, e = os.OpenFile(fileName+".idx", os.O_RDONLY, 0644); e != nil { return fmt.Errorf("cannot read Volume Index %s.idx: %s", fileName, e.Error()) } } else { glog.V(1).Infoln("open to write file", fileName+".idx") if indexFile, e = os.OpenFile(fileName+".idx", os.O_RDWR|os.O_CREATE, 0644); e != nil { return fmt.Errorf("cannot write Volume Index %s.idx: %s", fileName, e.Error()) } } glog.V(0).Infoln("loading file", fileName+".idx", "readonly", v.readOnly) if v.nm, e = LoadNeedleMap(indexFile); e != nil { glog.V(0).Infoln("loading error:", e) } } return e }
func (f *JSONFile) Load(warnOnNotFound bool) error { f.G().Log.Debug("+ loading %s file: %s", f.which, f.filename) file, err := os.Open(f.filename) if err != nil { if os.IsNotExist(err) { msg := fmt.Sprintf("No %s file found; tried %s", f.which, f.filename) if warnOnNotFound { f.G().Log.Warning(msg) } else { f.G().Log.Debug(msg) } return nil } else if os.IsPermission(err) { f.G().Log.Warning("Permission denied opening %s file %s", f.which, f.filename) return nil } else { return err } } f.exists = true defer file.Close() decoder := json.NewDecoder(file) obj := make(map[string]interface{}) // Treat empty files like an empty dictionary if err = decoder.Decode(&obj); err != nil && err != io.EOF { f.G().Log.Errorf("Error decoding %s file %s", f.which, f.filename) return err } f.jw = jsonw.NewWrapper(obj) f.G().Log.Debug("- successfully loaded %s file", f.which) return nil }
func (v *Volume) load(alsoLoadIndex bool) error { var e error fileName := path.Join(v.dir, v.Id.String()) if exists, canRead, canWrite, _ := checkFile(fileName + ".dat"); exists && !canRead { return fmt.Errorf("cannot read Volume Data file %s.dat", fileName) } else if !exists || canWrite { v.dataFile, e = os.OpenFile(fileName+".dat", os.O_RDWR|os.O_CREATE, 0644) } else if exists && canRead { glog.V(0).Infoln("opening " + fileName + ".dat in READONLY mode") v.dataFile, e = os.Open(fileName + ".dat") v.readOnly = true } else { return fmt.Errorf("Unknown state about Volume Data file %s.dat", fileName) } if e != nil { if !os.IsPermission(e) { return fmt.Errorf("cannot load Volume Data %s.dat: %s", fileName, e.Error()) } } if v.ReplicaType == CopyNil { e = v.readSuperBlock() } else { e = v.maybeWriteSuperBlock() } if e == nil && alsoLoadIndex { var indexFile *os.File if v.readOnly { glog.V(1).Infoln("open to read file", fileName+".idx") if indexFile, e = os.OpenFile(fileName+".idx", os.O_RDONLY, 0644); e != nil { return fmt.Errorf("cannot read Volume Data %s.dat: %s", fileName, e.Error()) } if v.ensureConvertIdxToCdb(fileName) { v.nm, e = OpenCdbMap(fileName + ".cdb") return e } if indexFile != nil { glog.V(0).Infoln("converting %s.idx to %s.cdb", fileName, fileName) if e = ConvertIndexToCdb(fileName+".cdb", indexFile); e != nil { glog.Errorln("error converting %s.idx to %s.cdb: %s", fileName, fileName, e) } else { indexFile.Close() os.Remove(indexFile.Name()) indexFile = nil } } } else { glog.V(1).Infoln("open to write file", fileName+".idx") if indexFile, e = os.OpenFile(fileName+".idx", os.O_RDWR|os.O_CREATE, 0644); e != nil { return fmt.Errorf("cannot write Volume Data %s.dat: %s", fileName, e.Error()) } } glog.V(0).Infoln("loading file", fileName+".idx", "readonly", v.readOnly) if v.nm, e = LoadNeedleMap(indexFile); e != nil { glog.V(0).Infoln("loading error:", e) } } return e }
// setupLogging attempts to log to a file, otherwise stderr func setupLogging() (*os.File, error) { // use date, time and filename for log output log.SetFlags(log.LstdFlags | log.Lshortfile) log.SetPrefix(*pluginName + "-volume-plugin: ") // setup logfile - path is set from logfileDir and pluginName logfileName := logfilePath() if !isDebugEnabled() && logfileName != "" { logFile, err := os.OpenFile(logfileName, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) if err != nil { // check if we can write to directory - otherwise just log to stderr? if os.IsPermission(err) { log.Printf("WARN: logging fallback to STDERR: %v", err) } else { // some other, more extreme system error return nil, err } } else { log.Printf("INFO: setting log file: %s", logfileName) log.SetOutput(logFile) return logFile, nil } } return nil, nil }
// TestHostKeyFile tests that reading and writing the wrong host key file fails func TestWrongHostKeyFile(t *testing.T) { // Non-existent host key file should fail f := NewHostKeyFile(wrongHostFile) _, err := f.GetHostKeys() if err == nil { t.Fatal("should fail to read wrong host file") } if _, ok := err.(*os.PathError); !ok { t.Fatalf("should fail to read wrong host file due to file miss, but got %v", err) } // Create a host key file we do not have permission to read os.OpenFile(wrongHostFile, os.O_CREATE, 0000) defer os.Remove(wrongHostFile) // If run as root, drop privileges temporarily if id := syscall.Geteuid(); id == 0 { if err := syscall.Setuid(12345); err != nil { t.Fatalf("error setting uid: %v", err) } defer syscall.Setuid(id) } err = f.PutHostKey("", nil) if err == nil { t.Fatal("should fail to write wrong host file") } if !os.IsPermission(err) { t.Fatalf("should fail to write wrong host file due to permission denied, but got %v", err) } }
// initialize config path if not present, return an error if either the dir // exists and is not writable or the dir does not exist and cannot be created func configPathInit() error { fi, err := os.Stat(CONFIG_PATH) // if it doesn't exist if err != nil && os.IsNotExist(err) { err = os.MkdirAll(CONFIG_PATH, CONFIG_PATH_MODE) return err // if it isn't a dir or symlink } else if !fi.IsDir() && (fi.Mode()&os.ModeSymlink) == 0 { return fmt.Errorf("Path %s must be directory or symlink.", CONFIG_PATH) } // if it exists, check for writability for i := 0; ; i++ { path := C(fmt.Sprintf("__testfile%d", i)) if isFile(path) { continue } _, err := os.Create(path) if err == nil { os.Remove(path) return nil } if os.IsPermission(err) { return fmt.Errorf("Path %s must be writable.", CONFIG_PATH) } return err } return errors.New("Unknown error setting up config path.") }
func Locked(confdir string) (bool, error) { if !util.FileExists(path.Join(confdir, LockFile)) { return false, nil } if lk, err := Lock(confdir); err != nil { // EAGAIN == someone else has the lock if err == syscall.EAGAIN { return true, nil } if strings.Contains(err.Error(), "can't Lock file") { return true, nil } // lock fails on permissions error if os.IsPermission(err) { return false, errPerm(confdir) } if isLockCreatePermFail(err) { return false, errPerm(confdir) } // otherwise, we cant guarantee anything, error out return false, err } else { lk.Close() return false, nil } }
func reportError(w http.ResponseWriter, e error, p string) { w.Header().Set("Content-Type", "text/html;charset=utf-8") data := make(map[string]string) data["title"] = "访问出错!" data["head"] = "<strong>当前位置:</strong> " + getPathLink(p) var text string switch { case os.IsNotExist(e): text = "您访问的文件不存在!" w.WriteHeader(404) case os.IsPermission(e): text = "当前目录或文件不允许访问!" w.WriteHeader(403) case PathAuthError == e: text = "您没有当前路径的访问权限!" w.WriteHeader(403) case AuthError == e: text = "认证失败!" w.Header().Set("WWW-Authenticate", "Basic realm=\"Please login\"") w.WriteHeader(401) default: text = "未知错误!" } data["content"] = fmt.Sprintf("<i><%s></i>", text) render(w, data) }
func printSockets(p *procfs.Proc, sockets []*procfs.Socket) error { fds, err := p.Fds() if err != nil { if !os.IsPermission(err) { return err } } inodes := []string{} for _, fd := range fds { inode := fd.SocketInode() if inode != "" { inodes = append(inodes, inode) } } str := []string{} for _, inode := range inodes { if s := procfs.Sockets(sockets).Find(inode); s != nil { str = append(str, fmt.Sprintf("%s %v %s", s.Protocol, s.LocalIP, s.LocalPort)) } } fmt.Printf(" %s", strings.Join(str, ", ")) return nil }
func handleArticles(site *Website, out string) error { dirs := []string{"articles"} for _, dir := range dirs { err := handleArticlePath(site, dir, "", out) if err != nil { switch { case os.IsNotExist(err): progress("%s", err.Error()) progress("The file was likely deleted during processing") case os.IsPermission(err): progress("%s", err.Error()) progress("Please check the file permissions on the repo") default: switch err.(type) { case TemplateError: progress("Required template missing: %s", err.Error()) return err case ParseError: if err.(ParseError).IsFatal() { return err.(ParseError).Err() } else { progress(err.Error()) return nil } } } } } return nil }
// convertCode converts a standard Go error into its canonical code. Note that // this is only used to translate the error returned by the server applications. func convertCode(err error) codes.Code { switch err { case nil: return codes.OK case io.EOF: return codes.OutOfRange case io.ErrClosedPipe, io.ErrNoProgress, io.ErrShortBuffer, io.ErrShortWrite, io.ErrUnexpectedEOF: return codes.FailedPrecondition case os.ErrInvalid: return codes.InvalidArgument case context.Canceled: return codes.Canceled case context.DeadlineExceeded: return codes.DeadlineExceeded } switch { case os.IsExist(err): return codes.AlreadyExists case os.IsNotExist(err): return codes.NotFound case os.IsPermission(err): return codes.PermissionDenied } return codes.Unknown }
func (self *supervisorBase) killByCmd(pid int) (bool, string) { pr, e := os.FindProcess(pid) if nil != e { if os.IsPermission(e) { e = execWithTimeout(self.killTimeout, self.stop_cmd.command(self.mode)) if nil != e { return false, e.Error() } return true, "" } return false, e.Error() } defer pr.Release() started := time.Now() e = execWithTimeout(self.killTimeout, self.stop_cmd.command(self.mode)) if nil != e { return false, e.Error() } used := time.Now().Sub(started) if used >= self.killTimeout { return false, fmt.Sprintf("timed out after %v", self.killTimeout) } e = waitWithTimeout(self.killTimeout-used, pr) if nil != e { return false, e.Error() } return true, "" }
// ConvertSystemError converts system error to appropriate trace error // if it is possible, otherwise, returns original error func ConvertSystemError(err error) error { innerError := Unwrap(err) if os.IsNotExist(innerError) { return WrapWithMessage(&NotFoundError{Message: innerError.Error()}, innerError.Error()) } if os.IsPermission(innerError) { return WrapWithMessage(&AccessDeniedError{Message: innerError.Error()}, innerError.Error()) } switch realErr := innerError.(type) { case *net.OpError: message := fmt.Sprintf("failed to connect to server %v", realErr.Addr) return WrapWithMessage(&ConnectionProblemError{ Message: message, Err: realErr}, message) case *os.PathError: message := fmt.Sprintf("failed to execute command %v error: %v", realErr.Path, realErr.Err) return WrapWithMessage(&AccessDeniedError{ Message: message, }, message) case x509.SystemRootsError, x509.UnknownAuthorityError: return wrapWithDepth(&TrustError{Err: innerError}, 2) default: return err } }
func TestMountOptionDefaultPermissions(t *testing.T) { if runtime.GOOS == "freebsd" { t.Skip("FreeBSD does not support DefaultPermissions") } t.Parallel() mnt, err := fstestutil.MountedT(t, fstestutil.SimpleFS{ fstestutil.ChildMap{"child": unwritableFile{}}, }, fuse.DefaultPermissions(), ) if err != nil { t.Fatal(err) } defer mnt.Close() // This will be prevented by kernel-level access checking when // DefaultPermissions is used. f, err := os.OpenFile(mnt.Dir+"/child", os.O_WRONLY, 0000) if err == nil { f.Close() t.Fatal("expected an error") } if !os.IsPermission(err) { t.Fatalf("expected a permission error, got %T: %v", err, err) } }
func TestTap(ot *testing.T) { tap, err := NewTap("") if os.IsPermission(err) { ot.Skip("you need root permission to run this test.") return } kmgTest.Equal(err, nil) defer tap.Close() kmgTest.Equal(tap.GetDeviceType(), DeviceTypeTap) err = kmgCmd.CmdString("ifconfig " + tap.Name() + " 10.209.34.1 up").GetExecCmd().Run() kmgTest.Equal(err, nil) /* cmd := kmgCmd.NewOsStdioCmdString("ping 10.0.0.2") err = cmd.Start() t.Equal(err, nil) defer cmd.Process.Kill() buf := make([]byte, 4096) n, err := tun.Read(buf) t.Equal(err, nil) t.Ok(n > 0) tun2, err := NewTap("") t.Equal(err, nil) defer tun2.Close() */ }
func TestIsPermission(t *testing.T) { for _, tt := range isPermissionTests { if got := os.IsPermission(tt.err); got != tt.want { t.Errorf("os.IsPermission(%#v) = %v; want %v", tt.err, got, tt.want) } } }
// Make a volume entry. func (s *posix) MakeVol(volume string) (err error) { defer func() { if err == syscall.EIO { atomic.AddInt32(&s.ioErrCount, 1) } }() if s.ioErrCount > maxAllowedIOError { return errFaultyDisk } if err = s.checkDiskFound(); err != nil { return err } volumeDir, err := s.getVolDir(volume) if err != nil { return err } // Make a volume entry, with mode 0777 mkdir honors system umask. err = os.Mkdir(preparePath(volumeDir), 0777) if err != nil { if os.IsExist(err) { return errVolumeExists } else if os.IsPermission(err) { return errDiskAccessDenied } return err } // Success return nil }
func (node *Node) OpenForReading() (*os.File, error) { file, err := os.OpenFile(node.path, os.O_RDONLY|syscall.O_NOATIME, 0) if os.IsPermission(err) { return os.OpenFile(node.path, os.O_RDONLY, 0) } return file, err }
func TestTun(ot *testing.T) { fmt.Println(1) tun, err := NewTun("") fmt.Println(2) if os.IsPermission(err) { ot.Skip("you need root permission to run this test.") return } kmgTest.Equal(err, nil) defer tun.Close() kmgTest.Equal(tun.GetDeviceType(), DeviceTypeTun) fmt.Println(3) err = SetP2PIpAndUp(tun, "10.209.34.1", "10.209.34.2") kmgTest.Equal(err, nil) err = SetMtu(tun, 1420) kmgTest.Equal(err, nil) fmt.Println(4) cmd := kmgCmd.CmdString("ping 10.209.34.2").GetExecCmd() err = cmd.Start() kmgTest.Equal(err, nil) defer cmd.Process.Kill() buf := make([]byte, 4096) n, err := tun.Read(buf) kmgTest.Equal(err, nil) kmgTest.Ok(n > 0) /* tun2, err := NewTun("") t.Equal(err, nil) defer tun2.Close() */ }