logo

utils-std

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

getconf.c (7600B)

    

  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 _ALL_SOURCE
  6. #define _DEFAULT_SOURCE
  7. #include "../libutils/getopt_nolong.h"
  9. #include <assert.h>
  10. #include <errno.h>
  11. #include <limits.h>
  12. #include <stdbool.h>
  13. #include <stdio.h>  // fputs
  14. #include <stdlib.h> // exit
  15. #include <string.h> // strerror
  16. #include <unistd.h> // getopt, pathconf
  18. // need to be after system headers
  19. #include "getconf_vars.h"
  21. const char *argv0 = "getconf";
  23. static int
  24. print_system_var(const char *var)
  25. {
  26. 	for(size_t i = 0; i < (sizeof(confstr_vars) / sizeof(*confstr_vars)); i++)
  27. 	{
  28. 		if(strcmp(confstr_vars[i].name, var) != 0) continue;
  30. 		errno = 0;
  31. 		size_t buflen = confstr(confstr_vars[i].value, (char *)NULL, 0);
  32. 		if(buflen == 0)
  33. 		{
  34. 			if(errno != 0)
  35. 			{
  36. 				fprintf(stderr,
  37. 				        "getconf: error: confstr(%d /* \"%s\" */, NULL, 0): %s\n",
  38. 				        confstr_vars[i].value,
  39. 				        var,
  40. 				        strerror(errno));
  41. 				return 1;
  42. 			}
  44. 			printf("undefined\n");
  45. 			return 0;
  46. 		}
  48. 		errno = 0;
  49. 		char *buf = malloc(buflen);
  50. 		if(!buf)
  51. 		{
  52. 			fprintf(stderr,
  53. 			        "getconf: error: Failed to allocate %zd bytes buffer for confstr: %s\n",
  54. 			        buflen,
  55. 			        strerror(errno));
  56. 			return 1;
  57. 		}
  59. 		errno = 0;
  60. 		size_t ret = confstr(confstr_vars[i].value, buf, buflen);
  61. 		if(ret == 0)
  62. 		{
  63. 			if(errno != 0)
  64. 			{
  65. 				fprintf(stderr,
  66. 				        "getconf: error: confstr(%d /* \"%s\" */, buf, %zd): %s\n",
  67. 				        confstr_vars[i].value,
  68. 				        var,
  69. 				        buflen,
  70. 				        strerror(errno));
  71. 				free(buf);
  72. 				return 1;
  73. 			}
  75. 			printf("undefined\n");
  76. 			free(buf);
  77. 			return 0;
  78. 		}
  80. 		fwrite(buf, (ret - 1), 1, stdout);
  81. 		free(buf);
  82. 		return 0;
  83. 	}
  85. 	for(size_t i = 0; i < (sizeof(sysconf_vars) / sizeof(*sysconf_vars)); i++)
  86. 	{
  87. 		if(strcmp(sysconf_vars[i].name, var) != 0) continue;
  89. 		errno = 0;
  90. 		int_least64_t ret = sysconf((int)(sysconf_vars[i].value));
  91. 		if(ret == -1 && errno != 0)
  92. 		{
  93. 			fprintf(stderr,
  94. 			        "getconf: error: sysconf(%d /* \"%s\" */): %s\n",
  95. 			        sysconf_vars[i].value,
  96. 			        var,
  97. 			        strerror(errno));
  98. 			return 1;
  99. 		}
  101. 		if(ret == -1) ret = sysconf_vars[i].limit_h;
  103. 		if(ret == -1)
  104. 		{
  105. 			printf("undefined\n");
  106. 			return 0;
  107. 		}
  109. 		printf("%" PRIdLEAST64 "\n", ret);
  110. 		return 0;
  111. 	}
  113. 	for(size_t i = 0; i < (sizeof(limits_vars) / sizeof(*limits_vars)); i++)
  114. 	{
  115. 		if(strcmp(limits_vars[i].name, var) != 0) continue;
  117. 		int_least64_t ret = limits_vars[i].limit_h;
  119. 		if(ret == -1)
  120. 		{
  121. 			printf("undefined\n");
  122. 			return 0;
  123. 		}
  125. 		printf("%" PRIdLEAST64 "\n", ret);
  126. 		return 0;
  127. 	}
  129. 	for(size_t i = 0; i < (sizeof(ulimits_vars) / sizeof(*ulimits_vars)); i++)
  130. 	{
  131. 		if(strcmp(ulimits_vars[i].name, var) != 0) continue;
  133. 		unsigned long long ret = ulimits_vars[i].limit_h;
  135. 		printf("%llu\n", ret);
  136. 		return 0;
  137. 	}
  139. 	fprintf(stderr, "getconf: error: unknown system_var \"%s\"\n", var);
  140. 	return 1;
  141. }
  143. int
  144. main(int argc, char *argv[])
  145. {
  146. 	bool o_all = false;
  148. 	int c = -1;
  149. 	while((c = getopt_nolong(argc, argv, ":av:")) != -1)
  150. 	{
  151. 		switch(c)
  152. 		{
  153. 		case 'a':
  154. 			o_all = true;
  155. 			break;
  156. 		case 'v':
  157. 			fputs("getconf: -v option is unsupported\n", stderr);
  158. 			return 1;
  159. 		}
  160. 	}
  162. 	argc -= optind;
  163. 	argv += optind;
  165. 	if(!o_all && argc == 1)
  166. 	{
  167. 		return print_system_var(argv[0]);
  168. 	}
  169. 	else if(!o_all && argc == 2)
  170. 	{
  171. 		for(size_t i = 0; i < (sizeof(pathconf_vars) / sizeof(*pathconf_vars)); i++)
  172. 		{
  173. 			if(strcmp(pathconf_vars[i].name, argv[0]) != 0) continue;
  175. 			errno = 0;
  176. 			int_least64_t ret = pathconf(argv[1], (int)(pathconf_vars[i].value));
  177. 			if(ret == -1 && errno != 0)
  178. 			{
  179. 				fprintf(stderr,
  180. 				        "getconf: error: pathconf(\"%s\", %d /* \"%s\" */): %s\n",
  181. 				        argv[1],
  182. 				        pathconf_vars[i].value,
  183. 				        argv[0],
  184. 				        strerror(errno));
  185. 				return 1;
  186. 			}
  187. 			if(ret == -1) ret = pathconf_vars[i].limit_h;
  189. 			printf("%" PRIdLEAST64 "\n", ret);
  190. 			return 0;
  191. 		}
  193. 		fprintf(stderr, "getconf: error: unknown path_var \"%s\"\n", argv[0]);
  194. 		return 1;
  195. 	}
  196. 	else if(o_all && (argc == 0 || argc == 1))
  197. 	{
  198. 		int err = 0;
  199. 		char *buf = NULL;
  200. 		size_t buflen = 0;
  201. 		for(size_t i = 0; i < (sizeof(confstr_vars) / sizeof(*confstr_vars)); i++)
  202. 		{
  203. 			errno = 0;
  204. 			size_t buflen_ret = confstr(confstr_vars[i].value, (char *)NULL, 0);
  205. 			if(buflen_ret == 0)
  206. 			{
  207. 				if(errno != 0)
  208. 				{
  209. 					fprintf(stderr,
  210. 					        "getconf: error: confstr(%d /* \"%s\" */, NULL, 0): %s\n",
  211. 					        confstr_vars[i].value,
  212. 					        confstr_vars[i].name,
  213. 					        strerror(errno));
  214. 					err = 1;
  215. 					continue;
  216. 				}
  218. 				printf("%s: undefined\n", confstr_vars[i].name);
  219. 				continue;
  220. 			}
  222. 			if(buflen_ret > buflen)
  223. 			{
  224. 				errno = 0;
  225. 				char *buf_ret = realloc(buf, buflen_ret);
  226. 				if(!buf_ret)
  227. 				{
  228. 					fprintf(stderr,
  229. 					        "getconf: error: Failed to allocate %zd bytes buffer for confstr: %s\n",
  230. 					        buflen,
  231. 					        strerror(errno));
  232. 					err = 1;
  233. 					continue;
  234. 				}
  235. 				buflen = buflen_ret;
  236. 				buf = buf_ret;
  237. 			}
  239. 			errno = 0;
  240. 			size_t ret = confstr(confstr_vars[i].value, buf, buflen);
  241. 			if(ret == 0)
  242. 			{
  243. 				if(errno != 0)
  244. 				{
  245. 					fprintf(stderr,
  246. 					        "getconf: error: confstr(%d /* \"%s\" */, buf, %zd): %s\n",
  247. 					        confstr_vars[i].value,
  248. 					        confstr_vars[i].name,
  249. 					        buflen,
  250. 					        strerror(errno));
  251. 					err = 1;
  252. 					continue;
  253. 				}
  255. 				printf("%s: undefined\n", confstr_vars[i].name);
  256. 				continue;
  257. 			}
  259. 			assert(buf);
  261. 			printf("%s: ", confstr_vars[i].name);
  262. 			fwrite(buf, (ret - 1), 1, stdout);
  263. 			printf("\n");
  264. 		}
  266. 		free(buf);
  268. 		for(size_t i = 0; i < (sizeof(sysconf_vars) / sizeof(*sysconf_vars)); i++)
  269. 		{
  270. 			errno = 0;
  271. 			int_least64_t ret = sysconf((int)(sysconf_vars[i].value));
  272. 			if(ret == -1 && errno != 0)
  273. 			{
  274. 				fprintf(stderr,
  275. 				        "getconf: error: sysconf(%d /* \"%s\" */): %s\n",
  276. 				        sysconf_vars[i].value,
  277. 				        sysconf_vars[i].name,
  278. 				        strerror(errno));
  279. 				err = 1;
  280. 				continue;
  281. 			}
  283. 			if(ret == -1) ret = sysconf_vars[i].limit_h;
  285. 			if(ret == -1)
  286. 			{
  287. 				printf("%s: undefined\n", sysconf_vars[i].name);
  288. 				continue;
  289. 			}
  291. 			printf("%s: %" PRIdLEAST64 "\n", sysconf_vars[i].name, ret);
  292. 		}
  294. 		for(size_t i = 0; i < (sizeof(limits_vars) / sizeof(*limits_vars)); i++)
  295. 		{
  296. 			int_least64_t ret = limits_vars[i].limit_h;
  298. 			if(ret == -1)
  299. 			{
  300. 				printf("%s: undefined\n", limits_vars[i].name);
  301. 				continue;
  302. 			}
  304. 			printf("%s: %" PRIdLEAST64 "\n", limits_vars[i].name, ret);
  305. 		}
  307. 		for(size_t i = 0; i < (sizeof(ulimits_vars) / sizeof(*ulimits_vars)); i++)
  308. 		{
  309. 			unsigned long long ret = ulimits_vars[i].limit_h;
  311. 			printf("%s: %llu\n", ulimits_vars[i].name, ret);
  312. 		}
  314. 		const char *path = argc == 1 ? argv[0] : ".";
  315. 		for(size_t i = 0; i < (sizeof(pathconf_vars) / sizeof(*pathconf_vars)); i++)
  316. 		{
  317. 			errno = 0;
  318. 			int_least64_t ret = pathconf(path, (int)(pathconf_vars[i].value));
  319. 			if(ret == -1 && errno != 0)
  320. 			{
  321. 				fprintf(stderr,
  322. 				        "getconf: error: pathconf(\"%s\", %d /* \"%s\" */): %s\n",
  323. 				        path,
  324. 				        pathconf_vars[i].value,
  325. 				        pathconf_vars[i].name,
  326. 				        strerror(errno));
  327. 				err = 1;
  328. 				continue;
  329. 			}
  330. 			if(ret == -1) ret = pathconf_vars[i].limit_h;
  332. 			printf("%s: %" PRIdLEAST64 "\n", pathconf_vars[i].name, ret);
  333. 		}
  335. 		return err;
  336. 	}
  337. 	else
  338. 	{
  339. 		fprintf(stderr, "getconf: error: wrong number of arguments\n");
  340. 		fprintf(stderr, "\
  341. Usage: getconf <system_var>\n\
  342.        getconf <path_var> <path>\n\
  343.        getconf -a [path]\n\
  344. ");
  345. 		return 1;
  346. 	}
  347. }