logo

utils-std

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

mv.c (10832B)

    

  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
  6. #define _GNU_SOURCE // copy_file_range
  7. #define _FILE_OFFSET_BITS 64
  9. // NetBSD <10 hides fdopendir behind _NETBSD_SOURCE
  10. #if __NetBSD_Version__ < 1000000000
  11. #define _NETBSD_SOURCE
  12. #endif
  14. #include "../lib/consent.h"
  15. #include "../lib/fs.h"
  17. #include <assert.h>
  18. #include <dirent.h> // fdopendir
  19. #include <errno.h>
  20. #include <fcntl.h>  // open
  21. #include <libgen.h> // basename
  22. #include <limits.h> // PATH_MAX
  23. #include <locale.h> // setlocale
  24. #include <stdbool.h>
  25. #include <stdint.h>   // SIZE_MAX
  26. #include <stdio.h>    // fprintf, rename
  27. #include <string.h>   // strcmp
  28. #include <sys/stat.h> // stat, S_ISDIR
  29. #include <unistd.h>   // getopt
  31. // Workaround against GNU glibc
  32. // https://sourceware.org/bugzilla/show_bug.cgi?id=18228
  33. #if defined(__linux__) && !defined(O_SEARCH)
  34. // As defined in musl
  35. #define O_SEARCH O_PATH
  36. #endif
  38. const char *argv0 = "mv";
  40. bool no_clob = false, force = false, interact = false, verbose = false;
  42. static int stdin_tty = 0;
  44. struct named_fd
  45. {
  46. 	int fd;
  47. 	const char *name;
  48. };
  50. static int do_renameat(struct named_fd srcdir,
  51.                        const char *restrict src,
  52.                        struct named_fd destdir,
  53.                        const char *restrict dest);
  55. static int
  56. copy_file_unlink(struct named_fd srcdir,
  57.                  const char *restrict src,
  58.                  struct stat src_status,
  59.                  struct named_fd destdir,
  60.                  const char *restrict dest)
  61. {
  62. 	int in = openat(srcdir.fd, src, O_RDONLY | O_NOCTTY);
  63. 	if(in < 0)
  64. 	{
  65. 		fprintf(stderr, "mv: Failed opening source '%s/%s': %s\n", srcdir.name, src, strerror(errno));
  66. 		errno = 0;
  67. 		return -1;
  68. 	}
  70. 	int out = openat(destdir.fd, dest, O_WRONLY | O_CREAT | O_NOCTTY, src_status.st_mode);
  71. 	if(out < 0)
  72. 	{
  73. 		fprintf(stderr,
  74. 		        "mv: Failed opening destination '%s/%s': %s\n",
  75. 		        destdir.name,
  76. 		        dest,
  77. 		        strerror(errno));
  78. 		errno = 0;
  79. 		return -1;
  80. 	}
  82. 	const struct timespec times[2] = {src_status.st_atim, src_status.st_mtim};
  83. 	if(futimens(out, times) != 0)
  84. 	{
  85. 		fprintf(stderr,
  86. 		        "mv: Warning: Failed copying access & modification times to '%s/%s': %s\n",
  87. 		        destdir.name,
  88. 		        dest,
  89. 		        strerror(errno));
  90. 		errno = 0;
  91. 	}
  93. 	if(fchown(out, src_status.st_uid, src_status.st_gid) != 0)
  94. 	{
  95. 		fprintf(stderr,
  96. 		        "mv: Warning: Failed copying owner & group to '%s/%s': %s\n",
  97. 		        destdir.name,
  98. 		        dest,
  99. 		        strerror(errno));
  100. 		errno = 0;
  101. 	}
  103. 	if(auto_file_copy(in, out, src_status.st_size, 0) < 0) return -1;
  105. 	return unlinkat(srcdir.fd, src, 0);
  106. }
  108. static int
  109. rename_dir_entries(struct named_fd srcdir, struct named_fd destdir)
  110. {
  111. 	DIR *dirsrc = fdopendir(srcdir.fd);
  112. 	if(dirsrc == NULL)
  113. 	{
  114. 		fprintf(
  115. 		    stderr, "mv: Failed fd-opening source directory '%s': %s\n", srcdir.name, strerror(errno));
  116. 		return -1;
  117. 	}
  119. 	while(true)
  120. 	{
  121. 		assert(errno == 0);
  122. 		errno = 0;
  123. 		struct dirent *dirsrc_ent = readdir(dirsrc);
  124. 		if(dirsrc_ent == NULL)
  125. 		{
  126. 			if(errno == 0) break;
  128. 			fprintf(
  129. 			    stderr, "mv: Failed reading source directory '%s': %s\n", srcdir.name, strerror(errno));
  130. 			closedir(dirsrc);
  131. 			errno = 0;
  132. 			return -1;
  133. 		}
  135. 		if(strcmp(dirsrc_ent->d_name, ".") == 0) continue;
  136. 		if(strcmp(dirsrc_ent->d_name, "..") == 0) continue;
  138. 		if(do_renameat(srcdir, dirsrc_ent->d_name, destdir, dirsrc_ent->d_name) < 0)
  139. 		{
  140. 			closedir(dirsrc);
  141. 			return -1;
  142. 		}
  143. 	}
  145. 	return 0;
  146. }
  148. static int
  149. do_renameat(struct named_fd srcdir,
  150.             const char *restrict src,
  151.             struct named_fd destdir,
  152.             const char *restrict dest)
  153. {
  154. 	if(destdir.fd == srcdir.fd && strcmp(src, dest) == 0)
  155. 	{
  156. 		fprintf(stderr, "mv: Error, passed to both source and destination: '%s'\n", src);
  157. 		return -1;
  158. 	}
  160. 	struct stat src_status;
  161. 	if(fstatat(srcdir.fd, src, &src_status, AT_SYMLINK_NOFOLLOW) < 0)
  162. 	{
  163. 		fprintf(stderr,
  164. 		        "mv: Failed getting status for source file '%s/%s': %s\n",
  165. 		        srcdir.name,
  166. 		        src,
  167. 		        strerror(errno));
  168. 		return -1;
  169. 	}
  170. 	if(S_ISLNK(src_status.st_mode))
  171. 	{
  172. 		struct stat src_link_status;
  173. 		if(fstatat(srcdir.fd, src, &src_link_status, 0) == 0)
  174. 		{
  175. 			src_status = src_link_status;
  176. 		}
  177. 	}
  179. 	errno = 0;
  181. 	struct stat dest_status;
  182. 	int ret = fstatat(destdir.fd, dest, &dest_status, 0);
  183. 	if(ret < 0 && errno != ENOENT)
  184. 	{
  185. 		fprintf(stderr,
  186. 		        "mv: Failed getting status for destination file '%s/%s': %s\n",
  187. 		        destdir.name,
  188. 		        dest,
  189. 		        strerror(errno));
  190. 		return -1;
  191. 	}
  193. 	errno = 0;
  195. 	if(ret == 0)
  196. 	{
  197. 		if(dest_status.st_ino == src_status.st_ino && dest_status.st_dev == src_status.st_dev) return 0;
  199. 		if(no_clob)
  200. 		{
  201. 			fprintf(stderr, "mv: Destination file '%s/%s' already exists\n", destdir.name, dest);
  202. 			return -1;
  203. 		}
  205. 		if(!force)
  206. 		{
  207. 			if(interact)
  208. 			{
  209. 				if(!consentf(
  210. 				       "mv: Destination file '%s/%s' already exists, overwrite? [yN] ", destdir.name, dest))
  211. 					return 0;
  212. 			}
  213. 			else if(stdin_tty)
  214. 			{
  215. 				if(faccessat(destdir.fd, dest, W_OK, 0) == 0)
  216. 				{
  217. 					if(!consentf("mv: No write permissions for destination file '%s/%s', overwrite? [yN] ",
  218. 					             destdir.name,
  219. 					             dest))
  220. 						return 0;
  221. 				}
  222. 				else
  223. 				{
  224. 					errno = 0;
  225. 				}
  226. 			}
  227. 		}
  228. 	}
  230. 	assert(errno == 0);
  231. 	if(renameat(srcdir.fd, src, destdir.fd, dest) < 0)
  232. 	{
  233. 		switch(errno)
  234. 		{
  235. 		case EXDEV:
  236. 			errno = 0;
  238. 			if(S_ISDIR(src_status.st_mode))
  239. 			{
  240. 				char child_srcdir_name[PATH_MAX] = "";
  241. 				snprintf(child_srcdir_name, PATH_MAX, "%s/%s", srcdir.name, src);
  243. 				struct named_fd child_srcdir = {
  244. 				    .fd = openat(srcdir.fd, src, O_RDONLY | O_DIRECTORY | O_CLOEXEC),
  245. 				    .name = child_srcdir_name,
  246. 				};
  248. 				if(child_srcdir.fd < 0)
  249. 				{
  250. 					fprintf(stderr,
  251. 					        "mv: Failed opening source directory '%s/%s': %s\n",
  252. 					        srcdir.name,
  253. 					        src,
  254. 					        strerror(errno));
  255. 					return -1;
  256. 				}
  258. 				if(mkdirat(destdir.fd, dest, src_status.st_mode) < 0)
  259. 				{
  260. 					fprintf(stderr,
  261. 					        "mv: Failed creating destination directory '%s/%s': %s\n",
  262. 					        destdir.name,
  263. 					        dest,
  264. 					        strerror(errno));
  265. 					return -1;
  266. 				}
  268. 				char child_destdir_name[PATH_MAX] = "";
  269. 				snprintf(child_destdir_name, PATH_MAX, "%s/%s", destdir.name, dest);
  270. 				struct named_fd child_destdir = {
  271. 				    .fd = openat(destdir.fd, dest, O_RDONLY | O_DIRECTORY | O_CLOEXEC),
  272. 				    .name = child_destdir_name,
  273. 				};
  275. 				if(rename_dir_entries(child_srcdir, child_destdir) < 0) return -1;
  277. 				close(child_srcdir.fd);
  278. 				close(child_destdir.fd);
  280. 				if(unlinkat(srcdir.fd, src, AT_REMOVEDIR) < 0)
  281. 				{
  282. 					fprintf(stderr,
  283. 					        "mv: Failed removing source directory '%s/%s': %s\n",
  284. 					        srcdir.name,
  285. 					        src,
  286. 					        strerror(errno));
  287. 					return -1;
  288. 				}
  289. 			}
  290. 			else
  291. 			{
  292. 				if(copy_file_unlink(srcdir, src, src_status, destdir, dest) < 0) return -1;
  293. 			}
  294. 			break;
  295. 		case EISDIR:
  296. 		case ENOTDIR:
  297. 			if(destdir.fd != AT_FDCWD)
  298. 			{
  299. 				fprintf(stderr, "mv: Failed moving '%s' into '%s': %s\n", src, dest, strerror(errno));
  300. 				return -1;
  301. 			}
  303. 			int tmp_destdir = openat(destdir.fd, dest, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  304. 			if(tmp_destdir < 0)
  305. 			{
  306. 				fprintf(
  307. 				    stderr, "mv: Failed opening destination directory '%s': %s\n", dest, strerror(errno));
  308. 				return -1;
  309. 			}
  311. 			if(renameat(srcdir.fd, src, tmp_destdir, src) < 0)
  312. 			{
  313. 				fprintf(
  314. 				    stderr, "mv: Failed moving '%s' into directory '%s': %s\n", src, dest, strerror(errno));
  315. 				return -1;
  316. 			}
  318. 			if(close(tmp_destdir) < 0)
  319. 			{
  320. 				fprintf(stderr, "mv: Failed closing directory '%s': %s\n", dest, strerror(errno));
  321. 				return -1;
  322. 			}
  323. 			break;
  324. 		default:
  325. 			fprintf(stderr,
  326. 			        "mv: Failed moving '%s' to '%s/%s': %s\n",
  327. 			        src,
  328. 			        destdir.name,
  329. 			        dest,
  330. 			        strerror(errno));
  331. 			return -1;
  332. 		}
  333. 	}
  335. 	if(verbose) fprintf(stderr, "mv: renamed '%s' -> '%s/%s'\n", src, destdir.name, dest);
  337. 	return 0;
  338. }
  340. static void
  341. usage(void)
  342. {
  343. 	fprintf(stderr, "Usage: mv [-f|-i|-n] [-v] source dest\n");
  344. 	fprintf(stderr, "       mv [-f|-i|-n] [-v] source... destdir\n");
  345. 	fprintf(stderr, "       mv [-f|-i|-n] [-v] -t destdir source...\n");
  346. }
  348. int
  349. main(int argc, char *argv[])
  350. {
  351. 	struct named_fd destdir = {
  352. 	    .fd = AT_FDCWD,
  353. 	    .name = ".",
  354. 	};
  355. 	struct named_fd srcdir = {
  356. 	    .fd = AT_FDCWD,
  357. 	    .name = ".",
  358. 	};
  360. 	int c = -1;
  361. 	while((c = getopt(argc, argv, ":fint:v")) != -1)
  362. 	{
  363. 		switch(c)
  364. 		{
  365. 		case 'f':
  366. 			force = true;
  367. 			interact = false;
  368. 			no_clob = false;
  369. 			break;
  370. 		case 'i':
  371. 			force = false;
  372. 			interact = true;
  373. 			no_clob = false;
  374. 			break;
  375. 		case 'n':
  376. 			force = false;
  377. 			interact = false;
  378. 			no_clob = true;
  379. 			break;
  380. 		case 't':
  381. 			destdir.name = optarg;
  382. 			destdir.fd = open(optarg, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  384. 			if(destdir.fd < 0)
  385. 			{
  386. 				fprintf(
  387. 				    stderr, "mv: Failed opening destination directory '%s': %s\n", optarg, strerror(errno));
  388. 				return 1;
  389. 			}
  390. 			break;
  391. 		case 'v':
  392. 			verbose = true;
  393. 			break;
  394. 		case ':':
  395. 			fprintf(stderr, "mv: Error: Missing operand for option: '-%c'\n", optopt);
  396. 			usage();
  397. 			return 1;
  398. 		case '?':
  399. 			fprintf(stderr, "mv: Error: Unrecognised option: '-%c'\n", optopt);
  400. 			usage();
  401. 			return 1;
  402. 		}
  403. 	}
  405. 	argc -= optind;
  406. 	argv += optind;
  408. 	errno = 0;
  409. 	setlocale(LC_ALL, "");
  410. 	if(errno != 0)
  411. 	{
  412. 		fprintf(stderr, "%s: Warning: Failed to initialize locales: %s\n", argv0, strerror(errno));
  413. 		errno = 0;
  414. 	}
  416. 	consent_init();
  418. 	stdin_tty = isatty(STDIN_FILENO);
  419. 	if(!stdin_tty) errno = 0;
  421. 	if(destdir.fd == AT_FDCWD)
  422. 	{
  423. 		if(argc <= 1)
  424. 		{
  425. 			fprintf(stderr, "mv: Not enough operands, %d given, expect >= 2\n", argc);
  426. 			return 1;
  427. 		}
  429. 		struct stat dest_status;
  430. 		int ret_stat = fstatat(destdir.fd, argv[1], &dest_status, 0);
  431. 		if(argc == 2 && (errno == ENOENT || (ret_stat == 0 && !S_ISDIR(dest_status.st_mode))))
  432. 		{
  433. 			int ret = do_renameat(srcdir, argv[0], destdir, argv[1]);
  435. 			consent_finish();
  436. 			return ret < 0 ? 1 : 0;
  437. 		}
  438. 		errno = 0;
  440. 		argc--;
  441. 		destdir.name = argv[argc];
  442. 		destdir.fd = open(destdir.name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  443. 		if(destdir.fd < 0)
  444. 		{
  445. 			fprintf(stderr,
  446. 			        "mv: Failed opening destination directory '%s': %s\n",
  447. 			        destdir.name,
  448. 			        strerror(errno));
  450. 			consent_finish();
  451. 			return 1;
  452. 		}
  453. 	}
  455. 	for(int i = 0; i < argc; i++)
  456. 	{
  457. 		char arg[PATH_MAX] = "";
  458. 		strcpy(arg, argv[i]);
  460. 		char *filename = basename(arg);
  462. 		if(do_renameat(srcdir, argv[i], destdir, filename) < 0)
  463. 		{
  464. 			consent_finish();
  465. 			return 1;
  466. 		}
  467. 	}
  469. 	consent_finish();
  471. 	if(close(destdir.fd) < 0)
  472. 	{
  473. 		fprintf(stderr, "mv: Failed closing directory '%s': %s\n", destdir.name, strerror(errno));
  474. 		return 1;
  475. 	}
  477. 	return 0;
  478. }