Fixing formatting with astyle in tests/*

tests/gtcp_proxy/gtcp-proxy.c

@@ -332,7 +332,9 @@ static void *tcp_proxy(void *arg)
         for (i = 0; i < 100; i++)
         {
             if (tcp_can_send(con_skt, 100))
+            {
                 break;
+            }
 
             usleep(100);
         }
@@ -452,7 +454,9 @@ static void show_msg(int not_main_window, int style,
     GtkWidget *dialog;
 
     if (not_main_window)
+    {
         gdk_threads_enter();
+    }
 
     dialog = gtk_message_dialog_new(GTK_WINDOW(NULL),
                                     GTK_DIALOG_DESTROY_WITH_PARENT,
@@ -465,7 +469,9 @@ static void show_msg(int not_main_window, int style,
     gtk_widget_destroy(dialog);
 
     if (not_main_window)
+    {
         gdk_threads_leave();
+    }
 }
 
 /**
@@ -475,12 +481,16 @@ static void show_msg(int not_main_window, int style,
 static void show_status(int not_main_thread, char *msg)
 {
     if (not_main_thread)
+    {
         gdk_threads_enter();
+    }
 
     gtk_statusbar_push(GTK_STATUSBAR(g_statusbar), CONTEXT_ID, msg);
 
     if (not_main_thread)
+    {
         gdk_threads_leave();
+    }
 }
 
 /**
@@ -490,12 +500,16 @@ static void show_status(int not_main_thread, char *msg)
 static void clear_status(int not_main_thread)
 {
     if (not_main_thread)
+    {
         gdk_threads_enter();
+    }
 
     gtk_statusbar_remove_all(GTK_STATUSBAR(g_statusbar), CONTEXT_ID);
 
     if (not_main_thread)
+    {
         gdk_threads_leave();
+    }
 }
 
 /**
@@ -505,12 +519,16 @@ static void clear_status(int not_main_thread)
 static void enable_btn_start(int not_main_thread)
 {
     if (not_main_thread)
+    {
         gdk_threads_enter();
+    }
 
     gtk_widget_set_sensitive(GTK_WIDGET(g_btn_start), TRUE);
 
     if (not_main_thread)
+    {
         gdk_threads_leave();
+    }
 }
 
 /**
@@ -520,12 +538,16 @@ static void enable_btn_start(int not_main_thread)
 static void disable_btn_start(int not_main_thread)
 {
     if (not_main_thread)
+    {
         gdk_threads_enter();
+    }
 
     gtk_widget_set_sensitive(GTK_WIDGET(g_btn_start), FALSE);
 
     if (not_main_thread)
+    {
         gdk_threads_leave();
+    }
 }
 
 /**
@@ -569,12 +591,16 @@ static void show_loc_port_stats(int not_main_thread, int count)
     sprintf(buf, "%d", count);
 
     if (not_main_thread)
+    {
         gdk_threads_enter();
+    }
 
     gtk_entry_set_text(GTK_ENTRY(g_tbx_loc_stats), buf);
 
     if (not_main_thread)
+    {
         gdk_threads_leave();
+    }
 }
 
 /**
@@ -588,12 +614,16 @@ static void show_rem_port_stats(int not_main_thread, int count)
     sprintf(buf, "%d", count);
 
     if (not_main_thread)
+    {
         gdk_threads_enter();
+    }
 
     gtk_entry_set_text(GTK_ENTRY(g_tbx_rem_stats), buf);
 
     if (not_main_thread)
+    {
         gdk_threads_leave();
+    }
 }
 
 /**

tests/gtcp_proxy/gtcp.c

@@ -30,7 +30,9 @@ int tcp_socket_create(void)
 
     /* in win32 a socket is an unsigned int, in linux, it's an int */
     if ((rv = (int) socket(PF_INET, SOCK_STREAM, 0)) < 0)
+    {
         return -1;
+    }
 
     option_len = sizeof(option_value);
 
@@ -157,7 +159,9 @@ int tcp_last_error_would_block()
 void tcp_close(int skt)
 {
     if (skt <= 0)
+    {
         return;
+    }
 
 #if defined(_WIN32)
     closesocket(skt);
@@ -180,7 +184,9 @@ int tcp_socket(void)
 
     /* in win32 a socket is an unsigned int, in linux, it's an int */
     if ((rv = (int) socket(PF_INET, SOCK_STREAM, 0)) < 0)
+    {
         return -1;
+    }
 
     option_len = sizeof(option_value);
 
@@ -295,7 +301,9 @@ int tcp_socket_ok(int skt)
     if (getsockopt(skt, SOL_SOCKET, SO_ERROR, (char *) (&opt), &opt_len) == 0)
     {
         if (opt == 0)
+        {
             return 1;
+        }
     }
 
     return 0;
@@ -323,15 +331,21 @@ int tcp_select(int sck1, int sck2)
     FD_ZERO(&rfds);
 
     if (sck1 > 0)
+    {
         FD_SET(((unsigned int) sck1), &rfds);
+    }
 
     if (sck2 > 0)
+    {
         FD_SET(((unsigned int) sck2), &rfds);
+    }
 
     max = sck1;
 
     if (sck2 > max)
+    {
         max = sck2;
+    }
 
     rv = select(max + 1, &rfds, 0, 0, &time);
 
@@ -340,10 +354,14 @@ int tcp_select(int sck1, int sck2)
         rv = 0;
 
         if (FD_ISSET(((unsigned int) sck1), &rfds))
+        {
             rv = rv | 1;
+        }
 
         if (FD_ISSET(((unsigned int)sck2), &rfds))
+        {
             rv = rv | 2;
+        }
     }
     else
     {

tests/gtcp_proxy/hexdump.c

@@ -43,10 +43,13 @@ void hexdump(int address, char *buf, int len)
     unsigned char c;
 
     char cvt[] = {'0', '1', '2', '3', '4', '5', '6', '7',
-                  '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+                  '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+                 };
 
     if ((buf == NULL) || (len <= 0))
+    {
         return;
+    }
 
     addr = (address < 0) ? 0 : address;
     blocks = len / 16;
@@ -85,9 +88,13 @@ void hexdump(int address, char *buf, int len)
             outbuf[index2++] = ' ';
 
             if ((c >= 0x20) && (c <= 0x7e))
+            {
                 outbuf[index3++] = c;
+            }
             else
+            {
                 outbuf[index3++] = '.';
+            }
         }
 
         outbuf[index3] = 0;
@@ -95,7 +102,9 @@ void hexdump(int address, char *buf, int len)
     }
 
     if (!residual)
+    {
         return;
+    }
 
     outbuf[7] = cvt[(addr >>  0) & 0x0000000f];
     outbuf[6] = cvt[(addr >>  4) & 0x0000000f];
@@ -120,9 +129,13 @@ void hexdump(int address, char *buf, int len)
         outbuf[index2++] = ' ';
 
         if ((c >= 0x20) && (c <= 0x7e))
+        {
             outbuf[index3++] = c;
+        }
         else
+        {
             outbuf[index3++] = '.';
+        }
     }
 
     outbuf[index3] = 0;

tests/memtest/libmem.c

@@ -9,406 +9,406 @@
 
 #define LLOG_LEVEL 1
 #define LLOGLN(_log_level, _params) \
-do { \
-  if (_log_level < LLOG_LEVEL) \
-  { \
-    printf _params ; \
-    printf ("\n") ; \
-  } \
-} while (0)
+    do { \
+        if (_log_level < LLOG_LEVEL) \
+        { \
+            printf _params ; \
+            printf ("\n") ; \
+        } \
+    } while (0)
 
 struct mem_item
 {
-  unsigned int addr;
-  int bytes;
-  struct mem_item* next;
-  struct mem_item* prev;
+    unsigned int addr;
+    int bytes;
+    struct mem_item *next;
+    struct mem_item *prev;
 };
 
 struct mem_info
 {
-  unsigned int addr;
-  int bytes;
-  int flags;
-  struct mem_item* free_head;
-  struct mem_item* free_tail;
-  struct mem_item* used_head;
-  struct mem_item* used_tail;
-  int total_bytes;
+    unsigned int addr;
+    int bytes;
+    int flags;
+    struct mem_item *free_head;
+    struct mem_item *free_tail;
+    struct mem_item *used_head;
+    struct mem_item *used_tail;
+    int total_bytes;
 };
 
 /*****************************************************************************/
 static int
-libmem_free_mem_item(struct mem_info* self, struct mem_item* mi)
+libmem_free_mem_item(struct mem_info *self, struct mem_item *mi)
 {
-  if (self == 0 || mi == 0)
-  {
+    if (self == 0 || mi == 0)
+    {
+        return 0;
+    }
+    if (mi->prev != 0)
+    {
+        mi->prev->next = mi->next;
+    }
+    if (mi->next != 0)
+    {
+        mi->next->prev = mi->prev;
+    }
+    if (mi == self->free_head)
+    {
+        self->free_head = mi->next;
+    }
+    if (mi == self->free_tail)
+    {
+        self->free_tail = mi->prev;
+    }
+    if (mi == self->used_head)
+    {
+        self->used_head = mi->next;
+    }
+    if (mi == self->used_tail)
+    {
+        self->used_tail = mi->prev;
+    }
+    free(mi);
     return 0;
-  }
-  if (mi->prev != 0)
-  {
-    mi->prev->next = mi->next;
-  }
-  if (mi->next != 0)
-  {
-    mi->next->prev = mi->prev;
-  }
-  if (mi == self->free_head)
-  {
-    self->free_head = mi->next;
-  }
-  if (mi == self->free_tail)
-  {
-    self->free_tail = mi->prev;
-  }
-  if (mi == self->used_head)
-  {
-    self->used_head = mi->next;
-  }
-  if (mi == self->used_tail)
-  {
-    self->used_tail = mi->prev;
-  }
-  free(mi);
-  return 0;
 }
 
 /*****************************************************************************/
-void*
+void *
 libmem_init(unsigned int addr, int bytes)
 {
-  struct mem_info* self;
-  struct mem_item* mi;
+    struct mem_info *self;
+    struct mem_item *mi;
 
-  self = (struct mem_info*)malloc(sizeof(struct mem_info));
-  memset(self, 0, sizeof(struct mem_info));
-  self->addr = addr;
-  self->bytes = bytes;
-  //self->flags = 1;
-  mi = (struct mem_item*)malloc(sizeof(struct mem_item));
-  memset(mi, 0, sizeof(struct mem_item));
-  mi->addr = addr;
-  mi->bytes = bytes;
-  self->free_head = mi;
-  self->free_tail = mi;
-  return self;
+    self = (struct mem_info *)malloc(sizeof(struct mem_info));
+    memset(self, 0, sizeof(struct mem_info));
+    self->addr = addr;
+    self->bytes = bytes;
+    //self->flags = 1;
+    mi = (struct mem_item *)malloc(sizeof(struct mem_item));
+    memset(mi, 0, sizeof(struct mem_item));
+    mi->addr = addr;
+    mi->bytes = bytes;
+    self->free_head = mi;
+    self->free_tail = mi;
+    return self;
 }
 
 /*****************************************************************************/
 void
-libmem_deinit(void* aself)
+libmem_deinit(void *aself)
 {
-  struct mem_info* self;
+    struct mem_info *self;
 
-  self = (struct mem_info*)aself;
-  if (self == 0)
-  {
-    return;
-  }
-  while (self->free_head != 0)
-  {
-    libmem_free_mem_item(self, self->free_head);
-  }
-  while (self->used_head != 0)
-  {
-    libmem_free_mem_item(self, self->used_head);
-  }
-  free(self);
+    self = (struct mem_info *)aself;
+    if (self == 0)
+    {
+        return;
+    }
+    while (self->free_head != 0)
+    {
+        libmem_free_mem_item(self, self->free_head);
+    }
+    while (self->used_head != 0)
+    {
+        libmem_free_mem_item(self, self->used_head);
+    }
+    free(self);
 }
 
 /****************************************************************************/
 static int
-libmem_add_used_item(struct mem_info* self, unsigned int addr, int bytes)
+libmem_add_used_item(struct mem_info *self, unsigned int addr, int bytes)
 {
-  struct mem_item* mi;
-  struct mem_item* new_mi;
-  int added;
+    struct mem_item *mi;
+    struct mem_item *new_mi;
+    int added;
 
-  if (self == 0 || addr == 0)
-  {
-    return 1;
-  }
-  if (self->used_head == 0)
-  {
-    /* add first item */
-    new_mi = (struct mem_item*)malloc(sizeof(struct mem_item));
-    memset(new_mi, 0, sizeof(struct mem_item));
-    new_mi->addr = addr;
-    new_mi->bytes = bytes;
-    self->used_head = new_mi;
-    self->used_tail = new_mi;
-    return 0;
-  }
-  added = 0;
-  mi = self->used_head;
-  while (mi != 0)
-  {
-    if (mi->addr > addr)
+    if (self == 0 || addr == 0)
     {
-      /* add before */
-      new_mi = (struct mem_item*)malloc(sizeof(struct mem_item));
-      memset(new_mi, 0, sizeof(struct mem_item));
-      new_mi->addr = addr;
-      new_mi->bytes = bytes;
-      new_mi->prev = mi->prev;
-      new_mi->next = mi;
-      if (mi->prev != 0)
-      {
-        mi->prev->next = new_mi;
-      }
-      mi->prev = new_mi;
-      if (self->used_head == mi)
-      {
+        return 1;
+    }
+    if (self->used_head == 0)
+    {
+        /* add first item */
+        new_mi = (struct mem_item *)malloc(sizeof(struct mem_item));
+        memset(new_mi, 0, sizeof(struct mem_item));
+        new_mi->addr = addr;
+        new_mi->bytes = bytes;
         self->used_head = new_mi;
-      }
-      added = 1;
-      break;
+        self->used_tail = new_mi;
+        return 0;
     }
-    mi = mi->next;
-  }
-  if (!added)
-  {
-    /* add last */
-    new_mi = (struct mem_item*)malloc(sizeof(struct mem_item));
-    memset(new_mi, 0, sizeof(struct mem_item));
-    new_mi->addr = addr;
-    new_mi->bytes = bytes;
-    self->used_tail->next = new_mi;
-    new_mi->prev = self->used_tail;
-    self->used_tail = new_mi;
-  }
-  return 0;
+    added = 0;
+    mi = self->used_head;
+    while (mi != 0)
+    {
+        if (mi->addr > addr)
+        {
+            /* add before */
+            new_mi = (struct mem_item *)malloc(sizeof(struct mem_item));
+            memset(new_mi, 0, sizeof(struct mem_item));
+            new_mi->addr = addr;
+            new_mi->bytes = bytes;
+            new_mi->prev = mi->prev;
+            new_mi->next = mi;
+            if (mi->prev != 0)
+            {
+                mi->prev->next = new_mi;
+            }
+            mi->prev = new_mi;
+            if (self->used_head == mi)
+            {
+                self->used_head = new_mi;
+            }
+            added = 1;
+            break;
+        }
+        mi = mi->next;
+    }
+    if (!added)
+    {
+        /* add last */
+        new_mi = (struct mem_item *)malloc(sizeof(struct mem_item));
+        memset(new_mi, 0, sizeof(struct mem_item));
+        new_mi->addr = addr;
+        new_mi->bytes = bytes;
+        self->used_tail->next = new_mi;
+        new_mi->prev = self->used_tail;
+        self->used_tail = new_mi;
+    }
+    return 0;
 }
 
 /****************************************************************************/
 static int
-libmem_add_free_item(struct mem_info* self, unsigned int addr, int bytes)
+libmem_add_free_item(struct mem_info *self, unsigned int addr, int bytes)
 {
-  struct mem_item* mi;
-  struct mem_item* new_mi;
-  int added;
+    struct mem_item *mi;
+    struct mem_item *new_mi;
+    int added;
 
-  if (self == 0 || addr == 0)
-  {
-    return 1;
-  }
-  if (self->free_head == 0)
-  {
-    /* add first item */
-    new_mi = (struct mem_item*)malloc(sizeof(struct mem_item));
-    memset(new_mi, 0, sizeof(struct mem_item));
-    new_mi->addr = addr;
-    new_mi->bytes = bytes;
-    self->free_head = new_mi;
-    self->free_tail = new_mi;
-    return 0;
-  }
-  added = 0;
-  mi = self->free_head;
-  while (mi != 0)
-  {
-    if (mi->addr > addr)
+    if (self == 0 || addr == 0)
     {
-      if (mi->prev != 0)
-      {
-        if (mi->prev->addr + mi->prev->bytes == addr)
-        {
-          /* don't need to add, just make prev bigger */
-          mi->prev->bytes += bytes;
-          if (mi->prev->addr + mi->prev->bytes == mi->addr)
-          {
-            /* here we can remove one */
-            mi->prev->bytes += mi->bytes;
-            libmem_free_mem_item(self, mi);
-          }
-          return 0;
-        }
-      }
-      if (addr + bytes == mi->addr)
-      {
-        /* don't need to add here either */
-        mi->addr = addr;
-        mi->bytes += bytes;
-        return 0;
-      }
-      /* add before */
-      new_mi = (struct mem_item*)malloc(sizeof(struct mem_item));
-      memset(new_mi, 0, sizeof(struct mem_item));
-      new_mi->addr = addr;
-      new_mi->bytes = bytes;
-      new_mi->prev = mi->prev;
-      new_mi->next = mi;
-      if (mi->prev != 0)
-      {
-        mi->prev->next = new_mi;
-      }
-      mi->prev = new_mi;
-      if (self->free_head == mi)
-      {
-        self->free_head = new_mi;
-      }
-      added = 1;
-      break;
+        return 1;
     }
-    mi = mi->next;
-  }
-  if (!added)
-  {
-    /* add last */
-    new_mi = (struct mem_item*)malloc(sizeof(struct mem_item));
-    memset(new_mi, 0, sizeof(struct mem_item));
-    new_mi->addr = addr;
-    new_mi->bytes = bytes;
-    self->free_tail->next = new_mi;
-    new_mi->prev = self->free_tail;
-    self->free_tail = new_mi;
-  }
-  return 0;
+    if (self->free_head == 0)
+    {
+        /* add first item */
+        new_mi = (struct mem_item *)malloc(sizeof(struct mem_item));
+        memset(new_mi, 0, sizeof(struct mem_item));
+        new_mi->addr = addr;
+        new_mi->bytes = bytes;
+        self->free_head = new_mi;
+        self->free_tail = new_mi;
+        return 0;
+    }
+    added = 0;
+    mi = self->free_head;
+    while (mi != 0)
+    {
+        if (mi->addr > addr)
+        {
+            if (mi->prev != 0)
+            {
+                if (mi->prev->addr + mi->prev->bytes == addr)
+                {
+                    /* don't need to add, just make prev bigger */
+                    mi->prev->bytes += bytes;
+                    if (mi->prev->addr + mi->prev->bytes == mi->addr)
+                    {
+                        /* here we can remove one */
+                        mi->prev->bytes += mi->bytes;
+                        libmem_free_mem_item(self, mi);
+                    }
+                    return 0;
+                }
+            }
+            if (addr + bytes == mi->addr)
+            {
+                /* don't need to add here either */
+                mi->addr = addr;
+                mi->bytes += bytes;
+                return 0;
+            }
+            /* add before */
+            new_mi = (struct mem_item *)malloc(sizeof(struct mem_item));
+            memset(new_mi, 0, sizeof(struct mem_item));
+            new_mi->addr = addr;
+            new_mi->bytes = bytes;
+            new_mi->prev = mi->prev;
+            new_mi->next = mi;
+            if (mi->prev != 0)
+            {
+                mi->prev->next = new_mi;
+            }
+            mi->prev = new_mi;
+            if (self->free_head == mi)
+            {
+                self->free_head = new_mi;
+            }
+            added = 1;
+            break;
+        }
+        mi = mi->next;
+    }
+    if (!added)
+    {
+        /* add last */
+        new_mi = (struct mem_item *)malloc(sizeof(struct mem_item));
+        memset(new_mi, 0, sizeof(struct mem_item));
+        new_mi->addr = addr;
+        new_mi->bytes = bytes;
+        self->free_tail->next = new_mi;
+        new_mi->prev = self->free_tail;
+        self->free_tail = new_mi;
+    }
+    return 0;
 }
 
 /*****************************************************************************/
 static int
-libmem_print(struct mem_info* self)
+libmem_print(struct mem_info *self)
 {
-  struct mem_item* mi;
+    struct mem_item *mi;
 
-  LLOGLN(0, ("libmem_print:"));
-  LLOGLN(0, ("  used_head %p", self->used_head));
-  LLOGLN(0, ("  used_tail %p", self->used_tail));
-  mi = self->used_head;
-  if (mi != 0)
-  {
-    LLOGLN(0, ("  used list"));
-    while (mi != 0)
+    LLOGLN(0, ("libmem_print:"));
+    LLOGLN(0, ("  used_head %p", self->used_head));
+    LLOGLN(0, ("  used_tail %p", self->used_tail));
+    mi = self->used_head;
+    if (mi != 0)
     {
-      LLOGLN(0, ("    ptr %p prev %p next %p addr 0x%8.8x bytes %d",
-             mi, mi->prev, mi->next, mi->addr, mi->bytes));
-      mi = mi->next;
+        LLOGLN(0, ("  used list"));
+        while (mi != 0)
+        {
+            LLOGLN(0, ("    ptr %p prev %p next %p addr 0x%8.8x bytes %d",
+                       mi, mi->prev, mi->next, mi->addr, mi->bytes));
+            mi = mi->next;
+        }
     }
-  }
-  LLOGLN(0, ("  free_head %p", self->free_head));
-  LLOGLN(0, ("  free_tail %p", self->free_tail));
-  mi = self->free_head;
-  if (mi != 0)
-  {
-    LLOGLN(0, ("  free list"));
-    while (mi != 0)
+    LLOGLN(0, ("  free_head %p", self->free_head));
+    LLOGLN(0, ("  free_tail %p", self->free_tail));
+    mi = self->free_head;
+    if (mi != 0)
     {
-      LLOGLN(0, ("    ptr %p prev %p next %p addr 0x%8.8x bytes %d",
-             mi, mi->prev, mi->next, mi->addr, mi->bytes));
-      mi = mi->next;
+        LLOGLN(0, ("  free list"));
+        while (mi != 0)
+        {
+            LLOGLN(0, ("    ptr %p prev %p next %p addr 0x%8.8x bytes %d",
+                       mi, mi->prev, mi->next, mi->addr, mi->bytes));
+            mi = mi->next;
+        }
     }
-  }
-  return 0;
+    return 0;
 }
 
 /*****************************************************************************/
 unsigned int
-libmem_alloc(void* obj, int bytes)
+libmem_alloc(void *obj, int bytes)
 {
-  struct mem_info* self;
-  struct mem_item* mi;
-  unsigned int addr;
+    struct mem_info *self;
+    struct mem_item *mi;
+    unsigned int addr;
 
-  if (bytes < 1)
-  {
+    if (bytes < 1)
+    {
+        return 0;
+    }
+    bytes = ALIGN(bytes);
+    self = (struct mem_info *)obj;
+    addr = 0;
+    mi = self->free_head;
+    while (mi != 0)
+    {
+        if (bytes <= mi->bytes)
+        {
+            addr = mi->addr;
+            mi->bytes -= bytes;
+            mi->addr += bytes;
+            if (mi->bytes < 1)
+            {
+                libmem_free_mem_item(self, mi);
+            }
+            break;
+        }
+        mi = mi->next;
+    }
+    if (addr != 0)
+    {
+        self->total_bytes += bytes;
+        libmem_add_used_item(self, addr, bytes);
+        if (self->flags & 1)
+        {
+            libmem_print(self);
+        }
+    }
+    else
+    {
+        LLOGLN(0, ("libmem_alloc: error"));
+    }
+    return addr;
+}
+
+/*****************************************************************************/
+int
+libmem_free(void *obj, unsigned int addr)
+{
+    struct mem_info *self;
+    struct mem_item *mi;
+
+    if (addr == 0)
+    {
+        return 0;
+    }
+    self = (struct mem_info *)obj;
+    mi = self->used_tail;
+    while (mi != 0)
+    {
+        if (mi->addr == addr)
+        {
+            self->total_bytes -= mi->bytes;
+            libmem_add_free_item(self, mi->addr, mi->bytes);
+            libmem_free_mem_item(self, mi);
+            if (self->flags & 1)
+            {
+                libmem_print(self);
+            }
+            return 0;
+        }
+        mi = mi->prev;
+    }
+    LLOGLN(0, ("libmem_free: error"));
+    return 1;
+}
+
+/*****************************************************************************/
+int
+libmem_set_flags(void *obj, int flags)
+{
+    struct mem_info *self;
+
+    self = (struct mem_info *)obj;
+    self->flags |= flags;
     return 0;
-  }
-  bytes = ALIGN(bytes);
-  self = (struct mem_info*)obj;
-  addr = 0;
-  mi = self->free_head;
-  while (mi != 0)
-  {
-    if (bytes <= mi->bytes)
-    {
-      addr = mi->addr;
-      mi->bytes -= bytes;
-      mi->addr += bytes;
-      if (mi->bytes < 1)
-      {
-        libmem_free_mem_item(self, mi);
-      }
-      break;
-    }
-    mi = mi->next;
-  }
-  if (addr != 0)
-  {
-    self->total_bytes += bytes;
-    libmem_add_used_item(self, addr, bytes);
-    if (self->flags & 1)
-    {
-      libmem_print(self);
-    }
-  }
-  else
-  {
-    LLOGLN(0, ("libmem_alloc: error"));
-  }
-  return addr;
 }
 
 /*****************************************************************************/
 int
-libmem_free(void* obj, unsigned int addr)
+libmem_clear_flags(void *obj, int flags)
 {
-  struct mem_info* self;
-  struct mem_item* mi;
+    struct mem_info *self;
 
-  if (addr == 0)
-  {
+    self = (struct mem_info *)obj;
+    self->flags &= ~flags;
     return 0;
-  }
-  self = (struct mem_info*)obj;
-  mi = self->used_tail;
-  while (mi != 0)
-  {
-    if (mi->addr == addr)
-    {
-      self->total_bytes -= mi->bytes;
-      libmem_add_free_item(self, mi->addr, mi->bytes);
-      libmem_free_mem_item(self, mi);
-      if (self->flags & 1)
-      {
-        libmem_print(self);
-      }
-      return 0;
-    }
-    mi = mi->prev;
-  }
-  LLOGLN(0, ("libmem_free: error"));
-  return 1;
 }
 
 /*****************************************************************************/
 int
-libmem_set_flags(void* obj, int flags)
+libmem_get_alloced_bytes(void *obj)
 {
-  struct mem_info* self;
+    struct mem_info *self;
 
-  self = (struct mem_info*)obj;
-  self->flags |= flags;
-  return 0;
-}
-
-/*****************************************************************************/
-int
-libmem_clear_flags(void* obj, int flags)
-{
-  struct mem_info* self;
-
-  self = (struct mem_info*)obj;
-  self->flags &= ~flags;
-  return 0;
-}
-
-/*****************************************************************************/
-int
-libmem_get_alloced_bytes(void* obj)
-{
-  struct mem_info* self;
-
-  self = (struct mem_info*)obj;
-  return self->total_bytes;
+    self = (struct mem_info *)obj;
+    return self->total_bytes;
 }

tests/memtest/libmem.h

@@ -2,19 +2,19 @@
 #ifndef _LIBMEM_C
 #define _LIBMEM_C
 
-void*
+void *
 libmem_init(unsigned int addr, int bytes);
 void
-libmem_deinit(void* aself);
+libmem_deinit(void *aself);
 unsigned int
-libmem_alloc(void* obj, int bytes);
+libmem_alloc(void *obj, int bytes);
 int
-libmem_free(void* obj, unsigned int addr);
+libmem_free(void *obj, unsigned int addr);
 int
-libmem_set_flags(void* obj, int flags);
+libmem_set_flags(void *obj, int flags);
 int
-libmem_clear_flags(void* obj, int flags);
+libmem_clear_flags(void *obj, int flags);
 int
-libmem_get_alloced_bytes(void* obj);
+libmem_get_alloced_bytes(void *obj);
 
 #endif

tests/memtest/memtest.c

@@ -5,56 +5,56 @@
 
 #include "libmem.h"
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
-  void* obj;
-  unsigned int addr1;
-  unsigned int addr2;
-  unsigned int addr3;
-  unsigned int addr4;
-  unsigned int addr5;
-  int index;
-  int rd;
+    void *obj;
+    unsigned int addr1;
+    unsigned int addr2;
+    unsigned int addr3;
+    unsigned int addr4;
+    unsigned int addr5;
+    int index;
+    int rd;
 
-  srand(time(0));
-  obj = libmem_init(0x80000000, 64 * 1024 * 1024);
-  for (index = 0; index < 256; index++)
-  {
-    rd = rand() & 0xffff;
-    printf("1 rd %d\n", rd);
-    addr1 = libmem_alloc(obj, rd);
-    rd = rand() & 0xffff;
-    printf("2 rd %d\n", rd);
-    addr2 = libmem_alloc(obj, rd);
-    rd = rand() & 0xffff;
-    printf("3 rd %d\n", rd);
-    addr3 = libmem_alloc(obj, rd);
-    rd = rand() & 0xffff;
-    printf("4 rd %d\n", rd);
-    addr4 = libmem_alloc(obj, rd);
-    addr5 = libmem_alloc(obj, rd);
-    libmem_free(obj, addr1);
-    printf("5\n");
-    addr1 = libmem_alloc(obj, 64);
-    printf("6\n");
-    libmem_free(obj, addr3);
-    printf("7\n");
-    addr3 = libmem_alloc(obj, 64 * 1024);
-    libmem_free(obj, addr5);
-    addr5 = libmem_alloc(obj, 64 * 1024);
-    printf("8\n");
-    libmem_free(obj, addr1);
-    printf("9\n");
-    libmem_free(obj, addr2);
-    printf("10\n");
-    libmem_free(obj, addr3);
-    libmem_free(obj, addr4);
-    if (index == 255)
+    srand(time(0));
+    obj = libmem_init(0x80000000, 64 * 1024 * 1024);
+    for (index = 0; index < 256; index++)
     {
-      libmem_set_flags(obj, 1);
+        rd = rand() & 0xffff;
+        printf("1 rd %d\n", rd);
+        addr1 = libmem_alloc(obj, rd);
+        rd = rand() & 0xffff;
+        printf("2 rd %d\n", rd);
+        addr2 = libmem_alloc(obj, rd);
+        rd = rand() & 0xffff;
+        printf("3 rd %d\n", rd);
+        addr3 = libmem_alloc(obj, rd);
+        rd = rand() & 0xffff;
+        printf("4 rd %d\n", rd);
+        addr4 = libmem_alloc(obj, rd);
+        addr5 = libmem_alloc(obj, rd);
+        libmem_free(obj, addr1);
+        printf("5\n");
+        addr1 = libmem_alloc(obj, 64);
+        printf("6\n");
+        libmem_free(obj, addr3);
+        printf("7\n");
+        addr3 = libmem_alloc(obj, 64 * 1024);
+        libmem_free(obj, addr5);
+        addr5 = libmem_alloc(obj, 64 * 1024);
+        printf("8\n");
+        libmem_free(obj, addr1);
+        printf("9\n");
+        libmem_free(obj, addr2);
+        printf("10\n");
+        libmem_free(obj, addr3);
+        libmem_free(obj, addr4);
+        if (index == 255)
+        {
+            libmem_set_flags(obj, 1);
+        }
+        libmem_free(obj, addr5);
     }
-    libmem_free(obj, addr5);
-  }
-  libmem_deinit(obj);
-  return 0;
+    libmem_deinit(obj);
+    return 0;
 }

tests/tcp_proxy/main.c

@@ -170,15 +170,15 @@ g_tcp_set_non_blocking(int sck)
 
 /*****************************************************************************/
 static int
-g_tcp_bind(int sck, const char* port)
+g_tcp_bind(int sck, const char *port)
 {
-  struct sockaddr_in s;
+    struct sockaddr_in s;
 
-  memset(&s, 0, sizeof(struct sockaddr_in));
-  s.sin_family = AF_INET;
-  s.sin_port = htons((tui16)atoi(port));
-  s.sin_addr.s_addr = INADDR_ANY;
-  return bind(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in));
+    memset(&s, 0, sizeof(struct sockaddr_in));
+    s.sin_family = AF_INET;
+    s.sin_port = htons((tui16)atoi(port));
+    s.sin_addr.s_addr = INADDR_ANY;
+    return bind(sck, (struct sockaddr *)&s, sizeof(struct sockaddr_in));
 }
 
 /*****************************************************************************/
@@ -300,10 +300,10 @@ g_tcp_accept(int sck)
 
 /*****************************************************************************/
 static int
-g_tcp_connect(int sck, const char* address, const char* port)
+g_tcp_connect(int sck, const char *address, const char *port)
 {
     struct sockaddr_in s;
-    struct hostent* h;
+    struct hostent *h;
 
     g_memset(&s, 0, sizeof(struct sockaddr_in));
     s.sin_family = AF_INET;
@@ -320,13 +320,13 @@ g_tcp_connect(int sck, const char* address, const char* port)
                 {
                     if ((*(h->h_addr_list)) != 0)
                     {
-                        s.sin_addr.s_addr = *((int*)(*(h->h_addr_list)));
+                        s.sin_addr.s_addr = *((int *)(*(h->h_addr_list)));
                     }
                 }
             }
         }
     }
-    return connect(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in));
+    return connect(sck, (struct sockaddr *)&s, sizeof(struct sockaddr_in));
 }
 
 /*****************************************************************************/