xref: /titanic_51/usr/src/lib/libpkg/common/isdir.c (revision 7509ca605713ac7f244b0e812b1712dd25f04da1)
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 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
26  */
27 
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
30 
31 
32 #include <stdio.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <archives.h>
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <limits.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41 #include <string.h>
42 #include "pkglocale.h"
43 #include "pkglibmsgs.h"
44 
45 /*
46  * Defines for cpio/compression checks.
47  */
48 #define	BIT_MASK		0x1f
49 #define	BLOCK_MASK		0x80
50 
51 #define	MASK_CK(x, y)	(((x) & (y)) == (y))
52 #define	ISCOMPCPIO	((unsigned char) cm.c_mag[0] == m_h[0] && \
53 			(unsigned char) cm.c_mag[1] == m_h[1] && \
54 			(MASK_CK((unsigned char) cm.c_mag[2], BLOCK_MASK) || \
55 			MASK_CK((unsigned char) cm.c_mag[2], BIT_MASK)))
56 
57 #define	ISCPIO		(cm.b_mag != CMN_BIN && \
58 			(strcmp(cm.c_mag, CMS_ASC) == 0) && \
59 			(strcmp(cm.c_mag, CMS_CHR) == 0) && \
60 			(strcmp(cm.c_mag, CMS_CRC) == 0))
61 
62 /* location of distributed file system types database */
63 
64 #define	REMOTE_FS_DBFILE	"/etc/dfs/fstypes"
65 
66 /* character array used to hold dfs types database contents */
67 
68 static long		numRemoteFstypes = -1;
69 static char		**remoteFstypes = (char **)NULL;
70 
71 /* forward declarations */
72 
73 static void _InitRemoteFstypes(void);
74 
75 int isFdRemote(int a_fd);
76 int isPathRemote(char *a_path);
77 int isFstypeRemote(char *a_fstype);
78 int isdir(char *path);
79 int isfile(char *dir, char *file);
80 int iscpio(char *path, int *iscomp);
81 
82 /*
83  * Name:	isdir
84  * Description:	determine if specified path exists and is a directory
85  * Arguments:	path - pointer to string representing the path to verify
86  * returns: 0 - directory exists
87  *	    1 - directory does not exist or is not a directory
88  * NOTE:	errno is set appropriately
89  */
90 
91 int
92 isdir(char *path)
93 {
94 	struct stat statbuf;
95 
96 	/* return error if path does not exist */
97 
98 	if (stat(path, &statbuf) != 0) {
99 		return (1);
100 	}
101 
102 	/* return error if path is not a directory */
103 
104 	if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
105 		errno = ENOTDIR;
106 		return (1);
107 	}
108 
109 	return (0);
110 }
111 
112 /*
113  * Name:	isfile
114  * Description:	determine if specified path exists and is a directory
115  * Arguments:	dir - pointer to string representing the directory where
116  *			the file is located
117  *			== NULL - use "file" argument only
118  *		file - pointer to string representing the file to verify
119  * Returns:	0 - success - file exists
120  *		1 - failure - file does not exist OR is not a file
121  * NOTE:	errno is set appropriately
122  */
123 
124 int
125 isfile(char *dir, char *file)
126 {
127 	struct stat statbuf;
128 	char	path[PATH_MAX];
129 
130 	/* construct full path if directory specified */
131 
132 	if (dir) {
133 		(void) snprintf(path, sizeof (path), "%s/%s", dir, file);
134 		file = path;
135 	}
136 
137 	/* return error if path does not exist */
138 
139 	if (stat(file, &statbuf) != 0) {
140 		return (1);
141 	}
142 
143 	/* return error if path is a directory */
144 
145 	if ((statbuf.st_mode & S_IFMT) == S_IFDIR) {
146 		errno = EISDIR;
147 		return (1);
148 	}
149 
150 	/* return error if path is not a file */
151 
152 	if ((statbuf.st_mode & S_IFMT) != S_IFREG) {
153 		errno = EINVAL;
154 		return (1);
155 	}
156 
157 	return (0);
158 }
159 
160 int
161 iscpio(char *path, int *iscomp)
162 {
163 	/*
164 	 * Compressed File Header.
165 	 */
166 	unsigned char m_h[] = { "\037\235" };		/* 1F 9D */
167 
168 	static union {
169 		short int	b_mag;
170 		char		c_mag[CMS_LEN];
171 	}	cm;
172 
173 	struct stat	statb;
174 	int		fd;
175 
176 
177 	*iscomp = 0;
178 
179 	if ((fd = open(path, O_RDONLY, 0)) == -1) {
180 		if (errno != ENOENT) {
181 			perror("");
182 			(void) fprintf(stderr, pkg_gt(ERR_ISCPIO_OPEN), path);
183 		}
184 		return (0);
185 	} else {
186 		if (fstat(fd, &statb) == -1) {
187 			perror("");
188 			(void) fprintf(stderr, pkg_gt(ERR_ISCPIO_FSTAT), path);
189 			(void) close(fd);
190 			return (0);
191 		} else {
192 			if (S_ISREG(statb.st_mode)) {	/* Must be a file */
193 				if (read(fd, cm.c_mag, sizeof (cm.c_mag)) !=
194 				    sizeof (cm.c_mag)) {
195 					perror("");
196 					(void) fprintf(stderr,
197 					    pkg_gt(ERR_ISCPIO_READ), path);
198 					(void) close(fd);
199 					return (0);
200 				}
201 				/*
202 				 * Try to determine if the file is a compressed
203 				 * file, if that fails, try to determine if it
204 				 * is a cpio archive, if that fails, then we
205 				 * fail!
206 				 */
207 				if (ISCOMPCPIO) {
208 					*iscomp = 1;
209 					(void) close(fd);
210 					return (1);
211 				} else if (ISCPIO) {
212 					(void) fprintf(stderr,
213 					    pkg_gt(ERR_ISCPIO_NOCPIO),
214 					    path);
215 					(void) close(fd);
216 					return (0);
217 				}
218 				(void) close(fd);
219 				return (1);
220 			} else {
221 				(void) close(fd);
222 				return (0);
223 			}
224 		}
225 	}
226 }
227 
228 /*
229  * Name:	isPathRemote
230  * Description:	determine if a path object is local or remote
231  * Arguments:	a_path - [RO, *RO] - (char *)
232  *			Pointer to string representing the path to check
233  * Returns:	int
234  *			1 - the path is remote
235  *			0 - the path is local to this system
236  *			-1 - cannot determine if path is remote or local
237  */
238 
239 int
240 isPathRemote(char *a_path)
241 {
242 	int		r;
243 	struct stat	statbuf;
244 
245 	r = lstat(a_path, &statbuf);
246 	if (r < 0) {
247 		return (-1);
248 	}
249 
250 	return (isFstypeRemote(statbuf.st_fstype));
251 }
252 
253 /*
254  * Name:	isFdRemote
255  * Description:	determine if an open file is local or remote
256  * Arguments:	a_fd - [RO, *RO] - (int)
257  *			Integer representing open file to check
258  * Returns:	int
259  *			1 - the path is remote
260  *			0 - the path is local to this system
261  *			-1 - cannot determine if path is remote or local
262  */
263 
264 int
265 isFdRemote(int a_fd)
266 {
267 	int		r;
268 	struct stat	statbuf;
269 
270 	r = fstat(a_fd, &statbuf);
271 	if (r < 0) {
272 		return (-1);
273 	}
274 
275 	return (isFstypeRemote(statbuf.st_fstype));
276 }
277 
278 /*
279  * Name:	isFstypeRemote
280  * Description:	determine if a file system type is remote (distributed)
281  * Arguments:	a_fstype - [RO, *RO] - (char *)
282  *			Pointer to string representing the file system type
283  *			to check
284  * Returns:	int
285  *			1 - the file system type is remote
286  *			0 - the file system type is local to this system
287  */
288 
289 int
290 isFstypeRemote(char *a_fstype)
291 {
292 	int	i;
293 
294 	/* initialize the list if it is not yet initialized */
295 
296 	_InitRemoteFstypes();
297 
298 	/* scan the list looking for the specified type */
299 
300 	for (i = 0; i < numRemoteFstypes; i++) {
301 		if (strcmp(remoteFstypes[i], a_fstype) == 0) {
302 			return (1);
303 		}
304 	}
305 
306 	/* type not found in remote file system type list - is not remote */
307 
308 	return (0);
309 }
310 
311 /*
312  * Name:	_InitRemoteFstypes
313  * Description:	initialize table of remote file system type names
314  * Arguments:	none
315  * Returns:	none
316  * Side Effects:
317  *	- The global array "(char **)remoteFstypes" is set to the
318  *	  address of an array of string pointers, each of which represents
319  *	  a single remote file system type
320  *	- The global variable "(long) numRemoteFstypes" is set to the total
321  *	  number of remote file system type strings (names) that are
322  *	  contained in the "remoteFstypes" global array.
323  *	- numRemoteFstypes is initialized to "-1" before any attempt has been
324  *	  made to read the remote file system type name database.
325  */
326 static void
327 _InitRemoteFstypes(void)
328 {
329 	FILE    *fp;
330 	char    line_buf[LINE_MAX];
331 
332 	/* return if already initialized */
333 
334 	if (numRemoteFstypes > 0) {
335 		return;
336 	}
337 
338 	/* if list is uninitialized, start with zero */
339 
340 	if (numRemoteFstypes == -1) {
341 		numRemoteFstypes = 0;
342 	}
343 
344 	/* open the remote file system type database file */
345 
346 	if ((fp = fopen(REMOTE_FS_DBFILE, "r")) == NULL) {
347 		/* no remote type database: use predefined remote types */
348 		remoteFstypes = (char **)realloc(remoteFstypes,
349 		    sizeof (char *) * (numRemoteFstypes+2));
350 		remoteFstypes[numRemoteFstypes++] = "nfs";	/* +1 */
351 		remoteFstypes[numRemoteFstypes++] = "autofs";	/* +2 */
352 		return;
353 	}
354 
355 	/*
356 	 * Read the remote file system type database; from fstypes(4):
357 	 *
358 	 * fstypes resides in directory /etc/dfs and lists distributed file
359 	 * system utilities packages installed on the system. For each installed
360 	 * distributed file system type, there is a line that begins with the
361 	 * file system type name (for example, ``nfs''), followed by white space
362 	 * and descriptive text.
363 	 *
364 	 * Lines will look at lot like this:
365 	 *
366 	 *	nfs NFS Utilities
367 	 *	autofs AUTOFS Utilities
368 	 */
369 
370 	while (fgets(line_buf, sizeof (line_buf), fp) != NULL) {
371 		char		buf[LINE_MAX];
372 		static char	format[128] = {'\0'};
373 
374 		if (format[0] == '\0') {
375 			/* create bounded format: %ns */
376 			(void) snprintf(format, sizeof (format),
377 			    "%%%ds", sizeof (buf)-1);
378 		}
379 
380 		(void) sscanf(line_buf, format, buf);
381 
382 		remoteFstypes = realloc(remoteFstypes,
383 		    sizeof (char *) * (numRemoteFstypes+1));
384 		remoteFstypes[numRemoteFstypes++] = strdup(buf);
385 	}
386 
387 	/* close database file and return */
388 
389 	(void) fclose(fp);
390 }
391