[Sysfence-commit] sysfence cp2memory.c,NONE,1.1

[mkoperto <mko...@us...>]

Update of /cvsroot/sysfence/sysfence
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv25212

Added Files:
	cp2memory.c 
Log Message:
copy rule to memory bufor


--- NEW FILE: cp2memory.c ---
/*
 
  copyright (c) 2004, Mirek Kopertowski <m.k...@po...>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License, version 2 as
  published by the Free Software Foundation (see file COPYING for details).

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  
*/
#include <string.h>
#include "parseopt/lex.h"
#include "getstats.h"
#include "conditions.h"

int get_expression_size (expression *expr)
{
    int     size=0;
    atomic  *a;

    switch (expr->type) {
        case ATOMIC:
            a = (atomic *)expr->arg1;
            if (a->type == DOUBLE) {
                size += sizeof(double);
            } else {
                size += sizeof(long int);
            }

            size += sizeof (atomic); 
            size += sizeof (expression); 

            return size ; 
        case RELATION:
            /* copy expression */
            size += get_expression_size ((expression *)expr->arg1);
            size += get_expression_size ((expression *)expr->arg2);
            size += sizeof (expression);

            return size;
        default:
            return 0;
    } 
}

int get_rundata_size (rundata *run)
{
    int     size=0;

    size += sizeof (rundata);
    if (run->runcmd) 
        size += (int)strlen (run->runcmd) + 1;
   
    return size;
}


int get_logdata_size (logdata *log)
{    
    return sizeof (logdata);
}

int get_rule_size (ruleset *rule) 
{
    int size=0;
    
    size += sizeof (ruleset);
    if (rule->name)
        size += (int)strlen (rule->name) + 1;
    
    /* expression size */
    size += get_expression_size (rule->expr);

    /* rundata size */
    if (rule->run)
        size += get_rundata_size (rule->run);

    /* logdata size*/
    if (rule->log)
        size += get_logdata_size (rule->log);
    
    return size;
}

void *cp_expression (void **buf, expression *expr)
{
    void        *b1, *b2;
    atomic      *a;
    expression  *e; 

    b1 = *buf;

    switch (expr->type) {
        case ATOMIC:
            /* copy thresh */
            a = (atomic *)expr->arg1;
            if (a->type == DOUBLE) {
                memcpy (*buf, (void *)a->thresh, sizeof (double));
                *buf += sizeof(double);
            } else {
                memcpy (*buf, (void *)a->thresh, sizeof (long int));
                *buf += sizeof(long int);
            }

            /* copy atomic */
            memcpy (*buf, (void *)a, sizeof(atomic));
            a = (atomic *) *buf;
            a->thresh = b1;
            *buf += sizeof (atomic); 

            /* copy expression */
            memcpy (*buf, (void *)expr, sizeof(expression));
            e = (expression *) *buf;
            e->arg1 = (void *)a;
            *buf += sizeof (expression); 

            return (void *)e ; 
        case RELATION:
            /* copy expression */
            b1 = cp_expression (buf, (expression *)expr->arg1);
            b2 = cp_expression (buf, (expression *)expr->arg2);
            memcpy (*buf, (void *)expr, sizeof (expression));
            e = (expression *) *buf;
            e->arg1 = b1;
            e->arg2 = b2;
            *buf += sizeof (expression);

            return (void *)e;
        default:
            return 0;
    } 
}

void *cp_rundata (void **buf, rundata *run)
{
    rundata *r;

    /* copy rundata */
    memcpy (*buf, (void *)run, sizeof (rundata));
    r = (rundata *) *buf;
    *buf += sizeof (rundata);
    
    /* copy runcmd */
    if (run->runcmd) {
        strcpy (*buf, run->runcmd);
        r->runcmd = (char *) *buf;
        *buf += (int)strlen (run->runcmd) + 1;
    }
    
    return (void *)r;
}


void *cp_logdata (void **buf, logdata *log)
{
    void *b;

    /* copy logdata */
    memcpy (*buf, (void *)log, sizeof (logdata));
    b = *buf;
    *buf += sizeof (logdata);
    
    return b;
}

void *cp_rule (void **buf, ruleset *rule) 
{
    ruleset     *r;

    /* copy rule */
    memcpy (*buf, (void *)rule, sizeof (ruleset));
    r = (ruleset *) *buf;
    *buf += sizeof (ruleset);

    /* copy name*/
    if (rule->name) {
        strcpy (*buf, rule->name);
        r->name = (char *) *buf;
        *buf += (int)strlen (rule->name) + 1;
    }

    /* copy expression */
    r->expr = (expression *) cp_expression (buf, rule->expr);

    /* copy rundata */
    if (r->run)
        r->run = (rundata *) cp_rundata (buf, rule->run);

    /* copy logdata */
    if (r->log)
        r->log = (logdata *) cp_logdata (buf, rule->log);
    
    return (void *)r;
}