* Re: [ 2/9 ] [ SEMANAGE ] Restore sepol compatibility
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
@ 2005-09-30 2:52 ` Ivan Gyurdiev
2005-09-30 2:55 ` [ 3/9 ] [ SEMANAGE ] Rename files Ivan Gyurdiev
` (8 subsequent siblings)
9 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 2:52 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
[-- Attachment #1: Type: text/plain, Size: 237 bytes --]
The attached patch restores compatibility with sepol broken in the
previous patch. It also adds stddef.h in a few places. The idea here is
to keep things from breaking, not to replace typedefs in this library
(this is a later patch).
[-- Attachment #2: libsemanage.01.sepol_compat.diff --]
[-- Type: text/x-patch, Size: 3295 bytes --]
diff -Naur libsemanage/include/semanage/user_record.h libsemanage.new/include/semanage/user_record.h
--- libsemanage/include/semanage/user_record.h 2005-09-23 10:37:40.000000000 -0400
+++ libsemanage.new/include/semanage/user_record.h 2005-09-27 23:49:10.000000000 -0400
@@ -1,6 +1,8 @@
#ifndef _SEMANAGE_USER_RECORD_H_
#define _SEMANAGE_USER_RECORD_H_
+#include <stddef.h>
+
struct semanage_user;
struct semanage_user_key;
typedef struct semanage_user* semanage_user_t;
diff -Naur libsemanage/src/boolean_record.c libsemanage.new/src/boolean_record.c
--- libsemanage/src/boolean_record.c 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new/src/boolean_record.c 2005-09-29 16:48:45.000000000 -0400
@@ -1,7 +1,7 @@
#include <sepol/boolean_record.h>
-typedef sepol_bool_t semanage_bool_t;
-typedef sepol_bool_key_t semanage_bool_key_t;
+typedef sepol_bool_t* semanage_bool_t;
+typedef sepol_bool_key_t* semanage_bool_key_t;
/* Key */
int semanage_bool_key_create(const char* name, semanage_bool_key_t* key) {
diff -Naur libsemanage/src/context_record.c libsemanage.new/src/context_record.c
--- libsemanage/src/context_record.c 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new/src/context_record.c 2005-09-29 16:49:13.000000000 -0400
@@ -1,6 +1,6 @@
#include <sepol/context_record.h>
-typedef sepol_context_t semanage_context_t;
+typedef sepol_context_t* semanage_context_t;
/* User */
const char* semanage_context_get_user(semanage_context_t con) {
diff -Naur libsemanage/src/iface_record.c libsemanage.new/src/iface_record.c
--- libsemanage/src/iface_record.c 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new/src/iface_record.c 2005-09-29 16:48:32.000000000 -0400
@@ -1,8 +1,8 @@
#include <sepol/iface_record.h>
-typedef sepol_context_t semanage_context_t;
-typedef sepol_iface_t semanage_iface_t;
-typedef sepol_iface_key_t semanage_iface_key_t;
+typedef sepol_context_t* semanage_context_t;
+typedef sepol_iface_t* semanage_iface_t;
+typedef sepol_iface_key_t* semanage_iface_key_t;
/* Key */
int semanage_iface_compare(semanage_iface_t iface, semanage_iface_key_t key) {
diff -Naur libsemanage/src/port_record.c libsemanage.new/src/port_record.c
--- libsemanage/src/port_record.c 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new/src/port_record.c 2005-09-29 16:49:05.000000000 -0400
@@ -1,8 +1,8 @@
#include <sepol/port_record.h>
-typedef sepol_context_t semanage_context_t;
-typedef sepol_port_t semanage_port_t;
-typedef sepol_port_key_t semanage_port_key_t;
+typedef sepol_context_t* semanage_context_t;
+typedef sepol_port_t* semanage_port_t;
+typedef sepol_port_key_t* semanage_port_key_t;
/* Key */
int semanage_port_compare(semanage_port_t port, semanage_port_key_t key) {
diff -Naur libsemanage/src/user_record.c libsemanage.new/src/user_record.c
--- libsemanage/src/user_record.c 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new/src/user_record.c 2005-09-29 16:48:56.000000000 -0400
@@ -1,7 +1,8 @@
+#include <stddef.h>
#include <sepol/user_record.h>
-typedef sepol_user_t semanage_user_t;
-typedef sepol_user_key_t semanage_user_key_t;
+typedef sepol_user_t* semanage_user_t;
+typedef sepol_user_key_t* semanage_user_key_t;
/* Key */
int semanage_user_key_create(const char* name, semanage_user_key_t* key) {
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: [ 3/9 ] [ SEMANAGE ] Rename files
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
2005-09-30 2:52 ` [ 2/9 ] [ SEMANAGE ] Restore sepol compatibility Ivan Gyurdiev
@ 2005-09-30 2:55 ` Ivan Gyurdiev
2005-09-30 3:02 ` [ 4/9 ] [ SEMANAGE ] Database initialization Stage 1 Ivan Gyurdiev
` (7 subsequent siblings)
9 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 2:55 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
[-- Attachment #1: Type: text/plain, Size: 226 bytes --]
The attached patch renames:
record_file.h -> interfaces.h
database_file.h -> database.h
with no changes in those files (hopefully).
This reflects changes in following patches.
Also, add proper status codes to some stubs.
[-- Attachment #2: libsemanage.02.rename.diff --]
[-- Type: text/x-patch, Size: 21054 bytes --]
diff -Naur libsemanage/src/database.c libsemanage.new2/src/database.c
--- libsemanage/src/database.c 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/database.c 2005-09-29 17:08:21.000000000 -0400
@@ -0,0 +1,367 @@
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdio_ext.h>
+#include <errno.h>
+#include "debug.h"
+#include "database.h"
+#include "interfaces.h"
+#include "users_file.h"
+#include "ports_file.h"
+
+/* Representation of the database once loaded in memory */
+typedef struct cache_entry {
+ record_t data;
+ struct cache_entry* prev;
+ struct cache_entry* next;
+} cache_entry_t;
+
+/* Database-specific configuration */
+struct dbase_config {
+
+ /* What's the format of this database */
+ record_table_t* rtable;
+
+ /* Where is it stored */
+ const char* filename;
+
+ /* Once parsed, it is cached here */
+ cache_entry_t* cache;
+ size_t cache_sz;
+};
+
+static int dbase_cache_add(
+ dbase_config_t* dconfig,
+ record_t data) {
+
+ cache_entry_t* entry =
+ (cache_entry_t*) malloc(sizeof (cache_entry_t));
+ if (entry == NULL)
+ goto omem;
+ entry->data = data;
+ entry->prev = NULL;
+ entry->next = dconfig->cache;
+ if (dconfig->cache != NULL)
+ dconfig->cache->prev = entry;
+ dconfig->cache = entry;
+ dconfig->cache_sz++;
+
+ return STATUS_SUCCESS;
+ omem:
+ /* FIXME: handle error condition */
+ return STATUS_ERR;
+}
+
+static int dbase_open_file(parse_info_t* info) {
+
+ info->file_stream = fopen(info->filename, "r");
+ if (!info->file_stream && (errno != ENOENT)) {
+ /* FIXME: handle error condition */
+ return STATUS_ERR;
+ }
+ if (info->file_stream)
+ __fsetlocking(info->file_stream, FSETLOCKING_BYCALLER);
+
+ return STATUS_SUCCESS;
+}
+
+static void dbase_close_file(parse_info_t* info) {
+ if (info->file_stream && (fclose(info->file_stream) < 0))
+ /* FIXME: handle error condition */
+ info->file_stream = NULL;
+}
+
+static int dbase_cache_fill(
+ dbase_config_t* dconfig) {
+
+ /* Already cached */
+ if (dconfig->cache != NULL)
+ return STATUS_SUCCESS;
+
+ int perr_fatal = 0;
+ /* FIXME: pass from caller? */
+
+ record_t process_record = NULL;
+ int pstatus = STATUS_SUCCESS;
+ parse_info_t parse_info;
+ parse_info.filename = dconfig->filename;
+ parse_info.parse_arg = NULL;
+ /* FIXME: pass from caller? */
+
+ if (dbase_open_file(&parse_info) < 0)
+ goto err;
+
+ /* Main processing loop */
+ do {
+ /* Create record */
+ if (dconfig->rtable->create(&process_record) < 0)
+ goto err;
+
+ /* Parse record */
+ pstatus = dconfig->rtable->parse(&parse_info, process_record);
+
+ /* Parse error is fatal, exit */
+ if (perr_fatal && (pstatus < 0))
+ goto err;
+
+ /* Parse error is not fatal */
+ else if (pstatus < 0)
+ continue;
+
+ /* Add record to list */
+ if (dbase_cache_add(dconfig, process_record) < 0)
+ goto err;
+
+ } while (pstatus != STATUS_NODATA);
+
+ dbase_close_file(&parse_info);
+ return STATUS_SUCCESS;
+
+ err:
+ /* FIXME: handle failure */
+ dconfig->rtable->free(process_record);
+ dbase_close_file(&parse_info);
+ return STATUS_ERR;
+}
+
+static int dbase_cache_locate(
+ dbase_config_t* dconfig,
+ record_key_t key,
+ cache_entry_t** entry) {
+
+ cache_entry_t* ptr;
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next) {
+ if (! dconfig->rtable->compare(ptr->data, key)) {
+ *entry = ptr;
+ return STATUS_SUCCESS;
+ }
+ }
+
+ return STATUS_NODATA;
+ err:
+ /* FIXME: handle error condition */
+ return STATUS_ERR;
+}
+
+int dbase_add(
+ dbase_config_t* dconfig,
+ record_key_t key,
+ record_t data) {
+
+ int exists;
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ if (dbase_exists(dconfig, key, &exists) < 0)
+ goto err;
+
+ else if (exists) {
+ /* FIXME: handle error condition */
+ goto err;
+ }
+
+ if (dbase_cache_add(dconfig, data) < 0)
+ goto err;
+
+ return STATUS_SUCCESS;
+
+ err:
+ /* FIXME: handle error condition */
+ return STATUS_ERR;
+}
+
+int dbase_modify(
+ dbase_config_t* dconfig,
+ record_key_t key,
+ record_t data) {
+
+ cache_entry_t* entry;
+ int status;
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ status = dbase_cache_locate(dconfig, key, &entry);
+ if (status < 0)
+ goto err;
+ if (status == STATUS_NODATA)
+ return dbase_add(dconfig,key,data);
+ else
+ entry->data = data;
+
+ return STATUS_SUCCESS;
+
+ err:
+ /* FIXME: handle error condition */
+ return STATUS_ERR;
+
+}
+
+int dbase_del(
+ dbase_config_t* dconfig,
+ record_key_t key) {
+
+ cache_entry_t* entry;
+ int status;
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ status = dbase_cache_locate(dconfig, key, &entry);
+ if (status < 0)
+ goto err;
+
+ else if (status != STATUS_NODATA) {
+ if (entry->next != NULL)
+ entry->next->prev = entry->prev;
+
+ if (entry->prev != NULL)
+ entry->prev->next = entry->next;
+ else
+ dconfig->cache = entry->next;
+
+ dconfig->rtable->free(entry->data);
+ dconfig->cache_sz--;
+ free(entry);
+ }
+
+ return STATUS_SUCCESS;
+ err:
+ /* FIXME: Handle error condition */
+ return STATUS_ERR;
+}
+
+int dbase_query(
+ dbase_config_t* dconfig,
+ record_key_t key,
+ record_t* response) {
+
+ cache_entry_t* entry;
+ int status;
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ status = dbase_cache_locate(dconfig, key, &entry);
+ if (status < 0 || status == STATUS_NODATA)
+ goto err;
+
+ if (dconfig->rtable->clone(entry->data, *response) < 0)
+ goto err;
+
+ return STATUS_SUCCESS;
+ err:
+ /* FIXME: Handle error condition */
+ return STATUS_ERR;
+}
+
+int dbase_exists(
+ dbase_config_t* dconfig,
+ record_key_t key,
+ int* response) {
+
+ cache_entry_t* entry;
+ int status;
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ status = dbase_cache_locate(dconfig, key, &entry);
+ if (status < 0)
+ goto err;
+
+ *response = (status != STATUS_NODATA);
+ return STATUS_SUCCESS;
+
+ err:
+ /* FIXME: handle error condition */
+ return STATUS_ERR;
+}
+
+int dbase_count(
+ dbase_config_t* dconfig,
+ int* response) {
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ *response = dconfig->cache_sz;
+ return STATUS_SUCCESS;
+
+ err:
+ /* FIXME: Handle error condition */
+ return STATUS_ERR;
+}
+
+int dbase_iterate(
+ dbase_config_t* dconfig,
+ int (*fn) (record_t record, void* varg),
+ void* fn_arg) {
+
+ int status;
+ cache_entry_t* ptr;
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next) {
+ status = fn(ptr->data, fn_arg);
+ if (status < 0)
+ goto err;
+
+ else if (status > 0)
+ break;
+ }
+
+ return STATUS_SUCCESS;
+
+ err:
+ /* FIXME: Handle error condition */
+ return STATUS_ERR;
+}
+
+int dbase_list(
+ dbase_config_t* dconfig,
+ record_t** records,
+ size_t* count) {
+
+ cache_entry_t* ptr;
+ record_t* tmp_records = NULL;
+ size_t tmp_count;
+ int i = 0;
+
+ if (dbase_cache_fill(dconfig) < 0)
+ goto err;
+
+ tmp_count = dconfig->cache_sz;
+
+ if (tmp_count > 0) {
+ tmp_records = (record_t*) calloc(tmp_count, sizeof (record_t));
+ if (tmp_records == NULL)
+ goto omem;
+
+ for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next)
+ if (dconfig->rtable->clone(ptr->data, &tmp_records[i++]) < 0)
+ goto err;
+
+ }
+ *records = tmp_records;
+ *count = tmp_count;
+
+ return STATUS_SUCCESS;
+
+ omem:
+ /* FIXME: handle error condition */
+
+ err:
+ for (; i >= 0; i--)
+ free(tmp_records[i]);
+ free(tmp_records);
+ /* FIXME: handle error condition */
+ return STATUS_ERR;
+}
diff -Naur libsemanage/src/database_file.c libsemanage.new2/src/database_file.c
--- libsemanage/src/database_file.c 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new2/src/database_file.c 1969-12-31 19:00:00.000000000 -0500
@@ -1,367 +0,0 @@
-#include <stdlib.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdio_ext.h>
-#include <errno.h>
-#include "debug.h"
-#include "database.h"
-#include "record_file.h"
-#include "users_file.h"
-#include "ports_file.h"
-
-/* Representation of the database once loaded in memory */
-typedef struct cache_entry {
- record_t data;
- struct cache_entry* prev;
- struct cache_entry* next;
-} cache_entry_t;
-
-/* Database-specific configuration */
-struct dbase_config {
-
- /* What's the format of this database */
- record_table_t* rtable;
-
- /* Where is it stored */
- const char* filename;
-
- /* Once parsed, it is cached here */
- cache_entry_t* cache;
- size_t cache_sz;
-};
-
-static int dbase_cache_add(
- dbase_config_t* dconfig,
- record_t data) {
-
- cache_entry_t* entry =
- (cache_entry_t*) malloc(sizeof (cache_entry_t));
- if (entry == NULL)
- goto omem;
- entry->data = data;
- entry->prev = NULL;
- entry->next = dconfig->cache;
- if (dconfig->cache != NULL)
- dconfig->cache->prev = entry;
- dconfig->cache = entry;
- dconfig->cache_sz++;
-
- return STATUS_SUCCESS;
- omem:
- /* FIXME: handle error condition */
- return STATUS_ERR;
-}
-
-static int dbase_open_file(parse_info_t* info) {
-
- info->file_stream = fopen(info->filename, "r");
- if (!info->file_stream && (errno != ENOENT)) {
- /* FIXME: handle error condition */
- return STATUS_ERR;
- }
- if (info->file_stream)
- __fsetlocking(info->file_stream, FSETLOCKING_BYCALLER);
-
- return STATUS_SUCCESS;
-}
-
-static void dbase_close_file(parse_info_t* info) {
- if (info->file_stream && (fclose(info->file_stream) < 0))
- /* FIXME: handle error condition */
- info->file_stream = NULL;
-}
-
-static int dbase_cache_fill(
- dbase_config_t* dconfig) {
-
- /* Already cached */
- if (dconfig->cache != NULL)
- return STATUS_SUCCESS;
-
- int perr_fatal = 0;
- /* FIXME: pass from caller? */
-
- record_t process_record = NULL;
- int pstatus = STATUS_SUCCESS;
- parse_info_t parse_info;
- parse_info.filename = dconfig->filename;
- parse_info.parse_arg = NULL;
- /* FIXME: pass from caller? */
-
- if (dbase_open_file(&parse_info) < 0)
- goto err;
-
- /* Main processing loop */
- do {
- /* Create record */
- if (dconfig->rtable->create(&process_record) < 0)
- goto err;
-
- /* Parse record */
- pstatus = dconfig->rtable->parse(&parse_info, process_record);
-
- /* Parse error is fatal, exit */
- if (perr_fatal && (pstatus < 0))
- goto err;
-
- /* Parse error is not fatal */
- else if (pstatus < 0)
- continue;
-
- /* Add record to list */
- if (dbase_cache_add(dconfig, process_record) < 0)
- goto err;
-
- } while (pstatus != STATUS_NODATA);
-
- dbase_close_file(&parse_info);
- return STATUS_SUCCESS;
-
- err:
- /* FIXME: handle failure */
- dconfig->rtable->free(process_record);
- dbase_close_file(&parse_info);
- return STATUS_ERR;
-}
-
-static int dbase_cache_locate(
- dbase_config_t* dconfig,
- record_key_t key,
- cache_entry_t** entry) {
-
- cache_entry_t* ptr;
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next) {
- if (! dconfig->rtable->compare(ptr->data, key)) {
- *entry = ptr;
- return STATUS_SUCCESS;
- }
- }
-
- return STATUS_NODATA;
- err:
- /* FIXME: handle error condition */
- return STATUS_ERR;
-}
-
-int dbase_add(
- dbase_config_t* dconfig,
- record_key_t key,
- record_t data) {
-
- int exists;
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- if (dbase_exists(dconfig, key, &exists) < 0)
- goto err;
-
- else if (exists) {
- /* FIXME: handle error condition */
- goto err;
- }
-
- if (dbase_cache_add(dconfig, data) < 0)
- goto err;
-
- return STATUS_SUCCESS;
-
- err:
- /* FIXME: handle error condition */
- return STATUS_ERR;
-}
-
-int dbase_modify(
- dbase_config_t* dconfig,
- record_key_t key,
- record_t data) {
-
- cache_entry_t* entry;
- int status;
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- status = dbase_cache_locate(dconfig, key, &entry);
- if (status < 0)
- goto err;
- if (status == STATUS_NODATA)
- return dbase_add(dconfig,key,data);
- else
- entry->data = data;
-
- return STATUS_SUCCESS;
-
- err:
- /* FIXME: handle error condition */
- return STATUS_ERR;
-
-}
-
-int dbase_del(
- dbase_config_t* dconfig,
- record_key_t key) {
-
- cache_entry_t* entry;
- int status;
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- status = dbase_cache_locate(dconfig, key, &entry);
- if (status < 0)
- goto err;
-
- else if (status != STATUS_NODATA) {
- if (entry->next != NULL)
- entry->next->prev = entry->prev;
-
- if (entry->prev != NULL)
- entry->prev->next = entry->next;
- else
- dconfig->cache = entry->next;
-
- dconfig->rtable->free(entry->data);
- dconfig->cache_sz--;
- free(entry);
- }
-
- return STATUS_SUCCESS;
- err:
- /* FIXME: Handle error condition */
- return STATUS_ERR;
-}
-
-int dbase_query(
- dbase_config_t* dconfig,
- record_key_t key,
- record_t* response) {
-
- cache_entry_t* entry;
- int status;
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- status = dbase_cache_locate(dconfig, key, &entry);
- if (status < 0 || status == STATUS_NODATA)
- goto err;
-
- if (dconfig->rtable->clone(entry->data, *response) < 0)
- goto err;
-
- return STATUS_SUCCESS;
- err:
- /* FIXME: Handle error condition */
- return STATUS_ERR;
-}
-
-int dbase_exists(
- dbase_config_t* dconfig,
- record_key_t key,
- int* response) {
-
- cache_entry_t* entry;
- int status;
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- status = dbase_cache_locate(dconfig, key, &entry);
- if (status < 0)
- goto err;
-
- *response = (status != STATUS_NODATA);
- return STATUS_SUCCESS;
-
- err:
- /* FIXME: handle error condition */
- return STATUS_ERR;
-}
-
-int dbase_count(
- dbase_config_t* dconfig,
- int* response) {
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- *response = dconfig->cache_sz;
- return STATUS_SUCCESS;
-
- err:
- /* FIXME: Handle error condition */
- return STATUS_ERR;
-}
-
-int dbase_iterate(
- dbase_config_t* dconfig,
- int (*fn) (record_t record, void* varg),
- void* fn_arg) {
-
- int status;
- cache_entry_t* ptr;
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next) {
- status = fn(ptr->data, fn_arg);
- if (status < 0)
- goto err;
-
- else if (status > 0)
- break;
- }
-
- return STATUS_SUCCESS;
-
- err:
- /* FIXME: Handle error condition */
- return STATUS_ERR;
-}
-
-int dbase_list(
- dbase_config_t* dconfig,
- record_t** records,
- size_t* count) {
-
- cache_entry_t* ptr;
- record_t* tmp_records = NULL;
- size_t tmp_count;
- int i = 0;
-
- if (dbase_cache_fill(dconfig) < 0)
- goto err;
-
- tmp_count = dconfig->cache_sz;
-
- if (tmp_count > 0) {
- tmp_records = (record_t*) calloc(tmp_count, sizeof (record_t));
- if (tmp_records == NULL)
- goto omem;
-
- for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next)
- if (dconfig->rtable->clone(ptr->data, &tmp_records[i++]) < 0)
- goto err;
-
- }
- *records = tmp_records;
- *count = tmp_count;
-
- return STATUS_SUCCESS;
-
- omem:
- /* FIXME: handle error condition */
-
- err:
- for (; i >= 0; i--)
- free(tmp_records[i]);
- free(tmp_records);
- /* FIXME: handle error condition */
- return STATUS_ERR;
-}
diff -Naur libsemanage/src/interfaces.h libsemanage.new2/src/interfaces.h
--- libsemanage/src/interfaces.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/interfaces.h 2005-09-23 10:38:06.000000000 -0400
@@ -0,0 +1,57 @@
+#ifndef _SEMANAGE_RECORD_FILE_H_
+#define _SEMANAGE_RECORD_FILE_H_
+
+#include <stdio.h>
+
+#ifndef RECORD_DEFINED
+typedef void* record_t;
+typedef void* record_key_t;
+#define RECORD_DEFINED
+#endif
+
+/* Structure available during parsing (created internally) */
+typedef struct parse_info {
+ /* Parser controlled */
+ /* Stub */
+
+ /* Engine-controlled */
+ const char* filename; /* Input stream file name */
+ FILE* file_stream; /* Input stream handle */
+
+ /* Caller supplied */
+ void* parse_arg;
+} parse_info_t;
+
+/* Record table format - necessary during processing */
+typedef struct record_table {
+
+ /* Create a record */
+ int (*create) (record_t* rec);
+
+ /* Extract key from record */
+ int (*key_extract) (record_t rec, record_key_t* key);
+
+ /* Free record key */
+ void (*key_free) (record_key_t key);
+
+ /* Return 0 if record can be matched against key,
+ * and 1 otherwise */
+ int (*compare) (record_t rec, record_key_t key);
+
+ /* Deep-copy clone of this record */
+ int (*clone) (record_t rec, record_t* new_rec);
+
+ /* Fill record structuure based on supplied parse info.
+ * Parser must return STATUS_NODATA when EOF is encountered.
+ * Parser must handle NULL file stream correctly */
+ int (*parse) (parse_info_t* info, record_t record);
+
+ /* Print record to stream */
+ int (*print) (record_t record, FILE* str);
+
+ /* Deallocate record resources. Must
+ * sucessfully handle NULL. */
+ void (*free) (record_t rec);
+} record_table_t;
+
+#endif
diff -Naur libsemanage/src/ports_file.c libsemanage.new2/src/ports_file.c
--- libsemanage/src/ports_file.c 2005-09-14 11:44:44.000000000 -0400
+++ libsemanage.new2/src/ports_file.c 2005-09-29 17:07:03.000000000 -0400
@@ -1,11 +1,14 @@
-#include <stdlib.h>
-#include <stdio.h>
#include <semanage/port_record.h>
typedef semanage_port_t record_t;
typedef semanage_port_key_t record_key_t;
#define RECORD_DEFINED
-#include "record_file.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <semanage/port_record.h>
+#include "debug.h"
+#include "interfaces.h"
static int semanage_port_print(
semanage_port_t port,
@@ -14,7 +17,7 @@
/* Stub */
port = NULL;
str = NULL;
- return -1;
+ return STATUS_SUCCESS;
}
static int semanage_port_parse(
@@ -24,7 +27,7 @@
/* Stub */
info = NULL;
port = NULL;
- return -1;
+ return STATUS_SUCCESS;
}
record_table_t RTABLE_PORT = {
diff -Naur libsemanage/src/ports_file.h libsemanage.new2/src/ports_file.h
--- libsemanage/src/ports_file.h 2005-09-14 11:44:44.000000000 -0400
+++ libsemanage.new2/src/ports_file.h 2005-09-29 17:07:13.000000000 -0400
@@ -1,7 +1,7 @@
#ifndef _SEMANAGE_PORTS_FILE_H_
#define _SEMANAGE_PORTS_FILE_H_
-#include "record_file.h"
+#include "interfaces.h"
extern record_table_t RTABLE_PORT;
diff -Naur libsemanage/src/record_file.h libsemanage.new2/src/record_file.h
--- libsemanage/src/record_file.h 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new2/src/record_file.h 1969-12-31 19:00:00.000000000 -0500
@@ -1,57 +0,0 @@
-#ifndef _SEMANAGE_RECORD_FILE_H_
-#define _SEMANAGE_RECORD_FILE_H_
-
-#include <stdio.h>
-
-#ifndef RECORD_DEFINED
-typedef void* record_t;
-typedef void* record_key_t;
-#define RECORD_DEFINED
-#endif
-
-/* Structure available during parsing (created internally) */
-typedef struct parse_info {
- /* Parser controlled */
- /* Stub */
-
- /* Engine-controlled */
- const char* filename; /* Input stream file name */
- FILE* file_stream; /* Input stream handle */
-
- /* Caller supplied */
- void* parse_arg;
-} parse_info_t;
-
-/* Record table format - necessary during processing */
-typedef struct record_table {
-
- /* Create a record */
- int (*create) (record_t* rec);
-
- /* Extract key from record */
- int (*key_extract) (record_t rec, record_key_t* key);
-
- /* Free record key */
- void (*key_free) (record_key_t key);
-
- /* Return 0 if record can be matched against key,
- * and 1 otherwise */
- int (*compare) (record_t rec, record_key_t key);
-
- /* Deep-copy clone of this record */
- int (*clone) (record_t rec, record_t* new_rec);
-
- /* Fill record structuure based on supplied parse info.
- * Parser must return STATUS_NODATA when EOF is encountered.
- * Parser must handle NULL file stream correctly */
- int (*parse) (parse_info_t* info, record_t record);
-
- /* Print record to stream */
- int (*print) (record_t record, FILE* str);
-
- /* Deallocate record resources. Must
- * sucessfully handle NULL. */
- void (*free) (record_t rec);
-} record_table_t;
-
-#endif
diff -Naur libsemanage/src/users_file.c libsemanage.new2/src/users_file.c
--- libsemanage/src/users_file.c 2005-09-14 11:44:44.000000000 -0400
+++ libsemanage.new2/src/users_file.c 2005-09-29 17:07:53.000000000 -0400
@@ -1,11 +1,13 @@
-#include <stdlib.h>
-#include <stdio.h>
#include <semanage/user_record.h>
typedef semanage_user_t record_t;
typedef semanage_user_key_t record_key_t;
#define RECORD_DEFINED
-#include "record_file.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "interfaces.h"
+#include "debug.h"
static int semanage_user_print(
semanage_user_t user,
@@ -14,7 +16,7 @@
/* Stub */
user = NULL;
str = NULL;
- return -1;
+ return STATUS_SUCCESS;
}
static int semanage_user_parse(
@@ -24,7 +26,7 @@
/* Stub */
info = NULL;
user = NULL;
- return -1;
+ return STATUS_SUCCESS;
}
record_table_t RTABLE_USER = {
diff -Naur libsemanage/src/users_file.h libsemanage.new2/src/users_file.h
--- libsemanage/src/users_file.h 2005-09-14 11:44:44.000000000 -0400
+++ libsemanage.new2/src/users_file.h 2005-09-29 17:08:00.000000000 -0400
@@ -1,7 +1,7 @@
#ifndef _SEMANAGE_USERS_FILE_H_
#define _SEMANAGE_USERS_FILE_H_
-#include "record_file.h"
+#include "interfaces.h"
extern record_table_t RTABLE_USER;
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: [ 4/9 ] [ SEMANAGE ] Database initialization Stage 1
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
2005-09-30 2:52 ` [ 2/9 ] [ SEMANAGE ] Restore sepol compatibility Ivan Gyurdiev
2005-09-30 2:55 ` [ 3/9 ] [ SEMANAGE ] Rename files Ivan Gyurdiev
@ 2005-09-30 3:02 ` Ivan Gyurdiev
2005-09-30 18:42 ` Ivan Gyurdiev
2005-09-30 3:04 ` [ 5/9 ] [ SEMANAGE ] Change database to singly-linked list Ivan Gyurdiev
` (6 subsequent siblings)
9 siblings, 1 reply; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 3:02 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
[-- Attachment #1: Type: text/plain, Size: 375 bytes --]
The attached patch breaks up semanage.h/semanage_private.h into
modules.h, handle.h, debug.h. It moves the debug function into debug.c.
It adds functions to intialize and release database resources, and uses
those to add USER and PORT file databases to the handle.
Also, rename some variables and datatypes. Fix caching. Add functions to
flush and invalidate the cache.
[-- Attachment #2: libsemanage.03.dbase_init1.diff --]
[-- Type: text/x-patch, Size: 31913 bytes --]
diff -Naur libsemanage/src/database.c libsemanage.new2/src/database.c
--- libsemanage/src/database.c 2005-09-29 17:08:21.000000000 -0400
+++ libsemanage.new2/src/database.c 2005-09-29 17:52:42.000000000 -0400
@@ -17,7 +17,7 @@
} cache_entry_t;
/* Database-specific configuration */
-struct dbase_config {
+struct dbase {
/* What's the format of this database */
record_table_t* rtable;
@@ -28,10 +28,69 @@
/* Once parsed, it is cached here */
cache_entry_t* cache;
size_t cache_sz;
+ int cached;
+ int cache_invalid;
};
+/* Initialize a database */
+int dbase_init(
+ record_table_t* rtable,
+ const char* filename,
+ dbase_t** dbase) {
+
+ dbase_t* tmp_dbase =
+ (dbase_t*) malloc(sizeof(dbase_t));
+
+ if (tmp_dbase == NULL)
+ goto omem;
+
+ tmp_dbase->rtable = rtable;
+ tmp_dbase->filename = filename;
+ tmp_dbase->cache = NULL;
+ tmp_dbase->cache_sz = 0;
+ tmp_dbase->cached = 0;
+ tmp_dbase->cache_invalid = 0;
+
+ *dbase = tmp_dbase;
+ return STATUS_SUCCESS;
+
+ omem:
+ /* FIXME: handle error codntion */
+ free(tmp_dbase);
+ return STATUS_ERR;
+}
+
+/* Release a database */
+void dbase_release(
+ dbase_t* dbase) {
+
+ cache_entry_t *prev, *ptr;
+ while (ptr != NULL) {
+ prev = ptr;
+ ptr = ptr->next;
+ dbase->rtable->free(prev->data);
+ free(prev);
+ }
+}
+
+/* Invalidate database cache */
+void dbase_invalidate_cache(
+ dbase_t* dbase) {
+
+ dbase->cache_invalid = 1;
+}
+
+/* Flush the database cache */
+int dbase_flush(
+ dbase_t* dbase) {
+
+ /* Stub */
+ dbase = NULL;
+ return STATUS_SUCCESS;
+}
+
static int dbase_cache_add(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_t data) {
cache_entry_t* entry =
@@ -40,11 +99,11 @@
goto omem;
entry->data = data;
entry->prev = NULL;
- entry->next = dconfig->cache;
- if (dconfig->cache != NULL)
- dconfig->cache->prev = entry;
- dconfig->cache = entry;
- dconfig->cache_sz++;
+ entry->next = dbase->cache;
+ if (dbase->cache != NULL)
+ dbase->cache->prev = entry;
+ dbase->cache = entry;
+ dbase->cache_sz++;
return STATUS_SUCCESS;
omem:
@@ -72,10 +131,10 @@
}
static int dbase_cache_fill(
- dbase_config_t* dconfig) {
+ dbase_t* dbase) {
/* Already cached */
- if (dconfig->cache != NULL)
+ if (dbase->cached && (!dbase->cache_invalid))
return STATUS_SUCCESS;
int perr_fatal = 0;
@@ -84,7 +143,7 @@
record_t process_record = NULL;
int pstatus = STATUS_SUCCESS;
parse_info_t parse_info;
- parse_info.filename = dconfig->filename;
+ parse_info.filename = dbase->filename;
parse_info.parse_arg = NULL;
/* FIXME: pass from caller? */
@@ -94,11 +153,11 @@
/* Main processing loop */
do {
/* Create record */
- if (dconfig->rtable->create(&process_record) < 0)
+ if (dbase->rtable->create(&process_record) < 0)
goto err;
/* Parse record */
- pstatus = dconfig->rtable->parse(&parse_info, process_record);
+ pstatus = dbase->rtable->parse(&parse_info, process_record);
/* Parse error is fatal, exit */
if (perr_fatal && (pstatus < 0))
@@ -109,33 +168,35 @@
continue;
/* Add record to list */
- if (dbase_cache_add(dconfig, process_record) < 0)
+ if (dbase_cache_add(dbase, process_record) < 0)
goto err;
} while (pstatus != STATUS_NODATA);
dbase_close_file(&parse_info);
+ dbase->cached = 1;
+ dbase->cache_invalid = 0;
return STATUS_SUCCESS;
err:
/* FIXME: handle failure */
- dconfig->rtable->free(process_record);
+ dbase->rtable->free(process_record);
dbase_close_file(&parse_info);
return STATUS_ERR;
}
static int dbase_cache_locate(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
cache_entry_t** entry) {
cache_entry_t* ptr;
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next) {
- if (! dconfig->rtable->compare(ptr->data, key)) {
+ for (ptr = dbase->cache; ptr != NULL; ptr = ptr->next) {
+ if (! dbase->rtable->compare(ptr->data, key)) {
*entry = ptr;
return STATUS_SUCCESS;
}
@@ -148,16 +209,16 @@
}
int dbase_add(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
record_t data) {
int exists;
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- if (dbase_exists(dconfig, key, &exists) < 0)
+ if (dbase_exists(dbase, key, &exists) < 0)
goto err;
else if (exists) {
@@ -165,7 +226,7 @@
goto err;
}
- if (dbase_cache_add(dconfig, data) < 0)
+ if (dbase_cache_add(dbase, data) < 0)
goto err;
return STATUS_SUCCESS;
@@ -176,21 +237,21 @@
}
int dbase_modify(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
record_t data) {
cache_entry_t* entry;
int status;
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- status = dbase_cache_locate(dconfig, key, &entry);
+ status = dbase_cache_locate(dbase, key, &entry);
if (status < 0)
goto err;
if (status == STATUS_NODATA)
- return dbase_add(dconfig,key,data);
+ return dbase_add(dbase,key,data);
else
entry->data = data;
@@ -203,16 +264,16 @@
}
int dbase_del(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key) {
cache_entry_t* entry;
int status;
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- status = dbase_cache_locate(dconfig, key, &entry);
+ status = dbase_cache_locate(dbase, key, &entry);
if (status < 0)
goto err;
@@ -223,10 +284,10 @@
if (entry->prev != NULL)
entry->prev->next = entry->next;
else
- dconfig->cache = entry->next;
+ dbase->cache = entry->next;
- dconfig->rtable->free(entry->data);
- dconfig->cache_sz--;
+ dbase->rtable->free(entry->data);
+ dbase->cache_sz--;
free(entry);
}
@@ -237,21 +298,21 @@
}
int dbase_query(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
record_t* response) {
cache_entry_t* entry;
int status;
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- status = dbase_cache_locate(dconfig, key, &entry);
+ status = dbase_cache_locate(dbase, key, &entry);
if (status < 0 || status == STATUS_NODATA)
goto err;
- if (dconfig->rtable->clone(entry->data, *response) < 0)
+ if (dbase->rtable->clone(entry->data, *response) < 0)
goto err;
return STATUS_SUCCESS;
@@ -261,17 +322,17 @@
}
int dbase_exists(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
int* response) {
cache_entry_t* entry;
int status;
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- status = dbase_cache_locate(dconfig, key, &entry);
+ status = dbase_cache_locate(dbase, key, &entry);
if (status < 0)
goto err;
@@ -284,13 +345,13 @@
}
int dbase_count(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
int* response) {
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- *response = dconfig->cache_sz;
+ *response = dbase->cache_sz;
return STATUS_SUCCESS;
err:
@@ -299,17 +360,17 @@
}
int dbase_iterate(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
int (*fn) (record_t record, void* varg),
void* fn_arg) {
int status;
cache_entry_t* ptr;
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next) {
+ for (ptr = dbase->cache; ptr != NULL; ptr = ptr->next) {
status = fn(ptr->data, fn_arg);
if (status < 0)
goto err;
@@ -326,7 +387,7 @@
}
int dbase_list(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_t** records,
size_t* count) {
@@ -335,18 +396,18 @@
size_t tmp_count;
int i = 0;
- if (dbase_cache_fill(dconfig) < 0)
+ if (dbase_cache_fill(dbase) < 0)
goto err;
- tmp_count = dconfig->cache_sz;
+ tmp_count = dbase->cache_sz;
if (tmp_count > 0) {
tmp_records = (record_t*) calloc(tmp_count, sizeof (record_t));
if (tmp_records == NULL)
goto omem;
- for (ptr = dconfig->cache; ptr != NULL; ptr = ptr->next)
- if (dconfig->rtable->clone(ptr->data, &tmp_records[i++]) < 0)
+ for (ptr = dbase->cache; ptr != NULL; ptr = ptr->next)
+ if (dbase->rtable->clone(ptr->data, &tmp_records[i++]) < 0)
goto err;
}
diff -Naur libsemanage/src/database.h libsemanage.new2/src/database.h
--- libsemanage/src/database.h 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new2/src/database.h 2005-09-29 17:53:26.000000000 -0400
@@ -1,53 +1,72 @@
#ifndef _SEMANAGE_DATABASE_H_
#define _SEMANAGE_DATABASE_H_
-#include <stddef.h>
-
#ifndef RECORD_DEFINED
typedef void* record_t;
typedef void* record_key_t;
#define RECORD_DEFINED
#endif
-struct dbase_config;
-typedef struct dbase_config dbase_config_t;
+#include <stddef.h>
+#include "interfaces.h"
+
+struct dbase;
+typedef struct dbase dbase_t;
+
+/* Initialize a database */
+extern int dbase_init(
+ record_table_t* rtable,
+ const char* filename,
+ dbase_t** dbase);
+
+/* Release a database */
+extern void dbase_release(
+ dbase_t* dbase);
+
+/* Flush a database to disk */
+extern int dbase_flush(
+ dbase_t* dbase);
+
+/* Invalidate the database cache */
+extern void dbase_invalidate_cache(
+ dbase_t* dbase);
extern int dbase_add(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
record_t data);
extern int dbase_modify(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
record_t data);
extern int dbase_del(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key);
extern int dbase_query(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
record_t* response);
extern int dbase_exists(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_key_t key,
int* response);
extern int dbase_count(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
int* response);
extern int dbase_iterate(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
int (*fn) (record_t record,
void* varg),
void* fn_arg);
extern int dbase_list(
- dbase_config_t* dconfig,
+ dbase_t* dbase,
record_t** records,
size_t* count);
diff -Naur libsemanage/src/debug.c libsemanage.new2/src/debug.c
--- libsemanage/src/debug.c 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/debug.c 2005-09-29 17:23:34.000000000 -0400
@@ -0,0 +1,38 @@
+/* Author: Joshua Brindle <jbrindle@tresys.co
+ * Jason Tang <jtang@tresys.com>
+ *
+ * Copyright (C) 2004-2005 Tresys Technology, LLC
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "handle.h"
+#include "debug.h"
+
+/* FIXME: redesign with callbacks ? */
+
+/* Write an error message to the current error buffer, up to the
+ * buffer's specified size. */
+#ifdef __GNUC__
+__attribute__ ((format (printf, 2, 3)))
+#endif
+void semanage_write_error(semanage_handle_t *sh, char *fmt, ...) {
+ va_list ap;
+ va_start(ap, fmt);
+ vsnprintf(sh->err_buf, SEMANAGE_ERRBUFSZ, fmt, ap);
+ va_end(ap);
+}
diff -Naur libsemanage/src/debug.h libsemanage.new2/src/debug.h
--- libsemanage/src/debug.h 2005-09-21 10:42:25.000000000 -0400
+++ libsemanage.new2/src/debug.h 2005-09-29 17:23:34.000000000 -0400
@@ -1,10 +1,39 @@
+/* Author: Joshua Brindle <jbrindle@tresys.com>
+ * Jason Tang <jtang@tresys.com>
+ * Ivan Gyurdiev <ivg2@cornell.edu>
+ *
+ * Copyright (C) 2005 Tresys Technology, LLC
+ * Copyright (C) 2005 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
#ifndef _SEPOL_INTERNAL_DEBUG_H_
#define _SEPOL_INTERNAL_DEBUG_H_
+#include "handle.h"
+
#define STATUS_SUCCESS 0
#define STATUS_ERR -1
#define STATUS_NODATA 1
-/* Define debug system in this header */
+/* FIXME: redesign with level argument ? */
+
+#ifdef __GNUC__
+__attribute__ ((format (printf, 2, 3)))
+#endif
+extern void semanage_write_error(semanage_handle_t *sh, char *fmt, ...);
#endif
diff -Naur libsemanage/src/direct_api.c libsemanage.new2/src/direct_api.c
--- libsemanage/src/direct_api.c 2005-09-28 15:56:00.000000000 -0400
+++ libsemanage.new2/src/direct_api.c 2005-09-29 17:23:34.000000000 -0400
@@ -17,10 +17,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include "semanage_private.h"
-#include "direct_api.h"
-#include "semanage_store.h"
-
#include <sepol/module.h>
#include <assert.h>
@@ -30,6 +26,12 @@
#include <sys/stat.h>
#include <sys/types.h>
+#include "debug.h"
+#include "handle.h"
+#include "modules.h"
+#include "direct_api.h"
+#include "semanage_store.h"
+
static void semanage_direct_destroy(semanage_handle_t *sh);
static int semanage_direct_disconnect(semanage_handle_t *sh);
static int semanage_direct_begintrans(semanage_handle_t *sh);
@@ -68,11 +70,15 @@
/* set up function pointers */
sh->funcs = &direct_funcs;
+
+ /* FIXME: configure policy query databases */
+
return 0;
}
static void semanage_direct_destroy(semanage_handle_t *sh) {
/* do nothing */
+ sh = NULL;
}
static int semanage_direct_disconnect(semanage_handle_t *sh) {
@@ -85,6 +91,9 @@
}
semanage_release_trans_lock(sh);
}
+
+ /* FIXME: release policy query databases */
+
return 0;
}
@@ -233,6 +242,8 @@
goto cleanup;
}
+ /* FIXME: write object databases into base */
+
/* write the linked base */
if ((linked_filename = semanage_path(SEMANAGE_TMP, SEMANAGE_LINKED)) == NULL ||
semanage_write_module(sh, linked_filename, base, POLICY_BASE) == -1 ||
diff -Naur libsemanage/src/direct_api.h libsemanage.new2/src/direct_api.h
--- libsemanage/src/direct_api.h 2005-09-28 15:56:00.000000000 -0400
+++ libsemanage.new2/src/direct_api.h 2005-09-29 17:23:34.000000000 -0400
@@ -20,7 +20,7 @@
#ifndef SEMANAGE_DIRECT_API_H
#define SEMANAGE_DIRECT_API_H
-#include "semanage_private.h"
+#include "handle.h"
int semanage_direct_connect(semanage_handle_t *sh);
diff -Naur libsemanage/src/handle.c libsemanage.new2/src/handle.c
--- libsemanage/src/handle.c 2005-09-28 15:56:00.000000000 -0400
+++ libsemanage.new2/src/handle.c 2005-09-29 17:23:34.000000000 -0400
@@ -21,10 +21,6 @@
/* This file implements only the publicly-visible handle functions to libsemanage. */
#include <semanage/semanage.h>
-#include "semanage_private.h"
-#include "direct_api.h"
-#include "semanage_conf.h"
-#include "semanage_store.h"
#include <selinux/selinux.h>
#include <stdarg.h>
@@ -33,35 +29,59 @@
#include <stdio.h>
#include <sys/time.h>
+#include "handle.h"
+#include "debug.h"
+#include "direct_api.h"
+#include "semanage_conf.h"
+#include "semanage_store.h"
+#include "users_file.h"
+#include "ports_file.h"
+#include "database.h"
+
#define SEMANAGE_COMMIT_READ_WAIT 5
semanage_handle_t *semanage_handle_create(void) {
- semanage_handle_t *sh;
- const char *conf_name;
+ semanage_handle_t *sh;
+ const char *conf_name;
+
+ /* Allocate handle */
+ if ((sh = calloc(1, sizeof(*sh))) == NULL)
+ goto omem;
+
+ /* Policy root */
+ const char *pr = selinux_policy_root();
+ if (!pr)
+ goto err;
+
+ if (semanage_check_init(pr))
+ goto err;
+
+ /* Config */
+ if ((conf_name = semanage_conf_path()) == NULL)
+ goto err;
+
+ if ((sh->conf = semanage_conf_parse(conf_name)) == NULL)
+ goto err;
+
+ /* Set timeout: some default value for now, later use config */
+ sh->timeout = SEMANAGE_COMMIT_READ_WAIT;
+
+ /* Configure object databases
+ * Hardcore DATA FILE backend for now */
+ if (user_file_dbase_init(&sh->dbase[DBASE_USERS]) < 0)
+ goto err;
+
+ if (port_file_dbase_init(&sh->dbase[DBASE_PORTS]) < 0)
+ goto err;
- /* Get the selinux policy root and pass to the path init function */
- const char *pr = selinux_policy_root();
- if (!pr)
- return NULL;
-
- if (semanage_check_init(pr))
- return NULL;
-
- if ((conf_name = semanage_conf_path()) == NULL) {
- goto cleanup;
- }
- if ((sh = calloc(1, sizeof(*sh))) == NULL) {
- return NULL;
- }
- if ((sh->conf = semanage_conf_parse(conf_name)) == NULL) {
- goto cleanup;
- }
- sh->timeout = SEMANAGE_COMMIT_READ_WAIT; /* some default value for now, later use config */
return sh;
- cleanup:
- semanage_handle_destroy(sh);
- return NULL;
+ omem:
+ /* FIXME: report error condition */
+ err:
+ /* FIXME: report error condition */
+ semanage_handle_destroy(sh);
+ return NULL;
}
int semanage_connect(semanage_handle_t *sh) {
@@ -96,13 +116,18 @@
}
void semanage_handle_destroy(semanage_handle_t *sh) {
- if (sh != NULL) {
- if (sh->funcs != NULL && sh->funcs->destroy != NULL) {
- sh->funcs->destroy(sh);
- }
- semanage_conf_destroy(sh->conf);
- free(sh);
- }
+ if (sh == NULL)
+ return;
+
+ if (sh->funcs != NULL && sh->funcs->destroy != NULL)
+ sh->funcs->destroy(sh);
+ semanage_conf_destroy(sh->conf);
+
+ /* Free object databases */
+ dbase_release(sh->dbase[DBASE_USERS]);
+ dbase_release(sh->dbase[DBASE_PORTS]);
+
+ free(sh);
}
const char *semanage_strerror(semanage_handle_t *sh) {
diff -Naur libsemanage/src/handle.h libsemanage.new2/src/handle.h
--- libsemanage/src/handle.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/handle.h 2005-09-29 17:53:04.000000000 -0400
@@ -0,0 +1,95 @@
+/* Author: Joshua Brindle <jbrindle@tresys.com>
+ * Jason Tang <jtang@tresys.com>
+ * Ivan Gyurdiev <ivg2@cornell.edu>
+ *
+ * Copyright (C) 2005 Tresys Technology, LLC
+ * Copyright (C) 2005 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _SEMANAGE_INTERNAL_HANDLE_H_
+#define _SEMANAGE_INTERNAL_HANDLE_H_
+
+#include <stddef.h>
+#include <semanage/handle.h>
+#include "modules.h"
+#include "semanage_conf.h"
+
+/* Can't include - circular dependency */
+struct dbase;
+
+/* FIXME: Some of this needs to go into modules.h */
+struct semanage_func_table {
+ void (*destroy)(semanage_handle_t *);
+ int (*disconnect)(semanage_handle_t *);
+ int (*begin_trans)(semanage_handle_t *);
+ int (*commit)(semanage_handle_t *);
+ int (*install)(semanage_handle_t *, char *, size_t);
+ int (*upgrade)(semanage_handle_t *, char *, size_t);
+ int (*install_base)(semanage_handle_t *, char *, size_t);
+ int (*remove)(semanage_handle_t *, char *);
+ int (*list)(semanage_handle_t *, semanage_module_info_t **, int *);
+};
+
+struct semanage_handle {
+ int con_id; /* Connection ID */
+ int policy_serial; /* Policy serial number at connect time */
+
+ /* Error management */
+ /* FIXME: re-design error system using callbacks (?) */
+#define SEMANAGE_ERRBUFSZ 1024
+ char err_buf[SEMANAGE_ERRBUFSZ];
+
+ /* one of these connections will actually be used while
+ * working with the module store -- the particular one if
+ * given by conf->store_type */
+ semanage_conf_t *conf;
+ union {
+ struct semanage_module_conn module;
+ } conn;
+ int is_connected;
+ int is_in_transaction;
+
+ /* This timeout is used for transactions and waiting for lock
+ -1 means wait indefinetely
+ 0 means return immediately
+ >0 means wait that many seconds */
+ int timeout;
+
+ /* these function pointers will point to the appropriate
+ * routine given the connection type. think of these as
+ * simulating polymorphism for non-OO languages. */
+ struct semanage_func_table *funcs;
+
+ /* Object databases */
+#define DBASE_COUNT 2
+#define DBASE_USERS 0
+#define DBASE_PORTS 1
+ struct dbase* dbase[DBASE_COUNT];
+};
+
+static inline
+struct dbase* semanage_user_dbase(semanage_handle_t* handle) {
+ return handle->dbase[DBASE_USERS];
+}
+
+static inline
+struct dbase* semanage_port_dbase(semanage_handle_t* handle) {
+ return handle->dbase[DBASE_PORTS];
+}
+
+#endif
+
diff -Naur libsemanage/src/modules.c libsemanage.new2/src/modules.c
--- libsemanage/src/modules.c 2005-09-28 15:56:00.000000000 -0400
+++ libsemanage.new2/src/modules.c 2005-09-29 17:23:34.000000000 -0400
@@ -21,7 +21,6 @@
/* This file implements only the publicly-visible module functions to libsemanage. */
#include <semanage/semanage.h>
-#include "semanage_private.h"
#include "direct_api.h"
#include "semanage_conf.h"
#include "semanage_store.h"
@@ -31,6 +30,10 @@
#include <stdlib.h>
#include <stdio.h>
+#include "handle.h"
+#include "modules.h"
+#include "debug.h"
+
int semanage_module_install(semanage_handle_t *sh,
char *module_data, size_t data_len) {
if (sh->funcs->install == NULL) {
diff -Naur libsemanage/src/modules.h libsemanage.new2/src/modules.h
--- libsemanage/src/modules.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/modules.h 2005-09-29 17:23:34.000000000 -0400
@@ -0,0 +1,36 @@
+/* Author: Joshua Brindle <jbrindle@tresys.com>
+ * Jason Tang <jtang@tresys.com>
+ *
+ * Copyright (C) 2005 Tresys Technology, LLC
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _SEMANAGE_INTERNAL_MODULES_H_
+#define _SEMANAGE_INTERNAL_MODULES_H_
+
+#include <semanage/modules.h>
+
+struct semanage_module_conn {
+ int translock_file_fd;
+ int readlock_file_fd;
+};
+
+struct semanage_module_info {
+ char *name; /* Key */
+ char *version;
+};
+
+#endif
diff -Naur libsemanage/src/ports_file.c libsemanage.new2/src/ports_file.c
--- libsemanage/src/ports_file.c 2005-09-29 17:07:03.000000000 -0400
+++ libsemanage.new2/src/ports_file.c 2005-09-29 17:49:14.000000000 -0400
@@ -9,6 +9,7 @@
#include <semanage/port_record.h>
#include "debug.h"
#include "interfaces.h"
+#include "database.h"
static int semanage_port_print(
semanage_port_t port,
@@ -30,7 +31,7 @@
return STATUS_SUCCESS;
}
-record_table_t RTABLE_PORT = {
+record_table_t SEMANAGE_PORT_RTABLE = {
/* Record base functions */
.create = semanage_port_create,
.key_extract = semanage_port_key_extract,
@@ -43,3 +44,17 @@
.parse = semanage_port_parse,
.print = semanage_port_print,
};
+
+int port_file_dbase_init(dbase_t** dbase) {
+ return dbase_init(
+ &SEMANAGE_PORT_RTABLE,
+ NULL, /* FIXME */
+ dbase);
+}
+
+void port_file_dbase_release(dbase_t* dbase) {
+ if (dbase == NULL)
+ return;
+
+ dbase_release(dbase);
+}
diff -Naur libsemanage/src/ports_file.h libsemanage.new2/src/ports_file.h
--- libsemanage/src/ports_file.h 2005-09-29 17:07:13.000000000 -0400
+++ libsemanage.new2/src/ports_file.h 2005-09-29 17:49:15.000000000 -0400
@@ -1,8 +1,16 @@
#ifndef _SEMANAGE_PORTS_FILE_H_
#define _SEMANAGE_PORTS_FILE_H_
-#include "interfaces.h"
+/*
+ * Header for the port DATA FILE backend
+ */
-extern record_table_t RTABLE_PORT;
+#include "database.h"
+
+int port_file_dbase_init(
+ dbase_t** dbase);
+
+void port_file_dbase_release(
+ dbase_t* dbase);
#endif
diff -Naur libsemanage/src/semanage.c libsemanage.new2/src/semanage.c
--- libsemanage/src/semanage.c 2005-09-28 15:56:00.000000000 -0400
+++ libsemanage.new2/src/semanage.c 2005-09-29 17:23:34.000000000 -0400
@@ -19,7 +19,6 @@
*/
#include <semanage/semanage.h>
-#include "semanage_private.h"
#include "direct_api.h"
#include "semanage_conf.h"
#include "semanage_store.h"
@@ -27,9 +26,6 @@
#include <stdarg.h>
#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <sys/time.h>
int semanage_init(void)
{
@@ -49,15 +45,3 @@
{
semanage_init();
}
-
-/* Write an error message to the current error buffer, up to the
- * buffer's specified size. */
-#ifdef __GNUC__
-__attribute__ ((format (printf, 2, 3)))
-#endif
-void semanage_write_error(semanage_handle_t *sh, char *fmt, ...) {
- va_list ap;
- va_start(ap, fmt);
- vsnprintf(sh->err_buf, SEMANAGE_ERRBUFSZ, fmt, ap);
- va_end(ap);
-}
diff -Naur libsemanage/src/semanage_private.h libsemanage.new2/src/semanage_private.h
--- libsemanage/src/semanage_private.h 2005-09-28 15:56:00.000000000 -0400
+++ libsemanage.new2/src/semanage_private.h 1969-12-31 19:00:00.000000000 -0500
@@ -1,86 +0,0 @@
-/* Author: Joshua Brindle <jbrindle@tresys.com>
- * Jason Tang <jtang@tresys.com>
- *
- * Copyright (C) 2005 Tresys Technology, LLC
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef SEMANAGE_PRIVATE_H
-#define SEMANAGE_PRIVATE_H
-
-#include <semanage/semanage.h>
-
-#include "semanage_conf.h"
-#include <stdlib.h>
-#include <sys/time.h>
-
-struct semanage_module_conn {
- int translock_file_fd;
- int readlock_file_fd;
-};
-
-struct semanage_func_table {
- void (*destroy)(semanage_handle_t *);
- int (*disconnect)(semanage_handle_t *);
- int (*begin_trans)(semanage_handle_t *);
- int (*commit)(semanage_handle_t *);
- int (*install)(semanage_handle_t *, char *, size_t);
- int (*upgrade)(semanage_handle_t *, char *, size_t);
- int (*install_base)(semanage_handle_t *, char *, size_t);
- int (*remove)(semanage_handle_t *, char *);
- int (*list)(semanage_handle_t *, semanage_module_info_t **, int *);
-};
-
-#define SEMANAGE_ERRBUFSZ 1024
-
-struct semanage_handle {
- int con_id; /* Connection ID */
- int policy_serial; /* Policy serial number at connect time */
- char err_buf[SEMANAGE_ERRBUFSZ];
-
- /* one of these connections will actually be used while
- * working with the module store -- the particular one is
- * given by conf->store_type */
- semanage_conf_t *conf;
- union {
- struct semanage_module_conn module;
- } conn;
- int is_connected;
- int is_in_transaction;
-
- /* these function pointers will point to the appropriate
- * routine given the connection type. think of these as
- * simulating polymorphism for non-OO languages. */
- struct semanage_func_table *funcs;
-
- /* This timeout is used for transactions and waiting for locks
- -1 means wait indefinetely
- 0 means return immediately
- >0 means wait that many seconds */
- int timeout;
-};
-
-struct semanage_module_info {
- char *name; /* Key */
- char *version;
-};
-
-#ifdef __GNUC__
-__attribute__ ((format (printf, 2, 3)))
-#endif
-void semanage_write_error(semanage_handle_t *sh, char *fmt, ...);
-
-#endif
diff -Naur libsemanage/src/semanage_store.c libsemanage.new2/src/semanage_store.c
--- libsemanage/src/semanage_store.c 2005-09-28 15:56:00.000000000 -0400
+++ libsemanage.new2/src/semanage_store.c 2005-09-29 17:23:34.000000000 -0400
@@ -45,6 +45,7 @@
#include <sys/types.h>
#include <sys/wait.h>
+#include "debug.h"
/* relative path names to enum semanage_paths to special files and
* directories for the module store */
diff -Naur libsemanage/src/semanage_store.h libsemanage.new2/src/semanage_store.h
--- libsemanage/src/semanage_store.h 2005-09-28 15:56:00.000000000 -0400
+++ libsemanage.new2/src/semanage_store.h 2005-09-29 17:23:34.000000000 -0400
@@ -22,11 +22,9 @@
#ifndef SEMANAGE_MODULE_STORE_H
#define SEMANAGE_MODULE_STORE_H
-#include "semanage_private.h"
-
#include <sys/time.h>
-
#include <sepol/module.h>
+#include "handle.h"
enum semanage_store_defs {
SEMANAGE_ACTIVE,
diff -Naur libsemanage/src/users_file.c libsemanage.new2/src/users_file.c
--- libsemanage/src/users_file.c 2005-09-29 17:07:53.000000000 -0400
+++ libsemanage.new2/src/users_file.c 2005-09-29 17:49:29.000000000 -0400
@@ -7,6 +7,7 @@
#include <stdlib.h>
#include <stdio.h>
#include "interfaces.h"
+#include "database.h"
#include "debug.h"
static int semanage_user_print(
@@ -29,7 +30,7 @@
return STATUS_SUCCESS;
}
-record_table_t RTABLE_USER = {
+record_table_t SEMANAGE_USER_RTABLE = {
/* Record base functions */
.create = semanage_user_create,
.key_extract = semanage_user_key_extract,
@@ -42,3 +43,18 @@
.parse = semanage_user_parse,
.print = semanage_user_print,
};
+
+int user_file_dbase_init(dbase_t** dbase) {
+ return dbase_init(
+ &SEMANAGE_USER_RTABLE,
+ NULL, /* FIXME */
+ dbase);
+}
+
+void user_file_dbase_release(dbase_t* dbase) {
+ if (dbase == NULL)
+ return;
+
+ dbase_release(dbase);
+}
+
diff -Naur libsemanage/src/users_file.h libsemanage.new2/src/users_file.h
--- libsemanage/src/users_file.h 2005-09-29 17:08:00.000000000 -0400
+++ libsemanage.new2/src/users_file.h 2005-09-29 17:42:54.000000000 -0400
@@ -1,8 +1,16 @@
#ifndef _SEMANAGE_USERS_FILE_H_
#define _SEMANAGE_USERS_FILE_H_
-#include "interfaces.h"
+/**
+ * Header for the users DATA FILE backend
+ */
-extern record_table_t RTABLE_USER;
+#include "database.h"
+
+int user_file_dbase_init(
+ dbase_t** dbase);
+
+void user_file_dbase_release(
+ dbase_t* dbase);
#endif
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: [ 4/9 ] [ SEMANAGE ] Database initialization Stage 1
2005-09-30 3:02 ` [ 4/9 ] [ SEMANAGE ] Database initialization Stage 1 Ivan Gyurdiev
@ 2005-09-30 18:42 ` Ivan Gyurdiev
0 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 18:42 UTC (permalink / raw)
To: selinux
>+/* Release a database */
>+void dbase_release(
>+ dbase_t* dbase) {
>+
>+ cache_entry_t *prev, *ptr;
>+ while (ptr != NULL) {
>+ prev = ptr;
>+ ptr = ptr->next;
>+ dbase->rtable->free(prev->data);
>+ free(prev);
>+ }
>+}
>
>
This is obviously wrong - ptr is not initialized, but I'm sure it's
fixed in one of those later patches (the last one..possibly)? Please
merge the whole patchset if there's no design issues - if there's bugs
I'd much rather fix them with followup patches, than by changing those.
--
This message was distributed to subscribers of the selinux mailing list.
If you no longer wish to subscribe, send mail to majordomo@tycho.nsa.gov with
the words "unsubscribe selinux" without quotes as the message.
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [ 5/9 ] [ SEMANAGE ] Change database to singly-linked list
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
` (2 preceding siblings ...)
2005-09-30 3:02 ` [ 4/9 ] [ SEMANAGE ] Database initialization Stage 1 Ivan Gyurdiev
@ 2005-09-30 3:04 ` Ivan Gyurdiev
2005-09-30 3:07 ` [ 6/9 ] [ SEMANAGE ] Database Initialization Stage 2 Ivan Gyurdiev
` (5 subsequent siblings)
9 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 3:04 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
[-- Attachment #1: Type: text/plain, Size: 114 bytes --]
This patch changes the previously doubly-linked list in database.c to a
singly-linked list, which is sufficient.
[-- Attachment #2: libsemanage.04.dbase_single_link.diff --]
[-- Type: text/x-patch, Size: 1580 bytes --]
diff -Naur libsemanage/src/database.c libsemanage.new2/src/database.c
--- libsemanage/src/database.c 2005-09-29 17:54:40.000000000 -0400
+++ libsemanage.new2/src/database.c 2005-09-29 18:03:08.000000000 -0400
@@ -12,7 +12,6 @@
/* Representation of the database once loaded in memory */
typedef struct cache_entry {
record_t data;
- struct cache_entry* prev;
struct cache_entry* next;
} cache_entry_t;
@@ -98,10 +97,7 @@
if (entry == NULL)
goto omem;
entry->data = data;
- entry->prev = NULL;
entry->next = dbase->cache;
- if (dbase->cache != NULL)
- dbase->cache->prev = entry;
dbase->cache = entry;
dbase->cache_sz++;
@@ -267,29 +263,26 @@
dbase_t* dbase,
record_key_t key) {
- cache_entry_t* entry;
- int status;
+ cache_entry_t *ptr, *prev = NULL;
if (dbase_cache_fill(dbase) < 0)
goto err;
- status = dbase_cache_locate(dbase, key, &entry);
- if (status < 0)
- goto err;
-
- else if (status != STATUS_NODATA) {
- if (entry->next != NULL)
- entry->next->prev = entry->prev;
-
- if (entry->prev != NULL)
- entry->prev->next = entry->next;
+ for (ptr = dbase->cache; ptr != NULL; ptr = ptr->next) {
+ if (! dbase->rtable->compare(ptr->data, key)) {
+ if (prev != NULL)
+ prev->next = ptr->next;
+ else
+ dbase->cache = ptr->next;
+
+ dbase->rtable->free(ptr->data);
+ dbase->cache_sz--;
+ free(ptr);
+ return STATUS_SUCCESS;
+ }
else
- dbase->cache = entry->next;
-
- dbase->rtable->free(entry->data);
- dbase->cache_sz--;
- free(entry);
- }
+ prev = ptr;
+ }
return STATUS_SUCCESS;
err:
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: [ 6/9 ] [ SEMANAGE ] Database Initialization Stage 2
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
` (3 preceding siblings ...)
2005-09-30 3:04 ` [ 5/9 ] [ SEMANAGE ] Change database to singly-linked list Ivan Gyurdiev
@ 2005-09-30 3:07 ` Ivan Gyurdiev
2005-09-30 3:14 ` [ 7/9 ] [ SEMANAGE ] Backend separation (Init 3) Ivan Gyurdiev
` (4 subsequent siblings)
9 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 3:07 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
[-- Attachment #1: Type: text/plain, Size: 334 bytes --]
This patch passes the handle down to the dbase_* functions, and selects
the correct database in users.c/ports.c. I need to add debugging
eventually, that will make use of the handle, but for now it's set to
NULL to block unused warning. Also, it may need to be forwarded deeper
into the call stack, but I'll leave that for later.
[-- Attachment #2: libsemanage.05.init2_handle.diff --]
[-- Type: text/x-patch, Size: 12196 bytes --]
diff -Naur libsemanage/include/semanage/ports.h libsemanage.new2/include/semanage/ports.h
--- libsemanage/include/semanage/ports.h 2005-09-23 10:37:40.000000000 -0400
+++ libsemanage.new2/include/semanage/ports.h 2005-09-29 18:13:45.000000000 -0400
@@ -3,35 +3,44 @@
#include <stddef.h>
#include <semanage/port_record.h>
+#include <semanage/handle.h>
extern int semanage_port_add(
+ semanage_handle_t* handle,
semanage_port_key_t key,
semanage_port_t data);
extern int semanage_port_modify(
+ semanage_handle_t* handle,
semanage_port_key_t key,
semanage_port_t data);
extern int semanage_port_del(
+ semanage_handle_t* handle,
semanage_port_key_t key);
extern int semanage_port_query(
+ semanage_handle_t* handle,
semanage_port_key_t key,
semanage_port_t* response);
extern int semanage_port_exists(
+ semanage_handle_t* handle,
semanage_port_key_t key,
int* response);
extern int semanage_port_count(
+ semanage_handle_t* handle,
int* response);
extern int semanage_port_iterate(
+ semanage_handle_t* handle,
int (*handler) (semanage_port_t record,
void* varg),
void* handler_arg);
extern int semanage_port_list(
+ semanage_handle_t* handle,
semanage_port_t** records,
size_t* count);
diff -Naur libsemanage/include/semanage/users.h libsemanage.new2/include/semanage/users.h
--- libsemanage/include/semanage/users.h 2005-09-23 10:37:40.000000000 -0400
+++ libsemanage.new2/include/semanage/users.h 2005-09-29 18:13:41.000000000 -0400
@@ -3,35 +3,44 @@
#include <stddef.h>
#include <semanage/user_record.h>
+#include <semanage/handle.h>
extern int semanage_user_add(
+ semanage_handle_t* handle,
semanage_user_key_t key,
semanage_user_t data);
extern int semanage_user_modify(
+ semanage_handle_t* handle,
semanage_user_key_t key,
semanage_user_t data);
extern int semanage_user_del(
+ semanage_handle_t* handle,
semanage_user_key_t key);
extern int semanage_user_query(
+ semanage_handle_t* handle,
semanage_user_key_t key,
semanage_user_t* response);
extern int semanage_user_exists(
+ semanage_handle_t* handle,
semanage_user_key_t key,
int* response);
extern int semanage_user_count(
+ semanage_handle_t* handle,
int* response);
extern int semanage_user_iterate(
+ semanage_handle_t* handle,
int (*handler) (semanage_user_t record,
void* varg),
void* handler_arg);
extern int semanage_user_list(
+ semanage_handle_t* handle,
semanage_user_t** records,
size_t* count);
diff -Naur libsemanage/src/database.c libsemanage.new2/src/database.c
--- libsemanage/src/database.c 2005-09-29 18:06:33.000000000 -0400
+++ libsemanage.new2/src/database.c 2005-09-29 18:29:54.000000000 -0400
@@ -6,8 +6,7 @@
#include "debug.h"
#include "database.h"
#include "interfaces.h"
-#include "users_file.h"
-#include "ports_file.h"
+#include "handle.h"
/* Representation of the database once loaded in memory */
typedef struct cache_entry {
@@ -183,7 +182,7 @@
static int dbase_cache_locate(
dbase_t* dbase,
- record_key_t key,
+ record_key_t key,
cache_entry_t** entry) {
cache_entry_t* ptr;
@@ -205,6 +204,7 @@
}
int dbase_add(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key,
record_t data) {
@@ -214,7 +214,7 @@
if (dbase_cache_fill(dbase) < 0)
goto err;
- if (dbase_exists(dbase, key, &exists) < 0)
+ if (dbase_exists(handle, dbase, key, &exists) < 0)
goto err;
else if (exists) {
@@ -228,11 +228,13 @@
return STATUS_SUCCESS;
err:
+ handle = NULL;
/* FIXME: handle error condition */
return STATUS_ERR;
}
int dbase_modify(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key,
record_t data) {
@@ -247,19 +249,20 @@
if (status < 0)
goto err;
if (status == STATUS_NODATA)
- return dbase_add(dbase,key,data);
+ return dbase_add(handle, dbase, key, data);
else
entry->data = data;
return STATUS_SUCCESS;
err:
+ handle = NULL;
/* FIXME: handle error condition */
return STATUS_ERR;
-
}
int dbase_del(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key) {
@@ -282,15 +285,17 @@
}
else
prev = ptr;
- }
+ }
return STATUS_SUCCESS;
err:
+ handle = NULL;
/* FIXME: Handle error condition */
return STATUS_ERR;
}
int dbase_query(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key,
record_t* response) {
@@ -310,11 +315,13 @@
return STATUS_SUCCESS;
err:
+ handle = NULL;
/* FIXME: Handle error condition */
return STATUS_ERR;
}
int dbase_exists(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key,
int* response) {
@@ -333,11 +340,13 @@
return STATUS_SUCCESS;
err:
+ handle = NULL;
/* FIXME: handle error condition */
return STATUS_ERR;
}
int dbase_count(
+ semanage_handle_t* handle,
dbase_t* dbase,
int* response) {
@@ -348,11 +357,13 @@
return STATUS_SUCCESS;
err:
+ handle = NULL;
/* FIXME: Handle error condition */
return STATUS_ERR;
}
int dbase_iterate(
+ semanage_handle_t* handle,
dbase_t* dbase,
int (*fn) (record_t record, void* varg),
void* fn_arg) {
@@ -375,11 +386,13 @@
return STATUS_SUCCESS;
err:
+ handle = NULL;
/* FIXME: Handle error condition */
return STATUS_ERR;
}
int dbase_list(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_t** records,
size_t* count) {
@@ -410,6 +423,7 @@
return STATUS_SUCCESS;
omem:
+ handle = NULL;
/* FIXME: handle error condition */
err:
diff -Naur libsemanage/src/database.h libsemanage.new2/src/database.h
--- libsemanage/src/database.h 2005-09-29 17:54:40.000000000 -0400
+++ libsemanage.new2/src/database.h 2005-09-29 18:29:28.000000000 -0400
@@ -8,6 +8,7 @@
#endif
#include <stddef.h>
+#include "handle.h"
#include "interfaces.h"
struct dbase;
@@ -32,40 +33,48 @@
dbase_t* dbase);
extern int dbase_add(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key,
record_t data);
extern int dbase_modify(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key,
record_t data);
extern int dbase_del(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key);
extern int dbase_query(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key,
record_t* response);
extern int dbase_exists(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_key_t key,
int* response);
extern int dbase_count(
+ semanage_handle_t* handle,
dbase_t* dbase,
int* response);
extern int dbase_iterate(
+ semanage_handle_t* handle,
dbase_t* dbase,
int (*fn) (record_t record,
void* varg),
void* fn_arg);
extern int dbase_list(
+ semanage_handle_t* handle,
dbase_t* dbase,
record_t** records,
size_t* count);
diff -Naur libsemanage/src/ports.c libsemanage.new2/src/ports.c
--- libsemanage/src/ports.c 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new2/src/ports.c 2005-09-29 18:31:19.000000000 -0400
@@ -1,64 +1,86 @@
-#include <stddef.h>
-#include <stdlib.h>
+/*
+ * Common code for manipulating port DATA backends
+ */
+
#include <semanage/port_record.h>
-#include <semanage/ports.h>
typedef semanage_port_key_t record_key_t;
typedef semanage_port_t record_t;
#define RECORD_DEFINED
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <semanage/ports.h>
#include "database.h"
+#include "handle.h"
int semanage_port_add(
+ semanage_handle_t* handle,
semanage_port_key_t key,
semanage_port_t data) {
-
- return dbase_add(NULL /* FIXME */, key, data);
+
+ dbase_t* dbase = semanage_port_dbase(handle);
+ return dbase_add(handle, dbase, key, data);
}
int semanage_port_modify(
+ semanage_handle_t* handle,
semanage_port_key_t key,
semanage_port_t data) {
- return dbase_modify(NULL /* FIXME */, key, data);
+ dbase_t* dbase = semanage_port_dbase(handle);
+ return dbase_modify(handle, dbase, key, data);
}
int semanage_port_del(
+ semanage_handle_t* handle,
semanage_port_key_t key) {
- return dbase_del(NULL /* FIXME */, key);
+ dbase_t* dbase = semanage_port_dbase(handle);
+ return dbase_del(handle, dbase, key);
}
int semanage_port_query(
+ semanage_handle_t* handle,
semanage_port_key_t key,
semanage_port_t* response) {
- return dbase_query(NULL /* FIXME */, key, response);
+ dbase_t* dbase = semanage_port_dbase(handle);
+ return dbase_query(handle, dbase, key, response);
}
int semanage_port_exists(
+ semanage_handle_t* handle,
semanage_port_key_t key,
int* response) {
- return dbase_exists(NULL /* FIXME */, key, response);
+ dbase_t* dbase = semanage_port_dbase(handle);
+ return dbase_exists(handle, dbase, key, response);
}
int semanage_port_count(
+ semanage_handle_t* handle,
int* response) {
- return dbase_count(NULL /*FIXME */, response);
+ dbase_t* dbase = semanage_port_dbase(handle);
+ return dbase_count(handle, dbase, response);
}
int semanage_port_iterate(
+ semanage_handle_t* handle,
int (*handler) (semanage_port_t record,
void* varg),
void* handler_arg) {
- return dbase_iterate(NULL /* FIXME */, handler, handler_arg);
+ dbase_t* dbase = semanage_port_dbase(handle);
+ return dbase_iterate(handle, dbase, handler, handler_arg);
}
int semanage_port_list(
+ semanage_handle_t* handle,
semanage_port_t** records,
size_t* count) {
- return dbase_list(NULL /* FIXME */, records, count);
+ dbase_t* dbase = semanage_port_dbase(handle);
+ return dbase_list(handle, dbase, records, count);
}
diff -Naur libsemanage/src/users.c libsemanage.new2/src/users.c
--- libsemanage/src/users.c 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new2/src/users.c 2005-09-29 18:24:27.000000000 -0400
@@ -1,64 +1,86 @@
-#include <stddef.h>
-#include <stdlib.h>
+/*
+ * Common code for manipulating user DATA backends
+ */
+
#include <semanage/user_record.h>
-#include <semanage/users.h>
typedef semanage_user_key_t record_key_t;
typedef semanage_user_t record_t;
#define RECORD_DEFINED
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <semanage/users.h>
+#include "handle.h"
#include "database.h"
int semanage_user_add(
+ semanage_handle_t* handle,
semanage_user_key_t key,
semanage_user_t data) {
-
- return dbase_add(NULL /*FIXME */, key, data);
+
+ dbase_t* dbase = semanage_user_dbase(handle);
+ return dbase_add(handle, dbase, key, data);
}
int semanage_user_modify(
+ semanage_handle_t* handle,
semanage_user_key_t key,
semanage_user_t data) {
-
- return dbase_modify(NULL /* FIXME */, key, data);
+
+ dbase_t* dbase = semanage_user_dbase(handle);
+ return dbase_modify(handle, dbase, key, data);
}
int semanage_user_del(
+ semanage_handle_t* handle,
semanage_user_key_t key) {
- return dbase_del(NULL /* FIXME */, key);
+ dbase_t* dbase = semanage_user_dbase(handle);
+ return dbase_del(handle, dbase, key);
}
int semanage_user_query(
+ semanage_handle_t* handle,
semanage_user_key_t key,
semanage_user_t* response) {
- return dbase_query(NULL /* FIXME */, key, response);
+ dbase_t* dbase = semanage_user_dbase(handle);
+ return dbase_query(handle, dbase, key, response);
}
int semanage_user_exists(
+ semanage_handle_t* handle,
semanage_user_key_t key,
int* response) {
- return dbase_exists(NULL /* FIXME */, key, response);
+ dbase_t* dbase = semanage_user_dbase(handle);
+ return dbase_exists(handle, dbase, key, response);
}
int semanage_user_count(
+ semanage_handle_t* handle,
int* response) {
- return dbase_count(NULL /* FIXME */, response);
+ dbase_t* dbase = semanage_user_dbase(handle);
+ return dbase_count(handle, dbase, response);
}
int semanage_user_iterate(
+ semanage_handle_t* handle,
int (*handler) (semanage_user_t record,
void* varg),
void* handler_arg) {
- return dbase_iterate(NULL /* FIXME */, handler, handler_arg);
+ dbase_t* dbase = semanage_user_dbase(handle);
+ return dbase_iterate(handle, dbase, handler, handler_arg);
}
int semanage_user_list(
+ semanage_handle_t* handle,
semanage_user_t** records,
size_t* count) {
- return dbase_list(NULL /* FIXME */, records, count);
+ dbase_t* dbase = semanage_user_dbase(handle);
+ return dbase_list(handle, dbase, records, count);
}
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: [ 7/9 ] [ SEMANAGE ] Backend separation (Init 3)
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
` (4 preceding siblings ...)
2005-09-30 3:07 ` [ 6/9 ] [ SEMANAGE ] Database Initialization Stage 2 Ivan Gyurdiev
@ 2005-09-30 3:14 ` Ivan Gyurdiev
2005-09-30 13:45 ` Ivan Gyurdiev
2005-09-30 3:16 ` [ 8/9 ] [ SEMANAGE ] Eliminate struct pointer typedefs Ivan Gyurdiev
` (3 subsequent siblings)
9 siblings, 1 reply; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 3:14 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
[-- Attachment #1: Type: text/plain, Size: 701 bytes --]
This patch:
- removes FILE-specific code from the database, and puts that in
database_file.[c,h].
- stubs out a second type of database - database_direct.[c,h] (for policy)
- adds user/port interfaces for the POLICY DIRECT database
- splits record table into base (in users.c/ports.c) and extensions -
FILE and POLICY DIRECT
- adds polymorphism on the database backend, and uses that in database
- adds init()/release() functions for the backend.
- forwards cache() and flush() operations to the backend
- adds some functions with the intent to use those for moving things
from a FILE to POLICY database, but I'm still not entirely sure how this
code will work (so it's partially disabled).
[-- Attachment #2: libsemanage.06.dbase_init3_backend_separation.diff --]
[-- Type: text/x-patch, Size: 33361 bytes --]
diff -Naur --exclude CVS libsemanage/src/database.c libsemanage.new2/src/database.c
--- libsemanage/src/database.c 2005-09-29 18:34:10.000000000 -0400
+++ libsemanage.new2/src/database.c 2005-09-29 19:08:50.000000000 -0400
@@ -1,39 +1,15 @@
#include <stdlib.h>
#include <stddef.h>
-#include <stdio.h>
-#include <stdio_ext.h>
-#include <errno.h>
#include "debug.h"
#include "database.h"
#include "interfaces.h"
#include "handle.h"
-/* Representation of the database once loaded in memory */
-typedef struct cache_entry {
- record_t data;
- struct cache_entry* next;
-} cache_entry_t;
-
-/* Database-specific configuration */
-struct dbase {
-
- /* What's the format of this database */
- record_table_t* rtable;
-
- /* Where is it stored */
- const char* filename;
-
- /* Once parsed, it is cached here */
- cache_entry_t* cache;
- size_t cache_sz;
- int cached;
- int cache_invalid;
-};
-
/* Initialize a database */
int dbase_init(
record_table_t* rtable,
- const char* filename,
+ dbase_backend_t* backend,
+ dbase_backend_table_t* btable,
dbase_t** dbase) {
dbase_t* tmp_dbase =
@@ -43,7 +19,8 @@
goto omem;
tmp_dbase->rtable = rtable;
- tmp_dbase->filename = filename;
+ tmp_dbase->backend = backend;
+ tmp_dbase->btable = btable;
tmp_dbase->cache = NULL;
tmp_dbase->cache_sz = 0;
tmp_dbase->cached = 0;
@@ -62,13 +39,15 @@
void dbase_release(
dbase_t* dbase) {
- cache_entry_t *prev, *ptr;
+ cache_entry_t *prev, *ptr = dbase->cache;
while (ptr != NULL) {
prev = ptr;
ptr = ptr->next;
dbase->rtable->free(prev->data);
free(prev);
}
+
+ free(dbase);
}
/* Invalidate database cache */
@@ -82,12 +61,13 @@
int dbase_flush(
dbase_t* dbase) {
- /* Stub */
- dbase = NULL;
+ if (dbase->btable->flush(dbase, dbase->backend) < 0)
+ return STATUS_ERR;
+
return STATUS_SUCCESS;
}
-static int dbase_cache_add(
+int dbase_cache_add(
dbase_t* dbase,
record_t data) {
@@ -106,80 +86,6 @@
return STATUS_ERR;
}
-static int dbase_open_file(parse_info_t* info) {
-
- info->file_stream = fopen(info->filename, "r");
- if (!info->file_stream && (errno != ENOENT)) {
- /* FIXME: handle error condition */
- return STATUS_ERR;
- }
- if (info->file_stream)
- __fsetlocking(info->file_stream, FSETLOCKING_BYCALLER);
-
- return STATUS_SUCCESS;
-}
-
-static void dbase_close_file(parse_info_t* info) {
- if (info->file_stream && (fclose(info->file_stream) < 0))
- /* FIXME: handle error condition */
- info->file_stream = NULL;
-}
-
-static int dbase_cache_fill(
- dbase_t* dbase) {
-
- /* Already cached */
- if (dbase->cached && (!dbase->cache_invalid))
- return STATUS_SUCCESS;
-
- int perr_fatal = 0;
- /* FIXME: pass from caller? */
-
- record_t process_record = NULL;
- int pstatus = STATUS_SUCCESS;
- parse_info_t parse_info;
- parse_info.filename = dbase->filename;
- parse_info.parse_arg = NULL;
- /* FIXME: pass from caller? */
-
- if (dbase_open_file(&parse_info) < 0)
- goto err;
-
- /* Main processing loop */
- do {
- /* Create record */
- if (dbase->rtable->create(&process_record) < 0)
- goto err;
-
- /* Parse record */
- pstatus = dbase->rtable->parse(&parse_info, process_record);
-
- /* Parse error is fatal, exit */
- if (perr_fatal && (pstatus < 0))
- goto err;
-
- /* Parse error is not fatal */
- else if (pstatus < 0)
- continue;
-
- /* Add record to list */
- if (dbase_cache_add(dbase, process_record) < 0)
- goto err;
-
- } while (pstatus != STATUS_NODATA);
-
- dbase_close_file(&parse_info);
- dbase->cached = 1;
- dbase->cache_invalid = 0;
- return STATUS_SUCCESS;
-
- err:
- /* FIXME: handle failure */
- dbase->rtable->free(process_record);
- dbase_close_file(&parse_info);
- return STATUS_ERR;
-}
-
static int dbase_cache_locate(
dbase_t* dbase,
record_key_t key,
@@ -187,7 +93,7 @@
cache_entry_t* ptr;
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
for (ptr = dbase->cache; ptr != NULL; ptr = ptr->next) {
@@ -211,7 +117,7 @@
int exists;
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
if (dbase_exists(handle, dbase, key, &exists) < 0)
@@ -242,7 +148,7 @@
cache_entry_t* entry;
int status;
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
status = dbase_cache_locate(dbase, key, &entry);
@@ -268,7 +174,7 @@
cache_entry_t *ptr, *prev = NULL;
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
for (ptr = dbase->cache; ptr != NULL; ptr = ptr->next) {
@@ -277,15 +183,15 @@
prev->next = ptr->next;
else
dbase->cache = ptr->next;
-
+
dbase->rtable->free(ptr->data);
dbase->cache_sz--;
free(ptr);
return STATUS_SUCCESS;
- }
+ }
else
prev = ptr;
- }
+ }
return STATUS_SUCCESS;
err:
@@ -303,7 +209,7 @@
cache_entry_t* entry;
int status;
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
status = dbase_cache_locate(dbase, key, &entry);
@@ -329,7 +235,7 @@
cache_entry_t* entry;
int status;
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
status = dbase_cache_locate(dbase, key, &entry);
@@ -350,7 +256,7 @@
dbase_t* dbase,
int* response) {
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
*response = dbase->cache_sz;
@@ -371,7 +277,7 @@
int status;
cache_entry_t* ptr;
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
for (ptr = dbase->cache; ptr != NULL; ptr = ptr->next) {
@@ -402,7 +308,7 @@
size_t tmp_count;
int i = 0;
- if (dbase_cache_fill(dbase) < 0)
+ if (dbase->btable->cache(dbase, dbase->backend) < 0)
goto err;
tmp_count = dbase->cache_sz;
diff -Naur --exclude CVS libsemanage/src/database_direct.c libsemanage.new2/src/database_direct.c
--- libsemanage/src/database_direct.c 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/database_direct.c 2005-09-29 18:52:38.000000000 -0400
@@ -0,0 +1,94 @@
+struct dbase_direct_backend;
+typedef struct dbase_direct_backend dbase_backend_t;
+#define BACKEND_DEFINED
+
+#include <stdlib.h>
+#include <sepol/policydb.h>
+#include "database_direct.h"
+#include "interfaces.h"
+#include "debug.h"
+
+/* POLICY DIRECT backend */
+struct dbase_direct_backend {
+
+ /* Backing file */
+ const char* filename;
+
+ /* Address to store the policydb object, once it's
+ * read from the file above. This is a double pointer,
+ * because the address will be provided from outside.
+ * This is done for two reasons:
+ *
+ * 1) We want to share the same policy backend object
+ * for multiple databases {user/interfaces/ports} -> same policydb
+ * backend. We don't want to re-construct the policy separately for
+ * each.
+ *
+ * 2) This allows the policydb to updated outside the dbase_*
+ * call chain...for example on commit(), after modifications are made.
+ */
+ policydb_t** policy;
+
+ /* Method of access */
+ record_direct_table_t* rptable;
+
+};
+
+static int dbase_direct_cache(
+ dbase_t* dbase,
+ dbase_direct_backend_t* backend) {
+
+ /* Stub */
+ dbase = NULL;
+ backend = NULL;
+ return STATUS_SUCCESS;
+}
+
+static int dbase_direct_flush(
+ dbase_t* dbase,
+ dbase_direct_backend_t* backend) {
+
+ /* Stub */
+ dbase = NULL;
+ backend = NULL;
+ return STATUS_SUCCESS;
+}
+
+int dbase_direct_init(
+ const char* filename,
+ policydb_t** policy_update_ptr,
+ record_direct_table_t* rptable,
+ dbase_direct_backend_t** backend) {
+
+ dbase_direct_backend_t* tmp_backend =
+ (dbase_direct_backend_t*) malloc(sizeof(dbase_direct_backend_t));
+
+ if (!tmp_backend)
+ goto omem;
+
+ tmp_backend->filename = filename;
+ tmp_backend->rptable = rptable;
+ tmp_backend->policy = policy_update_ptr;
+ *backend = tmp_backend;
+
+ return STATUS_SUCCESS;
+
+ omem:
+ /* FIXME: handle error condition */
+ free(tmp_backend);
+
+ return STATUS_ERR;
+}
+
+/* Release backend resources */
+void dbase_direct_release(
+ dbase_direct_backend_t* backend) {
+
+ free(backend);
+}
+
+/* DIRECT POLICY backend - method table implementation */
+dbase_backend_table_t SEMANAGE_DIRECT_BTABLE = {
+ .cache = dbase_direct_cache,
+ .flush = dbase_direct_flush,
+};
diff -Naur --exclude CVS libsemanage/src/database_direct.h libsemanage.new2/src/database_direct.h
--- libsemanage/src/database_direct.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/database_direct.h 2005-09-29 18:52:42.000000000 -0400
@@ -0,0 +1,24 @@
+#ifndef _SEMANAGE_DATABASE_DIRECT_INTERNAL_H_
+#define _SEMANAGE_DATABASE_DIRECT_INTERNAL_H_
+
+#include "database.h"
+#include "interfaces.h"
+
+struct dbase_direct_backend;
+typedef struct dbase_direct_backend dbase_direct_backend_t;
+
+/* POLICY DIRECT backend - initialization */
+extern int dbase_direct_init(
+ const char* filename,
+ policydb_t** policy_update_ptr,
+ record_direct_table_t* rptable,
+ dbase_direct_backend_t** backend);
+
+/* POLICY DIRECT backend - release */
+extern void dbase_direct_release(
+ dbase_direct_backend_t* backend);
+
+/* POLICY DIRECT backend - method table implementation */
+extern dbase_backend_table_t SEMANAGE_DIRECT_BTABLE;
+
+#endif
diff -Naur --exclude CVS libsemanage/src/database_file.c libsemanage.new2/src/database_file.c
--- libsemanage/src/database_file.c 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/database_file.c 2005-09-29 18:54:06.000000000 -0400
@@ -0,0 +1,143 @@
+struct dbase_file_backend;
+typedef struct dbase_file_backend dbase_backend_t;
+#define BACKEND_DEFINED
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio_ext.h>
+#include "debug.h"
+#include "interfaces.h"
+#include "database_file.h"
+
+/* FILE backend */
+struct dbase_file_backend {
+
+ /* Backing file */
+ const char* filename;
+
+ /* Method of access */
+ record_file_table_t* rftable;
+};
+
+static int dbase_file_open(parse_info_t* info) {
+
+ info->file_stream = fopen(info->filename, "r");
+ if (!info->file_stream && (errno != ENOENT)) {
+ /* FIXME: handle error condition */
+ return STATUS_ERR;
+ }
+ if (info->file_stream)
+ __fsetlocking(info->file_stream, FSETLOCKING_BYCALLER);
+
+ return STATUS_SUCCESS;
+}
+
+static void dbase_file_close(parse_info_t* info) {
+ if (info->file_stream && (fclose(info->file_stream) < 0))
+ /* FIXME: handle error condition */
+ info->file_stream = NULL;
+}
+
+static int dbase_file_cache(
+ dbase_t* dbase,
+ dbase_file_backend_t* backend) {
+
+ /* Already cached */
+ if (dbase->cached && (!dbase->cache_invalid))
+ return STATUS_SUCCESS;
+
+ int perr_fatal = 0;
+ /* FIXME: pass from caller? */
+
+ record_t process_record = NULL;
+ int pstatus = STATUS_SUCCESS;
+ parse_info_t parse_info;
+ parse_info.filename = backend->filename;
+ parse_info.parse_arg = NULL;
+ /* FIXME: pass from caller? */
+
+ if (dbase_file_open(&parse_info) < 0)
+ goto err;
+
+ /* Main processing loop */
+ do {
+ /* Create record */
+ if (dbase->rtable->create(&process_record) < 0)
+ goto err;
+
+ /* Parse record */
+ pstatus = backend->rftable->parse(&parse_info, process_record);
+
+ /* Parse error is fatal, exit */
+ if (perr_fatal && (pstatus < 0))
+ goto err;
+
+ /* Parse error is not fatal */
+ else if (pstatus < 0)
+ continue;
+
+ /* Add record to list */
+ if (dbase_cache_add(dbase, process_record) < 0)
+ goto err;
+
+ } while (pstatus != STATUS_NODATA);
+
+ dbase_file_close(&parse_info);
+ dbase->cached = 1;
+ dbase->cache_invalid = 0;
+ return STATUS_SUCCESS;
+
+ err:
+ /* FIXME: handle failure */
+ dbase->rtable->free(process_record);
+ dbase_file_close(&parse_info);
+ return STATUS_ERR;
+}
+
+/* Flush database to file */
+static int dbase_file_flush(
+ dbase_t* dbase,
+ dbase_file_backend_t* backend) {
+
+ /* Stub */
+ dbase = NULL;
+ backend = NULL;
+ return STATUS_SUCCESS;
+}
+
+int dbase_file_init(
+ const char* filename,
+ record_file_table_t* rftable,
+ dbase_file_backend_t** backend) {
+
+ dbase_file_backend_t* tmp_backend =
+ (dbase_file_backend_t*) malloc(sizeof(dbase_file_backend_t));
+
+ if (!tmp_backend)
+ goto omem;
+
+ tmp_backend->filename = filename;
+ tmp_backend->rftable = rftable;
+ *backend = tmp_backend;
+
+ return STATUS_SUCCESS;
+
+ omem:
+ /* FIXME: handle error condition */
+ free(tmp_backend);
+ return STATUS_ERR;
+}
+
+/* Release backend resources */
+void dbase_file_release(
+ dbase_file_backend_t* backend) {
+
+ free(backend);
+}
+
+/* FILE backend - method table implementation */
+dbase_backend_table_t SEMANAGE_FILE_BTABLE = {
+ .cache = dbase_file_cache,
+ .flush = dbase_file_flush,
+};
diff -Naur --exclude CVS libsemanage/src/database_file.h libsemanage.new2/src/database_file.h
--- libsemanage/src/database_file.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/database_file.h 2005-09-29 18:53:50.000000000 -0400
@@ -0,0 +1,23 @@
+#ifndef _SEMANAGE_DATABASE_FILE_INTERNAL_H_
+#define _SEMANAGE_DATABASE_FILE_INTERNAL_H_
+
+#include "database.h"
+#include "interfaces.h"
+
+struct dbase_file_backend;
+typedef struct dbase_file_backend dbase_file_backend_t;
+
+/* FILE backend - initialization */
+extern int dbase_file_init(
+ const char* filename,
+ record_file_table_t* rftable,
+ dbase_file_backend_t** backend);
+
+/* FILE backend - release */
+extern void dbase_file_release(
+ dbase_file_backend_t* backend);
+
+/* FILE backend - method table implementation */
+extern dbase_backend_table_t SEMANAGE_FILE_BTABLE;
+
+#endif
diff -Naur --exclude CVS libsemanage/src/database.h libsemanage.new2/src/database.h
--- libsemanage/src/database.h 2005-09-29 18:34:10.000000000 -0400
+++ libsemanage.new2/src/database.h 2005-09-29 18:57:01.000000000 -0400
@@ -7,19 +7,67 @@
#define RECORD_DEFINED
#endif
+#ifndef BACKEND_DEFINED
+typedef void* dbase_backend_t;
+#define BACKEND_DEFINED
+#endif
+
#include <stddef.h>
#include "handle.h"
#include "interfaces.h"
-struct dbase;
-typedef struct dbase dbase_t;
+/* ==========================================
+ Internal representation of the database.
+ Not to be used outside database_*.c
+ * =========================================== */
+
+/* Representation of the database once loaded in memory */
+typedef struct cache_entry {
+ record_t data;
+ struct cache_entry* next;
+} cache_entry_t;
+
+/* Database-specific configuration */
+typedef struct dbase {
+
+ /* Base record functions */
+ record_table_t* rtable;
+
+ /* Backend */
+ dbase_backend_t* backend;
+
+ /* Table to manipulate backend */
+ dbase_backend_table_t* btable;
+
+ /* In-memory representation (cache) */
+ cache_entry_t* cache;
+ size_t cache_sz;
+ int cached;
+ int cache_invalid;
+} dbase_t;
+
+/* Add a record to the database cache */
+extern int dbase_cache_add(
+ dbase_t* dbase,
+ record_t data);
+
+/* ======================================
+ API for use elsewhere:
+ ======================================= */
/* Initialize a database */
extern int dbase_init(
record_table_t* rtable,
- const char* filename,
+ dbase_backend_t* backend,
+ dbase_backend_table_t* btable,
dbase_t** dbase);
+/* Get back the backend object */
+static inline dbase_backend_t* dbase_get_backend(
+ dbase_t* dbase) {
+ return dbase->backend;
+}
+
/* Release a database */
extern void dbase_release(
dbase_t* dbase);
@@ -32,6 +80,7 @@
extern void dbase_invalidate_cache(
dbase_t* dbase);
+/* Standard database operations */
extern int dbase_add(
semanage_handle_t* handle,
dbase_t* dbase,
diff -Naur --exclude CVS libsemanage/src/handle.c libsemanage.new2/src/handle.c
--- libsemanage/src/handle.c 2005-09-29 17:54:40.000000000 -0400
+++ libsemanage.new2/src/handle.c 2005-09-29 19:14:00.000000000 -0400
@@ -124,8 +124,8 @@
semanage_conf_destroy(sh->conf);
/* Free object databases */
- dbase_release(sh->dbase[DBASE_USERS]);
- dbase_release(sh->dbase[DBASE_PORTS]);
+ user_file_dbase_release(sh->dbase[DBASE_USERS]);
+ port_file_dbase_release(sh->dbase[DBASE_PORTS]);
free(sh);
}
diff -Naur --exclude CVS libsemanage/src/interfaces.h libsemanage.new2/src/interfaces.h
--- libsemanage/src/interfaces.h 2005-09-23 10:38:06.000000000 -0400
+++ libsemanage.new2/src/interfaces.h 2005-09-29 18:58:33.000000000 -0400
@@ -1,7 +1,7 @@
#ifndef _SEMANAGE_RECORD_FILE_H_
#define _SEMANAGE_RECORD_FILE_H_
-#include <stdio.h>
+/* The interfaces below are used for polymorphism */
#ifndef RECORD_DEFINED
typedef void* record_t;
@@ -9,6 +9,17 @@
#define RECORD_DEFINED
#endif
+#ifndef BACKEND_DEFINED
+typedef void* dbase_backend_t;
+#define BACKEND_DEFINED
+#endif
+
+#include <stdio.h>
+#include <sepol/policydb.h>
+
+/* Circular dependency - can't include database.h */
+struct dbase;
+
/* Structure available during parsing (created internally) */
typedef struct parse_info {
/* Parser controlled */
@@ -22,7 +33,7 @@
void* parse_arg;
} parse_info_t;
-/* Record table format - necessary during processing */
+/* RECORD interface - method table */
typedef struct record_table {
/* Create a record */
@@ -41,6 +52,15 @@
/* Deep-copy clone of this record */
int (*clone) (record_t rec, record_t* new_rec);
+ /* Deallocate record resources. Must
+ * sucessfully handle NULL. */
+ void (*free) (record_t rec);
+
+} record_table_t;
+
+/* FILE extension to RECORD interface - method table */
+typedef struct record_file_table {
+
/* Fill record structuure based on supplied parse info.
* Parser must return STATUS_NODATA when EOF is encountered.
* Parser must handle NULL file stream correctly */
@@ -49,9 +69,28 @@
/* Print record to stream */
int (*print) (record_t record, FILE* str);
- /* Deallocate record resources. Must
- * sucessfully handle NULL. */
- void (*free) (record_t rec);
-} record_table_t;
+} record_file_table_t;
+
+/* POLICY DIRECT extension to RECORD interface - method table */
+typedef struct record_direct_table {
+
+ /* Load record into policy store */
+ int (*load) (policydb_t* policy, record_t record);
+
+ /* Extract records from policy store */
+ int (*list) (policydb_t* policy, record_t** records, size_t* nrecords);
+
+} record_direct_table_t;
+
+/* DBASE_BACKEND interface - method table */
+typedef struct dbase_backend_table {
+
+ /* Cache backend into dbase */
+ int (*cache) (struct dbase* dbase, dbase_backend_t* backend);
+
+ /* Flush dbase to backend */
+ int (*flush) (struct dbase* dbase, dbase_backend_t* backend);
+
+} dbase_backend_table_t;
#endif
diff -Naur --exclude CVS libsemanage/src/ports.c libsemanage.new2/src/ports.c
--- libsemanage/src/ports.c 2005-09-29 18:34:10.000000000 -0400
+++ libsemanage.new2/src/ports.c 2005-09-29 19:06:11.000000000 -0400
@@ -13,6 +13,17 @@
#include <semanage/ports.h>
#include "database.h"
#include "handle.h"
+#include "interfaces.h"
+
+/* Port base functions */
+record_table_t SEMANAGE_PORT_RTABLE = {
+ .create = semanage_port_create,
+ .key_extract = semanage_port_key_extract,
+ .key_free = semanage_port_key_free,
+ .clone = semanage_port_clone,
+ .compare = semanage_port_compare,
+ .free = semanage_port_free,
+};
int semanage_port_add(
semanage_handle_t* handle,
diff -Naur --exclude CVS libsemanage/src/ports_direct.c libsemanage.new2/src/ports_direct.c
--- libsemanage/src/ports_direct.c 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/ports_direct.c 2005-09-29 18:56:49.000000000 -0400
@@ -0,0 +1,54 @@
+/*
+ * Code for manipulating the port POLICY DIRECT backend
+ */
+#include <sepol/port_record.h>
+
+typedef sepol_port_t* record_t;
+typedef sepol_port_key_t* record_key_t;
+#define RECORD_DEFINED
+
+struct dbase_direct_backend;
+typedef struct dbase_direct_backend dbase_backend_t;
+#define BACKEND_DEFINED
+
+#include <stddef.h>
+#include <sepol/ports.h>
+#include <sepol/policydb.h>
+#include "ports_direct.h"
+#include "debug.h"
+#include "interfaces.h"
+#include "database_direct.h"
+
+/* PORT RECORD (SEPOL): method table (ports_policy.c) */
+extern record_table_t SEPOL_PORT_RTABLE;
+
+/* PORT RECORD (SEPOL): POLICY DIRECT extension : method table */
+record_direct_table_t SEMANAGE_PORT_DIRECT_RTABLE = {
+ .load = sepol_port_load,
+ .list = NULL, /* sepol_port_list, */
+};
+
+int port_direct_dbase_init(dbase_t** dbase) {
+ dbase_direct_backend_t* backend;
+
+ if (dbase_direct_init(
+ NULL, /* FIXME */
+ NULL, /* FIXME */
+ &SEMANAGE_PORT_DIRECT_RTABLE,
+ &backend) < 0)
+ return STATUS_ERR;
+
+ return dbase_init(
+ &SEPOL_PORT_RTABLE,
+ backend,
+ &SEMANAGE_DIRECT_BTABLE,
+ dbase);
+}
+
+void port_direct_dbase_release(dbase_t* dbase) {
+ if (dbase == NULL)
+ return;
+
+ dbase_direct_release(dbase_get_backend(dbase));
+ dbase_release(dbase);
+}
diff -Naur --exclude CVS libsemanage/src/ports_direct.h libsemanage.new2/src/ports_direct.h
--- libsemanage/src/ports_direct.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/ports_direct.h 2005-09-29 18:47:55.000000000 -0400
@@ -0,0 +1,16 @@
+#ifndef _SEMANAGE_PORTS_DIRECT_H_
+#define _SEMANAGE_PORTS_DIRECT_H_
+
+/*
+ * Header for the port POLICY DIRECT backend
+ */
+
+#include "database.h"
+
+int port_direct_dbase_init(
+ dbase_t** dbase);
+
+void port_direct_dbase_release(
+ dbase_t* dbase);
+
+#endif
diff -Naur --exclude CVS libsemanage/src/ports_file.c libsemanage.new2/src/ports_file.c
--- libsemanage/src/ports_file.c 2005-09-29 17:54:40.000000000 -0400
+++ libsemanage.new2/src/ports_file.c 2005-09-29 18:50:58.000000000 -0400
@@ -4,14 +4,17 @@
typedef semanage_port_key_t record_key_t;
#define RECORD_DEFINED
+struct dbase_file_backend;
+typedef struct dbase_file_backend dbase_backend_t;
+#define BACKEND_DEFINED
+
#include <stdlib.h>
#include <stdio.h>
-#include <semanage/port_record.h>
-#include "debug.h"
#include "interfaces.h"
-#include "database.h"
+#include "database_file.h"
+#include "debug.h"
-static int semanage_port_print(
+static int port_print(
semanage_port_t port,
FILE* str) {
@@ -21,7 +24,7 @@
return STATUS_SUCCESS;
}
-static int semanage_port_parse(
+static int port_parse(
parse_info_t* info,
semanage_port_t port) {
@@ -31,24 +34,28 @@
return STATUS_SUCCESS;
}
-record_table_t SEMANAGE_PORT_RTABLE = {
- /* Record base functions */
- .create = semanage_port_create,
- .key_extract = semanage_port_key_extract,
- .key_free = semanage_port_key_free,
- .clone = semanage_port_clone,
- .compare = semanage_port_compare,
- .free = semanage_port_free,
-
- /* Record functions for FILE backend */
- .parse = semanage_port_parse,
- .print = semanage_port_print,
+/* PORT RECORD: method table (ports.c) */
+extern record_table_t SEMANAGE_PORT_RTABLE;
+
+/* PORT RECORD: FILE extension: method table */
+record_file_table_t SEMANAGE_PORT_FILE_RTABLE = {
+ .parse = port_parse,
+ .print = port_print,
};
int port_file_dbase_init(dbase_t** dbase) {
+
+ dbase_file_backend_t* backend;
+
+ if (dbase_file_init(
+ NULL, /* FIXME */
+ &SEMANAGE_PORT_FILE_RTABLE, &backend) < 0)
+ return STATUS_ERR;
+
return dbase_init(
&SEMANAGE_PORT_RTABLE,
- NULL, /* FIXME */
+ backend,
+ &SEMANAGE_FILE_BTABLE,
dbase);
}
@@ -56,5 +63,6 @@
if (dbase == NULL)
return;
+ dbase_file_release(dbase_get_backend(dbase));
dbase_release(dbase);
}
diff -Naur --exclude CVS libsemanage/src/ports_policy.c libsemanage.new2/src/ports_policy.c
--- libsemanage/src/ports_policy.c 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/ports_policy.c 2005-09-29 19:01:45.000000000 -0400
@@ -0,0 +1,69 @@
+/*
+ * Common code for manipulating port POLICY backends
+ */
+
+#include <sepol/port_record.h>
+
+typedef sepol_port_key_t* record_key_t;
+typedef sepol_port_t* record_t;
+#define RECORD_DEFINED
+
+#include <semanage/port_record.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include "handle.h"
+#include "database.h"
+#include "interfaces.h"
+#include "ports_policy.h"
+#include "debug.h"
+
+static inline int convert(
+ semanage_port_key_t semanage_key,
+ semanage_port_t semanage_port,
+ sepol_port_key_t** sepol_key,
+ sepol_port_t** sepol_port) {
+
+ *sepol_key = (sepol_port_key_t*) semanage_key;
+ *sepol_port = (sepol_port_t*) semanage_port;
+ return STATUS_SUCCESS;
+}
+
+/* PORT RECORD (SEPOL): method table */
+record_table_t SEPOL_PORT_RTABLE = {
+ .create = sepol_port_create,
+ .key_extract = sepol_port_key_extract,
+ .key_free = sepol_port_key_free,
+ .clone = sepol_port_clone,
+ .compare = sepol_port_compare,
+ .free = sepol_port_free,
+};
+
+/* FIXME: might need to change */
+#if 0
+int semanage_port_policy_load(
+ semanage_handle_t* handle,
+ semanage_port_key_t key,
+ semanage_port_t data) {
+
+ sepol_port_t* sepol_data;
+ sepol_port_key_t* sepol_key;
+
+ if (convert(key, data, &sepol_key, &sepol_data) < 0)
+ return STATUS_ERR;
+
+ dbase_t* dbase = semanage_port_direct_dbase(handle);
+ return dbase_add(handle, dbase, sepol_key, sepol_data);
+}
+
+int semanage_port_policy_list(
+ semanage_handle_t* handle,
+ semanage_port_t** records,
+ size_t* count) {
+
+ /* Stub */
+ handle = NULL;
+ records = NULL;
+ count = NULL;
+ return STATUS_SUCCESS;
+}
+#endif
diff -Naur --exclude CVS libsemanage/src/ports_policy.h libsemanage.new2/src/ports_policy.h
--- libsemanage/src/ports_policy.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/ports_policy.h 2005-09-29 18:59:17.000000000 -0400
@@ -0,0 +1,18 @@
+#ifndef _SEMANAGE_PORTS_POLICY_H_
+#define _SEMANAGE_PORTS_POLICY_H_
+
+#include <stddef.h>
+#include <semanage/port_record.h>
+#include "handle.h"
+
+int semanage_port_policy_load(
+ semanage_handle_t* handle,
+ semanage_port_key_t key,
+ semanage_port_t data);
+
+int semanage_port_policy_list(
+ semanage_handle_t* handle,
+ semanage_port_t** records,
+ size_t* count);
+
+#endif
diff -Naur --exclude CVS libsemanage/src/users.c libsemanage.new2/src/users.c
--- libsemanage/src/users.c 2005-09-29 18:34:10.000000000 -0400
+++ libsemanage.new2/src/users.c 2005-09-29 19:06:03.000000000 -0400
@@ -13,6 +13,17 @@
#include <semanage/users.h>
#include "handle.h"
#include "database.h"
+#include "interfaces.h"
+
+/* Record base functions */
+record_table_t SEMANAGE_USER_RTABLE = {
+ .create = semanage_user_create,
+ .key_extract = semanage_user_key_extract,
+ .key_free = semanage_user_key_free,
+ .clone = semanage_user_clone,
+ .compare = semanage_user_compare,
+ .free = semanage_user_free,
+};
int semanage_user_add(
semanage_handle_t* handle,
diff -Naur --exclude CVS libsemanage/src/users_direct.c libsemanage.new2/src/users_direct.c
--- libsemanage/src/users_direct.c 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/users_direct.c 2005-09-29 18:56:47.000000000 -0400
@@ -0,0 +1,54 @@
+/*
+ * Code for manipulating the user DATA FILE backend
+ */
+#include <sepol/user_record.h>
+
+typedef sepol_user_t* record_t;
+typedef sepol_user_key_t* record_key_t;
+#define RECORD_DEFINED
+
+struct dbase_direct_backend;
+typedef struct dbase_direct_backend dbase_backend_t;
+#define BACKEND_DEFINED
+
+#include <stddef.h>
+#include <sepol/users.h>
+#include <sepol/policydb.h>
+#include "users_direct.h"
+#include "debug.h"
+#include "interfaces.h"
+#include "database_direct.h"
+
+/* USER RECORD (SEPOL): method table (users_policy.c) */
+extern record_table_t SEPOL_USER_RTABLE;
+
+/* USER RECRORD (SEPOL): POLICY DIRECT extension: method table */
+record_direct_table_t SEMANAGE_USER_DIRECT_RTABLE = {
+ .load = sepol_user_load,
+ .list = NULL, /* sepol_user_list */
+};
+
+int user_direct_dbase_init(dbase_t** dbase) {
+ dbase_direct_backend_t* backend;
+
+ if (dbase_direct_init(
+ NULL, /* FIXME */
+ NULL, /* FIXME */
+ &SEMANAGE_USER_DIRECT_RTABLE,
+ &backend) < 0)
+ return STATUS_ERR;
+
+ return dbase_init(
+ &SEPOL_USER_RTABLE,
+ backend,
+ &SEMANAGE_DIRECT_BTABLE,
+ dbase);
+}
+
+void user_direct_dbase_release(dbase_t* dbase) {
+ if (dbase == NULL)
+ return;
+
+ dbase_direct_release(dbase_get_backend(dbase));
+ dbase_release(dbase);
+}
diff -Naur --exclude CVS libsemanage/src/users_direct.h libsemanage.new2/src/users_direct.h
--- libsemanage/src/users_direct.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/users_direct.h 2005-09-29 18:47:50.000000000 -0400
@@ -0,0 +1,16 @@
+#ifndef _SEMANAGE_USERS_DIRECT_H_
+#define _SEMANAGE_USERS_DIRECT_H_
+
+/*
+ * Header for the user POLICY DIRECT backend
+ */
+
+#include "database.h"
+
+int user_direct_dbase_init(
+ dbase_t** dbase);
+
+void user_direct_dbase_release(
+ dbase_t* dbase);
+
+#endif
diff -Naur --exclude CVS libsemanage/src/users_file.c libsemanage.new2/src/users_file.c
--- libsemanage/src/users_file.c 2005-09-29 17:54:40.000000000 -0400
+++ libsemanage.new2/src/users_file.c 2005-09-29 19:11:43.000000000 -0400
@@ -4,13 +4,17 @@
typedef semanage_user_key_t record_key_t;
#define RECORD_DEFINED
+struct dbase_file_backend;
+typedef struct dbase_file_backend dbase_backend_t;
+#define BACKEND_DEFINED
+
#include <stdlib.h>
#include <stdio.h>
#include "interfaces.h"
-#include "database.h"
+#include "database_file.h"
#include "debug.h"
-static int semanage_user_print(
+static int user_print(
semanage_user_t user,
FILE* str) {
@@ -20,7 +24,7 @@
return STATUS_SUCCESS;
}
-static int semanage_user_parse(
+static int user_parse(
parse_info_t* info,
semanage_user_t user) {
@@ -30,24 +34,28 @@
return STATUS_SUCCESS;
}
-record_table_t SEMANAGE_USER_RTABLE = {
- /* Record base functions */
- .create = semanage_user_create,
- .key_extract = semanage_user_key_extract,
- .key_free = semanage_user_key_free,
- .clone = semanage_user_clone,
- .compare = semanage_user_compare,
- .free = semanage_user_free,
-
- /* Record functions for FILE backend */
- .parse = semanage_user_parse,
- .print = semanage_user_print,
+/* USER RECORD: metod table (users.c) */
+extern record_table_t SEMANAGE_USER_RTABLE;
+
+/* USER RECORD: FILE extension: method table */
+record_file_table_t SEMANAGE_USER_FILE_RTABLE = {
+ .parse = user_parse,
+ .print = user_print,
};
int user_file_dbase_init(dbase_t** dbase) {
+ dbase_file_backend_t* backend;
+
+ if (dbase_file_init(
+ NULL, /* FIXME */
+ &SEMANAGE_USER_FILE_RTABLE,
+ &backend) < 0)
+ return STATUS_ERR;
+
return dbase_init(
&SEMANAGE_USER_RTABLE,
- NULL, /* FIXME */
+ backend,
+ &SEMANAGE_FILE_BTABLE,
dbase);
}
@@ -55,6 +63,6 @@
if (dbase == NULL)
return;
+ dbase_file_release(dbase_get_backend(dbase));
dbase_release(dbase);
}
-
diff -Naur --exclude CVS libsemanage/src/users_policy.c libsemanage.new2/src/users_policy.c
--- libsemanage/src/users_policy.c 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/users_policy.c 2005-09-29 19:01:58.000000000 -0400
@@ -0,0 +1,69 @@
+/*
+ * Common code for manipulating user POLICY backends
+ */
+
+#include <sepol/user_record.h>
+
+typedef sepol_user_key_t* record_key_t;
+typedef sepol_user_t* record_t;
+#define RECORD_DEFINED
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <semanage/user_record.h>
+#include "handle.h"
+#include "database.h"
+#include "interfaces.h"
+#include "users_policy.h"
+#include "debug.h"
+
+static inline int convert(
+ semanage_user_key_t semanage_key,
+ semanage_user_t semanage_user,
+ sepol_user_key_t** sepol_key,
+ sepol_user_t** sepol_user) {
+
+ *sepol_key = (sepol_user_key_t*) semanage_key;
+ *sepol_user = (sepol_user_t*) semanage_user;
+ return STATUS_SUCCESS;
+}
+
+/* USER RECORD (SEPOL): method table */
+record_table_t SEPOL_USER_RTABLE = {
+ .create = sepol_user_create,
+ .key_extract = sepol_user_key_extract,
+ .key_free = sepol_user_key_free,
+ .clone = sepol_user_clone,
+ .compare = sepol_user_compare,
+ .free = sepol_user_free,
+};
+
+/* FIXME: might need to change */
+#if 0
+int semanage_user_policy_load(
+ semanage_handle_t* handle,
+ semanage_user_key_t key,
+ semanage_user_t data) {
+
+ sepol_user_t* sepol_data;
+ sepol_user_key_t* sepol_key;
+
+ if (convert(key, data, &sepol_key, &sepol_data) < 0)
+ return STATUS_ERR;
+
+ dbase_t* dbase = semanage_user_direct_dbase(handle);
+ return dbase_add(handle, dbase, sepol_key, sepol_data);
+}
+
+int semanage_user_policy_list(
+ semanage_handle_t* handle,
+ semanage_user_t** records,
+ size_t* count) {
+
+ /* Stub */
+ handle = NULL;
+ records = NULL;
+ count = NULL;
+ return STATUS_SUCCESS;
+}
+#endif
diff -Naur --exclude CVS libsemanage/src/users_policy.h libsemanage.new2/src/users_policy.h
--- libsemanage/src/users_policy.h 1969-12-31 19:00:00.000000000 -0500
+++ libsemanage.new2/src/users_policy.h 2005-09-29 18:59:14.000000000 -0400
@@ -0,0 +1,18 @@
+#ifndef _SEMANAGE_USERS_POLICY_H_
+#define _SEMANAGE_USERS_POLICY_H_
+
+#include <stddef.h>
+#include <semanage/user_record.h>
+#include "handle.h"
+
+int semanage_user_policy_load(
+ semanage_handle_t* handle,
+ semanage_user_key_t key,
+ semanage_user_t data);
+
+int semanage_user_policy_list(
+ semanage_handle_t* handle,
+ semanage_user_t** records,
+ size_t* count);
+
+#endif
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: [ 7/9 ] [ SEMANAGE ] Backend separation (Init 3)
2005-09-30 3:14 ` [ 7/9 ] [ SEMANAGE ] Backend separation (Init 3) Ivan Gyurdiev
@ 2005-09-30 13:45 ` Ivan Gyurdiev
0 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 13:45 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
I think this patch is definitely on the right track to separating the
cached dbase/list from its backend. Also, remember that I initially
wanted to iterate the flat file per function call. I later decided this
was a bad idea, after talking to Karl, but pointed out that in some
cases we don't want to load the whole database in memory, because it
might be too large.
One such case are rules. In particular, rule tables are compressed
within the policydb (via pointers to strings that are shared), and you
can't really implement a list() function based on records and keep that
compression at the same time - it's an internal policy detail and those
records are specifically designed _not_ to expose those - each record
should be standalone from the policy/other records.
In the general case, what we really want is... an iterate() function in
the backend. This addresses the concern of loading a large database in
memory by pushing the work to the backend. We still need the iterate()
function on the list in memory, because that's faster. However, we
should add the ability to mark a dbase "noncachable", and then look at
that in dbase_* functions, and if it says noncachable, we should not
attempt to construct a memory cache of the database, but instead should
use the backend iterate() function. Of course, if what you're really
doing is calling the list() function (as opposed to
query/count/exists/iterate/*), this won't gain you anything, but
really, for rules, who wants to look at the entire ruleset of a zillion
rules? What we probably want is a method to loop over them, and apply
programmatic changes or analyze them. I can add noncachable support on
certain functions one by one - no need to cover all of them now.. no
need to implement this on the FILE case either, which is what I was
doing initially...
I think this is one of my planned architecture changes before I try to
implement operations on a rule record.
--
This message was distributed to subscribers of the selinux mailing list.
If you no longer wish to subscribe, send mail to majordomo@tycho.nsa.gov with
the words "unsubscribe selinux" without quotes as the message.
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [ 8/9 ] [ SEMANAGE ] Eliminate struct pointer typedefs
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
` (5 preceding siblings ...)
2005-09-30 3:14 ` [ 7/9 ] [ SEMANAGE ] Backend separation (Init 3) Ivan Gyurdiev
@ 2005-09-30 3:16 ` Ivan Gyurdiev
2005-09-30 3:26 ` [ 9/9 ] [ SEPOL ] User list function, Bugfixes Ivan Gyurdiev
` (2 subsequent siblings)
9 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 3:16 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
[-- Attachment #1: Type: text/plain, Size: 140 bytes --]
This is the SEMANAGE equivalent to the first patch I sent for SEPOL.
It replaces struct pointer typedefs with struct alias for consistency.
[-- Attachment #2: libsemanage.07.consistency.typedefs.diff --]
[-- Type: text/x-patch, Size: 46879 bytes --]
diff -Naru --exclude CVS libsemanage/include/semanage/boolean_record.h libsemanage.new/include/semanage/boolean_record.h
--- libsemanage/include/semanage/boolean_record.h 2005-09-23 10:37:40.000000000 -0400
+++ libsemanage.new/include/semanage/boolean_record.h 2005-09-29 19:50:05.000000000 -0400
@@ -3,50 +3,50 @@
struct semanage_bool;
struct semanage_bool_key;
-typedef struct semanage_bool* semanage_bool_t;
-typedef struct semanage_bool_key* semanage_bool_key_t;
+typedef struct semanage_bool semanage_bool_t;
+typedef struct semanage_bool_key semanage_bool_key_t;
/* Key */
extern int semanage_bool_key_create(
const char* name,
- semanage_bool_key_t* key);
+ semanage_bool_key_t** key);
extern int semanage_bool_key_extract(
- semanage_bool_t boolean,
- semanage_bool_key_t* key);
+ semanage_bool_t* boolean,
+ semanage_bool_key_t** key);
extern void semanage_bool_key_free(
- semanage_bool_key_t key);
+ semanage_bool_key_t* key);
extern int semanage_bool_compare(
- semanage_bool_t boolean,
- semanage_bool_key_t key);
+ semanage_bool_t* boolean,
+ semanage_bool_key_t* key);
/* Name */
extern const char* semanage_bool_get_name(
- semanage_bool_t boolean);
+ semanage_bool_t* boolean);
extern int semanage_bool_set_name(
- semanage_bool_t boolean,
+ semanage_bool_t* boolean,
const char* name);
/* Value */
extern int semanage_bool_get_value(
- semanage_bool_t boolean);
+ semanage_bool_t* boolean);
extern void semanage_bool_set_value(
- semanage_bool_t boolean,
+ semanage_bool_t* boolean,
int value);
/* Create/Clone/Destroy */
extern int semanage_bool_create(
- semanage_bool_t* bool_ptr);
+ semanage_bool_t** bool_ptr);
extern int semanage_bool_clone(
- semanage_bool_t boolean,
- semanage_bool_t* bool_ptr);
+ semanage_bool_t* boolean,
+ semanage_bool_t** bool_ptr);
extern void semanage_bool_free(
- semanage_bool_t boolean);
+ semanage_bool_t* boolean);
#endif
diff -Naru --exclude CVS libsemanage/include/semanage/context_record.h libsemanage.new/include/semanage/context_record.h
--- libsemanage/include/semanage/context_record.h 2005-09-23 10:37:40.000000000 -0400
+++ libsemanage.new/include/semanage/context_record.h 2005-09-29 19:50:02.000000000 -0400
@@ -2,57 +2,57 @@
#define _SEMANAGE_CONTEXT_RECORD_H_
struct semanage_context;
-typedef struct semanage_context* semanage_context_t;
+typedef struct semanage_context semanage_context_t;
/* User */
extern const char* semanage_context_get_user(
- semanage_context_t con);
+ semanage_context_t* con);
extern int semanage_context_set_user(
- semanage_context_t con,
+ semanage_context_t* con,
const char* user);
/* Role */
extern const char* semanage_context_get_role(
- semanage_context_t con);
+ semanage_context_t* con);
extern int semanage_context_set_role(
- semanage_context_t con,
+ semanage_context_t* con,
const char* role);
/* Type */
extern const char* semanage_context_get_type(
- semanage_context_t con);
+ semanage_context_t* con);
extern int semanage_context_set_type(
- semanage_context_t con,
+ semanage_context_t* con,
const char* type);
/* MLS */
extern const char* semanage_context_get_mls(
- semanage_context_t con);
+ semanage_context_t* con);
extern int semanage_context_set_mls(
- semanage_context_t con,
+ semanage_context_t* con,
const char* mls_range);
/* Create/Clone/Destroy */
extern int semanage_context_create(
- semanage_context_t* con_ptr);
+ semanage_context_t** con_ptr);
extern int semanage_context_clone(
- semanage_context_t con,
- semanage_context_t* con_ptr);
+ semanage_context_t* con,
+ semanage_context_t** con_ptr);
extern void semanage_context_free(
- semanage_context_t con);
+ semanage_context_t* con);
/* Parse to/from string */
extern int semanage_context_from_string(
const char* str,
- semanage_context_t* con);
+ semanage_context_t** con);
extern char* semanage_context_to_string(
- semanage_context_t con);
+ semanage_context_t* con);
#endif
diff -Naru --exclude CVS libsemanage/include/semanage/iface_record.h libsemanage.new/include/semanage/iface_record.h
--- libsemanage/include/semanage/iface_record.h 2005-09-23 10:37:40.000000000 -0400
+++ libsemanage.new/include/semanage/iface_record.h 2005-09-29 19:52:17.000000000 -0400
@@ -5,57 +5,57 @@
struct semanage_iface;
struct semanage_iface_key;
-typedef struct semanage_iface* semanage_iface_t;
-typedef struct semanage_iface_key* semanage_iface_key_t;
+typedef struct semanage_iface semanage_iface_t;
+typedef struct semanage_iface_key semanage_iface_key_t;
/* Key */
extern int semanage_iface_compare(
- semanage_iface_t iface,
- semanage_iface_key_t key);
+ semanage_iface_t* iface,
+ semanage_iface_key_t* key);
extern int semanage_iface_key_create(
const char* name,
- semanage_iface_key_t* key_ptr);
+ semanage_iface_key_t** key_ptr);
extern int semanage_iface_key_extract(
- semanage_iface_t iface,
- semanage_iface_key_t* key_ptr);
+ semanage_iface_t* iface,
+ semanage_iface_key_t** key_ptr);
extern void semanage_iface_key_free(
- semanage_iface_key_t key);
+ semanage_iface_key_t* key);
/* Name */
extern const char* semanage_iface_get_name(
- semanage_iface_t iface);
+ semanage_iface_t* iface);
extern int semanage_iface_set_name(
semanage_user_t iface,
const char* name);
/* Context */
-extern semanage_context_t semanage_iface_get_ifcon(
- semanage_iface_t iface);
+extern semanage_context_t* semanage_iface_get_ifcon(
+ semanage_iface_t* iface);
extern int semanage_iface_set_ifcon(
- semanage_iface_t iface,
- semanage_context_t con);
+ semanage_iface_t* iface,
+ semanage_context_t* con);
-extern semanage_context_t semanage_iface_get_msgcon(
- semanage_iface_t iface);
+extern semanage_context_t* semanage_iface_get_msgcon(
+ semanage_iface_t* iface);
extern int semanage_iface_set_msgcon(
- semanage_iface_t iface,
- semanage_context_t con);
+ semanage_iface_t* iface,
+ semanage_context_t* con);
/* Create/Clone/Destroy */
extern int semanage_iface_create(
- semanage_iface_t* iface_ptr);
+ semanage_iface_t** iface_ptr);
extern int semanage_iface_clone(
- semanage_iface_t iface,
- semanage_iface_t* iface_ptr);
+ semanage_iface_t* iface,
+ semanage_iface_t** iface_ptr);
extern void semanage_iface_free(
- semanage_iface_t iface);
+ semanage_iface_t* iface);
#endif
diff -Naru --exclude CVS libsemanage/include/semanage/port_record.h libsemanage.new/include/semanage/port_record.h
--- libsemanage/include/semanage/port_record.h 2005-09-23 10:37:40.000000000 -0400
+++ libsemanage.new/include/semanage/port_record.h 2005-09-29 19:56:21.000000000 -0400
@@ -5,72 +5,72 @@
struct semanage_port;
struct semanage_port_key;
-typedef struct semanage_port* semanage_port_t;
-typedef struct semanage_port_key* semanage_port_key_t;
+typedef struct semanage_port semanage_port_t;
+typedef struct semanage_port_key semanage_port_key_t;
-#define SEMANAGE_PROTO_UDP SEPOL_PROTO_UDP
-#define SEMANAGE_PROTO_TCP SEPOL_PROTO_TCP
+#define SEMANAGE_PROTO_UDP 0
+#define SEMANAGE_PROTO_TCP 1
/* Key */
extern int semanage_port_compare(
- semanage_port_t port,
- semanage_port_key_t key);
+ semanage_port_t* port,
+ semanage_port_key_t* key);
extern int semanage_port_key_create(
int low, int high,
int proto,
- semanage_port_key_t* key_ptr);
+ semanage_port_key_t** key_ptr);
extern int semanage_port_key_extract(
- semanage_port_t port,
- semanage_port_key_t* key_ptr);
+ semanage_port_t* port,
+ semanage_port_key_t** key_ptr);
extern void semanage_port_key_free(
- semanage_port_key_t key);
+ semanage_port_key_t* key);
/* Protocol */
extern int semanage_port_get_proto(
- semanage_port_t port);
+ semanage_port_t* port);
extern int semanage_port_set_proto(
- semanage_port_t port,
+ semanage_port_t* port,
int proto);
extern const char* semanage_port_get_proto_str(
- semanage_port_t port);
+ semanage_port_t* port);
/* Port */
extern int semanage_port_get_low(
- semanage_port_t port);
+ semanage_port_t* port);
extern int semanage_port_get_high(
- semanage_port_t port);
+ semanage_port_t* port);
extern int semanage_port_set_port(
- semanage_port_t port,
+ semanage_port_t* port,
int port_num);
extern int semanage_port_set_range(
- semanage_port_t port,
+ semanage_port_t* port,
int low, int high);
/* Context */
-extern semanage_context_t semanage_port_get_con(
- semanage_port_t port);
+extern semanage_context_t* semanage_port_get_con(
+ semanage_port_t* port);
extern int semanage_port_set_con(
- semanage_port_t port,
- semanage_context_t con);
+ semanage_port_t* port,
+ semanage_context_t* con);
/* Create/Clone/Destroy */
extern int semanage_port_create(
- semanage_port_t* port_ptr);
+ semanage_port_t** port_ptr);
extern int semanage_port_clone(
- semanage_port_t port,
- semanage_port_t* port_ptr);
+ semanage_port_t* port,
+ semanage_port_t** port_ptr);
extern void semanage_port_free(
- semanage_port_t port);
+ semanage_port_t* port);
#endif
diff -Naru --exclude CVS libsemanage/include/semanage/ports.h libsemanage.new/include/semanage/ports.h
--- libsemanage/include/semanage/ports.h 2005-09-29 18:34:10.000000000 -0400
+++ libsemanage.new/include/semanage/ports.h 2005-09-29 19:55:09.000000000 -0400
@@ -7,26 +7,26 @@
extern int semanage_port_add(
semanage_handle_t* handle,
- semanage_port_key_t key,
- semanage_port_t data);
+ semanage_port_key_t* key,
+ semanage_port_t* data);
extern int semanage_port_modify(
semanage_handle_t* handle,
- semanage_port_key_t key,
- semanage_port_t data);
+ semanage_port_key_t* key,
+ semanage_port_t* data);
extern int semanage_port_del(
semanage_handle_t* handle,
- semanage_port_key_t key);
+ semanage_port_key_t* key);
extern int semanage_port_query(
semanage_handle_t* handle,
- semanage_port_key_t key,
- semanage_port_t* response);
+ semanage_port_key_t* key,
+ semanage_port_t** response);
extern int semanage_port_exists(
semanage_handle_t* handle,
- semanage_port_key_t key,
+ semanage_port_key_t* key,
int* response);
extern int semanage_port_count(
@@ -35,13 +35,13 @@
extern int semanage_port_iterate(
semanage_handle_t* handle,
- int (*handler) (semanage_port_t record,
+ int (*handler) (semanage_port_t* record,
void* varg),
void* handler_arg);
extern int semanage_port_list(
semanage_handle_t* handle,
- semanage_port_t** records,
+ semanage_port_t*** records,
size_t* count);
#endif
diff -Naru --exclude CVS libsemanage/include/semanage/user_record.h libsemanage.new/include/semanage/user_record.h
--- libsemanage/include/semanage/user_record.h 2005-09-29 16:59:38.000000000 -0400
+++ libsemanage.new/include/semanage/user_record.h 2005-09-29 19:53:37.000000000 -0400
@@ -5,89 +5,89 @@
struct semanage_user;
struct semanage_user_key;
-typedef struct semanage_user* semanage_user_t;
-typedef struct semanage_user_key* semanage_user_key_t;
+typedef struct semanage_user semanage_user_t;
+typedef struct semanage_user_key semanage_user_key_t;
/* Key */
extern int semanage_user_key_create(
const char* name,
- semanage_user_key_t* key);
+ semanage_user_key_t** key);
extern int semanage_user_key_extract(
- semanage_user_t user,
- semanage_user_key_t* key);
+ semanage_user_t* user,
+ semanage_user_key_t** key);
extern void semanage_user_key_free(
- semanage_user_key_t key);
+ semanage_user_key_t* key);
extern int semanage_user_compare(
- semanage_user_t user,
- semanage_user_key_t key);
+ semanage_user_t* user,
+ semanage_user_key_t* key);
/* Name */
extern const char* semanage_user_get_name(
- semanage_user_t user);
+ semanage_user_t* user);
extern int semanage_user_set_name(
- semanage_user_t user,
+ semanage_user_t* user,
const char* name);
/* MLS */
extern const char* semanage_user_get_mlslevel(
- semanage_user_t user);
+ semanage_user_t* user);
extern int semanage_user_set_mlslevel(
- semanage_user_t user,
+ semanage_user_t* user,
const char* mls_level);
extern const char* semanage_user_get_mlsrange(
- semanage_user_t user);
+ semanage_user_t* user);
extern int semanage_user_set_mlsrange(
- semanage_user_t user,
+ semanage_user_t* user,
const char* mls_range);
/* Role management */
extern int semanage_user_get_num_roles(
- semanage_user_t user);
+ semanage_user_t* user);
extern const char* semanage_user_get_defrole(
- semanage_user_t user);
+ semanage_user_t* user);
extern int semanage_user_add_role(
- semanage_user_t user,
+ semanage_user_t* user,
const char* role);
extern int semanage_user_del_role(
- semanage_user_t user,
+ semanage_user_t* user,
const char* role);
extern int semanage_user_has_role(
- semanage_user_t user,
+ semanage_user_t* user,
const char* role);
extern int semanage_user_set_defrole(
- semanage_user_t user,
+ semanage_user_t* user,
const char* role);
extern int semanage_user_get_roles(
- semanage_user_t user,
+ semanage_user_t* user,
const char*** roles_arr,
size_t* num_roles);
extern int semanage_user_set_roles(
- semanage_user_t user,
+ semanage_user_t* user,
const char** roles_arr,
size_t num_roles);
/* Create/Clone/Destroy */
extern int semanage_user_create(
- semanage_user_t* user_ptr);
+ semanage_user_t** user_ptr);
extern int semanage_user_clone(
- semanage_user_t user,
- semanage_user_t* user_ptr);
+ semanage_user_t* user,
+ semanage_user_t** user_ptr);
extern void semanage_user_free(
- semanage_user_t user);
+ semanage_user_t* user);
#endif
diff -Naru --exclude CVS libsemanage/include/semanage/users.h libsemanage.new/include/semanage/users.h
--- libsemanage/include/semanage/users.h 2005-09-29 18:34:10.000000000 -0400
+++ libsemanage.new/include/semanage/users.h 2005-09-29 19:54:22.000000000 -0400
@@ -7,26 +7,26 @@
extern int semanage_user_add(
semanage_handle_t* handle,
- semanage_user_key_t key,
- semanage_user_t data);
+ semanage_user_key_t* key,
+ semanage_user_t* data);
extern int semanage_user_modify(
semanage_handle_t* handle,
- semanage_user_key_t key,
- semanage_user_t data);
+ semanage_user_key_t* key,
+ semanage_user_t* data);
extern int semanage_user_del(
semanage_handle_t* handle,
- semanage_user_key_t key);
+ semanage_user_key_t* key);
extern int semanage_user_query(
semanage_handle_t* handle,
- semanage_user_key_t key,
- semanage_user_t* response);
+ semanage_user_key_t* key,
+ semanage_user_t** response);
extern int semanage_user_exists(
semanage_handle_t* handle,
- semanage_user_key_t key,
+ semanage_user_key_t* key,
int* response);
extern int semanage_user_count(
@@ -35,13 +35,13 @@
extern int semanage_user_iterate(
semanage_handle_t* handle,
- int (*handler) (semanage_user_t record,
+ int (*handler) (semanage_user_t* record,
void* varg),
void* handler_arg);
extern int semanage_user_list(
semanage_handle_t* handle,
- semanage_user_t** records,
+ semanage_user_t*** records,
size_t* count);
#endif
diff -Naru --exclude CVS libsemanage/src/boolean_record.c libsemanage.new/src/boolean_record.c
--- libsemanage/src/boolean_record.c 2005-09-29 16:59:38.000000000 -0400
+++ libsemanage.new/src/boolean_record.c 2005-09-29 19:34:45.000000000 -0400
@@ -1,52 +1,78 @@
#include <sepol/boolean_record.h>
-typedef sepol_bool_t* semanage_bool_t;
-typedef sepol_bool_key_t* semanage_bool_key_t;
+typedef sepol_bool_t semanage_bool_t;
+typedef sepol_bool_key_t semanage_bool_key_t;
/* Key */
-int semanage_bool_key_create(const char* name, semanage_bool_key_t* key) {
+int semanage_bool_key_create(
+ const char* name,
+ semanage_bool_key_t** key) {
+
return sepol_bool_key_create(name, key);
}
-int semanage_bool_key_extract(semanage_bool_t boolean, semanage_bool_key_t* key) {
+int semanage_bool_key_extract(
+ semanage_bool_t* boolean,
+ semanage_bool_key_t** key) {
+
return sepol_bool_key_extract(boolean, key);
}
-void semanage_bool_key_free(semanage_bool_key_t key) {
+void semanage_bool_key_free(semanage_bool_key_t* key) {
sepol_bool_key_free(key);
}
-int semanage_bool_compare(semanage_bool_t boolean, semanage_bool_key_t key) {
+int semanage_bool_compare(
+ semanage_bool_t* boolean,
+ semanage_bool_key_t* key) {
+
return sepol_bool_compare(boolean, key);
}
/* Name */
-const char* semanage_bool_get_name(semanage_bool_t boolean) {
+const char* semanage_bool_get_name(
+ semanage_bool_t* boolean) {
+
return sepol_bool_get_name(boolean);
}
-int semanage_bool_set_name(semanage_bool_t boolean, const char* name) {
+int semanage_bool_set_name(
+ semanage_bool_t* boolean,
+ const char* name) {
+
return sepol_bool_set_name(boolean, name);
}
/* Value */
-int semanage_bool_get_value(semanage_bool_t boolean) {
+int semanage_bool_get_value(
+ semanage_bool_t* boolean) {
+
return sepol_bool_get_value(boolean);
}
-void semanage_bool_set_value(semanage_bool_t boolean, int value) {
+void semanage_bool_set_value(
+ semanage_bool_t* boolean,
+ int value) {
+
sepol_bool_set_value(boolean, value);
}
/* Create/Clone/Destroy */
-int semanage_bool_create(semanage_bool_t* bool_ptr) {
+int semanage_bool_create(
+ semanage_bool_t** bool_ptr) {
+
return sepol_bool_create(bool_ptr);
}
-int semanage_bool_clone(semanage_bool_t boolean, semanage_bool_t* bool_ptr) {
+int semanage_bool_clone(
+ semanage_bool_t* boolean,
+ semanage_bool_t** bool_ptr) {
+
return sepol_bool_clone(boolean, bool_ptr);
}
-void semanage_bool_free(semanage_bool_t boolean) {
+void semanage_bool_free(
+ semanage_bool_t* boolean) {
+
sepol_bool_free(boolean);
}
diff -Naru --exclude CVS libsemanage/src/context_record.c libsemanage.new/src/context_record.c
--- libsemanage/src/context_record.c 2005-09-29 16:59:38.000000000 -0400
+++ libsemanage.new/src/context_record.c 2005-09-29 19:27:31.000000000 -0400
@@ -1,61 +1,61 @@
#include <sepol/context_record.h>
-typedef sepol_context_t* semanage_context_t;
+typedef sepol_context_t semanage_context_t;
/* User */
-const char* semanage_context_get_user(semanage_context_t con) {
+const char* semanage_context_get_user(semanage_context_t* con) {
return sepol_context_get_user(con);
}
-int semanage_context_set_user(semanage_context_t con, const char* user) {
+int semanage_context_set_user(semanage_context_t* con, const char* user) {
return sepol_context_set_user(con, user);
}
/* Role */
-const char* semanage_context_get_role(semanage_context_t con) {
+const char* semanage_context_get_role(semanage_context_t* con) {
return sepol_context_get_role(con);
}
-int semanage_context_set_role(semanage_context_t con, const char* role) {
+int semanage_context_set_role(semanage_context_t* con, const char* role) {
return sepol_context_set_role(con, role);
}
/* Type */
-const char* semanage_context_get_type(semanage_context_t con) {
+const char* semanage_context_get_type(semanage_context_t* con) {
return sepol_context_get_type(con);
}
-int semanage_context_set_type(semanage_context_t con, const char* type) {
+int semanage_context_set_type(semanage_context_t* con, const char* type) {
return sepol_context_set_type(con, type);
}
/* MLS */
-const char* semanage_context_get_mls(semanage_context_t con) {
+const char* semanage_context_get_mls(semanage_context_t* con) {
return sepol_context_get_mls(con);
}
-int semanage_context_set_mls(semanage_context_t con, const char* mls_range) {
+int semanage_context_set_mls(semanage_context_t* con, const char* mls_range) {
return sepol_context_set_mls(con, mls_range);
}
/* Create/Clone/Destroy */
-int semanage_context_create(semanage_context_t* con_ptr) {
+int semanage_context_create(semanage_context_t** con_ptr) {
return sepol_context_create(con_ptr);
}
-int semanage_context_clone(semanage_context_t con, semanage_context_t* con_ptr) {
+int semanage_context_clone(semanage_context_t* con, semanage_context_t** con_ptr) {
return sepol_context_clone(con, con_ptr);
}
-void semanage_context_free(semanage_context_t con) {
+void semanage_context_free(semanage_context_t* con) {
sepol_context_free(con);
}
/* Parse to/from string */
-int semanage_context_from_string(const char* str, semanage_context_t* con) {
+int semanage_context_from_string(const char* str, semanage_context_t** con) {
return sepol_context_from_string(str, con);
}
-char* semanage_context_to_string(semanage_context_t con) {
+char* semanage_context_to_string(semanage_context_t* con) {
return sepol_context_to_string(con);
}
diff -Naru --exclude CVS libsemanage/src/database.c libsemanage.new/src/database.c
--- libsemanage/src/database.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/database.c 2005-09-29 19:59:38.000000000 -0400
@@ -69,7 +69,7 @@
int dbase_cache_add(
dbase_t* dbase,
- record_t data) {
+ record_t* data) {
cache_entry_t* entry =
(cache_entry_t*) malloc(sizeof (cache_entry_t));
@@ -88,7 +88,7 @@
static int dbase_cache_locate(
dbase_t* dbase,
- record_key_t key,
+ record_key_t* key,
cache_entry_t** entry) {
cache_entry_t* ptr;
@@ -112,8 +112,8 @@
int dbase_add(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key,
- record_t data) {
+ record_key_t* key,
+ record_t* data) {
int exists;
@@ -142,8 +142,8 @@
int dbase_modify(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key,
- record_t data) {
+ record_key_t* key,
+ record_t* data) {
cache_entry_t* entry;
int status;
@@ -170,7 +170,7 @@
int dbase_del(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key) {
+ record_key_t* key) {
cache_entry_t *ptr, *prev = NULL;
@@ -203,8 +203,8 @@
int dbase_query(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key,
- record_t* response) {
+ record_key_t* key,
+ record_t** response) {
cache_entry_t* entry;
int status;
@@ -216,7 +216,7 @@
if (status < 0 || status == STATUS_NODATA)
goto err;
- if (dbase->rtable->clone(entry->data, *response) < 0)
+ if (dbase->rtable->clone(entry->data, response) < 0)
goto err;
return STATUS_SUCCESS;
@@ -229,7 +229,7 @@
int dbase_exists(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key,
+ record_key_t* key,
int* response) {
cache_entry_t* entry;
@@ -271,7 +271,7 @@
int dbase_iterate(
semanage_handle_t* handle,
dbase_t* dbase,
- int (*fn) (record_t record, void* varg),
+ int (*fn) (record_t* record, void* varg),
void* fn_arg) {
int status;
@@ -300,11 +300,11 @@
int dbase_list(
semanage_handle_t* handle,
dbase_t* dbase,
- record_t** records,
+ record_t*** records,
size_t* count) {
cache_entry_t* ptr;
- record_t* tmp_records = NULL;
+ record_t** tmp_records = NULL;
size_t tmp_count;
int i = 0;
@@ -314,7 +314,8 @@
tmp_count = dbase->cache_sz;
if (tmp_count > 0) {
- tmp_records = (record_t*) calloc(tmp_count, sizeof (record_t));
+ tmp_records = (record_t**)
+ calloc(tmp_count, sizeof (record_t*));
if (tmp_records == NULL)
goto omem;
diff -Naru --exclude CVS libsemanage/src/database_file.c libsemanage.new/src/database_file.c
--- libsemanage/src/database_file.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/database_file.c 2005-09-29 19:58:50.000000000 -0400
@@ -50,7 +50,7 @@
int perr_fatal = 0;
/* FIXME: pass from caller? */
- record_t process_record = NULL;
+ record_t* process_record = NULL;
int pstatus = STATUS_SUCCESS;
parse_info_t parse_info;
parse_info.filename = backend->filename;
diff -Naru --exclude CVS libsemanage/src/database.h libsemanage.new/src/database.h
--- libsemanage/src/database.h 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/database.h 2005-09-29 19:57:21.000000000 -0400
@@ -23,7 +23,7 @@
/* Representation of the database once loaded in memory */
typedef struct cache_entry {
- record_t data;
+ record_t* data;
struct cache_entry* next;
} cache_entry_t;
@@ -49,7 +49,7 @@
/* Add a record to the database cache */
extern int dbase_cache_add(
dbase_t* dbase,
- record_t data);
+ record_t* data);
/* ======================================
API for use elsewhere:
@@ -84,30 +84,30 @@
extern int dbase_add(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key,
- record_t data);
+ record_key_t* key,
+ record_t* data);
extern int dbase_modify(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key,
- record_t data);
+ record_key_t* key,
+ record_t* data);
extern int dbase_del(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key);
+ record_key_t* key);
extern int dbase_query(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key,
- record_t* response);
+ record_key_t* key,
+ record_t** response);
extern int dbase_exists(
semanage_handle_t* handle,
dbase_t* dbase,
- record_key_t key,
+ record_key_t* key,
int* response);
extern int dbase_count(
@@ -118,14 +118,14 @@
extern int dbase_iterate(
semanage_handle_t* handle,
dbase_t* dbase,
- int (*fn) (record_t record,
+ int (*fn) (record_t* record,
void* varg),
void* fn_arg);
extern int dbase_list(
semanage_handle_t* handle,
dbase_t* dbase,
- record_t** records,
+ record_t*** records,
size_t* count);
#endif
diff -Naru --exclude CVS libsemanage/src/iface_record.c libsemanage.new/src/iface_record.c
--- libsemanage/src/iface_record.c 2005-09-29 16:59:38.000000000 -0400
+++ libsemanage.new/src/iface_record.c 2005-09-29 19:38:07.000000000 -0400
@@ -1,65 +1,92 @@
#include <sepol/iface_record.h>
-typedef sepol_context_t* semanage_context_t;
-typedef sepol_iface_t* semanage_iface_t;
-typedef sepol_iface_key_t* semanage_iface_key_t;
+typedef sepol_context_t semanage_context_t;
+typedef sepol_iface_t semanage_iface_t;
+typedef sepol_iface_key_t semanage_iface_key_t;
/* Key */
-int semanage_iface_compare(semanage_iface_t iface, semanage_iface_key_t key) {
+int semanage_iface_compare(
+ semanage_iface_t* iface,
+ semanage_iface_key_t* key) {
+
return sepol_iface_compare(iface, key);
}
int semanage_iface_key_create(
const char* name,
- semanage_iface_key_t* key_ptr) {
+ semanage_iface_key_t** key_ptr) {
+
return sepol_iface_key_create(name, key_ptr);
}
int semanage_iface_key_extract(
- semanage_iface_t iface,
- semanage_iface_key_t* key_ptr) {
+ semanage_iface_t* iface,
+ semanage_iface_key_t** key_ptr) {
+
return sepol_iface_key_extract(iface, key_ptr);
}
-void semanage_iface_key_free(semanage_iface_key_t key) {
+void semanage_iface_key_free(
+ semanage_iface_key_t* key) {
sepol_iface_key_free(key);
}
/* Name */
-const char* semanage_iface_get_name(semanage_iface_t iface) {
+const char* semanage_iface_get_name(
+ semanage_iface_t* iface) {
+
return sepol_iface_get_name(iface);
}
-int semanage_iface_set_name(semanage_iface_t iface, const char* name) {
+int semanage_iface_set_name(
+ semanage_iface_t* iface,
+ const char* name) {
+
return sepol_iface_set_name(iface, name);
}
/* Context */
-semanage_context_t semanage_iface_get_ifcon(semanage_iface_t iface) {
+semanage_context_t* semanage_iface_get_ifcon(
+ semanage_iface_t* iface) {
+
return sepol_iface_get_ifcon(iface);
}
-int semanage_iface_set_ifcon(semanage_iface_t iface, semanage_context_t con) {
+int semanage_iface_set_ifcon(
+ semanage_iface_t* iface,
+ semanage_context_t* con) {
+
return sepol_iface_set_ifcon(iface, con);
}
-semanage_context_t semanage_iface_get_msgcon(semanage_iface_t iface) {
+semanage_context_t* semanage_iface_get_msgcon(
+ semanage_iface_t* iface) {
+
return sepol_iface_get_msgcon(iface);
}
-int semanage_iface_set_msgcon(semanage_iface_t iface, semanage_context_t con) {
+int semanage_iface_set_msgcon(
+ semanage_iface_t* iface, semanage_context_t* con) {
+
return sepol_iface_set_msgcon(iface, con);
}
/* Create/Clone/Destroy */
-int semanage_iface_create(semanage_iface_t* iface_ptr) {
+int semanage_iface_create(
+ semanage_iface_t** iface_ptr) {
+
return sepol_iface_create(iface_ptr);
}
-int semanage_iface_clone(semanage_iface_t iface, semanage_iface_t* iface_ptr) {
+int semanage_iface_clone(
+ semanage_iface_t* iface,
+ semanage_iface_t** iface_ptr) {
+
return sepol_iface_clone(iface, iface_ptr);
}
-void semanage_iface_free(semanage_iface_t iface) {
+void semanage_iface_free(
+ semanage_iface_t* iface) {
+
sepol_iface_free(iface);
}
diff -Naru --exclude CVS libsemanage/src/interfaces.h libsemanage.new/src/interfaces.h
--- libsemanage/src/interfaces.h 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/interfaces.h 2005-09-29 18:58:45.000000000 -0400
@@ -37,24 +37,24 @@
typedef struct record_table {
/* Create a record */
- int (*create) (record_t* rec);
+ int (*create) (record_t** rec);
/* Extract key from record */
- int (*key_extract) (record_t rec, record_key_t* key);
+ int (*key_extract) (record_t* rec, record_key_t** key);
/* Free record key */
- void (*key_free) (record_key_t key);
+ void (*key_free) (record_key_t* key);
/* Return 0 if record can be matched against key,
* and 1 otherwise */
- int (*compare) (record_t rec, record_key_t key);
+ int (*compare) (record_t* rec, record_key_t* key);
/* Deep-copy clone of this record */
- int (*clone) (record_t rec, record_t* new_rec);
+ int (*clone) (record_t* rec, record_t** new_rec);
/* Deallocate record resources. Must
* sucessfully handle NULL. */
- void (*free) (record_t rec);
+ void (*free) (record_t* rec);
} record_table_t;
@@ -64,10 +64,10 @@
/* Fill record structuure based on supplied parse info.
* Parser must return STATUS_NODATA when EOF is encountered.
* Parser must handle NULL file stream correctly */
- int (*parse) (parse_info_t* info, record_t record);
+ int (*parse) (parse_info_t* info, record_t* record);
/* Print record to stream */
- int (*print) (record_t record, FILE* str);
+ int (*print) (record_t* record, FILE* str);
} record_file_table_t;
@@ -75,10 +75,10 @@
typedef struct record_direct_table {
/* Load record into policy store */
- int (*load) (policydb_t* policy, record_t record);
+ int (*load) (policydb_t* policy, record_t* record);
/* Extract records from policy store */
- int (*list) (policydb_t* policy, record_t** records, size_t* nrecords);
+ int (*list) (policydb_t* policy, record_t*** records, size_t* nrecords);
} record_direct_table_t;
diff -Naru --exclude CVS libsemanage/src/port_record.c libsemanage.new/src/port_record.c
--- libsemanage/src/port_record.c 2005-09-29 16:59:38.000000000 -0400
+++ libsemanage.new/src/port_record.c 2005-09-29 19:37:50.000000000 -0400
@@ -1,78 +1,114 @@
#include <sepol/port_record.h>
-typedef sepol_context_t* semanage_context_t;
-typedef sepol_port_t* semanage_port_t;
-typedef sepol_port_key_t* semanage_port_key_t;
+typedef sepol_context_t semanage_context_t;
+typedef sepol_port_t semanage_port_t;
+typedef sepol_port_key_t semanage_port_key_t;
/* Key */
-int semanage_port_compare(semanage_port_t port, semanage_port_key_t key) {
+int semanage_port_compare(
+ semanage_port_t* port,
+ semanage_port_key_t* key) {
+
return sepol_port_compare(port, key);
}
int semanage_port_key_create(
int low, int high, int proto,
- semanage_port_key_t* key_ptr) {
+ semanage_port_key_t** key_ptr) {
+
return sepol_port_key_create(low, high, proto, key_ptr);
}
int semanage_port_key_extract(
- semanage_port_t port,
- semanage_port_key_t* key_ptr) {
+ semanage_port_t* port,
+ semanage_port_key_t** key_ptr) {
+
return sepol_port_key_extract(port, key_ptr);
}
-void semanage_port_key_free(semanage_port_key_t key) {
+void semanage_port_key_free(
+ semanage_port_key_t* key) {
+
sepol_port_key_free(key);
}
/* Protocol */
-int semanage_port_get_proto(semanage_port_t port) {
+int semanage_port_get_proto(
+ semanage_port_t* port) {
+
return sepol_port_get_proto(port);
}
-int semanage_port_set_proto(semanage_port_t port, int proto) {
+int semanage_port_set_proto(
+ semanage_port_t* port,
+ int proto) {
+
return sepol_port_set_proto(port, proto);
}
-const char* semanage_port_get_proto_str(semanage_port_t port) {
+const char* semanage_port_get_proto_str(
+ semanage_port_t* port) {
+
return sepol_port_get_proto_str(port);
}
/* Port */
-int semanage_port_get_low(semanage_port_t port) {
+int semanage_port_get_low(
+ semanage_port_t* port) {
+
return sepol_port_get_low(port);
}
-int semanage_port_get_high(semanage_port_t port) {
+int semanage_port_get_high(
+ semanage_port_t* port) {
+
return sepol_port_get_high(port);
}
-int semanage_port_set_port(semanage_port_t port, int port_num) {
+int semanage_port_set_port(
+ semanage_port_t* port,
+ int port_num) {
+
return sepol_port_set_port(port, port_num);
}
-int semanage_port_set_range(semanage_port_t port, int low, int high) {
+int semanage_port_set_range(
+ semanage_port_t* port,
+ int low, int high) {
+
return sepol_port_set_range(port, low, high);
}
/* Context */
-semanage_context_t semanage_port_get_con(semanage_port_t port) {
+semanage_context_t* semanage_port_get_con(
+ semanage_port_t* port) {
+
return sepol_port_get_con(port);
}
-int semanage_port_set_con(semanage_port_t port, semanage_context_t con) {
+int semanage_port_set_con(
+ semanage_port_t* port,
+ semanage_context_t* con) {
+
return sepol_port_set_con(port, con);
}
/* Create/Clone/Destroy */
-int semanage_port_create(semanage_port_t* port_ptr) {
+int semanage_port_create(
+ semanage_port_t** port_ptr) {
+
return sepol_port_create(port_ptr);
}
-int semanage_port_clone(semanage_port_t port, semanage_port_t* port_ptr) {
+int semanage_port_clone(
+ semanage_port_t* port,
+ semanage_port_t** port_ptr) {
+
return sepol_port_clone(port, port_ptr);
}
-void semanage_port_free(semanage_port_t port) {
+void semanage_port_free(
+ semanage_port_t* port) {
+
sepol_port_free(port);
}
diff -Naru --exclude CVS libsemanage/src/ports.c libsemanage.new/src/ports.c
--- libsemanage/src/ports.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/ports.c 2005-09-29 19:39:02.000000000 -0400
@@ -27,8 +27,8 @@
int semanage_port_add(
semanage_handle_t* handle,
- semanage_port_key_t key,
- semanage_port_t data) {
+ semanage_port_key_t* key,
+ semanage_port_t* data) {
dbase_t* dbase = semanage_port_dbase(handle);
return dbase_add(handle, dbase, key, data);
@@ -36,8 +36,8 @@
int semanage_port_modify(
semanage_handle_t* handle,
- semanage_port_key_t key,
- semanage_port_t data) {
+ semanage_port_key_t* key,
+ semanage_port_t* data) {
dbase_t* dbase = semanage_port_dbase(handle);
return dbase_modify(handle, dbase, key, data);
@@ -45,7 +45,7 @@
int semanage_port_del(
semanage_handle_t* handle,
- semanage_port_key_t key) {
+ semanage_port_key_t* key) {
dbase_t* dbase = semanage_port_dbase(handle);
return dbase_del(handle, dbase, key);
@@ -53,8 +53,8 @@
int semanage_port_query(
semanage_handle_t* handle,
- semanage_port_key_t key,
- semanage_port_t* response) {
+ semanage_port_key_t* key,
+ semanage_port_t** response) {
dbase_t* dbase = semanage_port_dbase(handle);
return dbase_query(handle, dbase, key, response);
@@ -62,7 +62,7 @@
int semanage_port_exists(
semanage_handle_t* handle,
- semanage_port_key_t key,
+ semanage_port_key_t* key,
int* response) {
dbase_t* dbase = semanage_port_dbase(handle);
@@ -79,7 +79,7 @@
int semanage_port_iterate(
semanage_handle_t* handle,
- int (*handler) (semanage_port_t record,
+ int (*handler) (semanage_port_t* record,
void* varg),
void* handler_arg) {
@@ -89,7 +89,7 @@
int semanage_port_list(
semanage_handle_t* handle,
- semanage_port_t** records,
+ semanage_port_t*** records,
size_t* count) {
dbase_t* dbase = semanage_port_dbase(handle);
diff -Naru --exclude CVS libsemanage/src/ports_direct.c libsemanage.new/src/ports_direct.c
--- libsemanage/src/ports_direct.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/ports_direct.c 2005-09-29 19:57:57.000000000 -0400
@@ -3,8 +3,8 @@
*/
#include <sepol/port_record.h>
-typedef sepol_port_t* record_t;
-typedef sepol_port_key_t* record_key_t;
+typedef sepol_port_t record_t;
+typedef sepol_port_key_t record_key_t;
#define RECORD_DEFINED
struct dbase_direct_backend;
diff -Naru --exclude CVS libsemanage/src/ports_file.c libsemanage.new/src/ports_file.c
--- libsemanage/src/ports_file.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/ports_file.c 2005-09-29 19:40:14.000000000 -0400
@@ -15,7 +15,7 @@
#include "debug.h"
static int port_print(
- semanage_port_t port,
+ semanage_port_t* port,
FILE* str) {
/* Stub */
@@ -26,7 +26,7 @@
static int port_parse(
parse_info_t* info,
- semanage_port_t port) {
+ semanage_port_t* port) {
/* Stub */
info = NULL;
@@ -49,7 +49,8 @@
if (dbase_file_init(
NULL, /* FIXME */
- &SEMANAGE_PORT_FILE_RTABLE, &backend) < 0)
+ &SEMANAGE_PORT_FILE_RTABLE,
+ &backend) < 0)
return STATUS_ERR;
return dbase_init(
diff -Naru --exclude CVS libsemanage/src/ports_policy.c libsemanage.new/src/ports_policy.c
--- libsemanage/src/ports_policy.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/ports_policy.c 2005-09-29 19:40:44.000000000 -0400
@@ -4,8 +4,8 @@
#include <sepol/port_record.h>
-typedef sepol_port_key_t* record_key_t;
-typedef sepol_port_t* record_t;
+typedef sepol_port_key_t record_key_t;
+typedef sepol_port_t record_t;
#define RECORD_DEFINED
#include <semanage/port_record.h>
@@ -18,8 +18,8 @@
#include "debug.h"
static inline int convert(
- semanage_port_key_t semanage_key,
- semanage_port_t semanage_port,
+ semanage_port_key_t* semanage_key,
+ semanage_port_t* semanage_port,
sepol_port_key_t** sepol_key,
sepol_port_t** sepol_port) {
@@ -42,8 +42,8 @@
#if 0
int semanage_port_policy_load(
semanage_handle_t* handle,
- semanage_port_key_t key,
- semanage_port_t data) {
+ semanage_port_key_t* key,
+ semanage_port_t* data) {
sepol_port_t* sepol_data;
sepol_port_key_t* sepol_key;
@@ -57,7 +57,7 @@
int semanage_port_policy_list(
semanage_handle_t* handle,
- semanage_port_t** records,
+ semanage_port_t*** records,
size_t* count) {
/* Stub */
diff -Naru --exclude CVS libsemanage/src/user_record.c libsemanage.new/src/user_record.c
--- libsemanage/src/user_record.c 2005-09-29 16:59:38.000000000 -0400
+++ libsemanage.new/src/user_record.c 2005-09-29 19:44:16.000000000 -0400
@@ -1,100 +1,151 @@
#include <stddef.h>
#include <sepol/user_record.h>
-typedef sepol_user_t* semanage_user_t;
-typedef sepol_user_key_t* semanage_user_key_t;
+typedef sepol_user_t semanage_user_t;
+typedef sepol_user_key_t semanage_user_key_t;
/* Key */
-int semanage_user_key_create(const char* name, semanage_user_key_t* key) {
+int semanage_user_key_create(
+ const char* name,
+ semanage_user_key_t** key) {
+
return sepol_user_key_create(name, key);
}
-int semanage_user_key_extract(semanage_user_t user, semanage_user_key_t* key) {
+int semanage_user_key_extract(
+ semanage_user_t* user,
+ semanage_user_key_t** key) {
+
return sepol_user_key_extract(user, key);
}
-void semanage_user_key_free(semanage_user_key_t key) {
+void semanage_user_key_free(
+ semanage_user_key_t* key) {
+
sepol_user_key_free(key);
}
-int semanage_user_compare(semanage_user_t user, semanage_user_key_t key) {
+int semanage_user_compare(
+ semanage_user_t* user,
+ semanage_user_key_t* key) {
+
return sepol_user_compare(user, key);
}
/* Name */
-const char* semanage_user_get_name(semanage_user_t user) {
+const char* semanage_user_get_name(
+ semanage_user_t* user) {
+
return sepol_user_get_name(user);
}
-int semanage_user_set_name(semanage_user_t user, const char* name) {
+int semanage_user_set_name(
+ semanage_user_t* user,
+ const char* name) {
+
return sepol_user_set_name(user, name);
}
/* MLS */
-const char* semanage_user_get_mlslevel(semanage_user_t user) {
+const char* semanage_user_get_mlslevel(
+ semanage_user_t* user) {
+
return sepol_user_get_mlslevel(user);
}
-int semanage_user_set_mlslevel(semanage_user_t user, const char* mls_level) {
+int semanage_user_set_mlslevel(
+ semanage_user_t* user,
+ const char* mls_level) {
+
return sepol_user_set_mlslevel(user, mls_level);
}
-const char* semanage_user_get_mlsrange(semanage_user_t user) {
+const char* semanage_user_get_mlsrange(
+ semanage_user_t* user) {
+
return sepol_user_get_mlsrange(user);
}
-int semanage_user_set_mlsrange(semanage_user_t user, const char* mls_range) {
+int semanage_user_set_mlsrange(
+ semanage_user_t* user,
+ const char* mls_range) {
+
return sepol_user_set_mlsrange(user, mls_range);
}
/* Role management */
-int semanage_user_get_num_roles(semanage_user_t user) {
+int semanage_user_get_num_roles(
+ semanage_user_t* user) {
+
return sepol_user_get_num_roles(user);
}
-const char* semanage_user_get_defrole(semanage_user_t user) {
+const char* semanage_user_get_defrole(
+ semanage_user_t* user) {
+
return sepol_user_get_defrole(user);
}
-int semanage_user_add_role(semanage_user_t user, const char* role) {
+int semanage_user_add_role(
+ semanage_user_t* user,
+ const char* role) {
+
return sepol_user_add_role(user, role);
}
-int semanage_user_del_role(semanage_user_t user, const char* role) {
+int semanage_user_del_role(
+ semanage_user_t* user,
+ const char* role) {
+
return sepol_user_del_role(user, role);
}
-int semanage_user_has_role(semanage_user_t user, const char* role) {
+int semanage_user_has_role(
+ semanage_user_t* user,
+ const char* role) {
+
return sepol_user_has_role(user, role);
}
-int semanage_user_set_defrole(semanage_user_t user, const char* role) {
+int semanage_user_set_defrole(
+ semanage_user_t* user,
+ const char* role) {
+
return sepol_user_set_defrole(user, role);
}
int semanage_user_get_roles(
- semanage_user_t user,
+ semanage_user_t* user,
const char*** roles_arr,
size_t* num_roles) {
+
return sepol_user_get_roles(user, roles_arr, num_roles);
}
int semanage_user_set_roles(
- semanage_user_t user,
+ semanage_user_t* user,
const char** roles_arr,
size_t num_roles) {
+
return sepol_user_set_roles(user, roles_arr, num_roles);
}
/* Create/Clone/Destroy */
-int semanage_user_create(semanage_user_t* user_ptr) {
+int semanage_user_create(
+ semanage_user_t** user_ptr) {
+
return sepol_user_create(user_ptr);
}
-int semanage_user_clone(semanage_user_t user, semanage_user_t* user_ptr) {
+int semanage_user_clone(
+ semanage_user_t* user,
+ semanage_user_t** user_ptr) {
+
return sepol_user_clone(user, user_ptr);
}
-void semanage_user_free(semanage_user_t user) {
+void semanage_user_free(
+ semanage_user_t* user) {
+
sepol_user_free(user);
}
diff -Naru --exclude CVS libsemanage/src/users.c libsemanage.new/src/users.c
--- libsemanage/src/users.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/users.c 2005-09-29 19:45:08.000000000 -0400
@@ -27,8 +27,8 @@
int semanage_user_add(
semanage_handle_t* handle,
- semanage_user_key_t key,
- semanage_user_t data) {
+ semanage_user_key_t* key,
+ semanage_user_t* data) {
dbase_t* dbase = semanage_user_dbase(handle);
return dbase_add(handle, dbase, key, data);
@@ -36,8 +36,8 @@
int semanage_user_modify(
semanage_handle_t* handle,
- semanage_user_key_t key,
- semanage_user_t data) {
+ semanage_user_key_t* key,
+ semanage_user_t* data) {
dbase_t* dbase = semanage_user_dbase(handle);
return dbase_modify(handle, dbase, key, data);
@@ -45,7 +45,7 @@
int semanage_user_del(
semanage_handle_t* handle,
- semanage_user_key_t key) {
+ semanage_user_key_t* key) {
dbase_t* dbase = semanage_user_dbase(handle);
return dbase_del(handle, dbase, key);
@@ -53,8 +53,8 @@
int semanage_user_query(
semanage_handle_t* handle,
- semanage_user_key_t key,
- semanage_user_t* response) {
+ semanage_user_key_t* key,
+ semanage_user_t** response) {
dbase_t* dbase = semanage_user_dbase(handle);
return dbase_query(handle, dbase, key, response);
@@ -62,7 +62,7 @@
int semanage_user_exists(
semanage_handle_t* handle,
- semanage_user_key_t key,
+ semanage_user_key_t* key,
int* response) {
dbase_t* dbase = semanage_user_dbase(handle);
@@ -79,7 +79,7 @@
int semanage_user_iterate(
semanage_handle_t* handle,
- int (*handler) (semanage_user_t record,
+ int (*handler) (semanage_user_t* record,
void* varg),
void* handler_arg) {
@@ -89,7 +89,7 @@
int semanage_user_list(
semanage_handle_t* handle,
- semanage_user_t** records,
+ semanage_user_t*** records,
size_t* count) {
dbase_t* dbase = semanage_user_dbase(handle);
diff -Naru --exclude CVS libsemanage/src/users_direct.c libsemanage.new/src/users_direct.c
--- libsemanage/src/users_direct.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/users_direct.c 2005-09-29 19:58:01.000000000 -0400
@@ -3,8 +3,8 @@
*/
#include <sepol/user_record.h>
-typedef sepol_user_t* record_t;
-typedef sepol_user_key_t* record_key_t;
+typedef sepol_user_t record_t;
+typedef sepol_user_key_t record_key_t;
#define RECORD_DEFINED
struct dbase_direct_backend;
diff -Naru --exclude CVS libsemanage/src/users_file.c libsemanage.new/src/users_file.c
--- libsemanage/src/users_file.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/users_file.c 2005-09-29 19:58:13.000000000 -0400
@@ -15,7 +15,7 @@
#include "debug.h"
static int user_print(
- semanage_user_t user,
+ semanage_user_t* user,
FILE* str) {
/* Stub */
@@ -26,7 +26,7 @@
static int user_parse(
parse_info_t* info,
- semanage_user_t user) {
+ semanage_user_t* user) {
/* Stub */
info = NULL;
diff -Naru --exclude CVS libsemanage/src/users_policy.c libsemanage.new/src/users_policy.c
--- libsemanage/src/users_policy.c 2005-09-29 19:17:48.000000000 -0400
+++ libsemanage.new/src/users_policy.c 2005-09-29 19:46:17.000000000 -0400
@@ -4,8 +4,8 @@
#include <sepol/user_record.h>
-typedef sepol_user_key_t* record_key_t;
-typedef sepol_user_t* record_t;
+typedef sepol_user_key_t record_key_t;
+typedef sepol_user_t record_t;
#define RECORD_DEFINED
#include <stddef.h>
@@ -18,8 +18,8 @@
#include "debug.h"
static inline int convert(
- semanage_user_key_t semanage_key,
- semanage_user_t semanage_user,
+ semanage_user_key_t* semanage_key,
+ semanage_user_t* semanage_user,
sepol_user_key_t** sepol_key,
sepol_user_t** sepol_user) {
@@ -42,8 +42,8 @@
#if 0
int semanage_user_policy_load(
semanage_handle_t* handle,
- semanage_user_key_t key,
- semanage_user_t data) {
+ semanage_user_key_t* key,
+ semanage_user_t* data) {
sepol_user_t* sepol_data;
sepol_user_key_t* sepol_key;
@@ -57,7 +57,7 @@
int semanage_user_policy_list(
semanage_handle_t* handle,
- semanage_user_t** records,
+ semanage_user_t*** records,
size_t* count) {
/* Stub */
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: [ 9/9 ] [ SEPOL ] User list function, Bugfixes
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
` (6 preceding siblings ...)
2005-09-30 3:16 ` [ 8/9 ] [ SEMANAGE ] Eliminate struct pointer typedefs Ivan Gyurdiev
@ 2005-09-30 3:26 ` Ivan Gyurdiev
2005-09-30 3:29 ` Memory leaks Ivan Gyurdiev
2005-09-30 3:34 ` Linking to semanage Ivan Gyurdiev
9 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 3:26 UTC (permalink / raw)
To: selinux; +Cc: dwalsh
[-- Attachment #1: Type: text/plain, Size: 1004 bytes --]
Steven, I implemented the interfaces you wanted. I think the end result
looks just as bad as before, if not worse.
However, it's now hidden away into mls.c, instead of having to implement
it in every caller. Also, looks like you were right not to trust me,
because I ran the code through valgrind, and found all kinds of bugs,
which I fixed (so says valgrind).
mls.c is just evil. Apparently compute_length () returns the size of the
context (plus the ':', which I don't want), *minus* the NULL terminator
at the end. However, mls_context_to_sid will write the NULL terminator
at the end. Not only will it write it, it won't skip over it, but will
stop on top of it ( I think), causing mayhem in my code. This interface
makes no sense to me - the replacement is based on it, but it hides the
detail from the caller.
Attached is my resubmission of the user list function, including new mls
functions, and a series of bugfixes for user roles. One of those is
particularly bad (realloc fix).
[-- Attachment #2: libsepol.08.user_list.bugs.diff --]
[-- Type: text/x-patch, Size: 10738 bytes --]
diff -Naur --exclude CVS libsepol/include/sepol/mls.h libsepol.new/include/sepol/mls.h
--- libsepol/include/sepol/mls.h 2005-07-13 15:42:37.000000000 -0400
+++ libsepol.new/include/sepol/mls.h 2005-09-29 20:44:29.000000000 -0400
@@ -34,15 +34,28 @@
#include <sepol/context.h>
#include <sepol/policydb.h>
+extern int mls_struct_from_string(
+ policydb_t* policydb,
+ const char* str,
+ context_struct_t* mls);
+
+extern int mls_struct_to_string(
+ policydb_t* policydb,
+ context_struct_t* mls,
+ char** str);
+
+/* Deprecated */
extern int mls_compute_context_len(policydb_t *policydb,
context_struct_t * context);
+/* Deprecated */
extern void mls_sid_to_context(policydb_t *policydb,
context_struct_t *context,
char **scontext);
extern int mls_context_isvalid(policydb_t *p, context_struct_t * c);
+/* Deprecated */
extern int mls_context_to_sid(policydb_t *policydb,
char oldc,
char **scontext,
@@ -63,5 +76,7 @@
context_struct_t *fromcon, user_datum_t *user,
context_struct_t *usercon);
-#endif /* _MLS_H_ */
+
+
+#endif
diff -Naur --exclude CVS libsepol/include/sepol/users.h libsepol.new/include/sepol/users.h
--- libsepol/include/sepol/users.h 2005-09-29 20:26:57.000000000 -0400
+++ libsepol.new/include/sepol/users.h 2005-09-29 20:31:49.000000000 -0400
@@ -32,10 +32,10 @@
policydb_t* policydb,
const char* role);
-/* Obtain an array of all valid users/roles */
-extern int sepol_get_valid_users(
+/* Obtain the user list */
+extern int sepol_user_list(
policydb_t* policydb,
- char*** users,
+ sepol_user_t*** users,
size_t* nusers);
extern int sepol_get_valid_roles(
diff -Naur --exclude CVS libsepol/src/mls.c libsepol.new/src/mls.c
--- libsepol/src/mls.c 2005-08-11 12:57:51.000000000 -0400
+++ libsepol.new/src/mls.c 2005-09-29 22:21:34.000000000 -0400
@@ -35,8 +35,65 @@
#include <stdlib.h>
+#include "debug.h"
#include "private.h"
+int mls_struct_to_string(
+ policydb_t* policydb,
+ context_struct_t* mls,
+ char** str) {
+
+ char *ptr = NULL, *ptr2 = NULL;
+
+ /* Temporary buffer - length + NULL terminator */
+ int len = mls_compute_context_len(policydb, mls) + 1;
+
+ ptr = (char*) malloc(len);
+ if (ptr == NULL)
+ goto omem;
+
+ /* Final string w/ ':' cut off */
+ ptr2 = (char*) malloc(len - 1);
+ if (ptr2 == NULL)
+ goto omem;
+
+ mls_sid_to_context(policydb, mls, &ptr);
+ ptr -= len - 1;
+ strcpy(ptr2, ptr + 1);
+
+ free(ptr);
+ *str = ptr2;
+ return STATUS_SUCCESS;
+
+ omem:
+ DEBUG(__FUNCTION__, "out of memory\n");
+ free(ptr);
+ free(ptr2);
+ return STATUS_ERR;
+
+}
+
+int mls_struct_from_string(
+ policydb_t* policydb,
+ const char* str,
+ context_struct_t* mls) {
+
+ char* tmp = strdup(str);
+ if (!tmp) {
+ DEBUG(__FUNCTION__, "out of memory\n");
+ return STATUS_ERR;
+ }
+
+ if (mls_context_to_sid(policydb, '$', &tmp, mls)) {
+ DEBUG(__FUNCTION__, "invalid MLS context %s\n", str);
+ free(tmp);
+ return STATUS_ERR;
+ }
+
+ free(tmp);
+ return STATUS_SUCCESS;
+}
+
/*
* Return the length in bytes for the MLS fields of the
* security context string representation of `context'.
diff -Naur --exclude CVS libsepol/src/user_record.c libsepol.new/src/user_record.c
--- libsepol/src/user_record.c 2005-09-29 20:26:57.000000000 -0400
+++ libsepol.new/src/user_record.c 2005-09-29 21:41:54.000000000 -0400
@@ -1,6 +1,7 @@
#include <errno.h>
#include <stdlib.h>
#include <string.h>
+#include <stddef.h>
#include <sepol/user_record.h>
#include "debug.h"
@@ -19,7 +20,7 @@
char** roles;
/* The number of roles */
- unsigned int num_roles;
+ size_t num_roles;
/* The default role */
char* def_role;
@@ -129,7 +130,9 @@
char* role_cp = strdup(role);
char* role_cp2 = strdup(role);
- char** roles_realloc = realloc(user->roles, user->num_roles + 1);
+ char** roles_realloc = realloc(user->roles,
+ sizeof(char*) * (user->num_roles + 1));
+
if (!role_cp || !role_cp2 || !roles_realloc)
goto omem;
@@ -138,6 +141,8 @@
user->roles[user->num_roles - 1] = role_cp;
if (!user->def_role)
user->def_role = role_cp2;
+ else
+ free(role_cp2);
return STATUS_SUCCESS;
@@ -151,7 +156,7 @@
}
int sepol_user_has_role(sepol_user_t* user, const char* role) {
- unsigned int i;
+ size_t i;
for (i = 0; i < user->num_roles; i++)
if (!strcmp(user->roles[i], role))
@@ -164,7 +169,7 @@
const char** roles_arr,
size_t num_roles) {
- unsigned int i;
+ size_t i;
char** tmp_roles =
(char**) calloc(1, sizeof(char*) * num_roles);
if (!tmp_roles)
@@ -200,7 +205,7 @@
const char*** roles_arr,
size_t* num_roles) {
- unsigned int i;
+ size_t i;
const char** tmp_roles =
(const char**) malloc(sizeof (char*) * user->num_roles);
if (!tmp_roles)
@@ -221,7 +226,7 @@
}
int sepol_user_del_role(sepol_user_t* user, const char* role) {
- unsigned int i;
+ size_t i;
for (i = 0; i < user->num_roles; i++) {
if (!strcmp(user->roles[i], role)) {
@@ -256,23 +261,34 @@
int sepol_user_set_defrole(sepol_user_t* user, const char* role) {
- /* First, add the role if we don't have it */
- if (!sepol_user_has_role(user, role)) {
- if (sepol_user_add_role(user, role) < 0)
- goto err;
- }
+ char* old_defrole = NULL;
+
+ /* Backup previous default role */
+ if (user->def_role)
+ old_defrole = user->def_role;
/* Set as default */
user->def_role = strdup(role);
if (!user->def_role)
goto omem;
+ /* Add the role if we don't have it */
+ if (!sepol_user_has_role(user, role)) {
+ if (sepol_user_add_role(user, role) < 0)
+ goto err;
+ }
+
+ /* Free old role */
+ free(old_defrole);
return STATUS_SUCCESS;
omem:
DEBUG(__FUNCTION__, "out of memory\n");
err:
+ free(user->def_role);
+ user->def_role = old_defrole;
+
DEBUG(__FUNCTION__, "could not set default role for %s to %s\n",
user->name, role);
return STATUS_ERR;
@@ -302,7 +318,7 @@
/* Deep copy clone */
int sepol_user_clone(sepol_user_t* user, sepol_user_t** user_ptr) {
sepol_user_t* new_user = NULL;
- unsigned int i;
+ size_t i;
if (sepol_user_create(&new_user) < 0)
goto err;
@@ -319,11 +335,11 @@
goto err;
if (user->mls_level &&
- (sepol_user_set_mlslevel(new_user, user->mls_level) < 0))
+ (sepol_user_set_mlslevel(new_user, user->mls_level) < 0))
goto err;
if (user->mls_range &&
- (sepol_user_set_mlsrange(new_user, user->mls_range) < 0))
+ (sepol_user_set_mlsrange(new_user, user->mls_range) < 0))
goto err;
*user_ptr = new_user;
@@ -337,7 +353,7 @@
/* Destroy */
void sepol_user_free(sepol_user_t* user) {
- unsigned int i;
+ size_t i;
if (!user)
return;
diff -Naur --exclude CVS libsepol/src/users.c libsepol.new/src/users.c
--- libsepol/src/users.c 2005-09-29 20:26:57.000000000 -0400
+++ libsepol.new/src/users.c 2005-09-29 21:00:54.000000000 -0400
@@ -241,19 +241,17 @@
/* For MLS systems */
if (mls_enabled) {
- char* mls_tmp;
context_init(&context);
/* MLS level */
if (mls_level == NULL) {
- DEBUG(__FUNCTION__, "mls is enabled, but no mls "
- "level found for user %s\n", name);
+ DEBUG(__FUNCTION__, "MLS is enabled, but no MLS "
+ "default level was defined for user %s\n", name);
goto err;
}
-
- mls_tmp = mls_level;
- if (mls_context_to_sid(policydb, '$', &mls_tmp, &context)) {
- DEBUG(__FUNCTION__, "invalid level %s for user %s\n",
+
+ if (mls_struct_from_string(policydb, mls_level, &context) < 0) {
+ DEBUG(__FUNCTION__, "invalid MLS default level %s for user %s\n",
mls_level, name);
goto err;
}
@@ -263,14 +261,13 @@
/* MLS range */
context_init(&context);
if (mls_range == NULL) {
- DEBUG(__FUNCTION__, "mls is enabled, but no mls"
- "range found for user %s\n", name);
+ DEBUG(__FUNCTION__, "MLS is enabled, but no MLS"
+ "range was defined for user %s\n", name);
goto err;
}
- mls_tmp = mls_range;
- if (mls_context_to_sid(policydb, '$', &mls_tmp, &context)) {
- DEBUG(__FUNCTION__, "invalid range %s for user %s\n",
+ if (mls_struct_from_string(policydb, mls_range, &context) < 0) {
+ DEBUG(__FUNCTION__, "invalid MLS range %s for user %s\n",
mls_range, name);
goto err;
}
@@ -368,18 +365,76 @@
/* Fill an array with all valid users */
-int sepol_get_valid_users(policydb_t* policydb, char*** users, size_t* nusers) {
+int sepol_user_list(
+ policydb_t* policydb,
+ sepol_user_t*** users,
+ size_t* nusers) {
+
size_t tmp_nusers = policydb->p_users.nprim;
- char **tmp_users = (char**) malloc(tmp_nusers * sizeof(char*));
- char **ptr;
+ sepol_user_t** tmp_users =
+ (sepol_user_t**) calloc(tmp_nusers, sizeof(sepol_user_t*));
+
+ sepol_user_t** ptr;
size_t i;
if (!tmp_users)
goto omem;
-
+
+ /* For each user */
for (i = 0; i < tmp_nusers; i++) {
- tmp_users[i] = strdup(policydb->p_user_val_to_name[i]);
- if (!tmp_users[i])
- goto omem;
+
+ const char* name = policydb->p_user_val_to_name[i];
+ user_datum_t* usrdatum = policydb->user_val_to_struct[i];
+ ebitmap_t* roles = &(usrdatum->roles.roles);
+ ebitmap_node_t* rnode;
+ unsigned bit;
+
+ if (sepol_user_create(&tmp_users[i]) < 0)
+ goto err;
+
+ if (sepol_user_set_name(tmp_users[i], name) < 0)
+ goto err;
+
+ /* Extract roles */
+ ebitmap_for_each_bit(roles, rnode, bit) {
+ if (ebitmap_node_get_bit(rnode, bit)) {
+ char* role = policydb->p_role_val_to_name[bit];
+ if (sepol_user_add_role(tmp_users[i], role) < 0)
+ goto err;
+ }
+ }
+
+ /* Extract MLS info */
+ if (mls_enabled) {
+ context_struct_t context;
+ char *str;
+
+ context_init(&context);
+ memcpy(&context.range.level[0],
+ &usrdatum->dfltlevel, sizeof(mls_level_t));
+ memcpy(&context.range.level[1],
+ &usrdatum->dfltlevel, sizeof(mls_level_t));
+
+ if (mls_struct_to_string(policydb, &context, &str) < 0)
+ goto err;
+
+ if (sepol_user_set_mlslevel(tmp_users[i], str) < 0 ) {
+ free(str);
+ goto err;
+ }
+ free(str);
+
+ context_init(&context);
+ memcpy(&context.range, &usrdatum->range, sizeof(mls_range_t));
+
+ if (mls_struct_to_string(policydb, &context, &str) < 0)
+ goto err;
+
+ if (sepol_user_set_mlsrange(tmp_users[i], str) < 0) {
+ free(str);
+ goto err;
+ }
+ free(str);
+ }
}
*nusers = tmp_nusers;
@@ -388,12 +443,14 @@
return STATUS_SUCCESS;
omem:
- DEBUG(__FUNCTION__, "out of memory, could not "
- "allocate list of valid users\n");
+ DEBUG(__FUNCTION__, "out of memory\n");
+
+ err:
+ DEBUG(__FUNCTION__, "could not enumerate users\n");
ptr = tmp_users;
- while (ptr && *ptr)
- free(*ptr++);
+ while (ptr && (*ptr != NULL))
+ sepol_user_free(*ptr++);
free(tmp_users);
return STATUS_ERR;
}
^ permalink raw reply [flat|nested] 15+ messages in thread* Memory leaks
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
` (7 preceding siblings ...)
2005-09-30 3:26 ` [ 9/9 ] [ SEPOL ] User list function, Bugfixes Ivan Gyurdiev
@ 2005-09-30 3:29 ` Ivan Gyurdiev
2005-09-30 6:01 ` Ivan Gyurdiev
2005-09-30 3:34 ` Linking to semanage Ivan Gyurdiev
9 siblings, 1 reply; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 3:29 UTC (permalink / raw)
To: selinux
Here's a couple of memory leaks, if anyone wants to investigate. If not,
I'll take a look at them eventually. The first one is my fault. The
second one isn't. The main binary I used doesn't bother freeing things,
but I think valgrind is smart enough to recognize that, and those are
real leaks.
==10639== 8 bytes in 2 blocks are definitely lost in loss record 4 of 74
==10639== at 0x1B9017F2: malloc (vg_replace_malloc.c:149)
==10639== by 0x805313F: sepol_user_get_roles (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
==10639== by 0x80493D9: main (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
==10639==
==10639==
==10639== 64 (32 direct, 32 indirect) bytes in 2 blocks are definitely
lost in loss record 21 of 74
==10639== at 0x1B9017F2: malloc (vg_replace_malloc.c:149)
==10639== by 0x805C46A: ebitmap_read (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
==10639== by 0x804EA64: mls_read_range_helper (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
==10639== by 0x805044D: user_read (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
==10639== by 0x8051923: policydb_read (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
==10639== by 0x8051F50: policydb_from_image (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
==10639== by 0x804AFE9: sepol_genusers (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
==10639== by 0x8049291: main (in
/home/phantom/rpmbuild/BUILD/test.mls/test)
--
This message was distributed to subscribers of the selinux mailing list.
If you no longer wish to subscribe, send mail to majordomo@tycho.nsa.gov with
the words "unsubscribe selinux" without quotes as the message.
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: Memory leaks
2005-09-30 3:29 ` Memory leaks Ivan Gyurdiev
@ 2005-09-30 6:01 ` Ivan Gyurdiev
0 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 6:01 UTC (permalink / raw)
To: selinux
Ivan Gyurdiev wrote:
> Here's a couple of memory leaks, if anyone wants to investigate. If
> not, I'll take a look at them eventually. The first one is my fault.
> The second one isn't. The main binary I used doesn't bother freeing
> things, but I think valgrind is smart enough to recognize that, and
> those are real leaks.
>
Disregard this, I am giving valgrind too much credit....adding free() in
main where appropriate fixes those non-leaks.
--
This message was distributed to subscribers of the selinux mailing list.
If you no longer wish to subscribe, send mail to majordomo@tycho.nsa.gov with
the words "unsubscribe selinux" without quotes as the message.
^ permalink raw reply [flat|nested] 15+ messages in thread
* Linking to semanage
2005-09-30 2:49 [ 1/9 ] [ SEPOL ] Eliminate struct pointer typedefs Ivan Gyurdiev
` (8 preceding siblings ...)
2005-09-30 3:29 ` Memory leaks Ivan Gyurdiev
@ 2005-09-30 3:34 ` Ivan Gyurdiev
2005-09-30 5:56 ` Ivan Gyurdiev
9 siblings, 1 reply; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 3:34 UTC (permalink / raw)
To: selinux
Okay, this test compiled a while ago... and now it won't link. I don't
understand why - can someone who knows something about linking give me a
hint? I hope I didn't break static linking with my patches somehow
(can't see how)...
[phantom@cobra test5]$ ./compile
test.c:(.text+0x1d): undefined reference to `semanage_handle_create'
test.c:(.text+0x41): undefined reference to `semanage_handle_destroy'
collect2: ld returned 1 exit status
[phantom@cobra test5]$ cat compile
gcc -static /usr/lib/libselinux.a /usr/lib/libsepol.a
/usr/lib/libsemanage.a test.c -o test
[phantom@cobra test5]$ nm /usr/lib/libsemanage.a|grep semanage_handle
00000000 T semanage_handle_create
00000209 T semanage_handle_destroy
--
This message was distributed to subscribers of the selinux mailing list.
If you no longer wish to subscribe, send mail to majordomo@tycho.nsa.gov with
the words "unsubscribe selinux" without quotes as the message.
^ permalink raw reply [flat|nested] 15+ messages in thread* Re: Linking to semanage
2005-09-30 3:34 ` Linking to semanage Ivan Gyurdiev
@ 2005-09-30 5:56 ` Ivan Gyurdiev
0 siblings, 0 replies; 15+ messages in thread
From: Ivan Gyurdiev @ 2005-09-30 5:56 UTC (permalink / raw)
To: selinux
Ivan Gyurdiev wrote:
> Okay, this test compiled a while ago... and now it won't link. I don't
> understand why - can someone who knows something about linking give me
> a hint? I hope I didn't break static linking with my patches somehow
> (can't see how)...
Hmm..apparently order of arguments to gcc matters for static linking. I
did not know that... reordering things differently makes it work.
--
This message was distributed to subscribers of the selinux mailing list.
If you no longer wish to subscribe, send mail to majordomo@tycho.nsa.gov with
the words "unsubscribe selinux" without quotes as the message.
^ permalink raw reply [flat|nested] 15+ messages in thread