1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25 /*
26 * Copyright (c) 2013 by Delphix. All rights reserved.
27 */
28
29 #define __EXTENSIONS__
30 #include <string.h>
31 #undef __EXTENSIONS__
32
33 #include <libgen.h>
34 #include <limits.h>
35 #include <stdio.h>
36 #include <errno.h>
37 #include <unistd.h>
38 #include <zone.h>
39
40 #include "libproc.h"
41 #include "Pcontrol.h"
42
43 /*
44 * Pexecname.c - Way too much code to attempt to derive the full pathname of
45 * the executable file from a process handle, be it dead or alive.
46 */
47
48 /*
49 * Once we've computed a cwd and a relative path, we use try_exec() to
50 * form an absolute path, call resolvepath() on it, and then let the
51 * caller's function do the final confirmation.
52 */
53 static int
54 try_exec(struct ps_prochandle *P, const char *cwd, const char *path, char *buf,
55 int (*isexec)(const char *, void *), void *isdata)
56 {
57 int i;
58
59 if (path[0] != '/')
60 (void) snprintf(buf, PATH_MAX, "%s/%s", cwd, path);
61 else
62 (void) strcpy(buf, path);
63
64 dprintf("try_exec \"%s\"\n", buf);
65
66 (void) Pfindobj(P, buf, buf, PATH_MAX);
67 if ((i = resolvepath(buf, buf, PATH_MAX)) > 0) {
68 buf[i] = '\0';
69 return (isexec(buf, isdata));
70 }
71
72 return (0); /* resolvepath failed */
73 }
74
75 /*
76 * The Pfindexec function contains the logic for the executable name dance.
77 * The caller provides a possible executable name or likely directory (the
78 * aout parameter), and a function which is responsible for doing any
79 * final confirmation on the executable pathname once a possible full
80 * pathname has been chosen.
81 */
82 char *
83 Pfindexec(struct ps_prochandle *P, const char *aout,
84 int (*isexec)(const char *, void *), void *isdata)
85 {
86 char cwd[PATH_MAX * 2];
87 char path[PATH_MAX];
88 char buf[PATH_MAX];
89 struct stat st;
90 uintptr_t addr;
91 char *p = path, *q;
92
93 dprintf("Pfindexec '%s'\n", aout);
94
95 if (P->execname)
96 return (P->execname); /* Already found */
97
98 errno = 0; /* Set to zero so we can tell if stat() failed */
99
100 /*
101 * First try: use the provided default value, if it is not a directory.
102 * If the aout parameter turns out to be a directory, this is
103 * interpreted as the directory to use as an alternate cwd for
104 * our subsequent attempts to locate the executable.
105 */
106 if (aout != NULL && stat(aout, &st) == 0 && !S_ISDIR(st.st_mode)) {
107 if (try_exec(P, ".", aout, buf, isexec, isdata))
108 goto found;
109 else
110 aout = ".";
111
112 } else if (aout == NULL || errno != 0)
113 aout = ".";
114
115 /*
116 * At this point 'aout' is either "." or an alternate cwd. We use
117 * realpath(3c) to turn this into a full pathname free of ".", "..",
118 * and symlinks. If this fails for some reason, fall back to "."
119 */
120 if (realpath(aout, cwd) == NULL)
121 (void) strcpy(cwd, ".");
122
123 /*
124 * Second try: read the string pointed to by the AT_SUN_EXECNAME
125 * auxv element, saved when the program was exec'd. If the full
126 * pathname try_exec() forms fails, try again using just the
127 * basename appended to our cwd. If that also fails, and the process
128 * is in a zone, try again with the zone path instead of our cwd.
129 */
130 if ((addr = Pgetauxval(P, AT_SUN_EXECNAME)) != (uintptr_t)-1L &&
131 Pread_string(P, path, sizeof (path), (off_t)addr) > 0) {
132 char zpath[PATH_MAX];
133 const psinfo_t *pi = Ppsinfo(P);
134
135 if (try_exec(P, cwd, path, buf, isexec, isdata))
136 goto found;
137
138 if (strchr(path, '/') != NULL && (p = basename(path)) != NULL &&
139 try_exec(P, cwd, p, buf, isexec, isdata))
140 goto found;
141
142 if (getzoneid() == GLOBAL_ZONEID &&
143 pi->pr_zoneid != GLOBAL_ZONEID &&
144 zone_getattr(pi->pr_zoneid, ZONE_ATTR_ROOT, zpath,
145 sizeof (zpath)) != -1) {
146 /*
147 * try_exec() only combines its cwd and path arguments
148 * if path is relative; but in our case even an absolute
149 * path inside a zone is a relative path from the global
150 * zone perspective. So we turn a non-global zone's
151 * absolute path into a relative path here before
152 * calling try_exec().
153 */
154 p = (path[0] == '/') ? path + 1 : path;
155 if (try_exec(P, zpath, p, buf, isexec, isdata))
156 goto found;
157 }
158 }
159
160 /*
161 * Third try: try using the first whitespace-separated token
162 * saved in the psinfo_t's pr_psargs (the initial value of argv[0]).
163 */
164 if (Ppsinfo(P) != NULL) {
165 (void) strncpy(path, P->psinfo.pr_psargs, PRARGSZ);
166 path[PRARGSZ] = '\0';
167
168 if ((p = strchr(path, ' ')) != NULL)
169 *p = '\0';
170
171 if (try_exec(P, cwd, path, buf, isexec, isdata))
172 goto found;
173
174 if (strchr(path, '/') != NULL && (p = basename(path)) != NULL &&
175 try_exec(P, cwd, p, buf, isexec, isdata))
176 goto found;
177 }
178
179 /*
180 * Fourth try: read the string pointed to by argv[0] out of the
181 * stack in the process's address space.
182 */
183 if (P->psinfo.pr_argv != NULL &&
184 Pread(P, &addr, sizeof (addr), P->psinfo.pr_argv) != -1 &&
185 Pread_string(P, path, sizeof (path), (off_t)addr) > 0) {
186
187 if (try_exec(P, cwd, path, buf, isexec, isdata))
188 goto found;
189
190 if (strchr(path, '/') != NULL && (p = basename(path)) != NULL &&
191 try_exec(P, cwd, p, buf, isexec, isdata))
192 goto found;
193 }
194
195 /*
196 * Fifth try: read the process's $PATH environment variable and
197 * search each directory named there for the name matching pr_fname.
198 */
199 if (Pgetenv(P, "PATH", cwd, sizeof (cwd)) != NULL) {
200 /*
201 * If the name from pr_psargs contains pr_fname as its
202 * leading string, then accept the name from pr_psargs
203 * because more bytes are saved there. Otherwise use
204 * pr_fname because this gives us new information.
205 */
206 (void) strncpy(path, P->psinfo.pr_psargs, PRARGSZ);
207 path[PRARGSZ] = '\0';
208
209 if ((p = strchr(path, ' ')) != NULL)
210 *p = '\0';
211
212 if (strchr(path, '/') != NULL || strncmp(path,
213 P->psinfo.pr_fname, strlen(P->psinfo.pr_fname)) != 0)
214 (void) strcpy(path, P->psinfo.pr_fname);
215
216 /*
217 * Now iterate over the $PATH elements, trying to form
218 * an executable pathname with each one.
219 */
220 for (p = strtok_r(cwd, ":", &q); p != NULL;
221 p = strtok_r(NULL, ":", &q)) {
222
223 if (*p != '/')
224 continue; /* Ignore anything relative */
225
226 if (try_exec(P, p, path, buf, isexec, isdata))
227 goto found;
228 }
229 }
230
231 errno = ENOENT;
232 return (NULL);
233
234 found:
235 if ((P->execname = strdup(buf)) == NULL)
236 dprintf("failed to malloc; executable name is \"%s\"", buf);
237
238 return (P->execname);
239 }
240
241 /*
242 * Return the full pathname for the executable file.
243 */
244 char *
245 Pexecname(struct ps_prochandle *P, char *buf, size_t buflen)
246 {
247 if (P->execname != NULL) {
248 (void) strncpy(buf, P->execname, buflen);
249 return (buf);
250 }
251
252 return (P->ops.pop_execname(P, buf, buflen, P->data));
253 }