aboutsummaryrefslogtreecommitdiff
path: root/main.c
diff options
context:
space:
mode:
authorDavid Moc <personal@cdatgoose.org>2026-11-19 02:10:24 +0100
committerDavid Moc <personal@cdatgoose.org>2026-11-19 02:10:24 +0100
commit74111495622a13104b4f6500f6dc8e9db6aec9bd (patch)
tree9695ff6f2abbb1d5f04bf9061d3ffafc248fb9f1 /main.c
Hello World!
Diffstat (limited to 'main.c')
-rw-r--r--main.c190
1 files changed, 190 insertions, 0 deletions
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..6f39821
--- /dev/null
+++ b/main.c
@@ -0,0 +1,190 @@
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "ccdjit.h"
+
+typedef struct Ops {
+ enum Way { Encrypt, Decrypt } way;
+ const char *language;
+} Ops;
+
+typedef char *(*lang_fn)(const char *);
+
+typedef struct Lang {
+ ccdjit_context *ctx;
+ ccdjit_module *module;
+ lang_fn encrypt;
+ lang_fn decrypt;
+} Lang;
+
+typedef struct Crypt {
+ Ops *options;
+ Lang *lang;
+ char *input_text;
+ char *output_text;
+} Crypt;
+
+Ops* create_ops(void);
+Lang* lang_load(const char *name);
+void lang_unload(Lang *lang);
+Crypt* create_crypt(Ops *options, Lang *lang, const char *input_text);
+int crypt_run(Crypt *crypt);
+void free_crypt(Crypt *crypt);
+
+Ops* create_ops(void) {
+ Ops *ops = malloc(sizeof(Ops));
+ if (!ops) return NULL;
+ ops->way = Encrypt;
+ ops->language = "english";
+ return ops;
+}
+
+// Only allow [a-z0-9_] so "../../etc/foo" can't escape langs/.
+static int valid_lang_name(const char *name) {
+ if (!*name) return 0;
+ for (const char *p = name; *p; p++)
+ if (!islower((unsigned char)*p) && !isdigit((unsigned char)*p) && *p != '_')
+ return 0;
+ return 1;
+}
+
+// Reads path and appends a stub main() so CCDJIT accepts it as a module.
+static char *load_plugin_source(const char *path) {
+ static const char stub[] = "\nint main(void) { return 0; }\n";
+
+ FILE *f = fopen(path, "rb");
+ if (!f) return NULL;
+
+ if (fseek(f, 0, SEEK_END) != 0) { fclose(f); return NULL; }
+ long n = ftell(f);
+ if (n < 0) { fclose(f); return NULL; }
+ rewind(f);
+
+ char *buf = malloc((size_t)n + sizeof stub);
+ if (!buf) { fclose(f); return NULL; }
+
+ if (fread(buf, 1, (size_t)n, f) != (size_t)n) {
+ free(buf);
+ fclose(f);
+ return NULL;
+ }
+ fclose(f);
+
+ memcpy(buf + n, stub, sizeof stub); // includes the NUL terminator
+ return buf;
+}
+
+Lang* lang_load(const char *name) {
+ if (!valid_lang_name(name)) {
+ fprintf(stderr, "Invalid language name: %s\n", name);
+ return NULL;
+ }
+
+ Lang *lang = calloc(1, sizeof(Lang));
+ if (!lang) return NULL;
+
+ ccdjit_options opts = {
+ .allow_filesystem_includes = 1,
+ .allow_system_includes = 1,
+ .allow_executable_memory = 1,
+ };
+ lang->ctx = ccdjit_context_new(&opts);
+ if (!lang->ctx) goto fail;
+ ccdjit_context_add_include_path(lang->ctx, "."); // finds lang.h
+
+ char path[256];
+ snprintf(path, sizeof path, "langs/%s.c", name);
+
+ char *src = load_plugin_source(path);
+ if (!src) {
+ fprintf(stderr, "Cannot read %s\n", path);
+ goto fail;
+ }
+
+ if (ccdjit_compile_string(lang->ctx, src, path, &lang->module) != 0) {
+ const ccdjit_diagnostic *d = ccdjit_context_last_error(lang->ctx);
+ fprintf(stderr, "[%s] %s:%d:%d: %s\n",
+ d->phase, d->filename, d->line, d->column, d->message);
+ free(src);
+ goto fail;
+ }
+ free(src);
+
+ lang->encrypt = (lang_fn)ccdjit_module_symbol(lang->module, "lang_encrypt");
+ lang->decrypt = (lang_fn)ccdjit_module_symbol(lang->module, "lang_decrypt");
+ if (!lang->encrypt || !lang->decrypt) {
+ fprintf(stderr, "%s must define lang_encrypt and lang_decrypt\n", path);
+ goto fail;
+ }
+ return lang;
+
+fail:
+ lang_unload(lang);
+ return NULL;
+}
+
+void lang_unload(Lang *lang) {
+ if (!lang) return;
+ if (lang->module) ccdjit_module_free(lang->module);
+ if (lang->ctx) ccdjit_context_free(lang->ctx);
+ free(lang);
+}
+
+Crypt* create_crypt(Ops *options, Lang *lang, const char *input_text) {
+ Crypt *crypt = calloc(1, sizeof(Crypt));
+ if (!crypt) return NULL;
+ crypt->options = options;
+ crypt->lang = lang;
+ crypt->input_text = strdup(input_text);
+ if (!crypt->input_text) { free(crypt); return NULL; }
+ return crypt;
+}
+
+int crypt_run(Crypt *crypt) {
+ lang_fn fn = crypt->options->way == Encrypt ? crypt->lang->encrypt
+ : crypt->lang->decrypt;
+ crypt->output_text = fn(crypt->input_text);
+ return crypt->output_text ? 0 : -1;
+}
+
+void free_crypt(Crypt *crypt) {
+ if (!crypt) return;
+ free(crypt->options);
+ lang_unload(crypt->lang);
+ free(crypt->input_text);
+ free(crypt->output_text);
+ free(crypt);
+}
+
+static void print_usage(const char *prog) {
+ fprintf(stderr, "Usage: %s [-e | -d] [-l <language>] <text>\n", prog);
+}
+
+int main(int argc, char **argv) {
+ Ops *ops = create_ops();
+ if (!ops) return EXIT_FAILURE;
+
+ const char *text = NULL;
+ for (int i = 1; i < argc; i++) {
+ if (strcmp(argv[i], "-e") == 0) ops->way = Encrypt;
+ else if (strcmp(argv[i], "-d") == 0) ops->way = Decrypt;
+ else if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) ops->language = argv[++i];
+ else if (argv[i][0] != '-' && !text) text = argv[i];
+ else { print_usage(argv[0]); free(ops); return EXIT_FAILURE; }
+ }
+ if (!text) { print_usage(argv[0]); free(ops); return EXIT_FAILURE; }
+
+ Lang *lang = lang_load(ops->language);
+ if (!lang) { free(ops); return EXIT_FAILURE; }
+
+ Crypt *crypt = create_crypt(ops, lang, text);
+ if (!crypt) { lang_unload(lang); free(ops); return EXIT_FAILURE; }
+
+ int rc = crypt_run(crypt);
+ if (rc == 0) printf("%s\n", crypt->output_text);
+ else fprintf(stderr, "Operation failed\n");
+
+ free_crypt(crypt);
+ return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+}