logo

utils-std

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

mv.c (14100B)

    

  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 "../config.h"
  15. #include "../libutils/consent.h"
  16. #include "../libutils/fs.h"
  17. #include "../libutils/getopt_nolong.h"
  18. #include "../libutils/lib_string.h"
  20. #include <dirent.h> // fdopendir
  21. #include <errno.h>
  22. #include <fcntl.h>  // open
  23. #include <libgen.h> // basename
  24. #include <limits.h> // PATH_MAX
  25. #include <locale.h> // setlocale
  26. #include <stdbool.h>
  27. #include <stdint.h>   // SIZE_MAX
  28. #include <stdio.h>    // fprintf, rename
  29. #include <string.h>   // strcmp
  30. #include <sys/stat.h> // stat, S_ISDIR
  31. #include <unistd.h>   // getopt
  32. #ifdef HAS_GETOPT_LONG
  33. #include <getopt.h>
  34. #endif
  36. // Workaround against GNU glibc
  37. // https://sourceware.org/bugzilla/show_bug.cgi?id=18228
  38. #if defined(__linux__) && !defined(O_SEARCH)
  39. // As defined in musl
  40. #define O_SEARCH O_PATH
  41. #endif
  43. const char *argv0 = "mv";
  45. bool no_clob = false, force = false, interact = false, verbose = false;
  46. bool always_interact = false;
  47. bool opt_T = false;
  49. static int stdin_tty = 0;
  51. struct named_fd
  52. {
  53. 	int fd;
  54. 	const char *name;
  55. 	const char *sep;
  56. };
  58. static int do_renameat(struct named_fd srcdir,
  59.                        const char *restrict src,
  60.                        struct named_fd destdir,
  61.                        const char *restrict dest);
  63. static int
  64. copy_file_unlink(struct named_fd srcdir,
  65.                  const char *restrict src,
  66.                  struct stat src_status,
  67.                  struct named_fd destdir,
  68.                  const char *restrict dest)
  69. {
  70. 	int in = openat(srcdir.fd, src, O_RDONLY | O_NOCTTY);
  71. 	if(in < 0)
  72. 	{
  73. 		fprintf(stderr,
  74. 		        "mv: error: Failed opening source '%s%s%s': %s\n",
  75. 		        srcdir.name,
  76. 		        srcdir.sep,
  77. 		        src,
  78. 		        strerror(errno));
  79. 		errno = 0;
  80. 		return -1;
  81. 	}
  83. 	int out = openat(destdir.fd, dest, O_WRONLY | O_CREAT | O_NOCTTY, src_status.st_mode);
  84. 	if(out < 0)
  85. 	{
  86. 		fprintf(stderr,
  87. 		        "mv: error: Failed opening destination '%s%s%s': %s\n",
  88. 		        destdir.name,
  89. 		        destdir.sep,
  90. 		        dest,
  91. 		        strerror(errno));
  92. 		errno = 0;
  93. 		return -1;
  94. 	}
  96. 	const struct timespec times[2] = {src_status.st_atim, src_status.st_mtim};
  97. 	if(futimens(out, times) != 0)
  98. 	{
  99. 		fprintf(stderr,
  100. 		        "mv: warning: Failed copying access & modification times to '%s%s%s': %s\n",
  101. 		        destdir.name,
  102. 		        destdir.sep,
  103. 		        dest,
  104. 		        strerror(errno));
  105. 		errno = 0;
  106. 	}
  108. 	if(fchown(out, src_status.st_uid, src_status.st_gid) != 0)
  109. 	{
  110. 		fprintf(stderr,
  111. 		        "mv: warning: Failed copying owner & group to '%s%s%s': %s\n",
  112. 		        destdir.name,
  113. 		        destdir.sep,
  114. 		        dest,
  115. 		        strerror(errno));
  116. 		errno = 0;
  117. 	}
  119. 	posix_fadvise(in, 0, 0, POSIX_FADV_SEQUENTIAL);
  120. 	posix_fadvise(out, 0, 0, POSIX_FADV_SEQUENTIAL);
  121. 	errno = 0;
  123. 	if(auto_file_copy(in, out, src_status.st_size, 0) < 0) return -1;
  125. 	int err = 0;
  126. 	err += close(in);
  127. 	err += close(out);
  128. 	err += unlinkat(srcdir.fd, src, 0);
  130. 	return err;
  131. }
  133. static int
  134. rename_dir_entries(struct named_fd srcdir, struct named_fd destdir)
  135. {
  136. 	DIR *dirsrc = fdopendir(srcdir.fd);
  137. 	if(dirsrc == NULL)
  138. 	{
  139. 		fprintf(stderr,
  140. 		        "mv: error: Failed fd-opening source directory '%s': %s\n",
  141. 		        srcdir.name ? srcdir.name : ".",
  142. 		        strerror(errno));
  143. 		return -1;
  144. 	}
  146. 	while(true)
  147. 	{
  148. 		errno = 0;
  149. 		struct dirent *dirsrc_ent = readdir(dirsrc);
  150. 		if(dirsrc_ent == NULL)
  151. 		{
  152. 			if(errno == 0) break;
  154. 			fprintf(stderr,
  155. 			        "mv: error: Failed reading source directory '%s': %s\n",
  156. 			        srcdir.name ? srcdir.name : ".",
  157. 			        strerror(errno));
  158. 			closedir(dirsrc);
  159. 			errno = 0;
  160. 			return -1;
  161. 		}
  163. 		if(strcmp(dirsrc_ent->d_name, ".") == 0) continue;
  164. 		if(strcmp(dirsrc_ent->d_name, "..") == 0) continue;
  166. 		if(do_renameat(srcdir, dirsrc_ent->d_name, destdir, dirsrc_ent->d_name) < 0)
  167. 		{
  168. 			closedir(dirsrc);
  169. 			return -1;
  170. 		}
  171. 	}
  173. 	closedir(dirsrc);
  175. 	return 0;
  176. }
  178. static int
  179. do_renameat(struct named_fd srcdir,
  180.             const char *restrict src,
  181.             struct named_fd destdir,
  182.             const char *restrict dest)
  183. {
  184. 	if(destdir.fd == srcdir.fd && strcmp(src, dest) == 0)
  185. 	{
  186. 		fprintf(stderr, "mv: error: Passed to both source and destination: '%s'\n", src);
  187. 		return -1;
  188. 	}
  190. 	struct stat src_status;
  191. 	if(fstatat(srcdir.fd, src, &src_status, AT_SYMLINK_NOFOLLOW) < 0)
  192. 	{
  193. 		fprintf(stderr,
  194. 		        "mv: error: Failed getting status for source file '%s%s%s': %s\n",
  195. 		        srcdir.name,
  196. 		        srcdir.sep,
  197. 		        src,
  198. 		        strerror(errno));
  199. 		return -1;
  200. 	}
  201. 	if(S_ISLNK(src_status.st_mode))
  202. 	{
  203. 		struct stat src_link_status;
  204. 		if(fstatat(srcdir.fd, src, &src_link_status, 0) == 0)
  205. 		{
  206. 			src_status = src_link_status;
  207. 		}
  208. 	}
  210. 	errno = 0;
  212. 	struct stat dest_status;
  213. 	int ret = fstatat(destdir.fd, dest, &dest_status, 0);
  214. 	if(ret < 0 && errno != ENOENT)
  215. 	{
  216. 		fprintf(stderr,
  217. 		        "mv: error: Failed getting status for destination file '%s%s%s': %s\n",
  218. 		        destdir.name,
  219. 		        destdir.sep,
  220. 		        dest,
  221. 		        strerror(errno));
  222. 		return -1;
  223. 	}
  225. 	errno = 0;
  227. 	if(ret == 0)
  228. 	{
  229. 		if(dest_status.st_ino == src_status.st_ino && dest_status.st_dev == src_status.st_dev) return 0;
  231. 		if(no_clob)
  232. 		{
  233. 			fprintf(stderr,
  234. 			        "mv: error: Destination file '%s%s%s' already exists\n",
  235. 			        destdir.name,
  236. 			        destdir.sep,
  237. 			        dest);
  238. 			return -1;
  239. 		}
  241. 		if(!force)
  242. 		{
  243. 			if(interact)
  244. 			{
  245. 				if(!consentf("mv: Destination file '%s%s%s' already exists, overwrite? [yN] ",
  246. 				             destdir.name,
  247. 				             destdir.sep,
  248. 				             dest))
  249. 					return 0;
  250. 			}
  251. 			else if(stdin_tty)
  252. 			{
  253. 				if(faccessat(destdir.fd, dest, W_OK, 0) != 0)
  254. 				{
  255. 					if(!consentf(
  256. 					       "mv: error: No write permissions for destination file '%s%s%s', overwrite? [yN] ",
  257. 					       destdir.name,
  258. 					       destdir.sep,
  259. 					       dest))
  260. 						return 0;
  261. 				}
  262. 				else
  263. 				{
  264. 					errno = 0;
  265. 				}
  266. 			}
  267. 		}
  268. 	}
  269. 	else if(interact && always_interact)
  270. 	{
  271. 		if(!consentf("mv: Move file '%s%s%s' to '%s%s%s'? [yN] ",
  272. 		             srcdir.name,
  273. 		             srcdir.sep,
  274. 		             src,
  275. 		             destdir.name,
  276. 		             destdir.sep,
  277. 		             dest))
  278. 			return 0;
  279. 	}
  281. 	if(renameat(srcdir.fd, src, destdir.fd, dest) < 0)
  282. 	{
  283. 		switch(errno)
  284. 		{
  285. 		case EXDEV:
  286. 			errno = 0;
  288. 			if(S_ISDIR(src_status.st_mode))
  289. 			{
  290. 				char child_srcdir_name[PATH_MAX] = "";
  291. 				snprintf(child_srcdir_name, PATH_MAX, "%s%s%s", srcdir.name, srcdir.sep, src);
  293. 				struct named_fd child_srcdir = {
  294. 				    .fd = openat(srcdir.fd, src, O_RDONLY | O_DIRECTORY | O_CLOEXEC),
  295. 				    .name = child_srcdir_name,
  296. 				    .sep = "/",
  297. 				};
  299. 				if(child_srcdir.fd < 0)
  300. 				{
  301. 					fprintf(stderr,
  302. 					        "mv: error: Failed opening source directory '%s%s%s': %s\n",
  303. 					        srcdir.name,
  304. 					        srcdir.sep,
  305. 					        src,
  306. 					        strerror(errno));
  307. 					return -1;
  308. 				}
  310. 				if(mkdirat(destdir.fd, dest, src_status.st_mode) < 0)
  311. 				{
  312. 					fprintf(stderr,
  313. 					        "mv: error: Failed creating destination directory '%s%s%s': %s\n",
  314. 					        destdir.name,
  315. 					        destdir.sep,
  316. 					        dest,
  317. 					        strerror(errno));
  318. 					return -1;
  319. 				}
  321. 				char child_destdir_name[PATH_MAX] = "";
  322. 				snprintf(child_destdir_name, PATH_MAX, "%s%s%s", destdir.name, destdir.sep, dest);
  323. 				struct named_fd child_destdir = {
  324. 				    .fd = openat(destdir.fd, dest, O_RDONLY | O_DIRECTORY | O_CLOEXEC),
  325. 				    .name = child_destdir_name,
  326. 				    .sep = "/",
  327. 				};
  329. 				if(child_destdir.fd < 0)
  330. 				{
  331. 					fprintf(stderr,
  332. 					        "mv: error: Failed opening destination directory '%s%s%s': %s\n",
  333. 					        destdir.name,
  334. 					        destdir.sep,
  335. 					        dest,
  336. 					        strerror(errno));
  337. 					return -1;
  338. 				}
  340. 				if(rename_dir_entries(child_srcdir, child_destdir) < 0) return -1;
  342. 				close(child_srcdir.fd);
  343. 				close(child_destdir.fd);
  345. 				if(unlinkat(srcdir.fd, src, AT_REMOVEDIR) < 0)
  346. 				{
  347. 					fprintf(stderr,
  348. 					        "mv: error: Failed removing source directory '%s%s%s': %s\n",
  349. 					        srcdir.name,
  350. 					        srcdir.sep,
  351. 					        src,
  352. 					        strerror(errno));
  353. 					return -1;
  354. 				}
  355. 			}
  356. 			else
  357. 			{
  358. 				if(copy_file_unlink(srcdir, src, src_status, destdir, dest) < 0) return -1;
  359. 			}
  360. 			break;
  361. 		case EISDIR:
  362. 		case ENOTDIR:
  363. 			if(opt_T)
  364. 			{
  365. 				fprintf(stderr, "mv: error: Failed moving '%s' to '%s': %s\n", src, dest, strerror(errno));
  366. 				return -1;
  367. 			}
  369. 			if(destdir.fd != AT_FDCWD)
  370. 			{
  371. 				fprintf(
  372. 				    stderr, "mv: error: Failed moving '%s' into '%s': %s\n", src, dest, strerror(errno));
  373. 				return -1;
  374. 			}
  376. 			int tmp_destdir = openat(destdir.fd, dest, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  377. 			if(tmp_destdir < 0)
  378. 			{
  379. 				fprintf(stderr,
  380. 				        "mv: error: Failed opening destination directory '%s': %s\n",
  381. 				        dest,
  382. 				        strerror(errno));
  383. 				return -1;
  384. 			}
  386. 			if(renameat(srcdir.fd, src, tmp_destdir, src) < 0)
  387. 			{
  388. 				fprintf(stderr,
  389. 				        "mv: error: Failed moving '%s' into directory '%s': %s\n",
  390. 				        src,
  391. 				        dest,
  392. 				        strerror(errno));
  393. 				return -1;
  394. 			}
  396. 			if(close(tmp_destdir) < 0)
  397. 			{
  398. 				fprintf(stderr, "mv: error: Failed closing directory '%s': %s\n", dest, strerror(errno));
  399. 				return -1;
  400. 			}
  401. 			break;
  402. 		default:
  403. 			fprintf(stderr,
  404. 			        "mv: error: Failed moving '%s' to '%s%s%s': %s\n",
  405. 			        src,
  406. 			        destdir.name,
  407. 			        destdir.sep,
  408. 			        dest,
  409. 			        strerror(errno));
  410. 			return -1;
  411. 		}
  412. 	}
  414. 	if(verbose)
  415. 		fprintf(stderr, "mv: renamed '%s' -> '%s%s%s'\n", src, destdir.name, destdir.sep, dest);
  417. 	return 0;
  418. }
  420. static void
  421. usage(void)
  422. {
  423. 	fprintf(stderr, "Usage: mv [-f|-Ii|-n] [-Tv] source dest\n");
  424. 	fprintf(stderr, "       mv [-f|-Ii|-n] [-v] source... destdir\n");
  425. 	fprintf(stderr, "       mv [-f|-Ii|-n] [-v] -t destdir source...\n");
  426. }
  428. int
  429. main(int argc, char *argv[])
  430. {
  431. 	struct named_fd destdir = {
  432. 	    .fd = AT_FDCWD,
  433. 	    .name = "",
  434. 	    .sep = "",
  435. 	};
  436. 	struct named_fd srcdir = {
  437. 	    .fd = AT_FDCWD,
  438. 	    .name = "",
  439. 	    .sep = "",
  440. 	};
  442. #ifdef HAS_GETOPT_LONG
  443. 	// Strictly for GNUisms compatibility so no long-only options
  444. 	// clang-format off
  445. 	static struct option opts[] = {
  446. 		{"force", no_argument, NULL, 'f'},
  447. 		{"always-interactive", no_argument, NULL, 'I'},
  448. 		{"interactive", no_argument, NULL, 'i'},
  449. 		{"no-clobber", no_argument, NULL, 'n'},
  450. 		{"target-directory", required_argument, NULL, 't'},
  451. 		{"no-target-directory", no_argument, NULL, 'T'},
  452. 		{"verbose", no_argument, NULL, 'v'},
  453. 		{0, 0, 0, 0},
  454. 	};
  455. 	// clang-format on
  457. 	// Need + as first character to get POSIX-style option parsing
  458. 	for(int c = -1; (c = getopt_long(argc, argv, "+:fIint:Tv", opts, NULL)) != -1;)
  459. #else
  460. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":fIint:Tv")) != -1;)
  461. #endif
  462. 	{
  463. 		switch(c)
  464. 		{
  465. 		case 'f':
  466. 			force = true;
  467. 			interact = false;
  468. 			no_clob = false;
  469. 			break;
  470. 		case 'I':
  471. 		case 'i':
  472. 			if(c == 'I') always_interact = true;
  473. 			force = false;
  474. 			interact = true;
  475. 			no_clob = false;
  476. 			break;
  477. 		case 'n':
  478. 			force = false;
  479. 			interact = false;
  480. 			no_clob = true;
  481. 			break;
  482. 		case 't':
  483. 			destdir.name = optarg;
  484. 			destdir.sep = "/";
  485. 			destdir.fd = open(optarg, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  487. 			if(destdir.fd < 0)
  488. 			{
  489. 				fprintf(stderr,
  490. 				        "mv: error: Failed opening destination directory '%s': %s\n",
  491. 				        optarg,
  492. 				        strerror(errno));
  493. 				return 1;
  494. 			}
  495. 			break;
  496. 		case 'T':
  497. 			opt_T = true;
  498. 			break;
  499. 		case 'v':
  500. 			verbose = true;
  501. 			break;
  502. 		case ':':
  503. 			fprintf(stderr, "mv: error: Missing operand for option: '-%c'\n", optopt);
  504. 			usage();
  505. 			return 1;
  506. 		case '?':
  507. 			GETOPT_UNKNOWN_OPT
  508. 			usage();
  509. 			return 1;
  510. 		}
  511. 	}
  513. 	argc -= optind;
  514. 	argv += optind;
  516. 	char *lc_all = setlocale(LC_ALL, "");
  517. 	if(lc_all == NULL)
  518. 	{
  519. 		fprintf(stderr,
  520. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  521. 		        argv0,
  522. 		        strerror(errno));
  523. 	}
  524. 	errno = 0;
  526. 	consent_init();
  528. 	stdin_tty = isatty(STDIN_FILENO);
  529. 	if(!stdin_tty) errno = 0;
  531. 	if(opt_T)
  532. 	{
  533. 		if(destdir.fd != AT_FDCWD)
  534. 		{
  535. 			fprintf(stderr, "mv: error: Cannot pass both -t and -T\n");
  536. 			usage();
  537. 			return 1;
  538. 		}
  540. 		if(argc != 2)
  541. 		{
  542. 			fprintf(stderr, "mv: error: Option -T passed but got %d arguments instead of 2\n", argc);
  543. 			usage();
  544. 			return 1;
  545. 		}
  546. 	}
  548. 	if(destdir.fd == AT_FDCWD)
  549. 	{
  550. 		if(argc <= 1)
  551. 		{
  552. 			fprintf(stderr, "mv: error: Not enough operands, %d given, expect >= 2\n", argc);
  553. 			usage();
  554. 			return 1;
  555. 		}
  557. 		if(opt_T)
  558. 		{
  559. 			int ret = do_renameat(srcdir, argv[0], destdir, argv[1]);
  561. 			consent_finish();
  562. 			return ret < 0 ? 1 : 0;
  563. 		}
  565. 		struct stat dest_status;
  566. 		int ret_stat = fstatat(destdir.fd, argv[1], &dest_status, 0);
  567. 		if(
  568. 		    // clang-format off
  569. 		    argc == 2 && (
  570. 		        (ret_stat != 0 && errno == ENOENT) ||
  571. 		        (ret_stat == 0 && !S_ISDIR(dest_status.st_mode))
  572. 		    )
  573. 		    // clang-format on
  574. 		)
  575. 		{
  576. 			int ret = do_renameat(srcdir, argv[0], destdir, argv[1]);
  578. 			consent_finish();
  579. 			return ret < 0 ? 1 : 0;
  580. 		}
  581. 		errno = 0;
  583. 		argc--;
  584. 		destdir.name = argv[argc];
  585. 		destdir.sep = "/";
  586. 		destdir.fd = open(destdir.name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  587. 		if(destdir.fd < 0)
  588. 		{
  589. 			fprintf(stderr,
  590. 			        "mv: error: Failed opening destination directory '%s': %s\n",
  591. 			        destdir.name,
  592. 			        strerror(errno));
  594. 			consent_finish();
  595. 			return 1;
  596. 		}
  597. 	}
  599. 	for(int i = 0; i < argc; i++)
  600. 	{
  601. 		static char arg[PATH_MAX] = "";
  602. 		lib_strlcpy(arg, argv[i], PATH_MAX);
  604. 		char *filename = basename(arg);
  606. 		if(do_renameat(srcdir, argv[i], destdir, filename) < 0)
  607. 		{
  608. 			consent_finish();
  609. 			return 1;
  610. 		}
  611. 	}
  613. 	consent_finish();
  615. 	if(close(destdir.fd) < 0)
  616. 	{
  617. 		fprintf(
  618. 		    stderr, "mv: error: Failed closing directory '%s': %s\n", destdir.name, strerror(errno));
  619. 		return 1;
  620. 	}
  622. 	return 0;
  623. }