logo

utils-std

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

mktemp.c (4087B)

    

  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. // getentropy got in POSIX.1-2024 but defining _POSIX_C_SOURCE causes too much side-effects
  6. #define _DEFAULT_SOURCE // getentropy
  8. #include <errno.h>
  9. #include <limits.h> // PATH_MAX
  10. #include <stdbool.h>
  11. #include <stdio.h>  // fprintf
  12. #include <stdlib.h> // getenv
  13. #include <string.h> // strerror
  14. #include <unistd.h> // getopt, getentropy
  15. #ifdef HAS_GETOPT_LONG
  16. #include <getopt.h>
  17. #endif
  19. const char *argv0 = "mktemp";
  21. static int
  22. unsafe_mktemp(char *template)
  23. {
  24. 	size_t l = strlen(template);
  26. 	size_t len = 0;
  27. 	size_t off = l - 1;
  28. 	while(off > 0 && template[off] == 'X')
  29. 		off--, len++;
  31. 	if(len < 6)
  32. 	{
  33. 		fprintf(stderr,
  34. 		        "%s: error: Template '%s' is invalid (need >= 6 final X, got %zd)\n",
  35. 		        argv0,
  36. 		        template,
  37. 		        len);
  38. 		return 1;
  39. 	}
  41. 	for(int retries = 100; 0 < retries; retries--)
  42. 	{
  43. 		unsigned long r = 0;
  44. 		if(getentropy(&r, sizeof(r)) != 0)
  45. 		{
  46. 			fprintf(stderr,
  47. 			        "%s: error: Failed to get entropy for random filename: %s\n",
  48. 			        argv0,
  49. 			        strerror(errno));
  50. 			return 1;
  51. 		}
  53. 		for(int i = len; i > 0; i--, r >>= 5)
  54. 			template[off + i] = 'A' + (r & 15) + (r & 16) * 2;
  56. 		if(access(template, F_OK) != 0 && errno == ENOENT)
  57. 		{
  58. 			puts(template);
  59. 			return 0;
  60. 		}
  61. 	}
  63. 	fprintf(stderr, "%s: error: Exhausted all 100 attempts at generating a filename\n", argv0);
  64. 	return 1;
  65. }
  67. int
  68. main(int argc, char *argv[])
  69. {
  70. 	bool o_create_dir = false, o_quiet = false, o_unsafe = false;
  71. 	char template[PATH_MAX] = "tmp.XXXXXXXXXX";
  72. 	const char *tmpdir = NULL;
  74. 	int c = -1;
  75. #ifdef HAS_GETOPT_LONG
  76. 	// Strictly for GNUisms compatibility so no long-only options
  77. 	// clang-format off
  78. 	static struct option opts[] = {
  79. 		{"directory", no_argument, 0, 'd'},
  80. 		{"dry-run", required_argument, 0, 'u'},
  81. 		{"quiet", no_argument, 0, 'q'},
  82. 		{"tmpdir", required_argument, 0, 'p'},
  83. 		{0, 0, 0, 0},
  84. 	};
  85. 	// clang-format on
  87. 	// Need + as first character to get POSIX-style option parsing
  88. 	while((c = getopt_long(argc, argv, "+:dqp:tu", opts, NULL)) != -1)
  89. #else
  90. 	while((c = getopt(argc, argv, ":dqp:tu")) != -1)
  91. #endif
  92. 	{
  93. 		switch(c)
  94. 		{
  95. 		case 'd':
  96. 			o_create_dir = true;
  97. 			break;
  98. 		case 'q':
  99. 			o_quiet = true;
  100. 			break;
  101. 		case 'p':
  102. 			tmpdir = optarg;
  103. 			break;
  104. 		case 't':
  105. 			if(tmpdir == NULL) tmpdir = getenv("TMPDIR");
  106. 			if(tmpdir == NULL) tmpdir = "/tmp";
  107. 			break;
  108. 		case 'u':
  109. 			o_unsafe = true;
  110. 			break;
  111. 		case '?':
  112. 			fprintf(stderr, "%s: error: Unrecognised option: '-%c'\n", argv0, optopt);
  113. 			return 1;
  114. 		default:
  115. 			fprintf(stderr, "%s: error: Unhandled getopt case '%c'\n", argv0, c);
  116. 			abort();
  117. 		}
  118. 	}
  120. 	argc -= optind;
  121. 	argv += optind;
  123. 	if(argc == 1)
  124. 	{
  125. 		strncpy(template, *argv, PATH_MAX);
  126. 	}
  127. 	else if(argc > 1)
  128. 	{
  129. 		fprintf(stderr, "%s: error: Only one template argument is supported, got %d\n", argv0, argc);
  130. 		return 1;
  131. 	}
  133. 	if(tmpdir)
  134. 	{
  135. 		if(chdir(tmpdir) < 0)
  136. 		{
  137. 			fprintf(stderr,
  138. 			        "%s: error: Failed changing directory into tmpdir '%s': %s\n",
  139. 			        argv0,
  140. 			        tmpdir,
  141. 			        strerror(errno));
  142. 			return 1;
  143. 		}
  145. 		printf("%s/", tmpdir);
  146. 	}
  148. 	char template_copy[PATH_MAX] = "";
  149. 	memcpy(template_copy, template, PATH_MAX);
  151. 	if(o_unsafe) return unsafe_mktemp(template);
  153. 	if(o_create_dir)
  154. 	{
  155. 		char *dir = mkdtemp(template);
  156. 		if(dir == NULL)
  157. 		{
  158. 			if(!o_quiet)
  159. 				fprintf(stderr,
  160. 				        "%s: error: Failed creating random directory with template '%s': %s\n",
  161. 				        argv0,
  162. 				        template_copy,
  163. 				        strerror(errno));
  165. 			return 1;
  166. 		}
  168. 		puts(dir);
  170. 		return 0;
  171. 	}
  173. 	int fd = mkstemp(template);
  174. 	if(fd < 0)
  175. 	{
  176. 		if(!o_quiet)
  177. 			fprintf(stderr,
  178. 			        "%s: error: Failed creating random file with template '%s': %s\n",
  179. 			        argv0,
  180. 			        template_copy,
  181. 			        strerror(errno));
  183. 		return 1;
  184. 	}
  186. 	puts(template);
  188. 	if(close(fd) < 0)
  189. 	{
  190. 		if(!o_quiet) fprintf(stderr, "%s: error: Failed closing file: %s\n", argv0, strerror(errno));
  192. 		return 1;
  193. 	}
  195. 	return 0;
  196. }