logo

utils-std

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

chown.c (8351B)

    

  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 "../libutils/fs.h"
  14. #include "../libutils/getopt_nolong.h"
  15. #include "../libutils/user_group_parse.h"
  17. #include <dirent.h> // fdopendir, readdir, closedir
  18. #include <errno.h>
  19. #include <fcntl.h>  // AT_FDCWD, fchownat
  20. #include <limits.h> // PATH_MAX
  21. #include <stdbool.h>
  22. #include <stdio.h>    // fprintf
  23. #include <stdlib.h>   // abort, exit
  24. #include <string.h>   // strerror, strcmp
  25. #include <sys/stat.h> // fstatat, S_ISDIR
  26. #include <unistd.h>   // getopt
  27. #ifdef HAS_GETOPT_LONG
  28. #include <getopt.h>
  29. #endif
  31. #define DEPTH_MAX 100
  33. const char *argv0 = NULL;
  35. static uid_t user = (uid_t)-1;
  36. static uid_t group = (uid_t)-1;
  38. static bool opt_v = false, opt_R = false;
  40. enum chown_follow_symlinks
  41. {
  42. 	CHOWN_FOLLOW_UNK_SYMLINKS,
  43. 	CHOWN_FOLLOW_ALL_SYMLINKS,
  44. 	CHOWN_FOLLOW_NO_SYMLINK,
  45. 	CHOWN_FOLLOW_ONE_SYMLINK,
  46. };
  48. static int
  49. do_fchownat(
  50.     int fd, char *name, char *acc_path, enum chown_follow_symlinks follow_symlinks, unsigned depth)
  51. {
  52. 	struct stat stats;
  53. 	int err = 0;
  55. 	int stat_opts = (follow_symlinks == CHOWN_FOLLOW_NO_SYMLINK) ? AT_SYMLINK_NOFOLLOW : 0;
  56. 	int chown_opts = (follow_symlinks == CHOWN_FOLLOW_NO_SYMLINK) ? AT_SYMLINK_NOFOLLOW : 0;
  58. 	if(depth == DEPTH_MAX)
  59. 	{
  60. 		fprintf(stderr,
  61. 		        "%s: error: Maximum levels of recursion (%d) reached at file '%s'\n",
  62. 		        argv0,
  63. 		        depth,
  64. 		        acc_path);
  65. 		return 1;
  66. 	}
  68. 	if(fstatat(fd, name, &stats, stat_opts) != 0)
  69. 	{
  70. 		fprintf(stderr,
  71. 		        "%s: error: Failed getting status for '%s': %s\n",
  72. 		        argv0,
  73. 		        acc_path,
  74. 		        strerror(errno));
  75. 		errno = 0;
  76. 		return 1;
  77. 	}
  79. 	bool change = false;
  80. 	if(user != (uid_t)-1 && stats.st_uid != user) change = true;
  81. 	if(group != (uid_t)-1 && stats.st_gid != group) change = true;
  83. 	if(change)
  84. 	{
  85. 		if(fchownat(fd, name, user, group, chown_opts) != 0)
  86. 		{
  87. 			fprintf(stderr,
  88. 			        "%s: error: Failed setting ownership to '%d:%d' for '%s': %s\n",
  89. 			        argv0,
  90. 			        user,
  91. 			        group,
  92. 			        acc_path,
  93. 			        strerror(errno));
  94. 			errno = 0;
  95. 			return 1;
  96. 		}
  98. 		if(opt_v)
  99. 			printf("%s: Ownership changed from %d:%d to %d:%d for '%s'\n",
  100. 			       argv0,
  101. 			       stats.st_uid,
  102. 			       stats.st_gid,
  103. 			       user,
  104. 			       group,
  105. 			       acc_path);
  106. 	}
  107. 	else
  108. 	{
  109. 		if(opt_v)
  110. 			printf("%s: Ownership already set to %d:%d for '%s'\n",
  111. 			       argv0,
  112. 			       stats.st_uid,
  113. 			       stats.st_gid,
  114. 			       acc_path);
  115. 	}
  117. 	if(opt_R && S_ISDIR(stats.st_mode))
  118. 	{
  119. 		int dir = openat(fd, name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  120. 		if(dir == -1)
  121. 		{
  122. 			fprintf(stderr,
  123. 			        "%s: error: Couldn't open '%s' as directory: %s\n",
  124. 			        argv0,
  125. 			        acc_path,
  126. 			        strerror(errno));
  127. 			errno = 0;
  128. 			return 1;
  129. 		}
  131. 		DIR *dirp = fdopendir(dir);
  132. 		if(dirp == NULL)
  133. 		{
  134. 			fprintf(stderr,
  135. 			        "%s: error: Couldn't get DIR entry for opened '%s': %s\n",
  136. 			        argv0,
  137. 			        acc_path,
  138. 			        strerror(errno));
  139. 			errno = 0;
  140. 			return 1;
  141. 		}
  143. 		while(true)
  144. 		{
  145. 			struct dirent *dp = readdir(dirp);
  146. 			if(dp == NULL)
  147. 			{
  148. 				if(errno == 0) break;
  150. 				fprintf(stderr,
  151. 				        "%s: error: Failed reading directory '%s': %s\n",
  152. 				        argv0,
  153. 				        acc_path,
  154. 				        strerror(errno));
  155. 				closedir(dirp); // FIXME: unhandled error
  156. 				errno = 0;
  157. 				return 1;
  158. 			}
  160. 			if(strcmp(dp->d_name, ".") == 0) continue;
  161. 			if(strcmp(dp->d_name, "..") == 0) continue;
  163. 			char new_path[PATH_MAX] = "";
  164. 			if(snprintf(new_path, PATH_MAX, "%s/%s", acc_path, dp->d_name) < 0)
  165. 			{
  166. 				fprintf(stderr,
  167. 				        "%s: error: Couldn't concatenate '%s' into parent '%s', skipping to next entry: %s",
  168. 				        argv0,
  169. 				        name,
  170. 				        acc_path,
  171. 				        strerror(errno));
  172. 				err++;
  173. 				errno = 0;
  174. 				continue;
  175. 			}
  177. 			enum chown_follow_symlinks child_follow_symlinks =
  178. 			    (follow_symlinks == CHOWN_FOLLOW_ONE_SYMLINK) ? CHOWN_FOLLOW_NO_SYMLINK : follow_symlinks;
  180. 			// No depth counter for now, unlikely to be a problem as symlinks aren't followed
  181. 			int ret = do_fchownat(dir, dp->d_name, new_path, child_follow_symlinks, depth + 1);
  182. 			if(ret != 0) return ret;
  183. 		}
  185. 		// fdopendir allocates memory for DIR, needs closedir
  186. 		if(closedir(dirp) != 0)
  187. 		{
  188. 			fprintf(stderr,
  189. 			        "%s: error: Deallocating directory entry for '%s' failed: %s\n",
  190. 			        argv0,
  191. 			        acc_path,
  192. 			        strerror(errno));
  193. 			errno = 0;
  194. 			return 1;
  195. 		}
  196. 	}
  198. 	return err;
  199. }
  201. static void
  202. usage(void)
  203. {
  204. 	if(strcmp(argv0, "chown") == 0)
  205. 		fprintf(stderr, "Usage: %s [-h | -R [-H|-L|-P]] owner[:group] file...\n", argv0);
  206. 	else if(strcmp(argv0, "chgrp") == 0)
  207. 		fprintf(stderr, "Usage: %s [-h | -R [-H|-L|-P]] group file...\n", argv0);
  208. 	else
  209. 	{
  210. 		fprintf(
  211. 		    stderr, "%s: error: Unknown utility '%s' expected either chown or chgrp\n", argv0, argv0);
  212. 		exit(1);
  213. 	}
  214. }
  216. int
  217. main(int argc, char *argv[])
  218. {
  219. 	argv0 = static_basename(argv[0]);
  220. 	char *ref_file = NULL;
  222. 	enum chown_follow_symlinks follow_symlinks = CHOWN_FOLLOW_UNK_SYMLINKS;
  224. #ifdef HAS_GETOPT_LONG
  225. 	// clang-format off
  226. 	enum long_opt_vals {
  227. 		OPT_REFERENCE = 1,
  228. 	};
  229. 	static struct option opts[] = {
  230. 		{"no-dereference", no_argument, NULL, 'h'},
  231. 		{"recursive", no_argument, NULL, 'R'},
  232. 		{"reference", required_argument, NULL, OPT_REFERENCE},
  233. 		{"verbose", no_argument, NULL, 'v'},
  234. 		{0, 0, 0, 0},
  235. 	};
  236. 	// clang-format on
  238. 	// Need + as first character to get POSIX-style option parsing
  239. 	for(int c = -1; (c = getopt_long(argc, argv, "+:hRHLPv", opts, NULL)) != -1;)
  240. #else
  241. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":hRHLPv")) != -1;)
  242. #endif
  243. 	{
  244. 		switch(c)
  245. 		{
  246. 		case 'h':
  247. 			follow_symlinks = CHOWN_FOLLOW_NO_SYMLINK;
  248. 			break;
  249. 		case 'R':
  250. 			opt_R = true;
  251. 			break;
  252. 		case 'H':
  253. 			follow_symlinks = CHOWN_FOLLOW_ONE_SYMLINK;
  254. 			break;
  255. 		case 'L':
  256. 			follow_symlinks = CHOWN_FOLLOW_ALL_SYMLINKS;
  257. 			break;
  258. 		case 'P':
  259. 			follow_symlinks = CHOWN_FOLLOW_NO_SYMLINK;
  260. 			break;
  261. 		case 'v':
  262. 			opt_v = true;
  263. 			break;
  264. #ifdef HAS_GETOPT_LONG
  265. 		case OPT_REFERENCE: // GNU & NetBSD
  266. 			ref_file = optarg;
  267. 			break;
  268. #endif
  269. 		case ':':
  270. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  271. 			usage();
  272. 			return 1;
  273. 		case '?':
  274. 			GETOPT_UNKNOWN_OPT
  275. 			usage();
  276. 			return 1;
  277. 		default:
  278. 			abort();
  279. 		}
  280. 	}
  282. 	argc -= optind;
  283. 	argv += optind;
  285. 	if(follow_symlinks == CHOWN_FOLLOW_UNK_SYMLINKS)
  286. 		follow_symlinks = opt_R ? CHOWN_FOLLOW_NO_SYMLINK : CHOWN_FOLLOW_ALL_SYMLINKS;
  288. 	if(ref_file != NULL)
  289. 	{
  290. 		if(argc < 1)
  291. 		{
  292. 			fprintf(stderr, "%s: error: Expects >=1 arguments, %d given\n", argv0, argc);
  293. 			usage();
  294. 			return 1;
  295. 		}
  297. 		struct stat ref_stat;
  298. 		if(stat(ref_file, &ref_stat) != 0)
  299. 		{
  300. 			fprintf(stderr,
  301. 			        "%s: error: Failed to get status from reference file '%s': %s\n",
  302. 			        argv0,
  303. 			        ref_file,
  304. 			        strerror(errno));
  305. 			return 1;
  306. 		}
  308. 		if(strcmp(argv0, "chown") == 0)
  309. 		{
  310. 			user = ref_stat.st_uid;
  311. 			group = ref_stat.st_gid;
  312. 		}
  313. 		else if(strcmp(argv0, "chgrp") == 0)
  314. 		{
  315. 			group = ref_stat.st_gid;
  316. 		}
  317. 		else
  318. 		{
  319. 			fprintf(
  320. 			    stderr, "%s: error: Unknown utility '%s' expected either chown or chgrp\n", argv0, argv0);
  321. 			return 1;
  322. 		}
  324. 		for(int i = 0; i < argc; i++)
  325. 		{
  326. 			int ret = do_fchownat(AT_FDCWD, argv[i], argv[i], follow_symlinks, 0);
  327. 			if(ret != 0) return ret;
  328. 		}
  330. 		return 0;
  331. 	}
  333. 	if(argc < 2)
  334. 	{
  335. 		fprintf(stderr, "%s: error: Expects >=2 arguments, %d given\n", argv0, argc);
  336. 		usage();
  337. 		return 1;
  338. 	}
  340. 	if(strcmp(argv0, "chown") == 0)
  341. 	{
  342. 		char *gname = strchr(argv[0], ':');
  343. 		if(gname != NULL)
  344. 		{
  345. 			gname[0] = 0;
  346. 			gname++;
  348. 			if(parse_group(gname, &group) < 0) return 1;
  349. 		}
  350. 		if(parse_user(argv[0], &user) < 0) return 1;
  351. 	}
  352. 	else if(strcmp(argv0, "chgrp") == 0)
  353. 	{
  354. 		if(parse_group(argv[0], &group) < 0) return 1;
  355. 	}
  356. 	else
  357. 	{
  358. 		fprintf(
  359. 		    stderr, "%s: error: Unknown utility '%s' expected either chown or chgrp\n", argv0, argv0);
  360. 		return 1;
  361. 	}
  363. 	for(int i = 1; i < argc; i++)
  364. 	{
  365. 		int ret = do_fchownat(AT_FDCWD, argv[i], argv[i], follow_symlinks, 0);
  366. 		if(ret != 0) return ret;
  367. 	}
  369. 	return 0;
  370. }