logo

bootstrap-initrd

Linux initrd to bootstrap from a small binary seed git clone https://anongit.hacktivis.me/git/bootstrap-initrd.git/

cp-stub.c (7066B)

    

  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
  8. #include <assert.h>
  9. #include <errno.h>
  10. #include <fcntl.h>  // linkat, AT_SYMLINK_FOLLOW
  11. #include <limits.h> // PATH_MAX
  12. #include <stdbool.h>
  13. #include <stdio.h>  // fprintf
  14. #include <string.h> // strerror
  15. #include <sys/stat.h>
  16. #include <unistd.h> // getopt, copy_file_range
  18. bool preserve_metadata = false, opt_R = false;
  19. bool follow_src_symlinks = false;
  21. mode_t mode = 00755;
  22. char *argv0 = "cp";
  24. // Copied from utils-std/lib/path.c remove on de-stubbing
  25. static char *
  26. static_basename(char *path)
  27. {
  28. 	char *sep = strrchr(path, '/');
  30. 	return (sep == NULL) ? path : sep + 1;
  31. }
  33. static int
  34. do_copy(char *src, char *dest, bool multi_src)
  35. {
  36. 	assert(errno == 0);
  37. 	struct stat src_stat;
  38. 	if(fstatat(AT_FDCWD, src, &src_stat, follow_src_symlinks ? 0 : AT_SYMLINK_NOFOLLOW) < 0)
  39. 	{
  40. 		fprintf(
  41. 		    stderr, "%s: Failed getting status for source '%s': %s\n", argv0, dest, strerror(errno));
  42. 		return -1;
  43. 	}
  45. 	struct stat dest_stat;
  46. 	if(stat(dest, &dest_stat) < 0)
  47. 	{
  48. 		if(errno == ENOENT)
  49. 		{
  50. 			errno = 0;
  51. 		}
  52. 		else
  53. 		{
  54. 			fprintf(stderr,
  55. 			        "%s: Failed getting status for destination '%s': %s\n",
  56. 			        argv0,
  57. 			        dest,
  58. 			        strerror(errno));
  59. 			return -1;
  60. 		}
  61. 	}
  63. 	char *dest_path = dest;
  64. 	char target[PATH_MAX] = "";
  65. 	if(multi_src || S_ISDIR(dest_stat.st_mode))
  66. 	{
  67. 		char *src_basename = static_basename(src);
  69. 		if(snprintf(target, PATH_MAX, "%s/%s", dest, src_basename) < 0)
  70. 		{
  71. 			fprintf(stderr,
  72. 			        "%s: Failed joining destination '%s' and source '%s'\n",
  73. 			        argv0,
  74. 			        dest,
  75. 			        src_basename);
  76. 			return -1;
  77. 		}
  79. 		dest_path = target;
  80. 	}
  82. 	if(S_ISDIR(src_stat.st_mode))
  83. 	{
  84. 		if(!opt_R)
  85. 		{
  86. 			fprintf(
  87. 			    stderr, "%s: Option -R not specified and source file '%s' is a directory\n", argv0, src);
  88. 			return -1;
  89. 		}
  91. 		if(mkdir(dest_path, mode | S_IRWXU) != 0)
  92. 		{
  93. 			if(errno != EEXIST)
  94. 			{
  95. 				fprintf(stderr,
  96. 				        "%s: Failed creating target directory '%s': %s\n",
  97. 				        argv0,
  98. 				        dest,
  99. 				        strerror(errno));
  100. 				return -1;
  101. 			}
  102. 			else
  103. 				errno = 0;
  104. 		}
  106. 		if(preserve_metadata)
  107. 		{
  108. 			struct timespec src_times[2] = {src_stat.st_atim, src_stat.st_mtim};
  109. 			if(utimensat(AT_FDCWD, dest_path, src_times, 0) != 0)
  110. 			{
  111. 				fprintf(stderr,
  112. 				        "%s: Error while setting access/modification times on '%s': %s\n",
  113. 				        argv0,
  114. 				        dest_path,
  115. 				        strerror(errno));
  116. 				return -1;
  117. 			}
  119. 			if(chown(dest_path, src_stat.st_uid, src_stat.st_gid) < 0)
  120. 			{
  121. 				fprintf(stderr,
  122. 				        "%s: Error: Failed setting ownership on file '%s': %s\n",
  123. 				        argv0,
  124. 				        dest_path,
  125. 				        strerror(errno));
  126. 				return -1;
  127. 			}
  128. 		}
  130. 		fprintf(stderr, "%s: FIXME: Copy the files inside '%s/'\n", argv0, dest);
  131. 		return -1;
  132. 	}
  133. 	else if(S_ISLNK(src_stat.st_mode))
  134. 	{
  135. 		char link[PATH_MAX] = "";
  136. 		if(readlink(src, link, sizeof(link)) < 0)
  137. 		{
  138. 			fprintf(stderr, "%s: Failed reading symlink of '%s': %s\n", argv0, src, strerror(errno));
  139. 			return -1;
  140. 		}
  142. 		if(symlink(link, dest_path) != 0)
  143. 		{
  144. 			fprintf(stderr,
  145. 			        "%s: Failed copying symlink '%s' to '%s': %s\n",
  146. 			        argv0,
  147. 			        src,
  148. 			        dest_path,
  149. 			        strerror(errno));
  150. 			return -1;
  151. 		}
  153. 		if(preserve_metadata)
  154. 		{
  155. 			struct timespec src_times[2] = {src_stat.st_atim, src_stat.st_mtim};
  156. 			if(utimensat(AT_FDCWD, dest_path, src_times, AT_SYMLINK_NOFOLLOW) != 0)
  157. 			{
  158. 				fprintf(stderr,
  159. 				        "%s: Error while setting access/modification times on '%s': %s\n",
  160. 				        argv0,
  161. 				        dest_path,
  162. 				        strerror(errno));
  163. 				return -1;
  164. 			}
  166. 			if(chown(dest, src_stat.st_uid, src_stat.st_gid) < 0)
  167. 			{
  168. 				fprintf(stderr,
  169. 				        "%s: Error: Failed setting ownership on file '%s': %s\n",
  170. 				        argv0,
  171. 				        dest_path,
  172. 				        strerror(errno));
  173. 				return -1;
  174. 			}
  175. 		}
  176. 	}
  177. 	else if(S_ISREG(src_stat.st_mode))
  178. 	{
  179. 		// FIXME: Handle writing into block devices
  180. 		int src_fd = open(src, O_RDONLY | O_NOFOLLOW);
  181. 		if(src_fd < 0)
  182. 		{
  183. 			fprintf(
  184. 			    stderr, "%s: Failed opening file '%s' for reading: %s\n", argv0, src, strerror(errno));
  185. 			return -1;
  186. 		}
  188. 		// FIXME: Handle -i (consent)
  189. 		int dest_fd = open(dest_path, O_CREAT | O_WRONLY | O_TRUNC, mode);
  190. 		if(dest_fd < 0)
  191. 		{
  192. 			// FIXME: Handle -f (unlink on creation-opening fail)
  193. 			fprintf(stderr,
  194. 			        "%s: Failed create-opening file '%s' for writing: %s\n",
  195. 			        argv0,
  196. 			        dest_path,
  197. 			        strerror(errno));
  198. 			return -1;
  199. 		}
  201. 		off_t len = src_stat.st_size;
  202. 		off_t ret = -1;
  203. 		do
  204. 		{
  205. 			ret = copy_file_range(src_fd, NULL, dest_fd, NULL, len, 0);
  206. 			if(ret == -1)
  207. 			{
  208. 				fprintf(stderr,
  209. 				        "%s: Error: Failed copying data from '%s' to '%s': %s\n",
  210. 				        argv0,
  211. 				        src,
  212. 				        dest_path,
  213. 				        strerror(errno));
  214. 				return -1;
  215. 			}
  216. 			len -= ret;
  217. 		} while(len > 0 && ret > 0);
  219. 		assert(errno == 0);
  221. 		if(preserve_metadata)
  222. 		{
  223. 			struct timespec src_times[2] = {src_stat.st_atim, src_stat.st_mtim};
  224. 			if(futimens(dest_fd, src_times) != 0)
  225. 			{
  226. 				fprintf(stderr,
  227. 				        "%s: Error while setting access/modification times on '%s': %s\n",
  228. 				        argv0,
  229. 				        dest_path,
  230. 				        strerror(errno));
  231. 				return -1;
  232. 			}
  234. 			if(fchown(dest_fd, src_stat.st_uid, src_stat.st_gid) < 0)
  235. 			{
  236. 				fprintf(stderr,
  237. 				        "%s: Error: Failed setting ownership on file '%s': %s\n",
  238. 				        argv0,
  239. 				        dest_path,
  240. 				        strerror(errno));
  241. 				return -1;
  242. 			}
  243. 		}
  245. 		assert(errno == 0);
  247. 		if(close(src_fd) < 0)
  248. 		{
  249. 			fprintf(stderr, "%s: Error closing '%s'\n", argv0, src);
  250. 			return -1;
  251. 		}
  253. 		if(close(dest_fd) < 0)
  254. 		{
  255. 			fprintf(stderr, "%s: Error closing '%s'\n", argv0, dest_path);
  256. 			return -1;
  257. 		}
  258. 	}
  259. 	else
  260. 	{
  261. 		fprintf(stderr, "%s: Unhandled file '%s' of type-mode %o\n", argv0, dest, src_stat.st_mode);
  262. 		return -1;
  263. 	}
  265. 	assert(errno == 0);
  267. 	return 0;
  268. }
  270. static void
  271. usage()
  272. {
  273. 	fprintf(stderr, "Usage: cp [-p] [-rR [-H|-L|-P]] source... destination\n");
  274. }
  276. int
  277. main(int argc, char *argv[])
  278. {
  279. 	int c = -1;
  280. 	while((c = getopt(argc, argv, ":pRHLP")) != -1)
  281. 	{
  282. 		switch(c)
  283. 		{
  284. 		case 'p':
  285. 			preserve_metadata = true;
  286. 			break;
  287. 		case 'R':
  288. 		case 'r':
  289. 			opt_R = true;
  290. 			break;
  291. 		case 'H':
  292. 			// FIXME: Only first level aka arguments, not traversal
  293. 			follow_src_symlinks = true;
  294. 			break;
  295. 		case 'L':
  296. 			follow_src_symlinks = true;
  297. 			break;
  298. 		case 'P':
  299. 			follow_src_symlinks = false;
  300. 			break;
  301. 		case '?':
  302. 			fprintf(stderr, "install: Unknown option '-%c'\n", optopt);
  303. 			usage();
  304. 			break;
  305. 		}
  306. 	}
  308. 	assert(errno == 0);
  310. 	argc -= optind;
  311. 	argv += optind;
  313. 	if(argc == 2)
  314. 	{
  315. 		if(do_copy(argv[0], argv[1], false) < 0) return 1;
  316. 	}
  317. 	else
  318. 	{
  319. 		char *dest = argv[argc - 1];
  321. 		for(int i = 0; i < argc - 1; i++)
  322. 		{
  323. 			char *src = argv[i];
  324. 			if(do_copy(src, dest, true) < 0) return 1;
  325. 		}
  326. 	}
  328. 	return 0;
  329. }