usr/utils/mkdir.c

#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "file_mode.h"

static mode_t leaf_mode, subdir_mode;
static int p_flag;

char *progname;

static __noreturn usage(void)
{
	fprintf(stderr, "Usage: %s [-p] [-m mode] dir...\n", progname);
	exit(1);
}

static int make_one_dir(char *dir, mode_t mode)
{
	struct stat stbuf;

	if (mkdir(dir, mode) == -1) {
		int err = errno;

		/*
		 * Ignore the error if it all of the following
		 * are satisfied:
		 *  - error was EEXIST
		 *  - -p was specified
		 *  - stat indicates that its a directory
		 */
		if (p_flag && errno == EEXIST &&
		    stat(dir, &stbuf) == 0 && S_ISDIR(stbuf.st_mode))
			return 1;
		errno = err;
		fprintf(stderr, "%s: ", progname);
		perror(dir);
		return -1;
	}
	return 0;
}

static int make_dir(char *dir)
{
	int ret;

	if (p_flag) {
		char *s, *p;

		/*
		 * Recurse each directory, trying to make it
		 * as we go.  Should we check to see if it
		 * exists, and if so if it's a directory
		 * before calling mkdir?
		 */
		s = dir;
		while ((p = strchr(s, '/')) != NULL) {
			/*
			 * Ignore the leading /
			 */
			if (p != dir) {
				*p = '\0';

				/*
				 * Make the intermediary directory.  POSIX
				 * says that these directories are created
				 * with umask,u+wx
				 */
				if (make_one_dir(dir, subdir_mode) == -1)
					return -1;

				*p = '/';
			}
			s = p + 1;
		}
	}

	/*
	 * Make the final target.  Only complain if the
	 * target already exists if -p was not specified.
	 * This is created with the asked for mode & ~umask
	 */
	ret = make_one_dir(dir, leaf_mode);
	if (ret == -1)
		return -1;

	/*
	 * We might not set all the permission bits.  Do that
	 * here (but only if we did create it.)
	 */
	if (ret == 0 && chmod(dir, leaf_mode) == -1) {
		int err_save = errno;

		/*
		 * We failed, remove the directory we created
		 */
		rmdir(dir);
		errno = err_save;
		fprintf(stderr, "%s: ", progname);
		perror(dir);
		return -1;
	}
	return 0;
}

int main(int argc, char *argv[])
{
	int c, ret = 0;
	mode_t saved_umask;

	progname = argv[0];

	saved_umask = umask(0);
	leaf_mode = (S_IRWXU | S_IRWXG | S_IRWXO) & ~saved_umask;
	subdir_mode = (saved_umask ^ (S_IRWXU | S_IRWXG | S_IRWXO))
	    | S_IWUSR | S_IXUSR;

	do {
		c = getopt(argc, argv, "pm:");
		if (c == EOF)
			break;
		switch (c) {
		case 'm':
			leaf_mode =
			    parse_file_mode(optarg, leaf_mode, saved_umask);
			break;
		case 'p':
			p_flag = 1;
			break;

		case '?':
			fprintf(stderr, "%s: invalid option -%c\n",
				progname, optopt);
			usage();
		}
	} while (1);

	if (optind == argc)
		usage();

	while (optind < argc) {
		if (make_dir(argv[optind]))
			ret = 255;	/* seems to be what gnu mkdir does */
		optind++;
	}

	return ret;
}
1	niro	532	#include <sys/stat.h>
2			#include <sys/types.h>
3			#include <errno.h>
4			#include <fcntl.h>
5			#include <signal.h>
6			#include <stdio.h>
7			#include <stdlib.h>
8			#include <string.h>
9			#include <unistd.h>
10
11			#include "file_mode.h"
12
13			static mode_t leaf_mode, subdir_mode;
14			static int p_flag;
15
16			char *progname;
17
18			static __noreturn usage(void)
19			{
20			fprintf(stderr, "Usage: %s [-p] [-m mode] dir...\n", progname);
21			exit(1);
22			}
23
24			static int make_one_dir(char *dir, mode_t mode)
25			{
26			struct stat stbuf;
27
28			if (mkdir(dir, mode) == -1) {
29			int err = errno;
30
31			/*
32			* Ignore the error if it all of the following
33			* are satisfied:
34			* - error was EEXIST
35			* - -p was specified
36			* - stat indicates that its a directory
37			*/
38			if (p_flag && errno == EEXIST &&
39			stat(dir, &stbuf) == 0 && S_ISDIR(stbuf.st_mode))
40			return 1;
41			errno = err;
42			fprintf(stderr, "%s: ", progname);
43			perror(dir);
44			return -1;
45			}
46			return 0;
47			}
48
49			static int make_dir(char *dir)
50			{
51			int ret;
52
53			if (p_flag) {
54			char s, p;
55
56			/*
57			* Recurse each directory, trying to make it
58			* as we go. Should we check to see if it
59			* exists, and if so if it's a directory
60			* before calling mkdir?
61			*/
62			s = dir;
63			while ((p = strchr(s, '/')) != NULL) {
64			/*
65			* Ignore the leading /
66			*/
67			if (p != dir) {
68			*p = '\0';
69
70			/*
71			* Make the intermediary directory. POSIX
72			* says that these directories are created
73			* with umask,u+wx
74			*/
75			if (make_one_dir(dir, subdir_mode) == -1)
76			return -1;
77
78			*p = '/';
79			}
80			s = p + 1;
81			}
82			}
83
84			/*
85			* Make the final target. Only complain if the
86			* target already exists if -p was not specified.
87			* This is created with the asked for mode & ~umask
88			*/
89			ret = make_one_dir(dir, leaf_mode);
90			if (ret == -1)
91			return -1;
92
93			/*
94			* We might not set all the permission bits. Do that
95			* here (but only if we did create it.)
96			*/
97			if (ret == 0 && chmod(dir, leaf_mode) == -1) {
98			int err_save = errno;
99
100			/*
101			* We failed, remove the directory we created
102			*/
103			rmdir(dir);
104			errno = err_save;
105			fprintf(stderr, "%s: ", progname);
106			perror(dir);
107			return -1;
108			}
109			return 0;
110			}
111
112			int main(int argc, char *argv[])
113			{
114			int c, ret = 0;
115			mode_t saved_umask;
116
117			progname = argv[0];
118
119			saved_umask = umask(0);
120			leaf_mode = (S_IRWXU \| S_IRWXG \| S_IRWXO) & ~saved_umask;
121			subdir_mode = (saved_umask ^ (S_IRWXU \| S_IRWXG \| S_IRWXO))
122			\| S_IWUSR \| S_IXUSR;
123
124			do {
125			c = getopt(argc, argv, "pm:");
126			if (c == EOF)
127			break;
128			switch (c) {
129			case 'm':
130			leaf_mode =
131			parse_file_mode(optarg, leaf_mode, saved_umask);
132			break;
133			case 'p':
134			p_flag = 1;
135			break;
136
137			case '?':
138			fprintf(stderr, "%s: invalid option -%c\n",
139			progname, optopt);
140			usage();
141			}
142			} while (1);
143
144			if (optind == argc)
145			usage();
146
147			while (optind < argc) {
148			if (make_dir(argv[optind]))
149			ret = 255; /* seems to be what gnu mkdir does */
150			optind++;
151			}
152
153			return ret;
154			}