logo

utils-std

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

ln.c (6220B)

    

  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. 			}
  84. 		}
  85. 		else if(fstat(destfd, &dest_stat) < 0)
  86. 		{
  87. 			fprintf(stderr,
  88. 			        "ln: error: Failed getting status for destination '%s': %s\n",
  89. 			        dest,
  90. 			        strerror(errno));
  91. 			return -1;
  92. 		}
  93. 	}
  95. 	int dirfd = AT_FDCWD;
  96. 	if(S_ISDIR(dest_stat.st_mode))
  97. 	{
  98. 		dirfd = destfd;
  99. 	}
  100. 	else
  101. 	{
  102. 		/* check if symbolic/hard link refers to same file */
  103. 		struct stat src_stat;
  104. 		if(stat(src, &src_stat) < 0)
  105. 		{
  106. 			if(errno != ENOENT)
  107. 			{
  108. 				fprintf(
  109. 				    stderr, "ln: error: Failed getting status for source '%s': %s\n", src, strerror(errno));
  110. 				return -1;
  111. 			}
  112. 		}
  113. 		else if(src_stat.st_dev == dest_stat.st_dev && src_stat.st_ino == dest_stat.st_ino)
  114. 		{
  115. 			fprintf(
  116. 			    stderr, "ln: info: Source '%s' and destination '%s' refer to the same file\n", src, dest);
  117. 			return 0;
  118. 		}
  120. 		if(unlink(dest) < 0)
  121. 		{
  122. 			fprintf(stderr, "ln: error: Failed unlinking destination '%s': %s\n", dest, strerror(errno));
  123. 			return -1;
  124. 		}
  125. 	}
  127. 	if(opt_s)
  128. 	{
  129. 		if(symlinkat(src, dirfd, dest) == 0) goto cleanup;
  131. 		fprintf(stderr, "ln: error: Failed creating symlink '%s': %s\n", dest, strerror(errno));
  132. 		return -1;
  133. 	}
  134. 	else
  135. 	{
  136. 		if(linkat(AT_FDCWD, src, dirfd, dest, link_flags) == 0) goto cleanup;
  138. 		fprintf(stderr,
  139. 		        "ln: error: Failed creating hard link from '%s' to '%s': %s\n",
  140. 		        src,
  141. 		        dest,
  142. 		        strerror(errno));
  143. 		return -1;
  144. 	}
  146. cleanup:
  147. 	if(destfd < 0) return 0;
  149. 	if(close(destfd) != 0)
  150. 	{
  151. 		fprintf(stderr,
  152. 		        "ln: error: Failed closing destination directory '%s': %s\n",
  153. 		        dest,
  154. 		        strerror(errno));
  155. 		return -1;
  156. 	}
  158. 	if(verbose) printf("'%s' -> '%s'\n", src, dest);
  160. 	return 0;
  161. }
  163. static void
  164. usage(void)
  165. {
  166. 	fprintf(stderr, "\
  167. Usage: ln [-fnv] [-L|-P] source... target\n\
  168.        ln -s [-fnv] reference... target\n\
  169. ");
  170. }
  172. int
  173. main(int argc, char *argv[])
  174. {
  175. #ifdef HAS_GETOPT_LONG
  176. 	// Strictly for GNUisms compatibility so no long-only options
  177. 	// clang-format off
  178. 	static struct option opts[] = {
  179. 		{"force", no_argument, NULL, 'f'},
  180. 		{"logical", no_argument, NULL, 'L'},
  181. 		{"no-dereference", no_argument, NULL, 'n'},
  182. 		{"physical", no_argument, NULL, 'P'},
  183. 		{"symbolic", no_argument, NULL, 's'},
  184. 		{"verbose", no_argument, NULL, 'v'},
  185. 		{0, 0, 0, 0},
  186. 	};
  187. 	// clang-format on
  189. 	// Need + as first character to get POSIX-style option parsing
  190. 	for(int c = -1; (c = getopt_long(argc, argv, "+:fnsLPv", opts, NULL)) != -1;)
  191. #else
  192. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":fnsLPv")) != -1;)
  193. #endif
  194. 	{
  195. 		switch(c)
  196. 		{
  197. 		case 'f':
  198. 			force = true;
  199. 			break;
  200. 		case 'n':
  201. 			FIELD_SET(open_target_flags, O_NOFOLLOW);
  202. 			break;
  203. 		case 's':
  204. 			opt_s = true;
  205. 			break;
  206. 		case 'L':
  207. 			FIELD_SET(link_flags, AT_SYMLINK_FOLLOW);
  208. 			break;
  209. 		case 'P':
  210. 			FIELD_CLR(link_flags, AT_SYMLINK_FOLLOW);
  211. 			break;
  212. 		case 'v':
  213. 			verbose = true;
  214. 			break;
  215. 		case '?':
  216. 			GETOPT_UNKNOWN_OPT
  217. 			usage();
  218. 			return 1;
  219. 		}
  220. 	}
  222. 	argc -= optind;
  223. 	argv += optind;
  225. 	char *target = argv[argc - 1];
  226. 	char dest[PATH_MAX] = "";
  228. 	if(argc <= 0)
  229. 	{
  230. 		fprintf(stderr, "ln: error: Not enough operands, %d given, expect >= 1\n", argc);
  231. 		return 1;
  232. 	}
  233. 	else if(argc == 1)
  234. 	{
  235. 		target = (char *)".";
  236. 		argc++;
  237. 	}
  238. 	else if(argc == 2)
  239. 	{
  240. 		int targetfd = open(target, open_target_flags);
  241. 		if(targetfd >= 0)
  242. 		{
  243. 			if(fstat(targetfd, &dest_stat) < 0)
  244. 			{
  245. 				fprintf(stderr,
  246. 				        "ln: error: Failed getting status for target '%s': %s\n",
  247. 				        dest,
  248. 				        strerror(errno));
  249. 				return -1;
  250. 			}
  252. 			if(!S_ISDIR(dest_stat.st_mode))
  253. 			{
  254. 				int ret = do_link(argv[0], argv[1], targetfd);
  256. 				return ret < 0 ? 1 : 0;
  257. 			}
  259. 			if(close(targetfd) < 0)
  260. 			{
  261. 				fprintf(stderr,
  262. 				        "ln: error: Failed closing target directory '%s': %s\n",
  263. 				        target,
  264. 				        strerror(errno));
  265. 				return -1;
  266. 			}
  267. 		}
  268. 		else
  269. 		{
  270. 			int ret = do_link(argv[0], argv[1], -1);
  272. 			return ret < 0 ? 1 : 0;
  273. 		}
  274. 	}
  276. 	for(int i = 0; i < argc - 1; i++)
  277. 	{
  278. 		char *src = argv[i];
  279. 		char *src_basename = basename(src);
  281. 		if(snprintf(dest, PATH_MAX, "%s/%s", target, src_basename) < 0)
  282. 		{
  283. 			fprintf(stderr,
  284. 			        "ln: error: Failed joining target '%s' and source basename '%s'\n",
  285. 			        target,
  286. 			        src_basename);
  287. 			return 1;
  288. 		}
  290. 		if(do_link(src, dest, -1) < 0) return 1;
  291. 	}
  293. 	return 0;
  294. }