logo

utils-std

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

env.c (3507B)

    

  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 _XOPEN_SOURCE 800 // wordexp
  8. #include <assert.h>  // assert
  9. #include <errno.h>   // errno
  10. #include <stdbool.h> // bool, true, false
  11. #include <stdio.h>   // puts, fprintf
  12. #include <stdlib.h>  // putenv
  13. #include <string.h>  // strchr, strerror
  14. #include <unistd.h>  // getopt, opt*
  15. #include <wordexp.h> // wordexp
  16. #ifdef HAS_GETOPT_LONG
  17. #include <getopt.h>
  18. #endif
  20. extern char **environ;
  21. char *envclear[1];
  23. static int
  24. do_export(void)
  25. {
  26. 	int i = 0;
  28. 	for(; environ[i] != NULL; i++)
  29. 	{
  30. 		if(puts(environ[i]) < 0)
  31. 		{
  32. 			perror("env: puts(environ[i])");
  33. 			return 1;
  34. 		}
  35. 	}
  37. 	return 0;
  38. }
  40. static void
  41. usage(void)
  42. {
  43. 	fprintf(stderr, "env [-i] [-u key] [key=value ...] [command [args]]\n");
  44. }
  46. int
  47. main(int argc, char *argv[])
  48. {
  49. 	bool flag_i = false;
  50. 	bool flag_S = false;
  51. 	wordexp_t opt_S;
  53. 	int c = -1;
  54. #ifdef HAS_GETOPT_LONG
  55. 	// Strictly for GNUisms compatibility so no long-only options
  56. 	// clang-format off
  57. 	static struct option opts[] = {
  58. 		{"ignore-environment", no_argument, 0, 'i'},
  59. 		{"unset", required_argument, 0, 'u'},
  60. 		{"split-string", required_argument, 0, 'S'},
  61. 		{0, 0, 0, 0},
  62. 	};
  63. 	// clang-format on
  65. 	// Need + as first character to get POSIX-style option parsing
  66. 	while((c = getopt_long(argc, argv, "+:iu:S:", opts, NULL)) != -1)
  67. #else
  68. 	while((c = getopt(argc, argv, ":iu:S:")) != -1)
  69. #endif
  70. 	{
  71. 		switch(c)
  72. 		{
  73. 		case 'i':
  74. 			flag_i = true;
  75. 			break;
  76. 		case 'u':
  77. 			unsetenv(optarg);
  78. 			break;
  79. 		case 'S':
  80. 			flag_S = true;
  81. 			int ret = wordexp(optarg, &opt_S, WRDE_NOCMD);
  82. 			switch(ret)
  83. 			{
  84. 			case 0:
  85. 				break;
  86. 			case WRDE_BADCHAR:
  87. 				fputs("env: Error: wordexpr returned WRDE_BADCHAR\n", stderr);
  88. 				return 1;
  89. 			case WRDE_BADVAL:
  90. 				fputs("env: Error: Undefined shell variable (WRDE_BADVAL)\n", stderr);
  91. 				return 1;
  92. 			case WRDE_CMDSUB:
  93. 				fputs("env: Error: Command substitution forbidden (WRDE_CMDSUB)\n", stderr);
  94. 				return 1;
  95. 			case WRDE_NOSPACE:
  96. 				fputs("env: Error: Out of memory (WRDE_NOSPACE)\n", stderr);
  97. 				return 1;
  98. 			case WRDE_SYNTAX:
  99. 				fputs("env: Error: Syntax Error (WRDE_SYNTAX)\n", stderr);
  100. 				return 1;
  101. 			default:
  102. 				fprintf(stderr, "env: Unknown error %d from wordexp\n", ret);
  103. 				return 1;
  104. 			}
  105. 			break;
  106. 		case ':':
  107. 			fprintf(stderr, "env: Error: Missing operand for option: '-%c'\n", optopt);
  108. 			usage();
  109. 			return 1;
  110. 		case '?':
  111. 			fprintf(stderr, "env: Error: Unrecognised option: '-%c'\n", optopt);
  112. 			usage();
  113. 			return 1;
  114. 		default:
  115. 			assert(false);
  116. 		}
  117. 	}
  119. 	argc -= optind;
  120. 	argv += optind;
  122. 	if(flag_i)
  123. 	{
  124. 		environ = envclear;
  125. 		envclear[0] = NULL;
  126. 	}
  128. 	for(; argv[0]; argv++, argc--)
  129. 	{
  130. 		char *sep = strchr(argv[0], '=');
  131. 		if(sep == NULL)
  132. 		{
  133. 			break;
  134. 		}
  136. 		*sep = 0;
  137. 		sep++;
  139. 		if(setenv(argv[0], sep, 1))
  140. 		{
  141. 			fprintf(stderr, "env: setenv(%s, %s, 1): %s\n", argv[0], sep, strerror(errno));
  142. 			return 1;
  143. 		}
  144. 	}
  146. 	if(flag_S)
  147. 	{
  148. 		errno = 0;
  149. 		if(execvp(opt_S.we_wordv[0], opt_S.we_wordv) < 0)
  150. 		{
  151. 			fprintf(stderr, "env: execvp(\"%s\", ...): %s\n", opt_S.we_wordv[0], strerror(errno));
  153. 			return (errno == ENOENT) ? 127 : 126;
  154. 		}
  155. 		assert(false);
  156. 	}
  158. 	if(argc < 1)
  159. 	{
  160. 		return do_export();
  161. 	}
  163. 	assert(argv[0]);
  164. 	errno = 0;
  165. 	if(execvp(argv[0], argv) < 0)
  166. 	{
  167. 		fprintf(stderr, "env: execvp(\"%s\", ...): %s\n", argv[0], strerror(errno));
  169. 		return (errno == ENOENT) ? 127 : 126;
  170. 	}
  172. 	assert(false);
  173. }