op_acid_db.c

知名的开源IDS的日志工具

        }

        /* Get the reference id */
        if(OpAcidDb_GetReferenceId(op_data, ref_system_id, ref->id, &ref_id) 
                != 1)
        {
            /* if not found */
            if(!(e_ref_tag = EscapeString(op_data, ref->id ? ref->id : "")))
                FatalError("Failed to escape string");
            
            if(snprintf(sql_buffer, MAX_QUERY_SIZE,
                        "INSERT INTO reference(ref_system_id, ref_tag) "
                        "VALUES('%u', '%s')", ref_system_id, e_ref_tag) 
                    < MAX_QUERY_SIZE)
            {
                free(e_ref_tag);
                Insert(op_data, sql_buffer, &ref_id); 
                if(ref_id == -1)
                {
                    OpAcidDb_GetReferenceId(op_data, ref_system_id, ref->id, 
                            &ref_id);
                }
            }
            else
            {
                FatalError("SQL query too big");
            }
        }

        /* INSERT record into the sig_reference join table */    
        if(snprintf(sql_buffer, MAX_QUERY_SIZE,
                    "INSERT INTO sig_reference(sig_id, ref_seq, ref_id) "
                    "VALUES('%u', '%u', '%u')", sig_id, ref_seq, ref_id) 
                < MAX_QUERY_SIZE)
        {
            Insert(op_data, sql_buffer, NULL); /* XXX: Error checking */
        }

        ++ref_seq;
        ref = ref->next;
    }
    return 0;
}

OpAcidDb_Data *OpAcidDb_ParseArgs(char *args)
{
    OpAcidDb_Data *op_data;

    op_data = (OpAcidDb_Data *)SafeAlloc(sizeof(OpAcidDb_Data));

    if(args != NULL)
    {
        char **toks;
        int num_toks;
        int i;
        /* parse out your args */
        toks = mSplit(args, ",", 31, &num_toks, '\\');
        for(i = 0; i < num_toks; ++i)
        {
            char **stoks;
            int num_stoks;
            char *index = toks[i];
            while(isspace((int)*index))
                ++index;
            stoks = mSplit(index, " ", 2, &num_stoks, 0);
            if(strcasecmp("database", stoks[0]) == 0)
            {
                if(num_stoks > 1 && op_data->database == NULL)
                    op_data->database = strdup(stoks[1]);
                else
                    LogMessage("Argument Error in %s(%i): %s\n", file_name, 
                            file_line, index);
            }
            else if(strcasecmp("server", stoks[0]) == 0)
            {
                if(num_stoks > 1 && op_data->server == NULL)
                    op_data->server = strdup(stoks[1]);
                else
                    LogMessage("Argument Error in %s(%i): %s\n", file_name, 
                            file_line, index);
            }
            else if(strcasecmp("user", stoks[0]) == 0)
            {
                if(num_stoks > 1 && op_data->user == NULL)
                    op_data->user = strdup(stoks[1]);
                else
                    LogMessage("Argument Error in %s(%i): %s\n", file_name, 
                            file_line, index);
            }
            else if(strcasecmp("password", stoks[0]) == 0)
            {
                if(num_stoks > 1 && op_data->password == NULL)
                    op_data->password = strdup(stoks[1]);
                else
                    LogMessage("Argument Error in %s(%i): %s\n", file_name, 
                            file_line, index);
            }
            else if(strcasecmp("sensor_id", stoks[0]) == 0)
            {
                if(num_stoks > 1 && op_data->sensor_id == 0)
                    op_data->sensor_id = atoi(stoks[1]);
                else
                    LogMessage("Argument Error in %s(%i): %s\n", file_name, 
                            file_line, index);
            }
            else if(strcasecmp("detail", stoks[0]) == 0)
            {
                if(num_stoks > 1)
                {
                    if(strcasecmp("full", stoks[1]) == 0)
                        op_data->detail = 1;
                }
                else 
                    LogMessage("Argument Error in %s(%i): %s\n", file_name, 
                            file_line, index);
            }
#ifdef ENABLE_MYSQL
            else if(strcasecmp("mysql", stoks[0]) == 0)
            {   
                if(op_data->flavor == 0)
                    op_data->flavor = FLAVOR_MYSQL;
                else
                    LogMessage("Argument Error in %s(%i): %s\n", file_name, 
                            file_line, index);
            }
#endif /* ENABLE_MYSQL */
#ifdef ENABLE_POSTGRES
            else if(strcasecmp("postgres", stoks[0]) == 0)
            {
                if(op_data->flavor == 0)
                    op_data->flavor = FLAVOR_POSTGRES;
                else
                    LogMessage("Argument Error in %s(%i): %s\n", file_name,
                            file_line, index);
            }
#endif /* ENABLE_POSTGRES */
            else
            {
                fprintf(stderr, "WARNING %s (%d) => Unrecognized argument for "
                        "AcidDb plugin: %s\n", file_name, file_line, index);
            }
            FreeToks(stoks, num_stoks);
        }
        /* free your mSplit tokens */
        FreeToks(toks, num_toks);
    }
    if(op_data->flavor == 0)
        FatalError("You must specify a database flavor\n");
    return op_data;
}


int DbConnect(OpAcidDb_Data *op_data)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return MysqlConnect(op_data);
#endif
#ifdef ENABLE_POSTGRES
        case FLAVOR_POSTGRES:
            return PostgresConnect(op_data);
#endif /* ENABLE_POSTGRES */
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
//    return 1;
}

int DbClose(OpAcidDb_Data *op_data)
{
    int rval = 0;
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            rval = MysqlClose(op_data->mysql);
            op_data->mysql = NULL;
            break;
#endif
#ifdef ENABLE_POSTGRES
        case FLAVOR_POSTGRES:
            rval = PostgresClose(op_data->pq);
            op_data->pq = NULL;
            break;
#endif /* ENABLE_POSTGRES */
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }

    return rval;
}


int SelectAsUInt(OpAcidDb_Data *op_data, char *sql, unsigned int *result)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return MysqlSelectAsUInt(op_data->mysql, sql, result);
#endif
#ifdef ENABLE_POSTGRES
        case FLAVOR_POSTGRES:
            return PostgresSelectAsUInt(op_data->pq, sql, result);
#endif /* ENABLE_POSTGRES */
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
}

int Insert(OpAcidDb_Data *op_data, char *sql, unsigned int *row_id)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return MysqlInsert(op_data->mysql, sql, row_id);
#endif
#ifdef ENABLE_POSTGRES
        case FLAVOR_POSTGRES:
            if(row_id)
                *row_id = -1;
            return PostgresInsert(op_data->pq, sql);
#endif /* ENABLE_POSTGRES */
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
}

char *EscapeString(OpAcidDb_Data *op_data, char *string)
{
    if(!op_data || !string)
        return NULL;

    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return MysqlEscapeString(op_data->mysql, string);
#endif
#ifdef ENABLE_POSTGRES
        case FLAVOR_POSTGRES:
            return PostgresEscapeString(op_data->pq, string);
#endif /* ENABLE_POSTGRES */
        default:
            FatalError("Database flavor not supported\n");
            return NULL;
    }
}
        

#ifdef ENABLE_MYSQL
int MysqlConnect(OpAcidDb_Data *op_data)
{
    op_data->mysql = mysql_init(NULL);
    if(!mysql_real_connect(op_data->mysql, op_data->server, op_data->user, 
                op_data->password, op_data->database, 0, NULL, 0))
    {
        FatalError("Failed to connect to database %s:XXXXXXXX@%s/%s: %s\n",
                op_data->user, op_data->server, 
                op_data->database, mysql_error(op_data->mysql));
    }
    return 0;
}

int MysqlClose(MYSQL *mysql)
{
    if(mysql_close)
        mysql_close(mysql);
    return 0;
}

int MysqlExecuteQuery(MYSQL *mysql, char *sql)
{
    int mysqlErrno;
    int result;
    while((result = mysql_query(mysql, sql) != 0))
    {
        mysqlErrno = mysql_errno(mysql);
        if(mysqlErrno < CR_MIN_ERROR)
        {
            if(pv.verbose)
                LogMessage("MySQL ERROR(%i): %s.  Aborting Query\n",
                        mysql_errno(mysql), mysql_error(mysql));
            return result;
        }
        if((mysqlErrno == CR_SERVER_LOST) 
                || (mysqlErrno == CR_SERVER_GONE_ERROR))
        {
            LogMessage("Lost connection to MySQL server.  Reconnecting\n");
            while(mysql_ping(mysql) != 0)
            {
                if(BarnyardSleep(15))
                    return result;
            }
            LogMessage("Reconnected to MySQL server.\n");
        }
        else
        {
            /* XXX we could spin here, but we do not */
            LogMessage("MySQL Error(%i): %s\n", mysqlErrno, mysql_error(mysql));
        }
    }
    return result;
}


int MysqlSelectAsUInt(MYSQL *mysql, char *sql, unsigned int *result)
{
    int rval = 0;
    MYSQL_RES *mysql_res;
    MYSQL_ROW tuple;
    
    if(MysqlExecuteQuery(mysql, sql) != 0)
    {
        /* XXX: should really just return up the chain */
        FatalError("Error (%s) executing query: %s\n", mysql_error(mysql), sql);
        return -1;
    }

    mysql_res = mysql_store_result(mysql);
    if((tuple = mysql_fetch_row(mysql_res)))
    {
        if(tuple[0] == NULL)
            *result = 0;
        else
            *result = atoi(tuple[0]);
        rval = 1;
    }
    mysql_free_result(mysql_res);
    return rval;
}

int MysqlInsert(MYSQL *mysql, char *sql, unsigned int *row_id)
{
    if(MysqlExecuteQuery(mysql, sql) != 0)
    {
        /* XXX: should really just return up the chain */
        FatalError("Error (%s) executing query: %s\n", mysql_error(mysql), sql);
        return -1;
    }

    if(row_id != NULL)
        *row_id = mysql_insert_id(mysql);
    return 0;
}

char *MysqlEscapeString(MYSQL *mysql, char *string)
{
    char *e_string = NULL;
    size_t len;
    
    if(!string || !mysql)
        return NULL;

    len = strlen(string);

    if(!(e_string = (char  *)calloc((len * 2) + 1, sizeof(char))))
    {
        FatalError("Out of memory (wanted %u bytes)",
                (len * 2) + 1);
        return NULL;
    }

    mysql_real_escape_string(mysql, e_string, string, len);

    return e_string;
}
#endif

#ifdef ENABLE_POSTGRES
int PostgresConnect(OpAcidDb_Data *op_data)
{
    if(!(op_data->pq = PQsetdbLogin(op_data->server, NULL, NULL, NULL, 
                    op_data->database, op_data->user, op_data->password)))
    {
        FatalError("Failed to create postgres connection object\n");
    }
    if(PQstatus(op_data->pq) != CONNECTION_OK)
    {
        FatalError("Failed to connect to database %s:XXXXXXXX@%s/%s: %s\n",
                op_data->user, op_data->server, 
                op_data->database, PQerrorMessage(op_data->pq));
    }

    return 0;
}

int PostgresClose(PGconn *pq)
{
    if(pq)
        PQfinish(pq);
    return 0;
}

int PostgresSelectAsUInt(PGconn *pq, char *sql, unsigned int *result)
{
    int rval = 0;
    PGresult *res = NULL;
    if(!pq || !sql || !result)
        return -1;

    if(!(res = PQexec(pq, sql)))
    {
        FatalError("PQexec failed: %s\n", PQerrorMessage(pq));
    }
    if(PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        FatalError("SQL command '%s' failed: %s", sql, PQerrorMessage(pq));
    }
    if(PQntuples(res) > 0)
    {
        char *value = PQgetvalue(res, 0, 0);
        if(value == NULL)
            *result = 0;
        else
            *result = atoi(value);
        rval = 1;
    }

    PQclear(res);
    return rval;
}

int PostgresInsert(PGconn *pq, char *sql)
{
    PGresult *res = NULL;
    if(!pq || !sql)
        return -1;

    if(!(res = PQexec(pq, sql)))
    {
        FatalError("PQexec failed: %s\n", PQerrorMessage(pq));
    }
    if(PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        FatalError("SQL command '%s' failed: %s", sql, PQerrorMessage(pq));
    }
    PQclear(res);
    return 0;
}

char *PostgresEscapeString(PGconn *pq, char *string)
{
    char *e_string = NULL;
    size_t len;
    
    if(!string || !pq)
        return NULL;

    len = strlen(string);

    if(!(e_string = (char  *)calloc((len * 2) + 1, sizeof(char))))
    {
        FatalError("Out of memory (wanted %u bytes)",
                (len * 2) + 1);
        return NULL;
    }

    PQescapeString(e_string, string, len);

    return e_string;
}
#endif /* ENABLE_POSTGRES */