logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

chmod.c (9482B)

    

  1. // utils-std: Collection of commonly available Unix tools
  2. // SPDX-FileCopyrightText: 2017 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-License-Identifier: MPL-2.0
  5. #define _POSIX_C_SOURCE 200809L
  7. // NetBSD <10 hides fdopendir behind _NETBSD_SOURCE
  8. #if __NetBSD_Version__ < 1000000000
  9. #define _NETBSD_SOURCE
  10. #endif
  12. #include "../config.h" // HAS_*
  13. #include "../lib/getopt_nolong.h"
  14. #include "../lib/mode.h"
  16. #include <dirent.h> // fdopendir, readdir, closedir
  17. #include <errno.h>
  18. #include <fcntl.h>  // AT_FDCWD
  19. #include <limits.h> // PATH_MAX
  20. #include <stdbool.h>
  21. #include <stdio.h>    // fprintf
  22. #include <string.h>   // strerror
  23. #include <sys/stat.h> // chmod, fstatat, S_ISDIR
  24. #include <unistd.h>   // getopt
  25. #ifdef HAS_GETOPT_LONG
  26. #include <getopt.h>
  27. #endif
  29. const char *argv0 = "chmod";
  30. bool opt_c = false, opt_v = false;
  32. static int
  33. do_fchmodat(int fd, char *mode_arg, char *name, char *acc_path, bool recursive)
  34. {
  35. 	struct stat stats;
  36. 	int err = 0;
  38. 	if(fstatat(fd, name, &stats, AT_SYMLINK_NOFOLLOW) != 0)
  39. 	{
  40. 		fprintf(stderr,
  41. 		        "%s: error: Failed getting status for '%s': %s\n",
  42. 		        argv0,
  43. 		        acc_path,
  44. 		        strerror(errno));
  45. 		errno = 0;
  46. 		return 1;
  47. 	}
  49. 	const char *errstr = NULL;
  50. 	mode_t mode = new_mode(mode_arg, stats.st_mode, &errstr);
  51. 	if(errstr != NULL)
  52. 	{
  53. 		fprintf(stderr, "%s: error: Failed parsing mode '%s': %s\n", argv0, mode_arg, errstr);
  54. 		return 1;
  55. 	}
  57. 	char mode_from[11] = "";
  58. 	symbolize_mode(stats.st_mode, mode_from);
  60. 	if(mode != stats.st_mode)
  61. 	{
  62. 		if(fchmodat(fd, name, mode, 0) != 0)
  63. 		{
  64. 			fprintf(stderr,
  65. 			        "%s: error: Failed setting permissions to 0%04o for '%s': %s\n",
  66. 			        argv0,
  67. 			        mode,
  68. 			        acc_path,
  69. 			        strerror(errno));
  70. 			errno = 0;
  71. 			return 1;
  72. 		}
  74. 		if(opt_c || opt_v)
  75. 		{
  76. 			char mode_to[11] = "";
  77. 			symbolize_mode(mode, mode_to);
  79. 			printf("%s: Permissions changed from 0%04o/%s to 0%04o/%s for '%s'\n",
  80. 			       argv0,
  81. 			       stats.st_mode & 07777,
  82. 			       mode_from,
  83. 			       mode & 07777,
  84. 			       mode_to,
  85. 			       acc_path);
  86. 		}
  87. 	}
  88. 	else if(opt_v)
  89. 		printf("%s: Permissions already set to 0%04o/%s for '%s'\n",
  90. 		       argv0,
  91. 		       stats.st_mode & 07777,
  92. 		       mode_from,
  93. 		       acc_path);
  95. 	if(recursive && S_ISDIR(stats.st_mode))
  96. 	{
  97. 		int dir = openat(fd, name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  98. 		if(dir == -1)
  99. 		{
  100. 			fprintf(stderr,
  101. 			        "%s: error: Couldn't open '%s' as directory: %s\n",
  102. 			        argv0,
  103. 			        acc_path,
  104. 			        strerror(errno));
  105. 			errno = 0;
  106. 			return 1;
  107. 		}
  109. 		DIR *dirp = fdopendir(dir);
  110. 		if(dirp == NULL)
  111. 		{
  112. 			fprintf(stderr,
  113. 			        "%s: error: Couldn't get DIR entry for opened '%s': %s\n",
  114. 			        argv0,
  115. 			        acc_path,
  116. 			        strerror(errno));
  117. 			errno = 0;
  118. 			return 1;
  119. 		}
  121. 		while(true)
  122. 		{
  123. 			struct dirent *dp = readdir(dirp);
  124. 			if(dp == NULL)
  125. 			{
  126. 				if(errno == 0) break;
  128. 				fprintf(stderr,
  129. 				        "%s: error: Failed reading directory '%s': %s\n",
  130. 				        argv0,
  131. 				        acc_path,
  132. 				        strerror(errno));
  133. 				closedir(dirp); // FIXME: unhandled error
  134. 				errno = 0;
  135. 				return 1;
  136. 			}
  138. 			if(strcmp(dp->d_name, ".") == 0) continue;
  139. 			if(strcmp(dp->d_name, "..") == 0) continue;
  141. 			char new_path[PATH_MAX] = "";
  142. 			if(snprintf(new_path, PATH_MAX, "%s/%s", acc_path, dp->d_name) < 0)
  143. 			{
  144. 				fprintf(
  145. 				    stderr,
  146. 				    "%s: error: Couldn't concatenate '%s' into parent '%s', skipping to next entry: %s\n",
  147. 				    argv0,
  148. 				    name,
  149. 				    acc_path,
  150. 				    strerror(errno));
  151. 				err++;
  152. 				errno = 0;
  153. 				continue;
  154. 			}
  156. 			// No depth counter for now, unlikely to be a problem
  157. 			int ret = do_fchmodat(dir, mode_arg, dp->d_name, new_path, true);
  158. 			if(ret != 0) return ret;
  159. 		}
  161. 		// fdopendir allocates memory for DIR, needs closedir
  162. 		if(closedir(dirp) != 0)
  163. 		{
  164. 			fprintf(stderr,
  165. 			        "%s: error: Deallocating directory entry for '%s' failed: %s\n",
  166. 			        argv0,
  167. 			        acc_path,
  168. 			        strerror(errno));
  169. 			errno = 0;
  170. 			return 1;
  171. 		}
  172. 	}
  174. 	return err;
  175. }
  177. static int
  178. copy_mode(int fd, mode_t mode, char *name, char *acc_path, bool recursive)
  179. {
  180. 	struct stat stats;
  181. 	int err = 0;
  183. 	if(fstatat(fd, name, &stats, AT_SYMLINK_NOFOLLOW) != 0)
  184. 	{
  185. 		fprintf(stderr,
  186. 		        "%s: error: Failed getting status for '%s': %s\n",
  187. 		        argv0,
  188. 		        acc_path,
  189. 		        strerror(errno));
  190. 		errno = 0;
  191. 		return 1;
  192. 	}
  194. 	char mode_from[11] = "";
  195. 	symbolize_mode(stats.st_mode, mode_from);
  197. 	if(mode != stats.st_mode)
  198. 	{
  199. 		if(fchmodat(fd, name, mode, 0) != 0)
  200. 		{
  201. 			fprintf(stderr,
  202. 			        "%s: error: Failed setting permissions to 0%04o for '%s': %s\n",
  203. 			        argv0,
  204. 			        mode,
  205. 			        acc_path,
  206. 			        strerror(errno));
  207. 			errno = 0;
  208. 			return 1;
  209. 		}
  211. 		if(opt_c || opt_v)
  212. 		{
  213. 			char mode_to[11] = "";
  214. 			symbolize_mode(mode, mode_to);
  216. 			printf("%s: Permissions changed from 0%04o/%s to 0%04o/%s for '%s'\n",
  217. 			       argv0,
  218. 			       stats.st_mode & 07777,
  219. 			       mode_from,
  220. 			       mode & 07777,
  221. 			       mode_to,
  222. 			       acc_path);
  223. 		}
  224. 	}
  225. 	else if(opt_v)
  226. 		printf("%s: Permissions already set to 0%04o/%s for '%s'\n",
  227. 		       argv0,
  228. 		       stats.st_mode & 07777,
  229. 		       mode_from,
  230. 		       acc_path);
  232. 	if(recursive && S_ISDIR(stats.st_mode))
  233. 	{
  234. 		int dir = openat(fd, name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  235. 		if(dir == -1)
  236. 		{
  237. 			fprintf(stderr,
  238. 			        "%s: error: Couldn't open '%s' as directory: %s\n",
  239. 			        argv0,
  240. 			        acc_path,
  241. 			        strerror(errno));
  242. 			errno = 0;
  243. 			return 1;
  244. 		}
  246. 		DIR *dirp = fdopendir(dir);
  247. 		if(dirp == NULL)
  248. 		{
  249. 			fprintf(stderr,
  250. 			        "%s: error: Couldn't get DIR entry for opened '%s': %s\n",
  251. 			        argv0,
  252. 			        acc_path,
  253. 			        strerror(errno));
  254. 			errno = 0;
  255. 			return 1;
  256. 		}
  258. 		while(true)
  259. 		{
  260. 			struct dirent *dp = readdir(dirp);
  261. 			if(dp == NULL)
  262. 			{
  263. 				if(errno == 0) break;
  265. 				fprintf(stderr,
  266. 				        "%s: error: Failed reading directory '%s': %s\n",
  267. 				        argv0,
  268. 				        acc_path,
  269. 				        strerror(errno));
  270. 				closedir(dirp); // FIXME: unhandled error
  271. 				errno = 0;
  272. 				return 1;
  273. 			}
  275. 			if(strcmp(dp->d_name, ".") == 0) continue;
  276. 			if(strcmp(dp->d_name, "..") == 0) continue;
  278. 			char new_path[PATH_MAX] = "";
  279. 			if(snprintf(new_path, PATH_MAX, "%s/%s", acc_path, dp->d_name) < 0)
  280. 			{
  281. 				fprintf(
  282. 				    stderr,
  283. 				    "%s: error: Couldn't concatenate '%s' into parent '%s', skipping to next entry: %s\n",
  284. 				    argv0,
  285. 				    name,
  286. 				    acc_path,
  287. 				    strerror(errno));
  288. 				err++;
  289. 				errno = 0;
  290. 				continue;
  291. 			}
  293. 			// No depth counter for now, unlikely to be a problem
  294. 			int ret = copy_mode(dir, mode, dp->d_name, new_path, true);
  295. 			if(ret != 0) return ret;
  296. 		}
  298. 		// fdopendir allocates memory for DIR, needs closedir
  299. 		if(closedir(dirp) != 0)
  300. 		{
  301. 			fprintf(stderr,
  302. 			        "%s: error: Deallocating directory entry for '%s' failed: %s\n",
  303. 			        argv0,
  304. 			        acc_path,
  305. 			        strerror(errno));
  306. 			errno = 0;
  307. 			return 1;
  308. 		}
  309. 	}
  311. 	return err;
  312. }
  314. static void
  315. usage(void)
  316. {
  317. 	fprintf(stderr, "\
  318. Usage: chmod [-cRv] <mode> <file...>\n\
  319.        chmod [-cRv] -F <ref_file> <file...>\n");
  320. }
  322. int
  323. main(int argc, char *argv[])
  324. {
  325. 	bool opt_R = false;
  326. 	char *ref_file = NULL;
  328. #ifdef HAS_GETOPT_LONG
  329. 	// clang-format off
  330. 	enum long_opt_vals {
  331. 		OPT_REFERENCE = 1,
  332. 	};
  333. 	static struct option opts[] = {
  334. 		{"changes", no_argument, 0, 'c'},
  335. 		{"recursive", no_argument, 0, 'R'},
  336. 		{"reference", required_argument, 0, OPT_REFERENCE},
  337. 		{"verbose", no_argument, 0, 'v'},
  338. 		{0, 0, 0, 0},
  339. 	};
  340. 	// clang-format on
  341. #endif
  343. 	for(int c = -1;;)
  344. 	{
  345. 		if(optind >= argc || !argv[optind]) break;
  347. 		if(argv[optind][0] == '-' && strchr("rwxugoa", argv[optind][1]))
  348. 		{
  349. 			fprintf(stderr,
  350. 			        "%s: warning: (portability) Pass -- before a mode with a leading dash(-) to "
  351. 			        "separate it from options\n",
  352. 			        argv0);
  353. 			break;
  354. 		}
  356. #ifdef HAS_GETOPT_LONG
  357. 		// Need + as first character to get POSIX-style option parsing
  358. 		c = getopt_long(argc, argv, "+:cRv", opts, NULL);
  359. #else
  360. 		c = getopt_nolong(argc, argv, ":cRv");
  361. #endif
  362. 		if(c == -1) break;
  364. 		switch(c)
  365. 		{
  366. 		case 'c': // GNU
  367. 			opt_c = true;
  368. 			break;
  369. 		case OPT_REFERENCE: // GNU & NetBSD
  370. 			ref_file = optarg;
  371. 			break;
  372. 		case 'R': // POSIX
  373. 			opt_R = true;
  374. 			break;
  375. 		case 'v': // GNU
  376. 			opt_v = true;
  377. 			break;
  378. 		case ':':
  379. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  380. 			usage();
  381. 			return 1;
  382. 		case '?': // GNU
  383. 			if(!got_long_opt) fprintf(stderr, "%s: error: Unrecognised option: '-%c'\n", argv0, optopt);
  384. 			usage();
  385. 			return 1;
  386. 		}
  387. 	}
  389. 	argc -= optind;
  390. 	argv += optind;
  392. 	if(ref_file != NULL)
  393. 	{
  394. 		if(argc < 1)
  395. 		{
  396. 			fprintf(stderr, "%s: error: Expected >=1 arguments, %d given\n", argv0, argc);
  397. 			usage();
  398. 			return 1;
  399. 		}
  401. 		struct stat ref_stat;
  402. 		if(stat(ref_file, &ref_stat) != 0)
  403. 		{
  404. 			fprintf(stderr,
  405. 			        "%s: error: Failed to get status from reference file '%s': %s\n",
  406. 			        argv0,
  407. 			        ref_file,
  408. 			        strerror(errno));
  409. 			return 1;
  410. 		}
  412. 		for(int i = 0; i < argc; i++)
  413. 		{
  414. 			int ret = copy_mode(AT_FDCWD, ref_stat.st_mode, argv[i], argv[i], opt_R);
  415. 			if(ret != 0) return ret;
  416. 		}
  418. 		return 0;
  419. 	}
  421. 	if(argc < 2)
  422. 	{
  423. 		fprintf(stderr, "%s: error: Expected >=2 arguments, %d given\n", argv0, argc);
  424. 		usage();
  425. 		return 1;
  426. 	}
  428. 	for(int i = 1; i < argc; i++)
  429. 	{
  430. 		int ret = do_fchmodat(AT_FDCWD, argv[0], argv[i], argv[i], opt_R);
  431. 		if(ret != 0) return ret;
  432. 	}
  434. 	return 0;
  435. }