logo

live-bootstrap

Mirror of <https://github.com/fosslinux/live-bootstrap>

script-generator.c (14803B)

    

  1. /*
  2.  * SPDX-FileCopyrightText: 2023 fosslinux <fosslinux@aussies.space>
  3.  *
  4.  * SPDX-License-Identifier: GPL-3.0-or-later
  5.  */
  7. #define MAX_TOKEN 64
  8. #define MAX_STRING 2048
  10. #include <bootstrappable.h>
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  15. struct Token {
  16. 	char *val;
  17. 	struct Token *next;
  18. };
  19. typedef struct Token Token;
  21. #define TYPE_BUILD 1
  22. #define TYPE_IMPROVE 2
  23. #define TYPE_DEFINE 3
  24. #define TYPE_JUMP 4
  25. #define TYPE_UNINSTALL 5
  27. struct Directive {
  28. 	Token *tok;
  29. 	struct Directive *next;
  30. 	int type;
  31. 	char *arg; /* The primary argument */
  32. };
  33. typedef struct Directive Directive;
  35. /* Tokenizer. */
  37. /* Skip over a comment. */
  38. char consume_comment(FILE *in) {
  39. 	/* Discard the rest of the line. */
  40. 	char c = fgetc(in);
  41. 	while (c != -1 && c != '\n')
  42. 		c = fgetc(in);
  43. 	return c;
  44. }
  46. char consume_line(FILE *in, Directive *directive) {
  47. 	char c = fgetc(in);
  49. 	/* Short-circuit if whole line is comment or blank line. */
  50. 	if (c == '#') {
  51. 		c = consume_comment(in);
  52. 		return c;
  53. 	} else if (c == '\n' || c == -1) {
  54. 		return c;
  55. 	}
  57. 	/* Ok, we will have something to put here. */
  58. 	directive->next = calloc(1, sizeof(Directive));
  59. 	directive = directive->next;
  61. 	Token *head = calloc(1, sizeof(Token));
  62. 	Token *cur = head;
  63. 	char *out;
  64. 	int i = 0;
  65. 	while (c != -1 && c != '\n') {
  66. 		/* Initialize next token. */
  67. 		cur->next = calloc(1, sizeof(Token));
  68. 		cur = cur->next;
  69. 		cur->val = calloc(MAX_TOKEN, sizeof(char));
  70. 		out = cur->val;
  71. 		/* Copy line to token until a space (or EOL/EOF) or comment is found. */
  72. 		while (c != -1 && c != '\n' && c != ' ' && c != '#') {
  73. 			out[0] = c;
  74. 			out += 1;
  75. 			c = fgetc(in);
  76. 		}
  77. 		/* Go to start of next token. */
  78. 		if (c == ' ') {
  79. 			c = fgetc(in);
  80. 		}
  81. 		/* Handle comment. */
  82. 		if (c == '#') {
  83. 			c = consume_comment(in);
  84. 		}
  85. 	}
  87. 	/* Add information to directive. */
  88. 	directive->tok = head->next;
  90. 	return c;
  91. }
  93. Directive *tokenizer(FILE *in) {
  94. 	Directive *head = calloc(1, sizeof(Directive));
  95. 	Directive *cur = head;
  97. 	char c;
  98. 	while (c != -1) {
  99. 		/*
  100. 		 * Note that consume_line fills cur->next, not cur.
  101. 		 * This avoids having an empty last Directive.
  102. 		 */
  103. 		c = consume_line(in, cur);
  104. 		if (cur->next != NULL) {
  105. 			cur = cur->next;
  106. 		}
  107. 	}
  108. 	return head->next;
  109. }
  111. /* Config variables. */
  113. struct Variable {
  114. 	char *name;
  115. 	char *val;
  116. 	struct Variable *next;
  117. };
  118. typedef struct Variable Variable;
  120. Variable *variables;
  122. Variable *load_config() {
  123. 	FILE *config = fopen("/steps/bootstrap.cfg", "r");
  124. 	/* File does not exist check. */
  125. 	if (config == NULL) {
  126. 		return NULL;
  127. 	}
  129. 	char *line = calloc(MAX_STRING, sizeof(char));
  130. 	Variable *head = calloc(1, sizeof(Variable));
  131. 	Variable *cur = head;
  132. 	/* For each line... */
  133. 	char *equals;
  134. 	while (fgets(line, MAX_STRING, config) != 0) {
  135. 		/* Weird M2-Planet behaviour. */
  136. 		if (*line == 0) {
  137. 			break;
  138. 		}
  139. 		cur->next = calloc(1, sizeof(Variable));
  140. 		cur = cur->next;
  141. 		/* Split on the equals. First half is name, second half is value. */
  142. 		equals = strchr(line, '=');
  143. 		if (equals == 0) {
  144. 			fputs("bootstrap.cfg should have the format var=val on each line.", stderr);
  145. 			exit(1);
  146. 		}
  147. 		cur->name = calloc(equals - line + 1, sizeof(char));
  148. 		strncpy(cur->name, line, equals - line);
  149. 		equals += 1;
  150. 		cur->val = calloc(strlen(equals), sizeof(char));
  151. 		strncpy(cur->val, equals, strlen(equals) - 1);
  152. 		line = calloc(MAX_STRING, sizeof(char));
  153. 	}
  154. 	variables = head->next;
  155. 	fclose(config);
  156. }
  158. void output_config(FILE *out) {
  159. 	Variable *variable;
  160. 	for (variable = variables; variable != NULL; variable = variable->next) {
  161. 		fputs(variable->name, out);
  162. 		fputs("=", out);
  163. 		fputs(variable->val, out);
  164. 		fputs("\n", out);
  165. 	}
  166. }
  168. char *get_var(char *name) {
  169. 	/* Search through existing variables. */
  170. 	Variable *var;
  171. 	Variable *last = NULL;
  172. 	for (var = variables; var != NULL; var = var->next) {
  173. 		if (strcmp(name, var->name) == 0) {
  174. 			return var->val;
  175. 		}
  176. 		last = var;
  177. 	}
  179. 	/* If the variable is unset, take it to be the empty string. */
  180. 	return "";
  181. }
  183. /* Recursive descent interpreter. */
  185. Token *fill(Token *tok, Directive *directive, int type) {
  186. 	directive->type = type;
  187. 	directive->arg = tok->val;
  188. 	return tok->next;
  189. }
  191. Token *logic(Token *tok, char **val) {
  192. 	/* logic = "("
  193. 	 *	 (name |
  194. 	 *	 (name "==" value) |
  195. 	 *	 (name "!=" value) |
  196. 	 *	 (logic "||" logic) |
  197. 	 *	 (logic "&&" logic))
  198. 	 *	 ")"
  199. 	 */
  201. 	char *lhs = tok->val;
  202. 	char *rhs;
  203. 	tok = tok->next;
  204. 	if (strcmp(tok->val, ")") == 0) {
  205. 		/* Case where it's just a constant. */
  206. 		*val = lhs;
  207. 		return tok;
  208. 	} else if (strcmp(tok->val, "==") == 0) {
  209. 		/* Case for equality. */
  210. 		rhs = tok->next->val;
  211. 		tok = tok->next->next;
  212. 		if (strcmp(get_var(lhs), rhs) == 0) {
  213. 			lhs = "True";
  214. 		} else {
  215. 			lhs = "False";
  216. 		}
  217. 	} else if (strcmp(tok->val, "!=") == 0) {
  218. 		/* Case for inequality. */
  219. 		rhs = tok->next->val;
  220. 		tok = tok->next->next;
  221. 		if (strcmp(get_var(lhs), rhs) == 0) {
  222. 			lhs = "False";
  223. 		} else {
  224. 			lhs = "True";
  225. 		}
  226. 	} else {
  227. 		fputs("Expected == or != after ", stderr);
  228. 		fputs(lhs, stderr);
  229. 		fputs(" in logic\n", stderr);
  230. 		exit(1);
  231. 	}
  233. 	if (strcmp(tok->val, ")") == 0) {
  234. 		*val = lhs;
  235. 		return tok;
  236. 	} else if (strcmp(tok->val, "||") == 0) {
  237. 		/* OR */
  238. 		tok = logic(tok->next, &rhs);
  239. 		if (strcmp(lhs, "True") == 0 || strcmp(rhs, "True") == 0) {
  240. 			lhs = "True";
  241. 		} else {
  242. 			lhs = "False";
  243. 		}
  244. 	} else if (strcmp(tok->val, "&&") == 0) {
  245. 		/* AND */
  246. 		tok = logic(tok->next, &rhs);
  247. 		if (strcmp(lhs, "True") == 0 && strcmp(rhs, "True") == 0) {
  248. 			lhs = "True";
  249. 		} else {
  250. 			lhs = "False";
  251. 		}
  252. 	} else {
  253. 		fputs("Expected || or && in logic\n", stderr);
  254. 		exit(1);
  255. 	}
  257. 	*val = lhs;
  258. 	return tok;
  259. }
  261. Token *primary_logic(Token *tok, char **val) {
  262. 	/* Starting ( */
  263. 	if (strcmp(tok->val, "(") != 0) {
  264. 		fputs("Expected logic to begin with (\n", stderr);
  265. 		exit(1);
  266. 	}
  267. 	tok = tok->next;
  269. 	tok = logic(tok, val);
  271. 	if (strcmp(tok->val, ")") != 0) {
  272. 		fputs("Expected logic to end with )\n", stderr);
  273. 		exit(1);
  274. 	}
  276. 	return tok;
  277. }
  279. int eval_predicate(Token *tok) {
  280. 	char *result;
  281. 	tok = primary_logic(tok, &result);
  282. 	return strcmp(result, "True") == 0;
  283. }
  285. Token *define(Token *tok, Directive *directive) {
  286. 	/* define = name "=" (logic | constant) */
  287. 	char *name = tok->val;
  288. 	tok = tok->next;
  289. 	if (strcmp(tok->val, "=") != 0) {
  290. 		fputs("define of ", stderr);
  291. 		fputs(name, stderr);
  292. 		fputs(" has a missing equals\n", stderr);
  293. 		exit(1);
  294. 	}
  295. 	tok = tok->next;
  297. 	char *val = calloc(MAX_STRING, sizeof(char));
  298. 	if (strcmp(tok->val, "(") == 0) {
  299. 		/* It is a logic. */
  300. 		tok = primary_logic(tok, &val);
  301. 	} else {
  302. 		/* It is a constant. */
  303. 		strcpy(val, tok->val);
  304. 	}
  306. 	/* Check for predicate. */
  307. 	tok = tok->next;
  308. 	if (tok != NULL) {
  309. 		if (!eval_predicate(tok)) {
  310. 			/* Nothing more to do. */
  311. 			return tok;
  312. 		}
  313. 	}
  315. 	/* Update existing variable, or else, add to the end of variables. */
  316. 	/* Special case: empty variables. */
  317. 	if (variables == NULL) {
  318. 		variables = calloc(1, sizeof(Variable));
  319. 		variables->name = name;
  320. 		variables->val = val;
  321. 	}
  323. 	Variable *var;
  324. 	for (var = variables; var->next != NULL; var = var->next) {
  325. 		if (strcmp(var->next->name, name) == 0) {
  326. 			var->next->val = val;
  327. 			break;
  328. 		}
  329. 	}
  330. 	if (var->next == NULL) {
  331. 		/* We did not update an existing variable. */
  332. 		var->next = calloc(1, sizeof(Variable));
  333. 		var->next->name = name;
  334. 		var->next->val = val;
  335. 	}
  337. 	return tok;
  338. }
  340. int interpret(Directive *directive) {
  341. 	/* directive = (build | improve | define | jump | uninstall) predicate? */
  342. 	Token *tok = directive->tok;
  343. 	if (strcmp(tok->val, "build:") == 0) {
  344. 		tok = fill(tok->next, directive, TYPE_BUILD);
  345. 	} else if (strcmp(tok->val, "improve:") == 0) {
  346. 		tok = fill(tok->next, directive, TYPE_IMPROVE);
  347. 	} else if (strcmp(tok->val, "jump:") == 0) {
  348. 		tok = fill(tok->next, directive, TYPE_JUMP);
  349. 	} else if (strcmp(tok->val, "define:") == 0) {
  350. 		tok = define(tok->next, directive);
  351. 		return 1; /* There is no codegen for a define. */
  352. 	} else if (strcmp(tok->val, "uninstall:") == 0) {
  353. 		tok = fill(tok->next, directive, TYPE_UNINSTALL);
  354. 		while (tok != NULL) {
  355. 			if (strcmp(tok->val, "(") == 0) {
  356. 				break;
  357. 			}
  358. 			if (strlen(directive->arg) + strlen(tok->val) + 1 > MAX_STRING) {
  359. 				fputs("somehow you have managed to have too many uninstall arguments.\n", stderr);
  360. 				exit(1);
  361. 			}
  362. 			directive->arg = strcat(directive->arg, " ");
  363. 			directive->arg = strcat(directive->arg, tok->val);
  364. 			tok = tok->next;
  365. 		}
  366. 	}
  368. 	if (tok != NULL) {
  369. 		return !eval_predicate(tok);
  370. 	}
  371. 	return 0;
  372. }
  374. Directive *interpreter(Directive *directives) {
  375. 	Directive *directive;
  376. 	Directive *last = NULL;
  377. 	for (directive = directives; directive != NULL; directive = directive->next) {
  378. 		if (interpret(directive)) {
  379. 			/* This means this directive needs to be removed from the linked list. */
  380. 			if (last == NULL) {
  381. 				/* First directive. */
  382. 				directives = directive->next;
  383. 			} else {
  384. 				last->next = directive->next;
  385. 			}
  386. 		} else {
  387. 			last = directive;
  388. 		}
  389. 	}
  390. 	return directives;
  391. }
  393. /* Script generator. */
  394. FILE *start_script(int id, int bash_build) {
  395. 	/* Create the file /steps/$id.sh */
  396. 	char *filename = calloc(MAX_STRING, sizeof(char));
  397. 	strcpy(filename, "/steps/");
  398. 	strcat(filename, int2str(id, 10, 0));
  399. 	strcat(filename, ".sh");
  401. 	FILE *out = fopen(filename, "w");
  402. 	if (out == NULL) {
  403. 		fputs("Error opening output file ", stderr);
  404. 		fputs(filename, stderr);
  405. 		fputs("\n", stderr);
  406. 		exit(1);
  407. 	}
  409. 	if (bash_build) {
  410. 		fputs("#!/bin/bash\n", out);
  411. 		if (strcmp(get_var("INTERACTIVE"), "True") == 0) {
  412. 			if (bash_build != 1) {
  413. 				fputs("set -E\ntrap 'env PS1=\"[TRAP] \\w # \" bash -i' ERR\n", out);
  414. 			} else {
  415. 				/* FIXME early bash has buggy ERR trap handling */
  416. 				fputs("set -e\ntrap 'bash -c '\"'\"'while true; do printf \""
  417. 				"[TRAP - use Ctrl+D] $(pwd) # \"; eval \"$(cat)\"; done'\"'\"'' EXIT\n",
  418. 				out);
  419. 			}
  420. 		} else {
  421. 			fputs("set -e\n", out);
  422. 		}
  423. 		fputs("cd /steps\n", out);
  424. 		fputs(". ./bootstrap.cfg\n", out);
  425. 		fputs(". ./env\n", out);
  426. 		fputs(". ./helpers.sh\n", out);
  427. 	} else {
  428. 		fputs("set -ex\n", out);
  429. 		fputs("cd /steps\n", out);
  430. 		output_config(out);
  431. 		FILE *env = fopen("/steps/env", "r");
  432. 		char *line = calloc(MAX_STRING, sizeof(char));
  433. 		while (fgets(line, MAX_STRING, env) != 0) {
  434. 			/* Weird M2-Planet behaviour. */
  435. 			if (*line == 0) {
  436. 				break;
  437. 			}
  438. 			fputs(line, out);
  439. 			line = calloc(MAX_STRING, sizeof(char));
  440. 		}
  441. 		fclose(env);
  442. 	}
  444. 	return out;
  445. }
  447. void output_call_script(FILE *out, char *type, char *name, int bash_build, int source) {
  448. 	if (bash_build) {
  449. 		if (source) {
  450. 			fputs(". ", out);
  451. 		} else {
  452. 			fputs("bash ", out);
  453. 		}
  454. 	} else {
  455. 		fputs("kaem --file ", out);
  456. 	}
  457. 	fputs("/steps/", out);
  458. 	if (strlen(type) != 0) {
  459. 		fputs(type, out);
  460. 		fputs("/", out);
  461. 	}
  462. 	fputs(name, out);
  463. 	fputs(".sh\n", out);
  464. }
  466. void output_build(FILE *out, Directive *directive, int pass_no, int bash_build) {
  467. 	if (bash_build) {
  468. 		fputs("build ", out);
  469. 		fputs(directive->arg, out);
  470. 		fputs(" pass", out);
  471. 		fputs(int2str(pass_no, 10, 0), out);
  472. 		fputs(".sh\n", out);
  473. 	} else {
  474. 		fputs("pkg=", out);
  475. 		fputs(directive->arg, out);
  476. 		fputs("\n", out);
  477. 		fputs("cd ${pkg}\n", out);
  478. 		fputs("kaem --file pass", out);
  479. 		fputs(int2str(pass_no, 10, 0), out);
  480. 		fputs(".kaem\n", out);
  481. 		fputs("cd ..\n", out);
  482. 	}
  483. }
  485. void generate_preseed_jump(int id) {
  486. 	FILE *out = fopen("/preseed-jump.kaem", "w");
  487. 	fputs("set -ex\n", out);
  488. 	fputs("PATH=/usr/bin\n", out);
  489. 	fputs("bash /steps/", out);
  490. 	fputs(int2str(id, 10, 0), out);
  491. 	fputs(".sh\n", out);
  492. 	fclose(out);
  493. }
  495. void generate(Directive *directives) {
  496. 	/*
  497. 	 * We are separating the stages given in the mainfest into a bunch of
  498. 	 * smaller scripts. The following conditions call for the creation of
  499. 	 * a new script:
  500. 	 * - a jump
  501. 	 * - build of bash
  502. 	 */
  504. 	int counter = 0;
  506. 	/* Initially, we use kaem, not bash. */
  507. 	int bash_build = 0;
  509. 	FILE *out = start_script(counter, bash_build);
  510. 	counter += 1;
  512. 	Directive *directive;
  513. 	Directive *past;
  514. 	char *filename;
  515. 	int pass_no;
  516. 	for (directive = directives; directive != NULL; directive = directive->next) {
  517. 		if (directive->type == TYPE_BUILD) {
  518. 			/* Get what pass number this is. */
  519. 			pass_no = 1;
  520. 			for (past = directives; past != directive; past = past->next) {
  521. 				if (strcmp(past->arg, directive->arg) == 0) {
  522. 					pass_no += 1;
  523. 				}
  524. 			}
  525. 			output_build(out, directive, pass_no, bash_build);
  526. 			if (strncmp(directive->arg, "bash-", 5) == 0) {
  527. 				if (!bash_build) {
  528. 					/*
  529. 					 * We are transitioning from bash to kaem, the point at which "early
  530. 					 * preseed" occurs. So generate the preseed jump script at this point.
  531. 					 */
  532. 					generate_preseed_jump(counter);
  533. 				}
  534. 				bash_build += 1;
  535. 				/* Create call to new script. */
  536. 				output_call_script(out, "", int2str(counter, 10, 0), bash_build, 0);
  537. 				fclose(out);
  538. 				out = start_script(counter, bash_build);
  539. 				counter += 1;
  540. 			}
  541. 		} else if (directive->type == TYPE_IMPROVE) {
  542. 			output_call_script(out, "improve", directive->arg, bash_build, 1);
  543. 		} else if (directive->type == TYPE_JUMP) {
  544. 			/*
  545. 			 * Create /init to call new script.
  546. 			 * We actually do this by creating /init.X for some number X, and then
  547. 			 * moving that to /init at the appropriate time.
  548. 			 */
  549. 			filename = calloc(MAX_STRING, sizeof(char));
  550. 			if (bash_build) {
  551. 				fputs("mv /init /init.bak\n", out);
  552. 				/* Move new init to /init. */
  553. 				strcpy(filename, "/init.");
  554. 				strcat(filename, int2str(counter, 10, 0));
  555. 				fputs("cp ", out);
  556. 				fputs(filename, out);
  557. 				fputs(" /init\n", out);
  558. 				fputs("chmod 755 /init\n", out);
  559. 			} else {
  560. 				strcpy(filename, "/kaem.run.");
  561. 				strcat(filename, int2str(counter, 10, 0));
  562. 				fputs("cp ", out);
  563. 				fputs(filename, out);
  564. 				fputs(" /kaem.run\n", out);
  565. 				fputs("cp /usr/bin/kaem /init\n", out);
  566. 				fputs("chmod 755 /init\n", out);
  567. 			}
  569. 			output_call_script(out, "jump", directive->arg, bash_build, 1);
  570. 			fclose(out);
  572. 			if (bash_build) {
  573. 				out = fopen(filename, "w");
  574. 				if (out == NULL) {
  575. 					fputs("Error opening /init\n", stderr);
  576. 					exit(1);
  577. 				}
  578. 				fputs("#!/bin/bash\n", out);
  579. 			} else {
  580. 				out = fopen(filename, "w");
  581. 				if (out == NULL) {
  582. 					fputs("Error opening /kaem.run\n", stderr);
  583. 					exit(1);
  584. 				}
  585. 				fputs("set -ex\n", out);
  586. 			}
  587. 			output_call_script(out, "", int2str(counter, 10, 0), bash_build, 0);
  588. 			fclose(out);
  589. 			out = start_script(counter, bash_build);
  590. 			counter += 1;
  591. 		} else if (directive->type == TYPE_UNINSTALL) {
  592. 			fputs("uninstall ", out);
  593. 			fputs(directive->arg, out);
  594. 			fputs("\n", out);
  595. 		}
  596. 	}
  597. 	fclose(out);
  598. }
  600. void main(int argc, char **argv) {
  601. 	if (argc != 2) {
  602. 		fputs("Usage: script-generator <script>\n", stderr);
  603. 		exit(1);
  604. 	}
  606. 	FILE *in = fopen(argv[1], "r");
  607. 	if (in == NULL) {
  608. 		fputs("Error opening input file\n", stderr);
  609. 		exit(1);
  610. 	}
  611. 	Directive *directives = tokenizer(in);
  612. 	fclose(in);
  613. 	load_config();
  614. 	directives = interpreter(directives);
  615. 	generate(directives);
  616. 	FILE *config = fopen("/steps/bootstrap.cfg", "w");
  617. 	output_config(config);
  618. 	fclose(config);
  619. }