logo

utils-std

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

mv.c (11681B)

    

  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 <dirent.h> // fdopendir
  18. #include <errno.h>
  19. #include <fcntl.h>  // open
  20. #include <libgen.h> // basename
  21. #include <limits.h> // PATH_MAX
  22. #include <locale.h> // setlocale
  23. #include <stdbool.h>
  24. #include <stdint.h>   // SIZE_MAX
  25. #include <stdio.h>    // fprintf, rename
  26. #include <string.h>   // strcmp
  27. #include <sys/stat.h> // stat, S_ISDIR
  28. #include <unistd.h>   // getopt
  30. // Workaround against GNU glibc
  31. // https://sourceware.org/bugzilla/show_bug.cgi?id=18228
  32. #if defined(__linux__) && !defined(O_SEARCH)
  33. // As defined in musl
  34. #define O_SEARCH O_PATH
  35. #endif
  37. const char *argv0 = "mv";
  39. bool no_clob = false, force = false, interact = false, verbose = false;
  41. static int stdin_tty = 0;
  43. struct named_fd
  44. {
  45. 	int fd;
  46. 	const char *name;
  47. 	const char *sep;
  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,
  66. 		        "mv: error: Failed opening source '%s%s%s': %s\n",
  67. 		        srcdir.name,
  68. 		        srcdir.sep,
  69. 		        src,
  70. 		        strerror(errno));
  71. 		errno = 0;
  72. 		return -1;
  73. 	}
  75. 	int out = openat(destdir.fd, dest, O_WRONLY | O_CREAT | O_NOCTTY, src_status.st_mode);
  76. 	if(out < 0)
  77. 	{
  78. 		fprintf(stderr,
  79. 		        "mv: error: Failed opening destination '%s%s%s': %s\n",
  80. 		        destdir.name,
  81. 		        destdir.sep,
  82. 		        dest,
  83. 		        strerror(errno));
  84. 		errno = 0;
  85. 		return -1;
  86. 	}
  88. 	const struct timespec times[2] = {src_status.st_atim, src_status.st_mtim};
  89. 	if(futimens(out, times) != 0)
  90. 	{
  91. 		fprintf(stderr,
  92. 		        "mv: warning: Failed copying access & modification times to '%s%s%s': %s\n",
  93. 		        destdir.name,
  94. 		        destdir.sep,
  95. 		        dest,
  96. 		        strerror(errno));
  97. 		errno = 0;
  98. 	}
  100. 	if(fchown(out, src_status.st_uid, src_status.st_gid) != 0)
  101. 	{
  102. 		fprintf(stderr,
  103. 		        "mv: warning: Failed copying owner & group to '%s%s%s': %s\n",
  104. 		        destdir.name,
  105. 		        destdir.sep,
  106. 		        dest,
  107. 		        strerror(errno));
  108. 		errno = 0;
  109. 	}
  111. 	if(auto_file_copy(in, out, src_status.st_size, 0) < 0) return -1;
  113. 	return unlinkat(srcdir.fd, src, 0);
  114. }
  116. static int
  117. rename_dir_entries(struct named_fd srcdir, struct named_fd destdir)
  118. {
  119. 	DIR *dirsrc = fdopendir(srcdir.fd);
  120. 	if(dirsrc == NULL)
  121. 	{
  122. 		fprintf(stderr,
  123. 		        "mv: error: Failed fd-opening source directory '%s': %s\n",
  124. 		        srcdir.name ? srcdir.name : ".",
  125. 		        strerror(errno));
  126. 		return -1;
  127. 	}
  129. 	while(true)
  130. 	{
  131. 		errno = 0;
  132. 		struct dirent *dirsrc_ent = readdir(dirsrc);
  133. 		if(dirsrc_ent == NULL)
  134. 		{
  135. 			if(errno == 0) break;
  137. 			fprintf(stderr,
  138. 			        "mv: error: Failed reading source directory '%s': %s\n",
  139. 			        srcdir.name ? srcdir.name : ".",
  140. 			        strerror(errno));
  141. 			closedir(dirsrc);
  142. 			errno = 0;
  143. 			return -1;
  144. 		}
  146. 		if(strcmp(dirsrc_ent->d_name, ".") == 0) continue;
  147. 		if(strcmp(dirsrc_ent->d_name, "..") == 0) continue;
  149. 		if(do_renameat(srcdir, dirsrc_ent->d_name, destdir, dirsrc_ent->d_name) < 0)
  150. 		{
  151. 			closedir(dirsrc);
  152. 			return -1;
  153. 		}
  154. 	}
  156. 	return 0;
  157. }
  159. static int
  160. do_renameat(struct named_fd srcdir,
  161.             const char *restrict src,
  162.             struct named_fd destdir,
  163.             const char *restrict dest)
  164. {
  165. 	if(destdir.fd == srcdir.fd && strcmp(src, dest) == 0)
  166. 	{
  167. 		fprintf(stderr, "mv: error: Passed to both source and destination: '%s'\n", src);
  168. 		return -1;
  169. 	}
  171. 	struct stat src_status;
  172. 	if(fstatat(srcdir.fd, src, &src_status, AT_SYMLINK_NOFOLLOW) < 0)
  173. 	{
  174. 		fprintf(stderr,
  175. 		        "mv: error: Failed getting status for source file '%s%s%s': %s\n",
  176. 		        srcdir.name,
  177. 		        srcdir.sep,
  178. 		        src,
  179. 		        strerror(errno));
  180. 		return -1;
  181. 	}
  182. 	if(S_ISLNK(src_status.st_mode))
  183. 	{
  184. 		struct stat src_link_status;
  185. 		if(fstatat(srcdir.fd, src, &src_link_status, 0) == 0)
  186. 		{
  187. 			src_status = src_link_status;
  188. 		}
  189. 	}
  191. 	errno = 0;
  193. 	struct stat dest_status;
  194. 	int ret = fstatat(destdir.fd, dest, &dest_status, 0);
  195. 	if(ret < 0 && errno != ENOENT)
  196. 	{
  197. 		fprintf(stderr,
  198. 		        "mv: error: Failed getting status for destination file '%s%s%s': %s\n",
  199. 		        destdir.name,
  200. 		        destdir.sep,
  201. 		        dest,
  202. 		        strerror(errno));
  203. 		return -1;
  204. 	}
  206. 	errno = 0;
  208. 	if(ret == 0)
  209. 	{
  210. 		if(dest_status.st_ino == src_status.st_ino && dest_status.st_dev == src_status.st_dev) return 0;
  212. 		if(no_clob)
  213. 		{
  214. 			fprintf(stderr,
  215. 			        "mv: error: Destination file '%s%s%s' already exists\n",
  216. 			        destdir.name,
  217. 			        destdir.sep,
  218. 			        dest);
  219. 			return -1;
  220. 		}
  222. 		if(!force)
  223. 		{
  224. 			if(interact)
  225. 			{
  226. 				if(!consentf("mv: Destination file '%s%s%s' already exists, overwrite? [yN] ",
  227. 				             destdir.name,
  228. 				             destdir.sep,
  229. 				             dest))
  230. 					return 0;
  231. 			}
  232. 			else if(stdin_tty)
  233. 			{
  234. 				if(faccessat(destdir.fd, dest, W_OK, 0) == 0)
  235. 				{
  236. 					if(!consentf(
  237. 					       "mv: error: No write permissions for destination file '%s%s%s', overwrite? [yN] ",
  238. 					       destdir.name,
  239. 					       destdir.sep,
  240. 					       dest))
  241. 						return 0;
  242. 				}
  243. 				else
  244. 				{
  245. 					errno = 0;
  246. 				}
  247. 			}
  248. 		}
  249. 	}
  251. 	if(renameat(srcdir.fd, src, destdir.fd, dest) < 0)
  252. 	{
  253. 		switch(errno)
  254. 		{
  255. 		case EXDEV:
  256. 			errno = 0;
  258. 			if(S_ISDIR(src_status.st_mode))
  259. 			{
  260. 				char child_srcdir_name[PATH_MAX] = "";
  261. 				snprintf(child_srcdir_name, PATH_MAX, "%s%s%s", srcdir.name, srcdir.sep, src);
  263. 				struct named_fd child_srcdir = {
  264. 				    .fd = openat(srcdir.fd, src, O_RDONLY | O_DIRECTORY | O_CLOEXEC),
  265. 				    .name = child_srcdir_name,
  266. 				    .sep = "/",
  267. 				};
  269. 				if(child_srcdir.fd < 0)
  270. 				{
  271. 					fprintf(stderr,
  272. 					        "mv: error: Failed opening source directory '%s%s%s': %s\n",
  273. 					        srcdir.name,
  274. 					        srcdir.sep,
  275. 					        src,
  276. 					        strerror(errno));
  277. 					return -1;
  278. 				}
  280. 				if(mkdirat(destdir.fd, dest, src_status.st_mode) < 0)
  281. 				{
  282. 					fprintf(stderr,
  283. 					        "mv: error: Failed creating destination directory '%s%s%s': %s\n",
  284. 					        destdir.name,
  285. 					        destdir.sep,
  286. 					        dest,
  287. 					        strerror(errno));
  288. 					return -1;
  289. 				}
  291. 				char child_destdir_name[PATH_MAX] = "";
  292. 				snprintf(child_destdir_name, PATH_MAX, "%s%s%s", destdir.name, destdir.sep, dest);
  293. 				struct named_fd child_destdir = {
  294. 				    .fd = openat(destdir.fd, dest, O_RDONLY | O_DIRECTORY | O_CLOEXEC),
  295. 				    .name = child_destdir_name,
  296. 				    .sep = "/",
  297. 				};
  299. 				if(rename_dir_entries(child_srcdir, child_destdir) < 0) return -1;
  301. 				close(child_srcdir.fd);
  302. 				close(child_destdir.fd);
  304. 				if(unlinkat(srcdir.fd, src, AT_REMOVEDIR) < 0)
  305. 				{
  306. 					fprintf(stderr,
  307. 					        "mv: error: Failed removing source directory '%s%s%s': %s\n",
  308. 					        srcdir.name,
  309. 					        srcdir.sep,
  310. 					        src,
  311. 					        strerror(errno));
  312. 					return -1;
  313. 				}
  314. 			}
  315. 			else
  316. 			{
  317. 				if(copy_file_unlink(srcdir, src, src_status, destdir, dest) < 0) return -1;
  318. 			}
  319. 			break;
  320. 		case EISDIR:
  321. 		case ENOTDIR:
  322. 			if(destdir.fd != AT_FDCWD)
  323. 			{
  324. 				fprintf(
  325. 				    stderr, "mv: error: Failed moving '%s' into '%s': %s\n", src, dest, strerror(errno));
  326. 				return -1;
  327. 			}
  329. 			int tmp_destdir = openat(destdir.fd, dest, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  330. 			if(tmp_destdir < 0)
  331. 			{
  332. 				fprintf(stderr,
  333. 				        "mv: error: Failed opening destination directory '%s': %s\n",
  334. 				        dest,
  335. 				        strerror(errno));
  336. 				return -1;
  337. 			}
  339. 			if(renameat(srcdir.fd, src, tmp_destdir, src) < 0)
  340. 			{
  341. 				fprintf(stderr,
  342. 				        "mv: error: Failed moving '%s' into directory '%s': %s\n",
  343. 				        src,
  344. 				        dest,
  345. 				        strerror(errno));
  346. 				return -1;
  347. 			}
  349. 			if(close(tmp_destdir) < 0)
  350. 			{
  351. 				fprintf(stderr, "mv: error: Failed closing directory '%s': %s\n", dest, strerror(errno));
  352. 				return -1;
  353. 			}
  354. 			break;
  355. 		default:
  356. 			fprintf(stderr,
  357. 			        "mv: error: Failed moving '%s' to '%s%s%s': %s\n",
  358. 			        src,
  359. 			        destdir.name,
  360. 			        destdir.sep,
  361. 			        dest,
  362. 			        strerror(errno));
  363. 			return -1;
  364. 		}
  365. 	}
  367. 	if(verbose)
  368. 		fprintf(stderr, "mv: renamed '%s' -> '%s%s%s'\n", src, destdir.name, destdir.sep, dest);
  370. 	return 0;
  371. }
  373. static void
  374. usage(void)
  375. {
  376. 	fprintf(stderr, "Usage: mv [-f|-i|-n] [-v] source dest\n");
  377. 	fprintf(stderr, "       mv [-f|-i|-n] [-v] source... destdir\n");
  378. 	fprintf(stderr, "       mv [-f|-i|-n] [-v] -t destdir source...\n");
  379. }
  381. int
  382. main(int argc, char *argv[])
  383. {
  384. 	struct named_fd destdir = {
  385. 	    .fd = AT_FDCWD,
  386. 	    .name = "",
  387. 	    .sep = "",
  388. 	};
  389. 	struct named_fd srcdir = {
  390. 	    .fd = AT_FDCWD,
  391. 	    .name = "",
  392. 	    .sep = "",
  393. 	};
  395. 	for(int c = -1; (c = getopt(argc, argv, ":fint:v")) != -1;)
  396. 	{
  397. 		switch(c)
  398. 		{
  399. 		case 'f':
  400. 			force = true;
  401. 			interact = false;
  402. 			no_clob = false;
  403. 			break;
  404. 		case 'i':
  405. 			force = false;
  406. 			interact = true;
  407. 			no_clob = false;
  408. 			break;
  409. 		case 'n':
  410. 			force = false;
  411. 			interact = false;
  412. 			no_clob = true;
  413. 			break;
  414. 		case 't':
  415. 			destdir.name = optarg;
  416. 			destdir.sep = "/";
  417. 			destdir.fd = open(optarg, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  419. 			if(destdir.fd < 0)
  420. 			{
  421. 				fprintf(stderr,
  422. 				        "mv: error: Failed opening destination directory '%s': %s\n",
  423. 				        optarg,
  424. 				        strerror(errno));
  425. 				return 1;
  426. 			}
  427. 			break;
  428. 		case 'v':
  429. 			verbose = true;
  430. 			break;
  431. 		case ':':
  432. 			fprintf(stderr, "mv: error: Missing operand for option: '-%c'\n", optopt);
  433. 			usage();
  434. 			return 1;
  435. 		case '?':
  436. 			fprintf(stderr, "mv: error: Unrecognised option: '-%c'\n", optopt);
  437. 			usage();
  438. 			return 1;
  439. 		}
  440. 	}
  442. 	argc -= optind;
  443. 	argv += optind;
  445. 	setlocale(LC_ALL, "");
  446. 	errno = 0;
  448. 	consent_init();
  450. 	stdin_tty = isatty(STDIN_FILENO);
  451. 	if(!stdin_tty) errno = 0;
  453. 	if(destdir.fd == AT_FDCWD)
  454. 	{
  455. 		if(argc <= 1)
  456. 		{
  457. 			fprintf(stderr, "mv: error: Not enough operands, %d given, expect >= 2\n", argc);
  458. 			return 1;
  459. 		}
  461. 		struct stat dest_status;
  462. 		int ret_stat = fstatat(destdir.fd, argv[1], &dest_status, 0);
  463. 		if(
  464. 		    // clang-format off
  465. 		    argc == 2 && (
  466. 		        (ret_stat != 0 && errno == ENOENT) ||
  467. 		        (ret_stat == 0 && !S_ISDIR(dest_status.st_mode))
  468. 		    )
  469. 		    // clang-format on
  470. 		)
  471. 		{
  472. 			int ret = do_renameat(srcdir, argv[0], destdir, argv[1]);
  474. 			consent_finish();
  475. 			return ret < 0 ? 1 : 0;
  476. 		}
  477. 		errno = 0;
  479. 		argc--;
  480. 		destdir.name = argv[argc];
  481. 		destdir.sep = "/";
  482. 		destdir.fd = open(destdir.name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
  483. 		if(destdir.fd < 0)
  484. 		{
  485. 			fprintf(stderr,
  486. 			        "mv: error: Failed opening destination directory '%s': %s\n",
  487. 			        destdir.name,
  488. 			        strerror(errno));
  490. 			consent_finish();
  491. 			return 1;
  492. 		}
  493. 	}
  495. 	for(int i = 0; i < argc; i++)
  496. 	{
  497. 		char arg[PATH_MAX] = "";
  498. 		strcpy(arg, argv[i]);
  500. 		char *filename = basename(arg);
  502. 		if(do_renameat(srcdir, argv[i], destdir, filename) < 0)
  503. 		{
  504. 			consent_finish();
  505. 			return 1;
  506. 		}
  507. 	}
  509. 	consent_finish();
  511. 	if(close(destdir.fd) < 0)
  512. 	{
  513. 		fprintf(
  514. 		    stderr, "mv: error: Failed closing directory '%s': %s\n", destdir.name, strerror(errno));
  515. 		return 1;
  516. 	}
  518. 	return 0;
  519. }