misc.c

Go to the documentation of this file.

/* Miscellaneous functions.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <pthread.h>
#include <sys/time.h>
#include <time.h>

#include "tcpproxy.h"
#include "misc.h"

/*----------------------------------------------------------------------
 * eprintf -  printf, but for stderr
 *----------------------------------------------------------------------
 */
inline void eprintf (const char *template, ...)
{
  va_list ap;
  va_start (ap, template);
  vfprintf (stderr, template, ap);
  va_end (ap);
}

/*----------------------------------------------------------------------
 * xmalloc -  allocates a block of memory, with error checking
 *            exits (safely) if malloc fails.
 *----------------------------------------------------------------------
 */
inline void *xmalloc (size_t size)
{
  register void *val;
  //DPRINT("xmalloc: entered, size=%u.\n", size);
  val = malloc(size);  
  if (val == NULL) {
      EPRINT("xmalloc: virtual memory exhausted.\n");
      safe_exit(EXIT_ERR_MEM_ALLOC);
  }
  return val;
}

/*----------------------------------------------------------------------
 * xfree -  deallocates a block of memory, with error checking
 *          exits (safely) if a null pointer is given.
 *----------------------------------------------------------------------
 */
inline void xfree(void* ptr)
{
    //DPRINT("xfree: entered, ptr=0x%x.\n", (unsigned)ptr);
    if(ptr == NULL) {
        EPRINT("xfree: attempt to free NULL pointer.\n");
        safe_exit(EXIT_ERR_MEM_FREE);
    } else {
        free(ptr);
    }
}

/*----------------------------------------------------------------------
 * mutex_lock -  locks a mutex, with error checking
 *               exits (safely) if the lock fails.
 *----------------------------------------------------------------------
 */
inline void mutex_lock(char *caller, pthread_mutex_t *mut)
{
    //DPRINT("mutex_lock: called from %s\n", caller);
    if(pthread_mutex_lock(mut)) {
        EPRINT("%s: error locking mutex.\n", caller);
        safe_exit(EXIT_ERR_MUTEX);
    }
}

/*----------------------------------------------------------------------
 * xmalloc -  unlocks a mutex, with error checking
 *            exits (safely) if the unlock fails.
 *----------------------------------------------------------------------
 */
inline void mutex_unlock(char *caller, pthread_mutex_t *mut)
{
    //DPRINT("mutex_unlock: called from %s\n", caller);
    if(pthread_mutex_unlock(mut)) {
        EPRINT("%s: error unlocking mutex.\n", caller);
        safe_exit(EXIT_ERR_MUTEX);
    }    
}

/*----------------------------------------------------------------------
 * get_uclock -  returns the number of microseconds since the Epoch
 *               (modulo MAX_LONG_INT).
 *----------------------------------------------------------------------
 */
inline long get_uclock()
{
    struct timeval tv;
    gettimeofday(&tv, 0);
    return (tv.tv_sec*1000000 + tv.tv_usec);
}

/*----------------------------------------------------------------------
 * get_mclock -  returns the number of milliseconds since the Epoch
 *               (modulo MAX_LONG_INT).
 *----------------------------------------------------------------------
 */
inline long get_mclock()
{
    struct timeval tv;
    gettimeofday(&tv, 0);
    return (tv.tv_sec*1000 + tv.tv_usec/1000);
}

/*----------------------------------------------------------------------
 * safe_exit -  performs a safe exit from the program, no matter who
 *              calls it. If called from the 'main' thread, the exit
 *              command is used. If called from a thread, the main
 *              thread is signalled to exit with a SIGTERM.
 *----------------------------------------------------------------------
 */
void safe_exit(int val)
{
    pthread_t self = pthread_self();

    request_exit = val;

    if(pthread_equal(self, main_thread)) {
        exit(val);
    } else {
        pthread_kill(main_thread, SIGTERM);
        pthread_exit(NULL);
    }
}

/*----------------------------------------------------------------------
 * ceil_div -  returns the ceiling of the division a / b
 *----------------------------------------------------------------------
 */
inline unsigned ceil_div(unsigned a, unsigned b)
{
    return (a/b) + (a%b ? 1 : 0);
}

---