op_sguil.c

知名的开源IDS的日志工具

            }
            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");

    if (op_data->sguild_host == NULL)
    {
	FatalError("You must specify a sguild host.\n");
    }

    if (!op_data->sguild_port)
    {
	FatalError("You must specify a sguild port.\n");
    }
    return op_data;
}


int sgDbConnect(OpSguil_Data *op_data)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return sgMysqlConnect(op_data);
#endif
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
//    return 1;
}

int sgDbClose(OpSguil_Data *op_data)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:  
            return sgMysqlClose(op_data->mysql);
#endif
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
}


int sgSelectAsUInt(OpSguil_Data *op_data, char *sql, unsigned int *result)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return sgMysqlSelectAsUInt(op_data->mysql, sql, result);
#endif
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
}

int sgInsert(OpSguil_Data *op_data, char *sql, unsigned int *row_id)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return sgMysqlInsert(op_data->mysql, sql, row_id);
#endif
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
}

int sgBeginTransaction(OpSguil_Data *op_data)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return sgMysqlInsert(op_data->mysql, "BEGIN", NULL);
#endif
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
}

int sgEndTransaction(OpSguil_Data *op_data)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return sgMysqlInsert(op_data->mysql, "COMMIT", NULL);
#endif
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
}
    
int sgAbortTransaction(OpSguil_Data *op_data)
{
    switch(op_data->flavor)
    {
#ifdef ENABLE_MYSQL
        case FLAVOR_MYSQL:
            return sgMysqlInsert(op_data->mysql, "ROLLBACK", NULL);
#endif
        default:
            FatalError("Database flavor not supported\n");
            return 1;
    }
}


#ifdef ENABLE_MYSQL
int sgMysqlConnect(OpSguil_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:%s@%s/%s: %s\n",
                op_data->user, op_data->password, op_data->server, 
                op_data->database, mysql_error(op_data->mysql));
    }
    return 0;
}

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

int sgMysqlExecuteQuery(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 sgMysqlSelectAsUInt(MYSQL *mysql, char *sql, unsigned int *result)
{
    int rval = 0;
    MYSQL_RES *mysql_res;
    MYSQL_ROW tuple;
    
    if(sgMysqlExecuteQuery(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 sgMysqlInsert(MYSQL *mysql, char *sql, unsigned int *row_id)
{
    if(sgMysqlExecuteQuery(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;
}
#endif

/* SguildConnect() opens a network socket to sguild for sending
 * RT event messages.  Bammkkkk
*/
int SguildConnect(OpSguil_Data *op_data)
{
	int sockfd;
	struct hostent *he;
	struct sockaddr_in server_addr;

	if ((he=gethostbyname(op_data->sguild_host)) == NULL)
        {
                FatalError("Cannot resolve hostname: %s\n", op_data->sguild_host);
                return 1;
        }
        
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        {
 
            FatalError("Cannot open a local socket.\n");
            return 1;
 
        }

        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(op_data->sguild_port);
        server_addr.sin_addr = *((struct in_addr *)he->h_addr);
        memset(&(server_addr.sin_zero), '\0', 8);

        if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) < 0)
        {
                                                                                                              
           LogMessage("Cannot connect to %s on TCP port %u.\n",
                op_data->sguild_host, op_data->sguild_port);
           close(sockfd);
           return 1;

        } 

        op_data->sguild_sock = sockfd;
        return 0;

}
/* I love google. http://pont.net/socket/prog/tcpServer.c */
int read_line(int newSd, char *line_to_return) {
  
  static int rcv_ptr=0;
  static char rcv_msg[MAX_MSG_LEN];
  static int n;
  int offset;

  offset=0;

  while(1) {
    if(rcv_ptr==0) {

      memset(rcv_msg,0x0,MAX_MSG_LEN);
      n = recv(newSd, rcv_msg, MAX_MSG_LEN, 0);
      if (n<0) {
	LogMessage("ERROR: Unable to read data.\n");
	return 1;
      } else if (n==0) {
	LogMessage("ERROR: Connecton closed by client\n");
	close(newSd);
	return 1;
      }
    }
  
    /* if new data read on socket */
    /* OR */
    /* if another line is still in buffer */

    /* copy line into 'line_to_return' */
    while(*(rcv_msg+rcv_ptr)!=0x0A && rcv_ptr<n) {
      memcpy(line_to_return+offset,rcv_msg+rcv_ptr,1);
      offset++;
      rcv_ptr++;
    }
    
    /* end of line + end of buffer => return line */
    if(rcv_ptr==n-1) { 
      /* set last byte to END_LINE */
      *(line_to_return+offset)=0x0A;
      rcv_ptr=0;
      return ++offset;
    } 
    
    /* end of line but still some data in buffer => return line */
    if(rcv_ptr <n-1) {
      /* set last byte to END_LINE */
      *(line_to_return+offset)=0x0A;
      rcv_ptr++;
      return ++offset;
    }

    /* end of buffer but line is not ended => */
    /*  wait for more data to arrive on socket */
    if(rcv_ptr == n) {
      rcv_ptr = 0;
    } 
    
  }
}

/* SguilSendEvent() sends the event via the open network socket.
 * Bammkkkk
*/
int SguilSendEvent(OpSguil_Data *op_data, char *eventMsg)
{

     int schars;
     char line[100];
     

     if((schars = send(op_data->sguild_sock, eventMsg, strlen(eventMsg), 0)) < 0)
     {
             LogMessage("ERROR! Couldn't send msg.\n");

             /* ReConnect to sguild */
             while(SguildConnect(op_data) == 1)
             {
                 if(op_data->nospin) return 0;
                 LogMessage("ERROR: Couldn't reconnect. Will try again in 15 secs.\n");
                 if (BarnyardSleep(15)) break;
             }
             LogMessage("Connected to %s.\n", op_data->sguild_host);
             SguilSendEvent(op_data, eventMsg);

     } else {

             //LogMessage("Msg sent: %s", eventMsg);
             //LogMessage("Chars sent: %i\n", schars);

             memset(line, 0x0, 100);
             if(read_line(op_data->sguild_sock, line) == 1)
             {

                 if (op_data->nospin == 0)
                 {


                    LogMessage("ERROR! Didn't receive confirmation. Trying to reconnect.\n");

                    /* ReConnect to sguild */
                    while(SguildConnect(op_data) == 1)
                    {
                        LogMessage("ERROR: Couldn't reconnect. Will try again in 15 secs.\n");
                        if (BarnyardSleep(15)) break;
                    }
 
                    LogMessage("Connected to %s.\n", op_data->sguild_host);
                    SguilSendEvent(op_data, eventMsg);

                 }

             }
     }
     return 0;
     
}

#endif