logo

utils-std

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

ln.c (6757B)

    

  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, opt_T = 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. 		if(opt_T)
  101. 		{
  102. 			fprintf(stderr, "ln: error: Option -T passed but target '%s' is a directory\n", dest);
  103. 			return -1;
  104. 		}
  106. 		dirfd = destfd;
  107. 	}
  108. 	else
  109. 	{
  110. 		/* check if symbolic/hard link refers to same file */
  111. 		struct stat src_stat;
  112. 		if(stat(src, &src_stat) < 0)
  113. 		{
  114. 			if(errno != ENOENT)
  115. 			{
  116. 				fprintf(
  117. 				    stderr, "ln: error: Failed getting status for source '%s': %s\n", src, strerror(errno));
  118. 				return -1;
  119. 			}
  120. 		}
  121. 		else if(src_stat.st_dev == dest_stat.st_dev && src_stat.st_ino == dest_stat.st_ino)
  122. 		{
  123. 			fprintf(
  124. 			    stderr, "ln: info: Source '%s' and destination '%s' refer to the same file\n", src, dest);
  125. 			return 0;
  126. 		}
  128. 		if(unlink(dest) < 0)
  129. 		{
  130. 			fprintf(stderr, "ln: error: Failed unlinking destination '%s': %s\n", dest, strerror(errno));
  131. 			return -1;
  132. 		}
  133. 	}
  135. 	if(opt_s)
  136. 	{
  137. 		if(symlinkat(src, dirfd, dest) == 0) goto cleanup;
  139. 		fprintf(stderr, "ln: error: Failed creating symlink '%s': %s\n", dest, strerror(errno));
  140. 		return -1;
  141. 	}
  142. 	else
  143. 	{
  144. 		if(linkat(AT_FDCWD, src, dirfd, dest, link_flags) == 0) goto cleanup;
  146. 		fprintf(stderr,
  147. 		        "ln: error: Failed creating hard link from '%s' to '%s': %s\n",
  148. 		        src,
  149. 		        dest,
  150. 		        strerror(errno));
  151. 		return -1;
  152. 	}
  154. cleanup:
  155. 	if(destfd < 0) return 0;
  157. 	if(close(destfd) != 0)
  158. 	{
  159. 		fprintf(stderr,
  160. 		        "ln: error: Failed closing destination directory '%s': %s\n",
  161. 		        dest,
  162. 		        strerror(errno));
  163. 		return -1;
  164. 	}
  166. 	if(verbose) printf("'%s' -> '%s'\n", src, dest);
  168. 	return 0;
  169. }
  171. static void
  172. usage(void)
  173. {
  174. 	fprintf(stderr, "\
  175. Usage: ln [-fnv] [-L|-P] -T source target\n\
  176.        ln [-fnv] [-L|-P] source... [target]\n\
  177.        ln -s [-fnv] reference... [target]\n\
  178. ");
  179. }
  181. int
  182. main(int argc, char *argv[])
  183. {
  184. #ifdef HAS_GETOPT_LONG
  185. 	// Strictly for GNUisms compatibility so no long-only options
  186. 	// clang-format off
  187. 	static struct option opts[] = {
  188. 		{"force", no_argument, NULL, 'f'},
  189. 		{"logical", no_argument, NULL, 'L'},
  190. 		{"no-dereference", no_argument, NULL, 'n'},
  191. 		{"no-target-directory", no_argument, NULL, 'T'},
  192. 		{"physical", no_argument, NULL, 'P'},
  193. 		{"symbolic", no_argument, NULL, 's'},
  194. 		{"verbose", no_argument, NULL, 'v'},
  195. 		{0, 0, 0, 0},
  196. 	};
  197. 	// clang-format on
  199. 	// Need + as first character to get POSIX-style option parsing
  200. 	for(int c = -1; (c = getopt_long(argc, argv, "+:fnsLPTv", opts, NULL)) != -1;)
  201. #else
  202. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":fnsLPTv")) != -1;)
  203. #endif
  204. 	{
  205. 		switch(c)
  206. 		{
  207. 		case 'f':
  208. 			force = true;
  209. 			break;
  210. 		case 'n':
  211. 			FIELD_SET(open_target_flags, O_NOFOLLOW);
  212. 			break;
  213. 		case 's':
  214. 			opt_s = true;
  215. 			break;
  216. 		case 'L':
  217. 			FIELD_SET(link_flags, AT_SYMLINK_FOLLOW);
  218. 			break;
  219. 		case 'P':
  220. 			FIELD_CLR(link_flags, AT_SYMLINK_FOLLOW);
  221. 			break;
  222. 		case 'v':
  223. 			verbose = true;
  224. 			break;
  225. 		case 'T':
  226. 			opt_T = true;
  227. 			break;
  228. 		case '?':
  229. 			GETOPT_UNKNOWN_OPT
  230. 			usage();
  231. 			return 1;
  232. 		}
  233. 	}
  235. 	argc -= optind;
  236. 	argv += optind;
  238. 	char *target = argv[argc - 1];
  239. 	char dest[PATH_MAX] = "";
  241. 	if(argc <= 0)
  242. 	{
  243. 		fprintf(stderr, "ln: error: Not enough operands, %d given, expect >= 1\n", argc);
  244. 		return 1;
  245. 	}
  246. 	else if(opt_T && argc != 2)
  247. 	{
  248. 		fprintf(stderr, "ln: error: Option -T passed, but got %d arguments instead of 2\n", argc);
  249. 		return 1;
  250. 	}
  251. 	else if(argc == 1)
  252. 	{
  253. 		target = (char *)".";
  254. 		argc++;
  255. 	}
  256. 	else if(argc == 2)
  257. 	{
  258. 		if(opt_T)
  259. 		{
  260. 			int ret = do_link(argv[0], argv[1], -1);
  262. 			return ret < 0 ? 1 : 0;
  263. 		}
  265. 		int targetfd = open(target, open_target_flags);
  266. 		if(targetfd >= 0)
  267. 		{
  268. 			if(fstat(targetfd, &dest_stat) < 0)
  269. 			{
  270. 				fprintf(stderr,
  271. 				        "ln: error: Failed getting status for target '%s': %s\n",
  272. 				        dest,
  273. 				        strerror(errno));
  274. 				return -1;
  275. 			}
  277. 			if(!S_ISDIR(dest_stat.st_mode))
  278. 			{
  279. 				int ret = do_link(argv[0], argv[1], targetfd);
  281. 				return ret < 0 ? 1 : 0;
  282. 			}
  284. 			if(close(targetfd) < 0)
  285. 			{
  286. 				fprintf(stderr,
  287. 				        "ln: error: Failed closing target directory '%s': %s\n",
  288. 				        target,
  289. 				        strerror(errno));
  290. 				return -1;
  291. 			}
  292. 		}
  293. 		else
  294. 		{
  295. 			int ret = do_link(argv[0], argv[1], -1);
  297. 			return ret < 0 ? 1 : 0;
  298. 		}
  299. 	}
  301. 	for(int i = 0; i < argc - 1; i++)
  302. 	{
  303. 		char *src = argv[i];
  304. 		char *src_basename = basename(src);
  306. 		if(snprintf(dest, PATH_MAX, "%s/%s", target, src_basename) < 0)
  307. 		{
  308. 			fprintf(stderr,
  309. 			        "ln: error: Failed joining target '%s' and source basename '%s'\n",
  310. 			        target,
  311. 			        src_basename);
  312. 			return 1;
  313. 		}
  315. 		if(do_link(src, dest, -1) < 0) return 1;
  316. 	}
  318. 	return 0;
  319. }