Logo Search packages:      
Sourcecode: bfbtester version File versions  Download package

data_stuff.c

/*
    BFBTester -- Brute Force Binary Tester
    Copyright (C) 2000 Mike Heffner <mheffner@vt.edu>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more 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.

      $Id: data_stuff.c,v 1.4.2.2 2001/01/22 05:31:12 fesnel Exp $
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef LINUX
#define _GNU_SOURCE
#endif

#include <stdio.h>
#include <stdlib.h>

#include <string.h>
#include <assert.h>

#include <sys/types.h>
#include <sys/wait.h>


#include "datatypes.h"
#include "data_stuff.h"
#include "utils.h"

#include "bfbt_queue.h"

/* E X E C   E N T R Y  */

DLIST_HEAD(exec_entry_head, _exec_entry) ExecEntry_Head;

static void
ExecEntry_constructor(void)                     __attribute__ ((constructor));

static void
ExecEntry_constructor(void)
{
      DLIST_INIT(&ExecEntry_Head);
}

static inline void
ExecEntry_init(ExecEntry *entry, struct stat *sb, char *fullname, 
                     ExecEntryStatus status, int test_flags)
{
      entry->fullname = strdup(fullname);
      memcpy(&entry->filestat, sb, sizeof(entry->filestat));
      entry->status = status;
      entry->test_flags = test_flags;
      entry->testtime.tv_sec = 0;
      entry->testtime.tv_usec = 0;
}

static void
ExecEntry_destroy(ExecEntry *entry)
{
      assert(entry != NULL);
      if (entry->fullname)    free(entry->fullname);
      free(entry);
}

static inline int
ExecEntry_compare(ExecEntry *e1, ExecEntry *e2)
{
      if (e1->filestat.st_ino == e2->filestat.st_ino)
            return TRUE;
      else
            return FALSE;
}

ExecEntry *
ExecEntry_add(char *name, struct stat *sb, ExecEntryStatus status,
          int test_flags)
{
      ExecEntry *new;

      assert(name != NULL && sb != NULL);

      new = xmalloc(sizeof(ExecEntry));
      ExecEntry_init(new, sb, name, status, test_flags);
      DLIST_INSERT_HEAD(&ExecEntry_Head, new, link);
      return new;
}

void
ExecEntry_subtract(ExecEntry *entry)
{
      assert(entry != NULL);
      DLIST_REMOVE(&ExecEntry_Head, entry, link);
      ExecEntry_destroy(entry);
}

ExecEntry *
ExecEntry_getnext(ExecEntry **entry)
{
      DLIST_GETNEXT(&ExecEntry_Head, entry, link);
      return *entry;
}

ExecEntry *
ExecEntry_findbyname(char *name)
{
      ExecEntry *entry = NULL;
      
      entry = ExecEntry_getnext(&entry);
      while (entry && strcmp(entry->fullname, name) != 0)
            entry = ExecEntry_getnext(&entry);
      return entry;
}

void
ExecEntry_release(ExecEntry *entry)
{
      DLIST_RELEASE(entry, link);
}

int
ExecEntry_isempty(void)
{
      return DLIST_ISEMPTY(&ExecEntry_Head);
}

/* T E S T   E N T R Y */

DLIST_HEAD(test_entry_head, _test_entry) TestEntry_Head;

static void
TestEntry_constructor(void)               __attribute__  ((constructor));

static void
TestEntry_constructor(void)
{
      DLIST_INIT(&TestEntry_Head);
}

extern char ** environ;

static inline void
TestEntry_init(TestEntry *entry, ExecEntry *parent, char **args, char **env)
{
      assert(entry != NULL);
      entry->pid = -1;
      entry->status = 0;
      if ((entry->progname = strdup(parent->fullname)) == NULL)
            bfbt_message(MSG_TYPE_ERRNO_ABORT, "Out of memory");
      entry->args = args;
      entry->args_str = args_to_str(entry->args);
      if (env) {
            entry->env = env_create(env);
            entry->env_flag = FALSE;
            entry->env_str = env_to_str(env);
      } else {
            entry->env = environ;
            entry->env_flag = TRUE;
            entry->env_str = NULL;
      }
}

void
TestEntry_destroy(TestEntry *entry)
{
      assert(entry != NULL);
      if (entry->progname)    free(entry->progname);
      if (entry->args_str)    free(entry->args_str);
      if (entry->env && entry->env_flag == FALSE)     free(entry->env);
      if (entry->env_str)           free(entry->env_str);
      free(entry);
}

TestEntry *
TestEntry_create(ExecEntry *parent, char **args, char **env)
{
      TestEntry *new;

      new = xmalloc(sizeof(TestEntry));
      TestEntry_init(new, parent, args, env);

      return new;
}

void
TestEntry_insert(TestEntry *entry)
{
      assert(entry != NULL && entry->pid != -1);
      DLIST_INSERT_HEAD(&TestEntry_Head, entry, link);
}

void
TestEntry_remove(TestEntry *entry)
{
      assert(entry != NULL && entry->pid != -1);

      DLIST_REMOVE(&TestEntry_Head, entry, link);
}

TestEntry *
TestEntry_getnext(TestEntry **entry)
{
      DLIST_GETNEXT(&TestEntry_Head, entry, link);
      return *entry;
}

/* C R A S H   R E P O R T S */

DLIST_HEAD(crashreport_slist_head, _crash_report) CrashReport_Head;

static void
CrashReport_constructor(void)                   __attribute__ ((constructor));

static void
CrashReport_constructor(void)
{
      DLIST_INIT(&CrashReport_Head);
}

static void
CrashReport_init(CrashReport *report, TestEntry *test_entry)
{
      report->progname = strdup(test_entry->progname);
      report->args_str = (test_entry->args_str ? strdup(test_entry->args_str)
                                    : NULL);
      report->env_str = (test_entry->env_str ? strdup(test_entry->env_str)
                                 : NULL);
      report->signal    = (int)WTERMSIG(test_entry->status);
      report->didCore = (int)WCOREDUMP(test_entry->status);
}

static void
CrashReport_destroy(CrashReport *report)
{
      if (report->progname)   free(report->progname);
      if (report->args_str)   free(report->args_str);
      if (report->env_str)    free(report->env_str);
      free(report);
}

CrashReport *
CrashReport_add(TestEntry *test_entry)
{
      CrashReport *new;

      assert(test_entry != NULL);
      new = xmalloc(sizeof(CrashReport));
      CrashReport_init(new, test_entry);
      DLIST_INSERT_HEAD(&CrashReport_Head, new, link);
      return new;
}

void
CrashReport_subtract(CrashReport *report)
{
      assert(report != NULL);
      DLIST_REMOVE(&CrashReport_Head, report, link);
      CrashReport_destroy(report);
}

void
CrashReport_log(CrashReport *report)
{
      bfbt_message(MSG_TYPE_MESSAGE,
                         "*** Crash <%s> ***\n"
                         "args:           %s\n"
                         "envs:           %s\n"
                         "Signal:         %d ( %s )\n"
                         "Core?           %s\n",
                         report->progname,
                         report->args_str ? report->args_str : "",
                         report->env_str ? report->env_str : "",
                         report->signal, strsignal(report->signal),
                         report->didCore ? "Yes" : "No");
}






Generated by  Doxygen 1.6.0   Back to index