520 lines
13 KiB
C
520 lines
13 KiB
C
/* Copyright 2005, Tresys Technology */
|
|
|
|
#include <stdio.h>
|
|
|
|
typedef unsigned char bool_t;
|
|
|
|
/* file_context_node
|
|
* A node used in a linked list of file contexts.
|
|
* Each node contains the regular expression, the type and
|
|
* the context, as well as information about the regular
|
|
* expression. The regular expression data (meta, stem_len
|
|
* and str_len) can be filled in by using the fc_fill_data
|
|
* function after the regular expression has been loaded.
|
|
* next points to the next node in the linked list.
|
|
*/
|
|
typedef struct file_context_node {
|
|
char *regex;
|
|
char *file_type;
|
|
char *context;
|
|
bool_t meta;
|
|
int stem_len;
|
|
int str_len;
|
|
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
|
|
* A node used in a linked list of buckets that contain
|
|
* file_context_node's.
|
|
* Each node contains a pointer to a file_context_node which
|
|
* is the header of its linked list. This linked list is the
|
|
* content of this bucket.
|
|
* next points to the next bucket in the linked list.
|
|
*/
|
|
typedef struct file_context_bucket {
|
|
file_context_node_t *data;
|
|
struct file_context_bucket *next;
|
|
} file_context_bucket_t;
|
|
|
|
|
|
|
|
/* fc_merge
|
|
* Merges two sorted file context linked lists into one
|
|
* sorted one.
|
|
* Pass two lists a and b, and after the completion of fc_merge,
|
|
* the final list is contained in a, and b is empty.
|
|
*/
|
|
file_context_node_t *fc_merge(file_context_node_t *a,
|
|
file_context_node_t *b)
|
|
{
|
|
file_context_node_t *a_current;
|
|
file_context_node_t *b_current;
|
|
file_context_node_t *temp;
|
|
file_context_node_t *jumpto;
|
|
|
|
/* If a is a empty list, and b is not,
|
|
* set a as b and proceed to the end. */
|
|
if (!a && b)
|
|
a = b;
|
|
/* If b is an empty list, leave a as it is. */
|
|
else if (!b) {
|
|
} else {
|
|
/* Make it so the list a has the lesser
|
|
* first element always. */
|
|
if (fc_compare(a, b) == 1) {
|
|
temp = a;
|
|
a = b;
|
|
b = temp;
|
|
}
|
|
a_current = a;
|
|
b_current = b;
|
|
|
|
/* Merge by inserting b's nodes inbetween a's nodes. */
|
|
while (a_current->next && b_current) {
|
|
jumpto = a_current->next;
|
|
|
|
/* Insert b's nodes inbetween the current a node
|
|
* and the next a node.*/
|
|
while (b_current && a_current->next &&
|
|
fc_compare(a_current->next,
|
|
b_current) != -1) {
|
|
temp = a_current->next;
|
|
a_current->next = b_current;
|
|
b_current = b_current->next;
|
|
a_current->next->next = temp;
|
|
a_current = a_current->next;
|
|
}
|
|
|
|
/* Skip all the inserted node from b to the
|
|
* next node in the original a. */
|
|
a_current = jumpto;
|
|
}
|
|
|
|
|
|
/* if there is anything left in b to be inserted,
|
|
put it on the end */
|
|
if (b_current) {
|
|
a_current->next = b_current;
|
|
}
|
|
}
|
|
|
|
b = NULL;
|
|
|
|
return a;
|
|
}
|
|
|
|
|
|
|
|
/* fc_merge_sort
|
|
* Sorts file contexts from least specific to more specific.
|
|
* The bucket linked list is passed and after the completion
|
|
* of the fc_merge_sort function, there is only one bucket
|
|
* (pointed to by master) that contains a linked list
|
|
* of all the file contexts, in sorted order.
|
|
* Explanation of the algorithm:
|
|
* The algorithm implemented in fc_merge_sort is an iterative
|
|
* implementation of merge sort.
|
|
* At first, each bucket has a linked list of file contexts
|
|
* that are 1 element each.
|
|
* Each pass, each odd numbered bucket is merged into the bucket
|
|
* before it. This halves the number of buckets each pass.
|
|
* It will continue passing over the buckets (as described above)
|
|
* until there is only one bucket left, containing the list of
|
|
* file contexts, sorted.
|
|
*/
|
|
void fc_merge_sort(file_context_bucket_t *master)
|
|
{
|
|
int i;
|
|
|
|
file_context_bucket_t *current;
|
|
file_context_bucket_t *temp;
|
|
|
|
file_context_node_t *ncurrent;
|
|
file_context_node_t *ntemp;
|
|
|
|
/* Loop until master is the only bucket left
|
|
* so that this will stop when master contains
|
|
* the sorted list. */
|
|
while (master->next) {
|
|
current = master;
|
|
|
|
/* This loop merges buckets two-by-two. */
|
|
while (current) {
|
|
if (current->next) {
|
|
/* Merge the next one into the current one. */
|
|
current->data =
|
|
fc_merge(current->data,
|
|
current->next->data);
|
|
/* remove the next bucket that is now empty. */
|
|
temp = current->next;
|
|
current->next = current->next->next;
|
|
free(temp);
|
|
}
|
|
current = current->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* fc_compare
|
|
* Compares two file contexts' regular expressions and returns:
|
|
* -1 if a is less specific than b
|
|
* 0 if a and be are equally specific
|
|
* 1 if a is more specific than b
|
|
* The comparison is based on the following statements,
|
|
* in order from most important to least important, given a and b:
|
|
* If a is a regular expression and b is not,
|
|
* -> a is less specific than b.
|
|
* If a's stem length is shorter than b's stem length,
|
|
* -> a is less specific than b.
|
|
* If a's string length is shorter than b's string length,
|
|
* -> a is less specific than b.
|
|
* If a does not have a specified type and b does not,
|
|
* -> a is less specific than 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
|
|
* and the other doesn't. */
|
|
if (a->meta && !b->meta)
|
|
return -1;
|
|
if (b->meta && !a->meta)
|
|
return 1;
|
|
|
|
/* Check to see if either a or b have a shorter stem
|
|
* length than the other. */
|
|
if (a->stem_len < b->stem_len)
|
|
return -1;
|
|
if (b->stem_len < a->stem_len)
|
|
return 1;
|
|
|
|
/* Check to see if either a or b have a shorter string
|
|
* length than the other. */
|
|
if (a->str_len < b->str_len)
|
|
return -1;
|
|
if (b->str_len < b->str_len)
|
|
return 1;
|
|
|
|
/* Check to see if either a or b has a specified type
|
|
* and the other doesn't. */
|
|
if (!a->type && b->type)
|
|
return -1;
|
|
if (!b->type && a->type)
|
|
return 1;
|
|
|
|
/* If none of the above conditions were satisfied,
|
|
* then a and b are equally specific. */
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/* fc_fill_data
|
|
* This processes a regular expression in a file context
|
|
* and sets the data held in file_context_node, namely
|
|
* meta, str_len and stem_len.
|
|
* The following changes are made to fc_node after the
|
|
* the completion of the function:
|
|
* fc_node->meta = 1 if regex has a meta character,
|
|
* 0 if not.
|
|
* fc_node->str_len = The string length of the regular
|
|
* expression.
|
|
* fc_node->stem_len = The number of characters up until
|
|
* the first meta character.
|
|
*/
|
|
void fc_fill_data(file_context_node_t *fc_node)
|
|
{
|
|
int c = 0;
|
|
|
|
fc_node->meta = 0;
|
|
fc_node->stem_len = 0;
|
|
fc_node->str_len = 0;
|
|
|
|
/* Process until the string termination character
|
|
* has been reached.
|
|
* Note: this while loop has been adapted from
|
|
* spec_hasMetaChars in matchpathcon.c from
|
|
* libselinux-1.22. */
|
|
while (fc_node->regex[c] != 0) {
|
|
switch (fc_node->regex[c]) {
|
|
case '.':
|
|
case '^':
|
|
case '$':
|
|
case '?':
|
|
case '*':
|
|
case '+':
|
|
case '|':
|
|
case '[':
|
|
case '(':
|
|
case '{':
|
|
/* If a meta character is found,
|
|
* set meta to one */
|
|
fc_node->meta = 1;
|
|
break;
|
|
case '\\':
|
|
/* If a escape character is found,
|
|
* skip the next character. */
|
|
c++;
|
|
default:
|
|
/* If no meta character has been found yet,
|
|
* add one to the stem length. */
|
|
if (!fc_node->meta)
|
|
fc_node->stem_len++;
|
|
break;
|
|
}
|
|
|
|
fc_node->str_len++;
|
|
c++;
|
|
}
|
|
}
|
|
|
|
/* main
|
|
* This program takes in two arguments, the input filename and the
|
|
* output filename. The input file should be syntactically correct.
|
|
* Overall what is done in the main is read in the file and store each
|
|
* line of code, sort it, then output it to the output file.
|
|
*/
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int lines;
|
|
size_t start, finish, regex_len;
|
|
size_t line_len, i, j;
|
|
char *str, *input_name, *output_name, *line_buf;
|
|
|
|
file_context_node_t *temp;
|
|
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. */
|
|
if (argc != 3) {
|
|
fprintf(stderr, "Error: invalid number of command line arguments.\n");
|
|
return 1;
|
|
}
|
|
|
|
input_name = argv[1];
|
|
output_name = argv[2];
|
|
|
|
i = j = lines = 0;
|
|
|
|
/* Make sure to have a terminating character, always. */
|
|
line_buf[BUF_SIZE - 1] = '\0';
|
|
|
|
/* Open the input file. */
|
|
if (!(in_file = fopen(input_name), "r")) {
|
|
fprintf(stderr, "Error: failure opening input file for read.\n");
|
|
return 1;
|
|
}
|
|
|
|
/* Parse the file into a file_context linked list. */
|
|
buf = NULL;
|
|
while (getline(&line_buf, &line_len, in_file) {
|
|
/* Get rid of whitespace from the front of the line. */
|
|
for (i = 0; i < line_len; i++) {
|
|
if (line_buf[i] != ' ' || line_buf[i] != '\t')
|
|
break;
|
|
}
|
|
|
|
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. */
|
|
start = i;
|
|
while (i < line_len && (line_buf[i] != ' ' || line_buf[i] != '\t'))
|
|
i++;
|
|
finish = i;
|
|
|
|
regex_len = start - finish;
|
|
|
|
if (regex_len == 0) {
|
|
file_context_node_destroy(temp);
|
|
free(temp);
|
|
continue;
|
|
}
|
|
|
|
temp->path = strndup(&line_buf[start], regex_len);
|
|
if (!temp->path) {
|
|
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
|
|
* is there). */
|
|
if (line_buf[i] == '-') {
|
|
|
|
temp->type = (char *)malloc(sizeof(char) * 3);
|
|
if (!(temp->type)) {
|
|
fprintf(stderr, "Error: failure allocating memory.\n");
|
|
return 1;
|
|
}
|
|
|
|
/* Fill the type into the array. */
|
|
temp->type[0] = line_buf[i];
|
|
temp->type[1] = line_buf[i + 1];
|
|
i += 2;
|
|
temp->type[2] = 0;
|
|
|
|
/* Get rid of whitespace after the type. */
|
|
while (line_buf[i] <= ' ')
|
|
i++;
|
|
}
|
|
|
|
/* Parse out the context from the line. */
|
|
start = i;
|
|
while (line_buf[i] > ' ')
|
|
i++;
|
|
finish = i;
|
|
|
|
/* Allocate a character array to hold the context. */
|
|
temp->context =
|
|
(char *) malloc(sizeof(char) *
|
|
(finish - start + 1));
|
|
if (!(temp->context)) {
|
|
printf
|
|
("Error: failure allocating memory.\n");
|
|
return -1;
|
|
}
|
|
temp->context[0] = 0;
|
|
|
|
/* Fill the context array. */
|
|
temp->context[(finish - start)] = 0;
|
|
for (j = 0; j < finish - start; j++) {
|
|
temp->context[j] = line_buf[j + start];
|
|
}
|
|
|
|
/* Set all the data about the regular
|
|
* expression. */
|
|
fc_fill_data(temp);
|
|
|
|
/* Link this line of code at the end of
|
|
* the linked list. */
|
|
current->next = temp;
|
|
current = current->next;
|
|
lines++;
|
|
}
|
|
free(buf);
|
|
fclose(path);
|
|
|
|
/* Create the bucket linked list from the earlier linked list. */
|
|
current = head->next;
|
|
bcurrent = master =
|
|
(file_context_bucket_t *)
|
|
malloc(sizeof(file_context_bucket_t));
|
|
/* Go until all the nodes have been put in individual buckets. */
|
|
while (current) {
|
|
/* Copy over the file context line into the bucket. */
|
|
bcurrent->data = current;
|
|
current = current->next;
|
|
|
|
/* Detatch the node in the bucket from the old list. */
|
|
bcurrent->data->next = NULL;
|
|
|
|
/* If there should be another bucket, put one at the end. */
|
|
if (current) {
|
|
bcurrent->next =
|
|
(file_context_bucket_t *)
|
|
malloc(sizeof(file_context_bucket_t));
|
|
if (!(bcurrent->next)) {
|
|
printf
|
|
("Error: failure allocating memory.\n");
|
|
return -1;
|
|
}
|
|
|
|
/* Make sure the new bucket thinks it's the end of the
|
|
* list. */
|
|
bcurrent->next->next = NULL;
|
|
|
|
bcurrent = bcurrent->next;
|
|
}
|
|
}
|
|
|
|
/* Sort the bucket list. */
|
|
fc_merge_sort(master);
|
|
|
|
/* Open the output file. */
|
|
if (!(path = fopen(argv[2], "w"))) {
|
|
printf("Error: failure opening output file for write.\n");
|
|
return -1;
|
|
}
|
|
|
|
/* Output the sorted file_context linked list to the output file. */
|
|
current = master->data;
|
|
while (current) {
|
|
/* Output the regular expression. */
|
|
i = 0;
|
|
while (current->regex[i] != 0) {
|
|
fprintf(path, "%c", current->regex[i]);
|
|
i++;
|
|
}
|
|
fprintf(path, "\t");
|
|
|
|
/* Output the type, if there is one. */
|
|
if (current->type) {
|
|
i = 0;
|
|
while (current->type[i] != 0) {
|
|
fprintf(path, "%c", current->type[i]);
|
|
i++;
|
|
}
|
|
fprintf(path, "\t");
|
|
}
|
|
|
|
/* Output the context. */
|
|
i = 0;
|
|
while (current->context[i] != 0) {
|
|
fprintf(path, "%c", current->context[i]);
|
|
i++;
|
|
}
|
|
fprintf(path, "\n");
|
|
|
|
/* Remove the node. */
|
|
temp = current;
|
|
current = current->next;
|
|
|
|
free(temp->regex);
|
|
if (temp->type)
|
|
free(temp->type);
|
|
free(temp->context);
|
|
free(temp);
|
|
}
|
|
free(master);
|
|
|
|
fclose(path);
|
|
|
|
return 0;
|
|
}
|