logo

utils-std

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

mode.c (6437B)

    

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