logo

utils-std

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

mode.c (6479B)

    

  1. // Collection of Unix tools, comparable to coreutils
  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 700 // S_ISVTX
  7. #include "mode.h"
  9. #include "bitmasks.h"
  11. #include <assert.h>
  12. #include <errno.h>
  13. #include <stdbool.h>
  14. #include <stdint.h>   // int8_t
  15. #include <stdio.h>    // strtol
  16. #include <stdlib.h>   // abort
  17. #include <string.h>   // strlen
  18. #include <sys/stat.h> // umask
  20. enum perm_who_e
  21. {
  22. 	WHO_RST = 0,   // 0b000
  23. 	WHO_USER = 1,  // 0b001
  24. 	WHO_GROUP = 2, // 0b010
  25. 	WHO_OTHER = 4, // 0b100
  26. 	WHO_ALL = 7,   // 0b111
  27. };
  29. enum operation_e
  30. {
  31. 	OP_RST,
  32. 	OP_ADD,
  33. 	OP_DEL,
  34. 	OP_SET,
  35. };
  37. struct modes
  38. {
  39. 	int8_t set;
  40. 	int8_t user;
  41. 	int8_t group;
  42. 	int8_t other;
  43. };
  45. struct modes_meta
  46. {
  47. 	enum perm_who_e dest;
  48. 	enum operation_e op;
  49. 	struct modes new_modes;
  50. };
  52. static void
  53. apply(struct modes_meta *meta, int8_t mode)
  54. {
  55. 	// get old, then reset to old. Yay to POSIX nonsense
  56. 	mode_t mask = umask(0);
  57. 	umask(mask);
  59. 	// negate to get a normal bitmask
  60. 	mask ^= 0777;
  62. 	switch(meta->op)
  63. 	{
  64. 	case OP_ADD:
  65. 		if(meta->dest == WHO_RST)
  66. 		{
  67. 			FIELD_SET(meta->new_modes.user, mode & ((mask >> 6) & 07));
  68. 			FIELD_SET(meta->new_modes.group, mode & ((mask >> 3) & 07));
  69. 			FIELD_SET(meta->new_modes.other, mode & ((mask >> 0) & 07));
  70. 		}
  71. 		if(FIELD_MATCH(meta->dest, WHO_USER)) FIELD_SET(meta->new_modes.user, mode);
  72. 		if(FIELD_MATCH(meta->dest, WHO_GROUP)) FIELD_SET(meta->new_modes.group, mode);
  73. 		if(FIELD_MATCH(meta->dest, WHO_OTHER)) FIELD_SET(meta->new_modes.other, mode);
  74. 		break;
  75. 	case OP_DEL:
  76. 		if(meta->dest == WHO_RST)
  77. 		{
  78. 			FIELD_CLR(meta->new_modes.user, mode & ((mask >> 6) & 07));
  79. 			FIELD_CLR(meta->new_modes.group, mode & ((mask >> 3) & 07));
  80. 			FIELD_CLR(meta->new_modes.other, mode & ((mask >> 0) & 07));
  81. 		}
  82. 		if(FIELD_MATCH(meta->dest, WHO_USER)) FIELD_CLR(meta->new_modes.user, mode);
  83. 		if(FIELD_MATCH(meta->dest, WHO_GROUP)) FIELD_CLR(meta->new_modes.group, mode);
  84. 		if(FIELD_MATCH(meta->dest, WHO_OTHER)) FIELD_CLR(meta->new_modes.other, mode);
  85. 		break;
  86. 	case OP_SET:
  87. 		if(meta->dest == WHO_RST)
  88. 		{
  89. 			meta->new_modes.user = mode & ((mask >> 6) & 07);
  90. 			meta->new_modes.group = mode & ((mask >> 3) & 07);
  91. 			meta->new_modes.other = mode & ((mask >> 0) & 07);
  92. 		}
  93. 		if(FIELD_MATCH(meta->dest, WHO_USER)) meta->new_modes.user = mode;
  94. 		if(FIELD_MATCH(meta->dest, WHO_GROUP)) meta->new_modes.group = mode;
  95. 		if(FIELD_MATCH(meta->dest, WHO_OTHER)) meta->new_modes.other = mode;
  97. 		// So a=rw is a=r+w rather than a=r,a=w
  98. 		meta->op = OP_ADD;
  99. 		break;
  100. 	default:
  101. 		abort();
  102. 	}
  103. }
  105. mode_t
  106. new_mode(const char *mode, mode_t old, const char **errstr)
  107. {
  108. 	// NULL? Then nothing to change :)
  109. 	if(mode == NULL) return old;
  111. 	size_t mode_len = strlen(mode);
  113. 	if(mode_len == 0) return old;
  115. 	bool symbolic = false;
  116. 	for(size_t i = 0; i < mode_len; i++)
  117. 	{
  118. 		if(mode[i] < '0' || mode[i] > '7')
  119. 		{
  120. 			if(mode[i] == '8' || mode[i] == '9')
  121. 			{
  122. 				*errstr = "contains digit outside of [0-7]";
  123. 				return old;
  124. 			}
  125. 			symbolic = true;
  126. 			break;
  127. 		}
  128. 	}
  130. 	if(!symbolic)
  131. 	{
  132. 		char *endptr = NULL;
  134. 		assert(errno == 0);
  135. 		long new = strtol(mode, &endptr, 8);
  137. 		if(errno != 0)
  138. 		{
  139. 			*errstr = strerror(errno);
  140. 			errno = 0;
  141. 			return old;
  142. 		}
  144. 		if(new < 0)
  145. 		{
  146. 			*errstr = "can't be negative";
  147. 			return old;
  148. 		}
  150. 		if(new > 07777)
  151. 		{
  152. 			*errstr = "can't be higher than 0o7777";
  153. 			return old;
  154. 		}
  156. 		return (old & 0770000) | new;
  157. 	}
  159. 	// ((^|,)[ugoa]*([+-=]|[ugo]|[rwxXst]+)+)+
  160. 	struct modes_meta meta = {.dest = WHO_RST,
  161. 	                          .op = OP_RST,
  162. 	                          .new_modes = {
  163. 	                              .set = (old & 07000) >> 9,
  164. 	                              .user = (old & 00700) >> 6,
  165. 	                              .group = (old & 00070) >> 3,
  166. 	                              .other = (old & 00007) >> 0,
  167. 	                          }};
  169. 	for(size_t i = 0; i < mode_len; i++)
  170. 	{
  171. 		char m = mode[i];
  173. 		switch(m)
  174. 		{
  175. 		// separator
  176. 		case ',':
  177. 			meta.dest = WHO_RST;
  178. 			meta.op = OP_RST;
  179. 			break;
  181. 		// who
  182. 		case 'u':
  183. 			if(meta.op == OP_RST)
  184. 				FIELD_SET(meta.dest, WHO_USER);
  185. 			else
  186. 				apply(&meta, meta.new_modes.user);
  187. 			break;
  188. 		case 'g':
  189. 			if(meta.op == OP_RST)
  190. 				FIELD_SET(meta.dest, WHO_GROUP);
  191. 			else
  192. 				apply(&meta, meta.new_modes.group);
  193. 			break;
  194. 		case 'o':
  195. 			if(meta.op == OP_RST)
  196. 				FIELD_SET(meta.dest, WHO_OTHER);
  197. 			else
  198. 				apply(&meta, meta.new_modes.other);
  199. 			break;
  200. 		case 'a':
  201. 			if(meta.op == OP_RST) FIELD_SET(meta.dest, WHO_ALL);
  202. 			// ignore =a, POSIX doesn't allows "a" in permcopy (would be a noop anyway)
  203. 			break;
  205. 		// op
  206. 		// Implementation-note: When another operator was set, override it
  207. 		case '+':
  208. 			meta.op = OP_ADD;
  209. 			break;
  210. 		case '-':
  211. 			meta.op = OP_DEL;
  212. 			break;
  213. 		case '=':
  214. 			meta.op = OP_SET;
  215. 			apply(&meta, 00);
  216. 			break;
  218. 		// perm
  219. 		case 'r':
  220. 			if(meta.op == OP_RST)
  221. 			{
  222. 				*errstr = "perm 'r' given without operator";
  223. 				return 0;
  224. 			}
  225. 			apply(&meta, 04);
  226. 			break;
  227. 		case 'w':
  228. 			if(meta.op == OP_RST)
  229. 			{
  230. 				*errstr = "perm 'w' given without operator";
  231. 				return 0;
  232. 			}
  233. 			apply(&meta, 02);
  234. 			break;
  235. 		case 'x':
  236. 			if(meta.op == OP_RST)
  237. 			{
  238. 				*errstr = "perm 'x' given without operator";
  239. 				return 0;
  240. 			}
  241. 			apply(&meta, 01);
  242. 			break;
  243. 		case 'X':
  244. 			if(meta.op == OP_RST)
  245. 			{
  246. 				*errstr = "perm 'X' given without operator";
  247. 				return 0;
  248. 			}
  249. 			if(S_ISDIR(old)) apply(&meta, 01);
  250. 			break;
  251. 		case 's':
  252. 			if(meta.op == OP_RST)
  253. 			{
  254. 				*errstr = "perm 's' given without operator";
  255. 				return 0;
  256. 			}
  257. 			if(FIELD_MATCH(meta.dest, WHO_USER))
  258. 				meta.new_modes.set = S_ISUID >> 9;
  259. 			else if(FIELD_MATCH(meta.dest, WHO_GROUP))
  260. 				meta.new_modes.set = S_ISGID >> 9;
  261. 			else
  262. 				meta.new_modes.set = S_ISUID >> 9;
  263. 			break;
  264. 		case 't':
  265. 			// Implementation defined behavior outside of directories and !(WHO_ALL|WHO_RST)
  266. 			if(meta.op == OP_RST)
  267. 			{
  268. 				*errstr = "perm 't' given without operator";
  269. 				return 0;
  270. 			}
  271. 			meta.new_modes.set = S_ISVTX >> 9;
  272. 			break;
  274. 		default:
  275. 			// Would need to either be non-thread-safe with a shared read-write buffer
  276. 			// or only allocate in this situation, meaning a memory leak.
  277. 			*errstr = "syntax error, got invalid character";
  279. 			return 0;
  280. 		}
  281. 	}
  283. 	// clang-format off
  284. 	return (old & 0770000)
  285. 	     | ((meta.new_modes.set   & 07) << 9)
  286. 	     | ((meta.new_modes.user  & 07) << 6)
  287. 	     | ((meta.new_modes.group & 07) << 3)
  288. 	     | ((meta.new_modes.other & 07) << 0);
  289. 	// clang-format on
  290. }