logo

utils-std

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

ln.c (6243B)

    

  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 _GNU_SOURCE     // O_PATH with glibc
  6. #define _DEFAULT_SOURCE // due to O_PATH
  7. // Don't define _POSIX_C_SOURCE otherwise FreeBSD hides O_PATH
  9. #include "../config.h"
  10. #include "../lib/bitmasks.h"
  11. #include "../libutils/getopt_nolong.h"
  13. #include <errno.h>
  14. #include <fcntl.h>  // linkat, AT_SYMLINK_FOLLOW
  15. #include <libgen.h> // basename
  16. #include <limits.h> // PATH_MAX
  17. #include <stdbool.h>
  18. #include <stdio.h>    // fprintf
  19. #include <string.h>   // strerror
  20. #include <sys/stat.h> // fstat
  21. #include <unistd.h>   // getopt, symlink, link
  22. #ifdef HAS_GETOPT_LONG
  23. #include <getopt.h>
  24. #endif
  26. const char *argv0 = "ln";
  28. static bool opt_s = false, force = false;
  29. static int link_flags = 0;
  30. static int open_target_flags = O_RDONLY | O_PATH;
  31. static int open_dest_flags = O_RDONLY | O_PATH | O_NOFOLLOW;
  32. static struct stat dest_stat;
  33. static bool verbose = false;
  35. static int
  36. do_link(char *src, char *dest, int destfd)
  37. {
  38. 	if(opt_s)
  39. 	{
  40. 		if(symlinkat(src, AT_FDCWD, dest) == 0) return 0;
  42. 		if(errno != EEXIST)
  43. 		{
  44. 			fprintf(stderr, "ln: error: Failed creating symlink '%s': %s\n", dest, strerror(errno));
  45. 			return -1;
  46. 		}
  47. 	}
  48. 	else
  49. 	{
  50. 		if(linkat(AT_FDCWD, src, AT_FDCWD, dest, link_flags) == 0) return 0;
  52. 		if(errno != EEXIST)
  53. 		{
  54. 			fprintf(stderr,
  55. 			        "ln: error: Failed creating hard link from '%s' to '%s': %s\n",
  56. 			        src,
  57. 			        dest,
  58. 			        strerror(errno));
  59. 			return -1;
  60. 		}
  61. 	}
  63. 	errno = 0;
  65. 	if(!force)
  66. 	{
  67. 		fprintf(stderr, "ln: error: Destination '%s' already exists\n", dest);
  68. 		return -1;
  69. 	}
  71. 	if(destfd < 0)
  72. 	{
  73. 		destfd = open(dest, open_dest_flags);
  74. 		if(destfd < 0)
  75. 		{
  76. 			if(errno != ENOENT)
  77. 			{
  78. 				fprintf(stderr,
  79. 				        "ln: error: Failed opening destination as path '%s': %s\n",
  80. 				        dest,
  81. 				        strerror(errno));
  82. 				return -1;
  83. 			}
  85. 			destfd = AT_FDCWD;
  86. 		}
  87. 		else if(fstat(destfd, &dest_stat) < 0)
  88. 		{
  89. 			fprintf(stderr,
  90. 			        "ln: error: Failed getting status for destination '%s': %s\n",
  91. 			        dest,
  92. 			        strerror(errno));
  93. 			return -1;
  94. 		}
  95. 	}
  97. 	int dirfd = AT_FDCWD;
  98. 	if(S_ISDIR(dest_stat.st_mode))
  99. 	{
  100. 		dirfd = destfd;
  101. 	}
  102. 	else
  103. 	{
  104. 		/* check if symbolic/hard link refers to same file */
  105. 		struct stat src_stat;
  106. 		if(stat(src, &src_stat) < 0)
  107. 		{
  108. 			if(errno != ENOENT)
  109. 			{
  110. 				fprintf(
  111. 				    stderr, "ln: error: Failed getting status for source '%s': %s\n", src, strerror(errno));
  112. 				return -1;
  113. 			}
  114. 		}
  115. 		else if(src_stat.st_dev == dest_stat.st_dev && src_stat.st_ino == dest_stat.st_ino)
  116. 		{
  117. 			fprintf(
  118. 			    stderr, "ln: info: Source '%s' and destination '%s' refer to the same file\n", src, dest);
  119. 			return 0;
  120. 		}
  122. 		if(unlink(dest) < 0)
  123. 		{
  124. 			fprintf(stderr, "ln: error: Failed unlinking destination '%s': %s\n", dest, strerror(errno));
  125. 			return -1;
  126. 		}
  127. 	}
  129. 	if(opt_s)
  130. 	{
  131. 		if(symlinkat(src, dirfd, dest) == 0) goto cleanup;
  133. 		fprintf(stderr, "ln: error: Failed creating symlink '%s': %s\n", dest, strerror(errno));
  134. 		return -1;
  135. 	}
  136. 	else
  137. 	{
  138. 		if(linkat(AT_FDCWD, src, dirfd, dest, link_flags) == 0) goto cleanup;
  140. 		fprintf(stderr,
  141. 		        "ln: error: Failed creating hard link from '%s' to '%s': %s\n",
  142. 		        src,
  143. 		        dest,
  144. 		        strerror(errno));
  145. 		return -1;
  146. 	}
  148. cleanup:
  149. 	if(destfd < 0) return 0;
  151. 	if(close(destfd) != 0)
  152. 	{
  153. 		fprintf(stderr,
  154. 		        "ln: error: Failed closing destination directory '%s': %s\n",
  155. 		        dest,
  156. 		        strerror(errno));
  157. 		return -1;
  158. 	}
  160. 	if(verbose) printf("'%s' -> '%s'\n", src, dest);
  162. 	return 0;
  163. }
  165. static void
  166. usage(void)
  167. {
  168. 	fprintf(stderr, "\
  169. Usage: ln [-fnv] [-L|-P] source... target\n\
  170.        ln -s [-fnv] reference... target\n\
  171. ");
  172. }
  174. int
  175. main(int argc, char *argv[])
  176. {
  177. #ifdef HAS_GETOPT_LONG
  178. 	// Strictly for GNUisms compatibility so no long-only options
  179. 	// clang-format off
  180. 	static struct option opts[] = {
  181. 		{"force", no_argument, NULL, 'f'},
  182. 		{"logical", no_argument, NULL, 'L'},
  183. 		{"no-dereference", no_argument, NULL, 'n'},
  184. 		{"physical", no_argument, NULL, 'P'},
  185. 		{"symbolic", no_argument, NULL, 's'},
  186. 		{"verbose", no_argument, NULL, 'v'},
  187. 		{0, 0, 0, 0},
  188. 	};
  189. 	// clang-format on
  191. 	// Need + as first character to get POSIX-style option parsing
  192. 	for(int c = -1; (c = getopt_long(argc, argv, "+:fnsLPv", opts, NULL)) != -1;)
  193. #else
  194. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":fnsLPv")) != -1;)
  195. #endif
  196. 	{
  197. 		switch(c)
  198. 		{
  199. 		case 'f':
  200. 			force = true;
  201. 			break;
  202. 		case 'n':
  203. 			FIELD_SET(open_target_flags, O_NOFOLLOW);
  204. 			break;
  205. 		case 's':
  206. 			opt_s = true;
  207. 			break;
  208. 		case 'L':
  209. 			FIELD_SET(link_flags, AT_SYMLINK_FOLLOW);
  210. 			break;
  211. 		case 'P':
  212. 			FIELD_CLR(link_flags, AT_SYMLINK_FOLLOW);
  213. 			break;
  214. 		case 'v':
  215. 			verbose = true;
  216. 			break;
  217. 		case '?':
  218. 			GETOPT_UNKNOWN_OPT
  219. 			usage();
  220. 			return 1;
  221. 		}
  222. 	}
  224. 	argc -= optind;
  225. 	argv += optind;
  227. 	char *target = argv[argc - 1];
  228. 	char dest[PATH_MAX] = "";
  230. 	if(argc <= 0)
  231. 	{
  232. 		fprintf(stderr, "ln: error: Not enough operands, %d given, expect >= 1\n", argc);
  233. 		return 1;
  234. 	}
  235. 	else if(argc == 1)
  236. 	{
  237. 		target = (char *)".";
  238. 		argc++;
  239. 	}
  240. 	else if(argc == 2)
  241. 	{
  242. 		int targetfd = open(target, open_target_flags);
  243. 		if(targetfd >= 0)
  244. 		{
  245. 			if(fstat(targetfd, &dest_stat) < 0)
  246. 			{
  247. 				fprintf(stderr,
  248. 				        "ln: error: Failed getting status for target '%s': %s\n",
  249. 				        dest,
  250. 				        strerror(errno));
  251. 				return -1;
  252. 			}
  254. 			if(!S_ISDIR(dest_stat.st_mode))
  255. 			{
  256. 				int ret = do_link(argv[0], argv[1], targetfd);
  258. 				return ret < 0 ? 1 : 0;
  259. 			}
  261. 			if(close(targetfd) < 0)
  262. 			{
  263. 				fprintf(stderr,
  264. 				        "ln: error: Failed closing target directory '%s': %s\n",
  265. 				        target,
  266. 				        strerror(errno));
  267. 				return -1;
  268. 			}
  269. 		}
  270. 		else
  271. 		{
  272. 			int ret = do_link(argv[0], argv[1], -1);
  274. 			return ret < 0 ? 1 : 0;
  275. 		}
  276. 	}
  278. 	for(int i = 0; i < argc - 1; i++)
  279. 	{
  280. 		char *src = argv[i];
  281. 		char *src_basename = basename(src);
  283. 		if(snprintf(dest, PATH_MAX, "%s/%s", target, src_basename) < 0)
  284. 		{
  285. 			fprintf(stderr,
  286. 			        "ln: error: Failed joining target '%s' and source basename '%s'\n",
  287. 			        target,
  288. 			        src_basename);
  289. 			return 1;
  290. 		}
  292. 		if(do_link(src, dest, -1) < 0) return 1;
  293. 	}
  295. 	return 0;
  296. }