rpms/selinux-policy
5
0
Fork 0
Code Issues Pull Requests Releases Activity

First cut at fixing fc_sort.

Browse Source
This commit is contained in:
Karl MacMillan 2005-06-07 21:20:14 +00:00
parent 2224ed3aa5
commit 6847e8295c
1 changed files with 318 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
refpolicy/support/fc_sort.c
View File

@ -1,5 +1,9 @@
/* Copyright 2005, Tresys Technology */
#include <stdio.h> #include <stdio.h>
typedef unsigned char bool_t;
/* file_context_node /* file_context_node
* A node used in a linked list of file contexts. * A node used in a linked list of file contexts.
* Each node contains the regular expression, the type and * Each node contains the regular expression, the type and
@ -9,18 +13,22 @@
* function after the regular expression has been loaded. * function after the regular expression has been loaded.
* next points to the next node in the linked list. * next points to the next node in the linked list.
*/ */
struct file_context_node { typedef struct file_context_node {
char *regex; char *regex;
char* type; char *file_type;
char *context; char *context;
int meta; bool_t meta;
int stem_len; int stem_len;
int str_len; int str_len;
struct file_context_node *next; struct file_context_node *next;
}; } file_context_node_t;
void file_context_node_destroy(file_context_node_t *x)
{
free(x->regex);
free(x->file_type);
free(x->context);
}
/* file_context_bucket /* file_context_bucket
* A node used in a linked list of buckets that contain * A node used in a linked list of buckets that contain
@ -30,11 +38,10 @@ struct file_context_node {
* content of this bucket. * content of this bucket.
* next points to the next bucket in the linked list. * next points to the next bucket in the linked list.
*/ */
struct file_context_bucket { typedef struct file_context_bucket {
struct file_context_node* data; file_context_node_t *data;
struct file_context_bucket *next; struct file_context_bucket *next;
}; } file_context_bucket_t;
@ -44,20 +51,21 @@ struct file_context_bucket {
* Pass two lists a and b, and after the completion of fc_merge, * Pass two lists a and b, and after the completion of fc_merge,
* the final list is contained in a, and b is empty. * the final list is contained in a, and b is empty.
*/ */
struct file_context_node* fc_merge( struct file_context_node* a, struct file_context_node* b ) file_context_node_t *fc_merge(file_context_node_t *a,
file_context_node_t *b)
{ {
struct file_context_node* a_current; file_context_node_t *a_current;
struct file_context_node* b_current; file_context_node_t *b_current;
struct file_context_node* temp; file_context_node_t *temp;
struct file_context_node* jumpto; file_context_node_t *jumpto;
/* If a is a empty list, and b is not, /* If a is a empty list, and b is not,
* set a as b and proceed to the end. */ * set a as b and proceed to the end. */
if (!a && b) if (!a && b)
a = b; a = b;
/* If b is an empty list, leave a as it is. */ /* If b is an empty list, leave a as it is. */
else if( !b ) { } else if (!b) {
else { } else {
/* Make it so the list a has the lesser /* Make it so the list a has the lesser
* first element always. */ * first element always. */
if (fc_compare(a, b) == 1) { if (fc_compare(a, b) == 1) {
@ -75,7 +83,9 @@ struct file_context_node* fc_merge( struct file_context_node* a, struct file_con
/* Insert b's nodes inbetween the current a node /* Insert b's nodes inbetween the current a node
* and the next a node.*/ * and the next a node.*/
while (b_current && a_current->next && while (b_current && a_current->next &&
fc_compare( a_current->next, b_current) != -1 ) { temp = a_current->next; fc_compare(a_current->next,
b_current) != -1) {
temp = a_current->next;
a_current->next = b_current; a_current->next = b_current;
b_current = b_current->next; b_current = b_current->next;
a_current->next->next = temp; a_current->next->next = temp;
@ -119,15 +129,15 @@ struct file_context_node* fc_merge( struct file_context_node* a, struct file_con
* until there is only one bucket left, containing the list of * until there is only one bucket left, containing the list of
* file contexts, sorted. * file contexts, sorted.
*/ */
void fc_merge_sort( struct file_context_bucket* master ) void fc_merge_sort(file_context_bucket_t *master)
{ {
int i; int i;
struct file_context_bucket* current; file_context_bucket_t *current;
struct file_context_bucket* temp; file_context_bucket_t *temp;
struct file_context_node* ncurrent; file_context_node_t *ncurrent;
struct file_context_node* ntemp; file_context_node_t *ntemp;
/* Loop until master is the only bucket left /* Loop until master is the only bucket left
* so that this will stop when master contains * so that this will stop when master contains
@ -139,7 +149,9 @@ void fc_merge_sort( struct file_context_bucket* master )
while (current) { while (current) {
if (current->next) { if (current->next) {
/* Merge the next one into the current one. */ /* Merge the next one into the current one. */
current->data = fc_merge( current->data, current->next->data ); current->data =
fc_merge(current->data,
current->next->data);
/* remove the next bucket that is now empty. */ /* remove the next bucket that is now empty. */
temp = current->next; temp = current->next;
current->next = current->next->next; current->next = current->next->next;
@ -166,7 +178,7 @@ void fc_merge_sort( struct file_context_bucket* master )
* If a does not have a specified type and b does not, * If a does not have a specified type and b does not,
* -> a is less specific than b. * -> a is less specific than b.
*/ */
int fc_compare( struct file_context_node* a, struct file_context_node* b ) int fc_compare(file_context_node_t *a, file_context_node_t *b)
{ {
/* Check to see if either a or b have meta characters /* Check to see if either a or b have meta characters
* and the other doesn't. */ * and the other doesn't. */
@ -216,7 +228,7 @@ int fc_compare( struct file_context_node* a, struct file_context_node* b )
* fc_node->stem_len = The number of characters up until * fc_node->stem_len = The number of characters up until
* the first meta character. * the first meta character.
*/ */
void fc_fill_data( struct file_context_node* fc_node ) void fc_fill_data(file_context_node_t *fc_node)
{ {
int c = 0; int c = 0;
@ -252,7 +264,8 @@ void fc_fill_data( struct file_context_node* fc_node )
default: default:
/* If no meta character has been found yet, /* If no meta character has been found yet,
* add one to the stem length. */ * add one to the stem length. */
if( !fc_node->meta ) fc_node->stem_len++; if (!fc_node->meta)
fc_node->stem_len++;
break; break;
} }
@ -269,92 +282,105 @@ void fc_fill_data( struct file_context_node* fc_node )
*/ */
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
int i, j, lines; int lines;
int start, finish; size_t start, finish, regex_len;
char* str; size_t line_len, i, j;
struct file_context_node* temp; char *str, *input_name, *output_name, *line_buf;
struct file_context_node* head;
struct file_context_node* current;
struct file_context_node* array;
struct file_context_bucket* master;
struct file_context_bucket* bcurrent;
FILE *path; file_context_node_t *temp;
char line_buf[ 127 ]; file_context_node_t *head;
file_context_node_t *current;
file_context_node_t *array;
file_context_bucket_t *master;
file_context_bucket_t *bcurrent;
FILE *in_file, *out_file;
/* Check for the correct number of command line arguments. */ /* Check for the correct number of command line arguments. */
if (argc != 3) { if (argc != 3) {
printf( "Error: invalid number of command line arguments.\n" ); fprintf(stderr, "Error: invalid number of command line arguments.\n");
return -1; return 1;
} }
input_name = argv[1];
output_name = argv[2];
i = j = lines = 0; i = j = lines = 0;
/* Allocate the head of the file_context linked list. */
if( !( current = head = (struct file_context_node*)malloc( sizeof( struct file_context_node ) ) ) ) {
printf( "Error: failure allocating memory.\n" );
return -1;
}
/* Make sure to have a terminating character, always. */ /* Make sure to have a terminating character, always. */
line_buf[127] = 0; line_buf[BUF_SIZE - 1] = '\0';
/* Open the input file. */ /* Open the input file. */
if( !( path = fopen( argv[1], "r" ) ) ) { if (!(in_file = fopen(input_name), "r")) {
printf( "Error: failure opening input file for read.\n" ); fprintf(stderr, "Error: failure opening input file for read.\n");
return -1; return 1;
} }
/* Parse the file into a file_context linked list. */ /* Parse the file into a file_context linked list. */
while( fgets( line_buf, 126, path ) != NULL ) { buf = NULL;
while (getline(&line_buf, &line_len, in_file) {
/* Get rid of whitespace from the front of the line. */ /* Get rid of whitespace from the front of the line. */
i = 0; for (i = 0; i < line_len; i++) {
while( line_buf[i] && line_buf[i] <= ' ' ) i++; if (line_buf[i] != ' ' || line_buf[i] != '\t')
break;
/* Check if the line isn't empty and isn't a comment */
if( line_buf[i] && line_buf[i] != '#' ) {
/* Allocate a new node. */
temp = (struct file_context_node*)malloc( sizeof( struct file_context_node ) );
if( !temp ) {
printf( "Error: failure allocating memory.\n" );
return -1;
} }
temp->next = NULL;
if (i >= line_len)
continue;
/* Check if the line isn't empty and isn't a comment */
if (line_buf[i] == '#')
continue;
/* We have a valid line - allocate a new node. */
temp = (file_context_node_t *)malloc(sizeof(file_context_node_t));
if (!temp) {
fprintf(stderr, "Error: failure allocating memory.\n");
return 1;
}
memset(temp, 0, sizeof(file_context_node_t));
/* Parse out the regular expression from the line. */ /* Parse out the regular expression from the line. */
start = i; start = i;
while( line_buf[i] > ' ' )i++; while (i < line_len && (line_buf[i] != ' ' || line_buf[i] != '\t'))
i++;
finish = i; finish = i;
/* Allocate a character array to hold the regular regex_len = start - finish;
* expression. */
temp->regex = (char*)malloc( sizeof( char ) * ( finish - start + 1) );
if( !( temp->regex ) ) {
printf( "Error: failure allocating memory.\n" );
return -1;
}
temp->regex[0] = 0;
/* Fill the regular expression array. */ if (regex_len == 0) {
temp->regex[ ( finish - start ) ] = 0; file_context_node_destroy(temp);
for( j = 0; j < finish - start; j++ ) { free(temp);
temp->regex[j] = line_buf[j + start]; continue;
} }
/* Get rid of whitespace after the regular temp->path = strndup(&line_buf[start], regex_len);
* expression. */ if (!temp->path) {
while( line_buf[i] <= ' ' ) i++; file_context_node_destroy(temp);
free(temp);
fprintf(stderr, "Memory error\n");
return 1;
}
/* Get rid of whitespace after the regular expression. */
for (; i < line_len; i++) {
if (line_buf[i] != ' ' || line_buf[i] != '\t')
break;
}
if (i == line_len) {
file_context_node_destroy(temp);
free(temp);
continue;
}
/* Parse out the type from the line (if it /* Parse out the type from the line (if it
* is there). */ * is there). */
if (line_buf[i] == '-') { if (line_buf[i] == '-') {
/* Allocate a character array to
* hold the type. */
temp->type = (char *)malloc(sizeof(char) * 3); temp->type = (char *)malloc(sizeof(char) * 3);
if (!(temp->type)) { if (!(temp->type)) {
printf( "Error: failure allocating memory.\n" ); fprintf(stderr, "Error: failure allocating memory.\n");
return -1; return 1;
} }
/* Fill the type into the array. */ /* Fill the type into the array. */
@ -364,18 +390,23 @@ int main( int argc, char *argv[])
temp->type[2] = 0; temp->type[2] = 0;
/* Get rid of whitespace after the type. */ /* Get rid of whitespace after the type. */
while( line_buf[i] <= ' ' ) i++; while (line_buf[i] <= ' ')
i++;
} }
/* Parse out the context from the line. */ /* Parse out the context from the line. */
start = i; start = i;
while( line_buf[i] > ' ' ) i++; while (line_buf[i] > ' ')
i++;
finish = i; finish = i;
/* Allocate a character array to hold the context. */ /* Allocate a character array to hold the context. */
temp->context = (char*)malloc( sizeof( char ) * ( finish - start + 1 ) ); temp->context =
(char *) malloc(sizeof(char) *
(finish - start + 1));
if (!(temp->context)) { if (!(temp->context)) {
printf( "Error: failure allocating memory.\n" ); printf
("Error: failure allocating memory.\n");
return -1; return -1;
} }
temp->context[0] = 0; temp->context[0] = 0;
@ -396,12 +427,14 @@ int main( int argc, char *argv[])
current = current->next; current = current->next;
lines++; lines++;
} }
} free(buf);
fclose(path); fclose(path);
/* Create the bucket linked list from the earlier linked list. */ /* Create the bucket linked list from the earlier linked list. */
current = head->next; current = head->next;
bcurrent = master = (struct file_context_bucket*)malloc( sizeof( struct file_context_bucket ) ); bcurrent = master =
(file_context_bucket_t *)
malloc(sizeof(file_context_bucket_t));
/* Go until all the nodes have been put in individual buckets. */ /* Go until all the nodes have been put in individual buckets. */
while (current) { while (current) {
/* Copy over the file context line into the bucket. */ /* Copy over the file context line into the bucket. */
@ -413,9 +446,12 @@ int main( int argc, char *argv[])
/* If there should be another bucket, put one at the end. */ /* If there should be another bucket, put one at the end. */
if (current) { if (current) {
bcurrent->next = (struct file_context_bucket*) malloc( sizeof( struct file_context_bucket ) ); bcurrent->next =
(file_context_bucket_t *)
malloc(sizeof(file_context_bucket_t));
if (!(bcurrent->next)) { if (!(bcurrent->next)) {
printf( "Error: failure allocating memory.\n" ); printf
("Error: failure allocating memory.\n");
return -1; return -1;
} }
@ -481,4 +517,3 @@ int main( int argc, char *argv[])
return 0; return 0;
} }