ipc düzenleme/temizleme.

comard/README

@@ -4,13 +4,15 @@ COMARd
 
 Modüller:
 ---------
+* main.c		Ana süreç
 * model.c		Sistem modelini yükleme/indeksleme
 * data.c		Veritabanı (acl, script, apps, model, config)
+* csl.c			CSL - Python VM yardımcıları
 * job.c			İş yapan süreçler (Register, Execute, Remove script)
 * process.c		Süreç yönetimi ve süreçler arası iletişim
 * cfg.c			Komut satırı parametreleri
 * rpc_unix.c	Unix soket üzerinden comar çağrısı modülü
-* main.c		Ana süreç
+* iksemel.c		Model dosyasını okumak için dahili minimal XML parser
 
 Kod stili:
 ----------

comard/include/data.h

@@ -24,8 +24,8 @@ int db_get_data(const char *key, char **bufferp, size_t *sizep);
 int db_put_data(const char *key, const char *buffer, size_t size);
 void db_close_storage(void);
 
-int db_get_acl(int node_no, const char *method, char **bufferp, size_t *sizep);
-int db_put_acl(int node_no, const char *method, const char *buffer, size_t size);
+int db_get_acl(int node_no, char **bufferp, size_t *sizep);
+int db_put_acl(int node_no, const char *buffer, size_t size);
 
 
 #endif /* DB_H */

comard/include/job.h

@@ -10,8 +10,9 @@
 #ifndef JOB_H
 #define JOB_H 1
 
-int job_start_register(int node_no, const char *app, const char *csl_file);
-int job_start_execute(int node_no, const char *app);
+#include "rpc.h"
+
+int job_start(int cmd, struct ipc_data *ipc_msg, size_t ipc_size);
 
 
 #endif /* JOB_H */

comard/include/process.h

@@ -35,7 +35,7 @@ void proc_init(void);
 struct ProcChild *proc_fork(void (*child_func)(void));
 int proc_listen(struct ProcChild **senderp, int *cmdp, size_t *sizep, int timeout);
 int proc_send(struct ProcChild *p, int cmd, const void *data, size_t data_size);
-int proc_recv(struct ProcChild *p, void **datap, size_t size);
+int proc_recv(struct ProcChild *p, void *datap, size_t size);
 int proc_recv_to(struct ProcChild *p, void *data, size_t size);
 
 

comard/include/rpc.h

@@ -20,17 +20,12 @@ enum {
 	CMD_CALL
 };
 
-struct reg_cmd {
+struct ipc_data {
 	int node;
 	size_t app_len;
 	char data[4];
 };
 
-struct call_cmd {
-	int node;
-	// FIXME: parameters
-};
-
 void rpc_unix_start(void);
 
 

comard/src/data.c

@@ -128,15 +128,46 @@ make_list(char *old, const char *item)
 int
 db_put_script(int node_no, const char *app, const char *buffer, size_t size)
 {
-	DB *code_db = NULL, *model_db = NULL;
+	DB *code_db = NULL, *model_db = NULL, *app_db = NULL;
 	DBT key, data;
 	char *old;
 	int e, ret = -1;
 
-	code_db = open_db("code.db");
-	if (!code_db) goto out;
+	app_db = open_db("app.db");
+	if (!app_db) goto out;
 	model_db = open_db("model.db");
 	if (!model_db) goto out;
+	code_db = open_db("code.db");
+	if (!code_db) goto out;
+
+	memset(&key, 0, sizeof(DBT));
+	memset(&data, 0, sizeof(DBT));
+	key.data = app;
+	key.size = strlen(key.data);
+	data.flags = DB_DBT_MALLOC;
+
+	e = app_db->get(app_db, NULL, &key, &data, 0);
+	if (e == DB_NOTFOUND) {
+		old = "";
+	} else if (e) {
+		goto out;
+	} else {
+		old = data.data;
+	}
+
+	if (strstr(old, make_key(node_no, NULL)) == NULL) {
+		memset(&key, 0, sizeof(DBT));
+		memset(&data, 0, sizeof(DBT));
+		key.data = app;
+		key.size = strlen(key.data);
+		data.data = make_list(old, make_key(node_no, NULL));
+		data.size = strlen(data.data) + 1;
+
+		e = app_db->put(app_db, NULL, &key, &data, 0);
+		free(data.data);
+		if (e) goto out;
+	}
+	if (strcmp(old, "") != 0) free(old);
 
 	memset(&key, 0, sizeof(DBT));
 	memset(&data, 0, sizeof(DBT));
@@ -180,15 +211,54 @@ db_put_script(int node_no, const char *app, const char *buffer, size_t size)
 
 	ret = 0;
 out:
-	if (model_db) close_db(model_db);
 	if (code_db) close_db(code_db);
+	if (model_db) close_db(model_db);
+	if (app_db) close_db(app_db);
 	return ret;
 }
 
 int
 db_del_app(const char *app)
 {
-	return -1;
+	DB *code_db = NULL, *model_db = NULL, *app_db = NULL;
+	DBT key, data;
+	char *list;
+	int e, ret = -1;
+
+	app_db = open_db("app.db");
+	if (!app_db) goto out;
+	model_db = open_db("model.db");
+	if (!model_db) goto out;
+	code_db = open_db("code.db");
+	if (!code_db) goto out;
+
+	memset(&key, 0, sizeof(DBT));
+	memset(&data, 0, sizeof(DBT));
+	key.data = app;
+	key.size = strlen(key.data);
+	data.flags = DB_DBT_MALLOC;
+
+	e = app_db->get(app_db, NULL, &key, &data, 0);
+	if (e == DB_NOTFOUND) {
+		puts("no such app");
+		goto out;
+	} else if (e) {
+		goto out;
+	} else {
+		printf("app %s registered (%s)\n", app, data.data);
+		list = data.data;
+	}
+
+//	e = 
+
+	free(list);
+
+	ret = 0;
+out:
+	if (code_db) close_db(code_db);
+	if (model_db) close_db(model_db);
+	if (app_db) close_db(app_db);
+	return ret;
 }
 
 static DB *n_code_db;

comard/src/job.c

@@ -55,26 +55,17 @@ load_file(const char *fname, int *sizeptr)
 	return data;
 }
 
-static void
-register_proc(void)
+static int
+do_register(int node, const char *app, const char *fname)
 {
-	struct reg_cmd *cmd;
-	struct ProcChild *sender;
 	char *buf;
 	char *code;
 	size_t codelen;
 	int e;
-	int c;
-	size_t size;
-
-	while (1) {
-		if (1 == proc_listen(&sender, &c, &size, 1)) break;
-	}
-	proc_recv(sender, &cmd, size);
-
+printf("Register(%d,%s,%s)\n", node, app, fname);
 	csl_setup();
 
-	buf = load_file(&cmd->data[0] + cmd->app_len + 1, NULL);
+	buf = load_file(fname, NULL);
 	if (!buf) {
 		proc_send(TO_PARENT, CMD_FAIL, NULL, 0);
 		exit(1);
@@ -86,82 +77,84 @@ register_proc(void)
 		exit(1);
 	}
 
-	db_put_script(cmd->node, &cmd->data[0], code, codelen);
+	db_put_script(node, app, code, codelen);
 
 	proc_send(TO_PARENT, CMD_RESULT, NULL, 0);
 
 	csl_cleanup();
+
+	return 0;
 }
 
-int
-job_start_register(int node_no, const char *app, const char *csl_file)
+static int
+do_remove(const char *app)
 {
-	struct ProcChild *p;
-	struct reg_cmd *cmd;
-	size_t sz;
-
-	sz = sizeof(struct reg_cmd) + strlen(app) + strlen(csl_file);
-	cmd = malloc(sz);
-	if (!cmd) return -1;
-	cmd->node = node_no;
-	cmd->app_len = strlen(app);
-	strcpy(&cmd->data[0], app);
-	strcpy(&cmd->data[0] + strlen(app) + 1, csl_file);
-	p = proc_fork(register_proc);
-	if (!p) {
-		free(cmd);
-		return -1;
-	}
-	proc_send(p, CMD_REGISTER, cmd, sz);
-	free(cmd);
-	return 0;
+printf("Remove(%s)\n", app);
+	return -1;
 }
 
-static void
-exec_proc(void)
+static int
+do_call(int node)		// FIXME: app, args
 {
-	struct ProcChild *sender;
-	struct call_cmd *cmd;
-	char *apps;
 	char *code;
 	char *res;
+	char *apps;
 	size_t reslen;
 	size_t size;
-	int c;
 	int e;
-
-	while (1) {
-		if (1 == proc_listen(&sender, &c, &size, 1)) break;
-	}
-	proc_recv(sender, &cmd, size);
-
+printf("Call(%d)\n", node);
 	csl_setup();
 
-	if (db_open_node(model_parent(cmd->node), &apps) != 0) {
+	if (db_open_node(model_parent(node), &apps) != 0) {
 		proc_send(TO_PARENT, CMD_FAIL, NULL, 0);
 		exit(1);
 	}
 
 	// FIXME: multiple apps & value return
 	db_get_code(apps, &code, &size);
-	e = csl_execute(code, size, model_get_method(cmd->node), &res, &reslen);
+	e = csl_execute(code, size, model_get_method(node), &res, &reslen);
 	free(res);
 
 	db_close_node();
 
 	csl_cleanup();
+
+	return 0;
+}
+
+static void
+job_proc(void)
+{
+	struct ProcChild *sender;
+	struct ipc_data *ipc;
+	int cmd;
+	size_t size;
+
+	while (1) {
+		if (1 == proc_listen(&sender, &cmd, &size, 1)) break;
+	}
+	proc_recv(sender, &ipc, size);
+
+	switch (cmd) {
+		case CMD_REGISTER:
+			do_register(ipc->node, &ipc->data[0], &ipc->data[0] + ipc->app_len + 1);
+			break;
+		case CMD_REMOVE:
+			do_remove(&ipc->data[0]);
+			break;
+		case CMD_CALL:
+			do_call(ipc->node);
+			break;
+	}
 }
 
 int
-job_start_execute(int node_no, const char *app) // FIXME: args
+job_start(int cmd, struct ipc_data *ipc_msg, size_t ipc_size)
 {
 	struct ProcChild *p;
-	struct call_cmd cmd;
-
-	cmd.node = node_no;
 
-	p = proc_fork(exec_proc);
+	p = proc_fork(job_proc);
 	if (!p) return -1;
-	proc_send(p, CMD_CALL, &cmd, sizeof(struct call_cmd));
+	if (proc_send(p, cmd, ipc_msg, ipc_size)) return -1;
 	return 0;
 }

comard/src/main.c

@@ -22,7 +22,7 @@ int
 main(int argc, char *argv[])
 {
 	struct ProcChild *p, *rpc;
-	struct reg_cmd *data;
+	struct ipc_data *ipc;
 	int cmd;
 	int size;
 
@@ -38,16 +38,11 @@ main(int argc, char *argv[])
 		if (1 == proc_listen(&p, &cmd, &size, 1)) {
 			switch (cmd) {
 				case CMD_REGISTER:
-					proc_recv(p, &data, size);
-					printf("Register(%d, %s, %s)\n", data->node, data->data, &data->data[0] + data->app_len + 1);
-					job_start_register(data->node, data->data, &data->data[0] + data->app_len + 1);
-					break;
 				case CMD_REMOVE:
-					break;
 				case CMD_CALL:
-					proc_recv(p, &data, size);
-					printf("Call(%d)\n", data->node);
-					job_start_execute(data->node, NULL);
+					proc_recv(p, &ipc, size);
+					job_start(cmd, ipc, size);
+					free(ipc);
 					break;
 			}
 		}

comard/src/process.c

@@ -160,11 +160,15 @@ proc_send(struct ProcChild *p, int cmd, const void *data, size_t size)
 }
 
 int
-proc_recv(struct ProcChild *p, void **datap, size_t size)
+proc_recv(struct ProcChild *p, void *datap, size_t size)
 {
-	*datap = malloc(size);
-	if (NULL == *datap) return -1;
-	if (proc_recv_to(p, *datap, size)) return -2;
+	char **datap2;
+
+	datap2 = (char **) datap;
+	*datap2 = malloc(size);
+	if (NULL == *datap2) return -1;
+	if (proc_recv_to(p, *datap2, size)) return -2;
+
 //printf("get_data(%p, %d [%.*s])\n", p, size, size, *datap);
 	return 0;
 }

comard/src/rpc_unix.c

@@ -93,10 +93,45 @@ rem_conn(struct connection *c)
 	free(c);
 }
 
+static int
+get_str(char **str, char **arg)
+{
+	char *s, *t;
+
+	s = *str;
+	if (s == NULL) return -1;
+	if (s[0] == '"') {
+		// quoted string
+		// FIXME: handle escape codes
+		++s;
+		*arg = s;
+		t = strchr(s, '"');
+		if (t) {
+			*t = '\0';
+			++t;
+			if (t[0] == ' ') ++t;
+			*str = t;
+		} else {
+			return -1;
+		}
+	} else {
+		// plain string
+		*arg = s;
+		t = strchr(s, ' ');
+		if (t) {
+			*t = '\0';
+			*str = t + 1;
+		} else {
+			*str = NULL;
+		}
+	}
+	return 0;
+}
+
 static int
 parse_rpc(struct connection *c)
 {
-	struct reg_cmd *cmd;
+	struct ipc_data *ipc;
 	size_t size;
 	char *t, *s;
 	int no;
@@ -106,36 +141,31 @@ printf("RPC [%s]\n", c->buffer);
 	switch (c->buffer[0]) {
 		case '+':
 			// register cmd, object name, app name, file name follows
-			s = strchr(t, ' ');
-			if (!s) return -1;
-			*s = '\0';
-			no = model_lookup_object(t);
+			if (get_str(&t, &s)) return -1;
+			no = model_lookup_object(s);
 			if (no == -1) return -1;
-			t = s + 1;
-			s = strchr(t, ' ');
-			if (!s) return -1;
-			*s = '\0';
-			++s;
-			size = sizeof(struct reg_cmd) + strlen(t) + strlen(s);
-			cmd = malloc(size);
-			cmd->node = no;
-			cmd->app_len = strlen(t);
-			strcpy(&cmd->data[0], t);
-			strcpy(&cmd->data[0] + strlen(t) + 1, s);
-			proc_send(TO_PARENT, CMD_REGISTER, cmd, size);
-			free(cmd);
+			if (get_str(&t, &s)) return -1;
+			size = sizeof(struct ipc_data) + strlen(t) + strlen(s);
+			ipc = malloc(size);
+			ipc->node = no;
+			ipc->app_len = strlen(s);
+			strcpy(&ipc->data[0], s);
+			strcpy(&ipc->data[0] + strlen(s) + 1, t);
+			proc_send(TO_PARENT, CMD_REGISTER, ipc, size);
+			free(ipc);
 			return 0;
 		case '-':
+			// app name
 			return 0;
 		case '$':
 			// call cmd, method name, (app name), (args)
 			no = model_lookup_method(t);
 			if (no == -1) return -1;
-			{
-				struct call_cmd cmd;
-				cmd.node = no;
-				proc_send(TO_PARENT, CMD_CALL, &cmd, sizeof(cmd));
-			}
+			size = sizeof(struct ipc_data);
+			ipc = malloc(size);
+			ipc->node = no;
+			proc_send(TO_PARENT, CMD_CALL, ipc, sizeof(size));
+			free(ipc);
 			return 0;
 		default:
 			return -1;