| // Copyright 2017 The LUCI Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // Package prober exports Probe, which implements logic to identify a wrapper's |
| // wrapped target. In addition to basic PATH/filename lookup, Prober contains |
| // logic to ensure that the wrapper is not the same software as the current |
| // running instance, and enables optional hard-coded wrap target paths and |
| // runtime checks. |
| package prober |
| |
| import ( |
| "context" |
| "os" |
| "path/filepath" |
| "strings" |
| |
| "go.chromium.org/luci/common/errors" |
| "go.chromium.org/luci/common/logging" |
| "go.chromium.org/luci/common/system/environ" |
| "go.chromium.org/luci/common/system/filesystem" |
| ) |
| |
| // CheckWrapperFunc is an optional function that can be implemented for a |
| // Prober to check if a candidate path is a wrapper. |
| type CheckWrapperFunc func(c context.Context, path string, env environ.Env) (isWrapper bool, err error) |
| |
| // Probe can Locate a Target executable by probing the local system PATH. |
| // |
| // Target should be an executable name resolvable by exec.LookPath. On |
| // Windows systems, this may omit the executable extension (e.g., "bat", "exe") |
| // since that is augmented via the PATHEXT environment variable (see |
| // "probe_windows.go"). |
| type Probe struct { |
| // Target is the name of the target (as seen by exec.LookPath) that we are |
| // searching for. |
| Target string |
| |
| // RelativePathOverride is a series of forward-slash-delimited paths to |
| // directories relative to the wrapper executable that will be checked |
| // prior to checking PATH. This allows bundles (e.g., CIPD) that include both |
| // the wrapper and a real implementation, to force the wrapper to use |
| // the bundled implementation. |
| RelativePathOverride []string |
| |
| // CheckWrapper, if not nil, is a function called on a candidate wrapper to |
| // determine whether or not that candidate is valid. |
| // |
| // On success, it will return isWrapper, which will be true if path is a |
| // wrapper instance and false if it is not. If an error occurred during |
| // checking, the error should be returned and isWrapper will be ignored. If |
| // a candidate is a wrapper, or if an error occurred during check, the |
| // candidate will be discarded and the probe will continue. |
| // |
| // CheckWrapper should be lightweight and fast, as it may be called multiple |
| // times. |
| CheckWrapper CheckWrapperFunc |
| |
| // Self and Selfstat are resolved contain the path and FileInfo of the |
| // currently running executable, respectively. They can both be resolved via |
| // ResolveSelf, and may be empty if resolution has not been performed, or if |
| // the current executable could not be resolved. They may also be set |
| // explicitly, bypassing the need to perform resolution. |
| Self string |
| SelfStat os.FileInfo |
| |
| // PathDirs, if not zero, contains the list of directories to search. If |
| // zero, the os.PathListSeparator-delimited PATH environment variable will |
| // be used. |
| PathDirs []string |
| } |
| |
| // ResolveSelf attempts to identify the current process. If successful, p's |
| // Self will be set to an absolute path reference to Self, and its SelfStat |
| // field will be set to the os.FileInfo for that path. |
| // |
| // If this process was invoked via symlink, the path to the symlink will be |
| // returned if possible. |
| func (p *Probe) ResolveSelf(argv0 string) error { |
| if p.Self != "" { |
| return nil |
| } |
| |
| // Get the authoritative executable from the system. |
| exec, err := os.Executable() |
| if err != nil { |
| return errors.Annotate(err, "failed to get executable").Err() |
| } |
| |
| execStat, err := os.Stat(exec) |
| if err != nil { |
| return errors.Annotate(err, "failed to stat executable: %s", exec).Err() |
| } |
| |
| // Before using "os.Executable" result, which is known to resolve symlinks on |
| // Linux, try and identify via argv0. |
| if argv0 != "" && filesystem.AbsPath(&argv0) == nil { |
| if st, err := os.Stat(argv0); err == nil && os.SameFile(execStat, st) { |
| // argv[0] is the same file as our executable, but may be an unresolved |
| // symlink. Prefer it. |
| p.Self, p.SelfStat = argv0, st |
| return nil |
| } |
| } |
| |
| p.Self, p.SelfStat = exec, execStat |
| return nil |
| } |
| |
| // Locate attempts to locate the system's Target by traversing the available |
| // PATH. |
| // |
| // cached is the cached path, passed from wrapper to wrapper through the a |
| // State struct in the environment. This may be empty, if there was no cached |
| // path or if the cached path was invalid. |
| // |
| // env is the environment to operate with, and will not be modified during |
| // execution. |
| func (p *Probe) Locate(c context.Context, cached string, env environ.Env) (string, error) { |
| // If we have a cached path, check that it exists and is executable and use it |
| // if it is. |
| if cached != "" { |
| switch cachedStat, err := os.Stat(cached); { |
| case err == nil: |
| // Use the cached path. First, pass it through a sanity check to ensure |
| // that it is not self. |
| if p.SelfStat == nil || !os.SameFile(p.SelfStat, cachedStat) { |
| logging.Debugf(c, "Using cached value: %s", cached) |
| return cached, nil |
| } |
| logging.Debugf(c, "Cached value [%s] is this wrapper [%s]; ignoring.", cached, p.Self) |
| |
| case os.IsNotExist(err): |
| // Our cached path doesn't exist, so we will have to look for a new one. |
| |
| case err != nil: |
| // We couldn't check our cached path, so we will have to look for a new |
| // one. This is an unexpected error, though, so emit it. |
| logging.Debugf(c, "Failed to stat cached [%s]: %s", cached, err) |
| } |
| } |
| |
| // Get stats on our parent directory. This may fail; if so, we'll skip the |
| // SameFile check. |
| var selfDir string |
| var selfDirStat os.FileInfo |
| if p.Self != "" { |
| selfDir = filepath.Dir(p.Self) |
| |
| var err error |
| if selfDirStat, err = os.Stat(selfDir); err != nil { |
| logging.Debugf(c, "Failed to stat self directory [%s]: %s", selfDir, err) |
| } |
| } |
| |
| // Walk through PATH. Our goal is to find the first program named Target that |
| // isn't self and doesn't identify as a wrapper. |
| pathDirs := p.PathDirs |
| if pathDirs == nil { |
| pathDirs = strings.Split(env.GetEmpty("PATH"), string(os.PathListSeparator)) |
| } |
| |
| // Build our list of directories to check for Target. |
| checkDirs := make([]string, 0, len(pathDirs)+len(p.RelativePathOverride)) |
| if selfDir != "" { |
| for _, rpo := range p.RelativePathOverride { |
| checkDirs = append(checkDirs, filepath.Join(selfDir, filepath.FromSlash(rpo))) |
| } |
| } |
| checkDirs = append(checkDirs, pathDirs...) |
| |
| // Iterate through each check directory and look for a Target candidate within |
| // it. |
| checked := make(map[string]struct{}, len(checkDirs)) |
| for _, dir := range checkDirs { |
| if _, ok := checked[dir]; ok { |
| continue |
| } |
| checked[dir] = struct{}{} |
| |
| path := p.checkDir(c, dir, selfDirStat, env) |
| if path != "" { |
| return path, nil |
| } |
| } |
| |
| return "", errors.Reason("could not find target in system"). |
| InternalReason("target(%s)/dirs(%v)", p.Target, pathDirs).Err() |
| } |
| |
| // checkDir checks "checkDir" for our Target executable. It ignores |
| // executables whose target is the same file or shares the same parent directory |
| // as "self". |
| func (p *Probe) checkDir(c context.Context, dir string, selfDir os.FileInfo, env environ.Env) string { |
| // If we have a self directory defined, ensure that "dir" isn't the same |
| // directory. If it is, we will ignore this option, since we are looking for |
| // something outside of the wrapper directory. |
| if selfDir != nil { |
| switch checkDirStat, err := os.Stat(dir); { |
| case err == nil: |
| // "dir" exists; if it is the same as "selfDir", we can ignore it. |
| if os.SameFile(selfDir, checkDirStat) { |
| logging.Debugf(c, "Candidate shares wrapper directory [%s]; skipping...", dir) |
| return "" |
| } |
| |
| case os.IsNotExist(err): |
| logging.Debugf(c, "Candidate directory does not exist [%s]; skipping...", dir) |
| return "" |
| |
| default: |
| logging.Debugf(c, "Failed to stat candidate directory [%s]: %s", dir, err) |
| return "" |
| } |
| } |
| |
| t, err := findInDir(p.Target, dir, env) |
| if err != nil { |
| return "" |
| } |
| |
| // Make sure this file isn't the same as "self", if available. |
| if p.SelfStat != nil { |
| switch st, err := os.Stat(t); { |
| case err == nil: |
| if os.SameFile(p.SelfStat, st) { |
| logging.Debugf(c, "Candidate [%s] is same file as wrapper; skipping...", t) |
| return "" |
| } |
| |
| case os.IsNotExist(err): |
| // "t" no longer exists, so we can't use it. |
| return "" |
| |
| default: |
| logging.Debugf(c, "Failed to stat candidate path [%s]: %s", t, err) |
| return "" |
| } |
| } |
| |
| if err := filesystem.AbsPath(&t); err != nil { |
| logging.Debugf(c, "Failed to normalize candidate path [%s]: %s", t, err) |
| return "" |
| } |
| |
| // Try running the candidate command and confirm that it is not a wrapper. |
| if p.CheckWrapper != nil { |
| switch isWrapper, err := p.CheckWrapper(c, t, env); { |
| case err != nil: |
| logging.Debugf(c, "Failed to check if [%s] is a wrapper: %s", t, err) |
| return "" |
| |
| case isWrapper: |
| logging.Debugf(c, "Candidate is a wrapper: %s", t) |
| return "" |
| } |
| } |
| |
| return t |
| } |