qsup-admin.c

Go to the documentation of this file.

#include <aquosa/qsup_lib.h>
#include <sys/types.h>
#include <pwd.h>
#include <stdio.h>
#include <grp.h>
#include <string.h>
#include <errno.h>

#define MAX_LINE 1024
#define MAX_RULENAME 6 /* max(USER(4), GROUP (5), LEVEL (5)) = 5 + 1 = 6 */
#define MAX_TOKENLENGTH 32

/* Error codes */
#define PARSE_ERROR 1
#define INVALID_RULE 2
#define NO_ENTRY 3

typedef enum rules {LEVEL=1, GROUP, USER} rule_type;

/* Every rule has an ID (number or string) plus a chain of tokens */
struct rule
{
        rule_type r_type;
        int rule_id;
        union value
        {
                qsup_constraints_t qc;
                qos_bw_t qb;
        } rule_value;
};


void pushout_nums (char** buf, int n)
{
        int i = 1;
        while ((n = n / 10) != 0) i++;

        *buf = *buf + i;
}

int fill_rule (char* buf, struct rule* r)
{
        char* str;
        float f_value;
        unsigned int uint_value;

        if (r->r_type == LEVEL)
        {
                r->rule_value.qb = 0;
                if ((str = strstr (buf, "max=")) != NULL)
                {
                        if (sscanf (str, "max=%f", &f_value) == EOF)
                                return PARSE_ERROR;
                        else
                                r->rule_value.qb = d2bw (f_value);
                }
                if (r->rule_value.qb == 0)
                        return INVALID_RULE;
                return 0;
        }
        else
        {
                r->rule_value.qc.level = -1;
                r->rule_value.qc.weight = -1;
                r->rule_value.qc.max_bw = 0;
                r->rule_value.qc.max_min_bw = 0;
                r->rule_value.qc.flags_mask = 0;

                if ((str = strstr (buf, "level=")) != NULL)
                        if (sscanf (str, "level=%d", &(r->rule_value.qc.level)) == EOF)
                                return PARSE_ERROR;
                if ((str = strstr (buf, "weight=")) != NULL)
                        if (sscanf (str, "weight=%d", &(r->rule_value.qc.weight)) == EOF)
                                return PARSE_ERROR;
                if ((str = strstr (buf, "max=")) != NULL)
                {
                        if (sscanf (str, "max=%f", &f_value) == EOF)
                                return PARSE_ERROR;
                        else
                                r->rule_value.qc.max_bw = d2bw (f_value);
                }
                if ((str = strstr (buf, "max_gua=")) != NULL)
                {
                        if (sscanf (str, "max_gua=%f", &f_value) == EOF)
                                return PARSE_ERROR;
                        else
                                r->rule_value.qc.max_min_bw = d2bw (f_value);
                }
                if ((str = strstr (buf, "flags_mask=")) != NULL)
                {
                        if (sscanf (str, "flags_mask=%x", &uint_value) == EOF)
                                return PARSE_ERROR;
                        else
                                r->rule_value.qc.flags_mask = uint_value;
                }

                if (r->rule_value.qc.level == -1 || r->rule_value.qc.max_bw == 0 || r->rule_value.qc.max_min_bw == 0)
                        return INVALID_RULE;

                return 0;
        }
}


rule_type getrule (char** buf)
{
        char* rule_name = malloc (sizeof (char) * MAX_RULENAME);

        sscanf (*buf, "%s", rule_name);
        *buf = *buf + strlen (rule_name);

        if (!strcmp (rule_name, "level"))
        {
                free(rule_name);
                return LEVEL;
        }
        if (!strcmp (rule_name, "group"))
        {
                free(rule_name);
                return GROUP;
        }
        if (!strcmp (rule_name, "user"))
        {
                free(rule_name);
                return USER;
        }
        return 0;
}

int parse_rule (struct rule* r, char* buf)
{
        int id_is_numeric;

        while (buf[0] == ' ') buf++; /* Stripping off white spaces */

        if (buf[0] - '0' < 10 && buf[0] - '0' >= 0) /* First letter is a number */
                id_is_numeric = 1;
        else    
                id_is_numeric = 0;

        switch (r->r_type)
        {
                case LEVEL:
                        if (!(id_is_numeric)) /* First letter is not a number? Error! */
                                return PARSE_ERROR;
                        /* Take the level ID */
                        sscanf (buf, "%d", &(r->rule_id));
                        /* Put the index to the first non-number char */
                        pushout_nums (&buf, r->rule_id);
                        break;
                case GROUP:
                        if (!(id_is_numeric)) /* First letter is not a number? */
                        {
                                char str[MAX_TOKENLENGTH];
                                struct group* g;
                        
                                sscanf (buf, "%s", str);
                                if ((g = getgrnam (str)) == 0)
                                        return NO_ENTRY;

                                r->rule_id = g->gr_gid;
                                buf = buf + strlen(str);
                        }
                        else
                        {
                                /* Take the Group ID */
                                sscanf (buf, "%d", &(r->rule_id));
                                /* Put the index to the first non-number char */
                                pushout_nums (&buf, r->rule_id);
                        }

                        break;
                case USER:
                        if (!(id_is_numeric)) /* First letter is not a number? */
                        {
                                char str[MAX_TOKENLENGTH];
                                struct passwd* p;
                        
                                sscanf (buf, "%s", str);
                                if ((p = getpwnam (str)) == 0 )
                                        return NO_ENTRY; /* Fills out a struct passwd matching str name */

                                r->rule_id = p->pw_uid;
                                buf = buf + strlen(str);
                        }
                        else
                        {
                                /* Take the user ID */
                                sscanf (buf, "%d", &(r->rule_id));
                                /* Put the index to the first non-number char */
                                pushout_nums (&buf, r->rule_id);
                        }
                        break;
                default:
                        return 1;
                }

                while (buf[0] == ' ') buf++;
                return fill_rule (buf, r);
}


int main(int argc, char* argv[])
{
        FILE *supconf_i;
        char line[MAX_LINE];
        char* buffer;
        struct rule* a_rule;

        if (argc != 2 || strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)
        {
                fprintf (stderr, "Usage: %s {-h | --help | <rules_file>}\n", argv[0]);
                exit(1);
        }

        /* Opening file to be parsed */
        supconf_i = fopen (argv[1], "r");
        if (supconf_i == NULL) {
                fprintf(stderr, "Could not open rules file '%s': %s\n",
                        argv[1], strerror(errno));
                exit(-1);
        }
        qos_chk_ok_exit (qsup_init ());

        /* Here we parse the configurator file line by line */
        while (fgets (line, MAX_LINE, supconf_i) != NULL)
        {
                buffer = line;
                
                while (buffer[0] == ' ') buffer++; /* Let's strip off all the white spaces */
                /* Is the line just read a comment? Let's move on */
                if (buffer[0] == '#' || buffer[0] == '\n')
                        continue;

                a_rule = malloc (sizeof (struct rule));
                
                /* Line is not a comment, let's read it */
                a_rule->r_type = getrule (&buffer);
                /* Let's check if this is a valid rule type */
                if (!a_rule->r_type)
                {
                        free (a_rule);
                        continue;
                }
                
                /* It's valid, let's parse the values */        
                if (parse_rule (a_rule, buffer) != 0)
                {
                        free (a_rule);
                        continue;
                }
                
                switch (a_rule->r_type)
                {
                        case LEVEL:
                                qos_chk_ok_exit (qsup_add_level_rule (a_rule->rule_id, a_rule->rule_value.qb));
                                break;
                        case GROUP:
                                qos_chk_ok_exit (qsup_add_group_rule (a_rule->rule_id, &(a_rule->rule_value.qc))); 
                                break;
                        case USER:
                                qos_chk_ok_exit (qsup_add_user_rule (a_rule->rule_id, &(a_rule->rule_value.qc))); 
                                break;
                        default:
                                break;
                }
                free (a_rule);
        }

        qsup_cleanup();
        return 0;
}

---