logo

utils-std

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

chown.c (6986B)

    

  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 "../lib/fs.h"
  13. #include "../lib/user_group_parse.h"
  15. #include <assert.h>
  16. #include <dirent.h> // fdopendir, readdir, closedir
  17. #include <errno.h>
  18. #include <fcntl.h>  // AT_FDCWD, fchownat
  19. #include <limits.h> // PATH_MAX
  20. #include <stdbool.h>
  21. #include <stdio.h>    // fprintf
  22. #include <stdlib.h>   // abort, exit
  23. #include <string.h>   // strerror, strcmp
  24. #include <sys/stat.h> // fstatat, S_ISDIR
  25. #include <unistd.h>   // getopt
  26. #ifdef HAS_GETOPT_LONG
  27. #include <getopt.h>
  28. #endif
  30. const char *argv0 = NULL;
  32. static uid_t user = (uid_t)-1;
  33. static uid_t group = (uid_t)-1;
  35. static bool opt_v = false, opt_R = false;
  37. enum chown_follow_symlinks
  38. {
  39. 	CHOWN_FOLLOW_UNK_SYMLINKS,
  40. 	CHOWN_FOLLOW_ALL_SYMLINKS,
  41. 	CHOWN_FOLLOW_NO_SYMLINK,
  42. 	CHOWN_FOLLOW_ONE_SYMLINK,
  43. };
  45. static int
  46. do_fchownat(int fd, char *name, char *acc_path, enum chown_follow_symlinks follow_symlinks)
  47. {
  48. 	struct stat stats;
  49. 	int err = 0;
  51. 	int stat_opts = (follow_symlinks == CHOWN_FOLLOW_NO_SYMLINK) ? AT_SYMLINK_NOFOLLOW : 0;
  52. 	int chown_opts = (follow_symlinks == CHOWN_FOLLOW_NO_SYMLINK) ? AT_SYMLINK_NOFOLLOW : 0;
  54. 	assert(errno == 0);
  55. 	if(fstatat(fd, name, &stats, stat_opts) != 0)
  56. 	{
  57. 		fprintf(stderr, "%s: Failed getting status for '%s': %s\n", argv0, acc_path, strerror(errno));
  58. 		errno = 0;
  59. 		return 1;
  60. 	}
  62. 	bool change = false;
  63. 	if(user != (uid_t)-1 && stats.st_uid != user) change = true;
  64. 	if(group != (uid_t)-1 && stats.st_gid != group) change = true;
  66. 	if(change)
  67. 	{
  68. 		assert(errno == 0);
  69. 		if(fchownat(fd, name, user, group, chown_opts) != 0)
  70. 		{
  71. 			fprintf(stderr,
  72. 			        "%s: Failed setting ownership to '%d:%d' for '%s': %s\n",
  73. 			        argv0,
  74. 			        user,
  75. 			        group,
  76. 			        acc_path,
  77. 			        strerror(errno));
  78. 			errno = 0;
  79. 			return 1;
  80. 		}
  82. 		if(opt_v)
  83. 			printf("%s: Ownership changed from %d:%d to %d:%d for '%s'\n",
  84. 			       argv0,
  85. 			       stats.st_uid,
  86. 			       stats.st_gid,
  87. 			       user,
  88. 			       group,
  89. 			       acc_path);
  90. 	}
  91. 	else
  92. 	{
  93. 		if(opt_v)
  94. 			printf("%s: Ownership already set to %d:%d for '%s'\n",
  95. 			       argv0,
  96. 			       stats.st_uid,
  97. 			       stats.st_gid,
  98. 			       acc_path);
  99. 	}
  101. 	if(opt_R && S_ISDIR(stats.st_mode))
  102. 	{
  103. 		assert(errno == 0);
  104. 		int dir = openat(fd, name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  105. 		if(dir == -1)
  106. 		{
  107. 			fprintf(
  108. 			    stderr, "%s: Couldn't open '%s' as directory: %s\n", argv0, acc_path, strerror(errno));
  109. 			errno = 0;
  110. 			return 1;
  111. 		}
  113. 		assert(errno == 0);
  114. 		DIR *dirp = fdopendir(dir);
  115. 		if(dirp == NULL)
  116. 		{
  117. 			fprintf(stderr,
  118. 			        "%s: Couldn't get DIR entry for opened '%s': %s\n",
  119. 			        argv0,
  120. 			        acc_path,
  121. 			        strerror(errno));
  122. 			errno = 0;
  123. 			return 1;
  124. 		}
  126. 		while(true)
  127. 		{
  128. 			assert(errno == 0);
  129. 			struct dirent *dp = readdir(dirp);
  130. 			if(dp == NULL)
  131. 			{
  132. 				if(errno == 0) break;
  134. 				fprintf(
  135. 				    stderr, "%s: Failed reading directory '%s': %s\n", argv0, acc_path, strerror(errno));
  136. 				closedir(dirp); // FIXME: unhandled error
  137. 				errno = 0;
  138. 				return 1;
  139. 			}
  141. 			if(strcmp(dp->d_name, ".") == 0) continue;
  142. 			if(strcmp(dp->d_name, "..") == 0) continue;
  144. 			assert(errno == 0);
  145. 			char new_path[PATH_MAX] = "";
  146. 			if(snprintf(new_path, PATH_MAX, "%s/%s", acc_path, dp->d_name) < 0)
  147. 			{
  148. 				fprintf(stderr,
  149. 				        "%s: Couldn't concatenate '%s' into parent '%s', skipping to next entry: %s",
  150. 				        argv0,
  151. 				        name,
  152. 				        acc_path,
  153. 				        strerror(errno));
  154. 				err++;
  155. 				errno = 0;
  156. 				continue;
  157. 			}
  159. 			enum chown_follow_symlinks child_follow_symlinks =
  160. 			    (follow_symlinks == CHOWN_FOLLOW_ONE_SYMLINK) ? CHOWN_FOLLOW_NO_SYMLINK : follow_symlinks;
  162. 			// No depth counter for now, unlikely to be a problem as symlinks aren't followed
  163. 			int ret = do_fchownat(dir, dp->d_name, new_path, child_follow_symlinks);
  164. 			if(ret != 0) return ret;
  165. 		}
  167. 		// fdopendir allocates memory for DIR, needs closedir
  168. 		assert(errno == 0);
  169. 		if(closedir(dirp) != 0)
  170. 		{
  171. 			fprintf(stderr,
  172. 			        "%s: Deallocating directory entry for '%s' failed: %s\n",
  173. 			        argv0,
  174. 			        acc_path,
  175. 			        strerror(errno));
  176. 			errno = 0;
  177. 			return 1;
  178. 		}
  179. 	}
  181. 	return err;
  182. }
  184. static void
  185. usage(void)
  186. {
  187. 	if(strcmp(argv0, "chown") == 0)
  188. 		fprintf(stderr, "Usage: %s [-h | -R [-H|-L|-P]] owner[:group] file...\n", argv0);
  189. 	else if(strcmp(argv0, "chgrp") == 0)
  190. 		fprintf(stderr, "Usage: %s [-h | -R [-H|-L|-P]] group file...\n", argv0);
  191. 	else
  192. 	{
  193. 		fprintf(stderr, "%s: Unknown utility '%s' expected either chown or chgrp\n", argv0, argv0);
  194. 		exit(1);
  195. 	}
  196. }
  198. int
  199. main(int argc, char *argv[])
  200. {
  201. 	argv0 = static_basename(argv[0]);
  203. 	enum chown_follow_symlinks follow_symlinks = CHOWN_FOLLOW_UNK_SYMLINKS;
  205. 	int c = -1;
  206. #ifdef HAS_GETOPT_LONG
  207. 	// Strictly for GNUisms compatibility so no long-only options
  208. 	// clang-format off
  209. 	static struct option opts[] = {
  210. 		{"no-dereference", no_argument, 0, 'h'},
  211. 		{"recursive", no_argument, 0, 'R'},
  212. 		{"verbose", no_argument, 0, 'v'},
  213. 		{0, 0, 0, 0},
  214. 	};
  215. 	// clang-format on
  217. 	// Need + as first character to get POSIX-style option parsing
  218. 	while((c = getopt_long(argc, argv, "+:hRHLPv", opts, NULL)) != -1)
  219. #else
  220. 	while((c = getopt(argc, argv, ":hRHLPv")) != -1)
  221. #endif
  222. 	{
  223. 		switch(c)
  224. 		{
  225. 		case 'h':
  226. 			follow_symlinks = CHOWN_FOLLOW_NO_SYMLINK;
  227. 			break;
  228. 		case 'R':
  229. 			opt_R = true;
  230. 			break;
  231. 		case 'H':
  232. 			follow_symlinks = CHOWN_FOLLOW_ONE_SYMLINK;
  233. 			break;
  234. 		case 'L':
  235. 			follow_symlinks = CHOWN_FOLLOW_ALL_SYMLINKS;
  236. 			break;
  237. 		case 'P':
  238. 			follow_symlinks = CHOWN_FOLLOW_NO_SYMLINK;
  239. 			break;
  240. 		case 'v':
  241. 			opt_v = true;
  242. 			break;
  243. 		case ':':
  244. 			fprintf(stderr, "%s: Error: Missing operand for option: '-%c'\n", argv0, optopt);
  245. 			usage();
  246. 			return 1;
  247. 		case '?':
  248. 			fprintf(stderr, "%s: Error: Unrecognised option: '-%c'\n", argv0, optopt);
  249. 			usage();
  250. 			return 1;
  251. 		default:
  252. 			abort();
  253. 		}
  254. 	}
  256. 	argc -= optind;
  257. 	argv += optind;
  259. 	if(follow_symlinks == CHOWN_FOLLOW_UNK_SYMLINKS)
  260. 		follow_symlinks = opt_R ? CHOWN_FOLLOW_NO_SYMLINK : CHOWN_FOLLOW_ALL_SYMLINKS;
  262. 	if(argc < 2)
  263. 	{
  264. 		fprintf(stderr, "%s: Expects >=2 arguments, %d given\n", argv0, argc);
  265. 		usage();
  266. 		return 1;
  267. 	}
  269. 	if(strcmp(argv0, "chown") == 0)
  270. 	{
  271. 		char *gname = strchr(argv[0], ':');
  272. 		if(gname != NULL)
  273. 		{
  274. 			gname[0] = 0;
  275. 			gname++;
  277. 			if(parse_group(gname, &group) < 0) return 1;
  278. 		}
  279. 		if(parse_user(argv[0], &user) < 0) return 1;
  280. 	}
  281. 	else if(strcmp(argv0, "chgrp") == 0)
  282. 	{
  283. 		if(parse_group(argv[0], &group) < 0) return 1;
  284. 	}
  285. 	else
  286. 	{
  287. 		fprintf(stderr, "%s: Unknown utility '%s' expected either chown or chgrp\n", argv0, argv0);
  288. 		return 1;
  289. 	}
  291. 	for(int i = 1; i < argc; i++)
  292. 	{
  293. 		int ret = do_fchownat(AT_FDCWD, argv[i], argv[i], follow_symlinks);
  294. 		if(ret != 0) return ret;
  295. 	}
  297. 	return 0;
  298. }