undns 0.4.0a

data/ext/undns/originAS.h

@@ -0,0 +1,17 @@
+/* (c) neil spring 2002 */
+
+#include "nscommon.h"
+#include <netinet/in.h>
+
+void origins_init(const char *origins_dat);
+unsigned short origin_for_address(in_addr_t a);
+unsigned short origin_for_address_str(const char *addrstring);
+
+boolean origin_prefix_for_address(in_addr_t a, 
+                                      /*@out@*/ unsigned short *asn, 
+                                      /*@out@*/ in_addr_t *prefix,
+                                      /*@out@*/ unsigned char *prefixlen);
+boolean origin_prefix_for_address_str(const char *addrstring, 
+                                      /*@out@*/ unsigned short *asn, 
+                                      /*@out@*/ in_addr_t *prefix,
+                                      /*@out@*/ unsigned char *prefixlen);

data/ext/undns/progress.c

@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2002
+ * Neil Spring and the University of Washington.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author(s) may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.  
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include<float.h>
+#include<assert.h>
+
+#include"nscommon.h"
+
+/* gettimeofday */
+#include <sys/time.h>
+#include <unistd.h>
+
+#include <string.h>
+
+#include"progress.h"
+
+/* snprintf */
+#define _GNU_SOURCE
+#include <stdio.h>
+#ifdef HAVE_DMALLOC_H
+#include<dmalloc.h>
+#endif
+#ifndef HAVE_SNPRINTF
+int snprintf ( char *str, size_t n, const char *format, ... );
+#endif
+
+__inline static float diffTime(struct timeval bigger, struct timeval smaller) {
+  long sec = bigger.tv_sec - smaller.tv_sec;
+  long usec = bigger.tv_usec - smaller.tv_usec;
+  return((float)sec + (float)usec/1000000.0);
+}
+
+
+static unsigned int next = 1;
+static float fnext;
+static char barstore[] =  
+"==============================================================================";
+static char fmtstring[60];
+static const char *label =""; 
+static boolean bAnnotate = FALSE;
+static boolean bEnabled = TRUE;
+static unsigned int spoonum;
+static char ratestring[20];
+static char timestring[20];
+
+static void progress_timestring(float rate);
+#define iBAR_WIDTHdefault 51
+#define bBAR_WIDTHdefault 51
+#define fBAR_WIDTHdefault ((float)iBAR_WIDTH)
+#define bfBAR_WIDTHdefault ((float)bBAR_WIDTH)
+ 
+static unsigned int iBAR_WIDTH = iBAR_WIDTHdefault;
+static unsigned int bBAR_WIDTH = bBAR_WIDTHdefault;
+static float fBAR_WIDTH = ((float)iBAR_WIDTHdefault);
+static float bfBAR_WIDTH = ((float)bBAR_WIDTHdefault);
+
+void progress_reset()  {
+  next = 0;
+  fnext = 0.0;
+}
+void progress_disable()  {
+  bEnabled = FALSE;
+}
+
+void progress(const float f) {
+  // fprintf(stderr,"%f\n",f);
+  if(!bEnabled) return;
+  if(f < FLT_EPSILON) {
+    fprintf(stderr, "\r>");
+    next = 1;
+  } else {
+    if(f >= ((float)(next))/fBAR_WIDTH || f >= (float)1.0) {
+      next = (unsigned int)(f*fBAR_WIDTH)+1;
+      if(bAnnotate) {
+	snprintf(fmtstring, sizeof(fmtstring), "\r%s:%3.0f%%%% %%-%ds| %u", label, f*100.0, iBAR_WIDTH, spoonum);
+      }
+      else 
+	snprintf(fmtstring, sizeof(fmtstring), "\r%s:%3.0f%%%% %%-%ds|", label, f*100.0, iBAR_WIDTH);
+      if(next > 1 )barstore[next-2]='>';
+      barstore[next-1]='\0';
+      fprintf(stderr, fmtstring, barstore);
+      //fprintf(stderr, "\r%s>", barstore);
+      barstore[next-1]='=';
+      if(next > 1 )barstore[next-2]='=';
+    }
+    if(f >= (float)1.0-FLT_EPSILON){
+      fprintf(stderr,"\n");
+      bAnnotate = FALSE;
+    }
+  }
+}
+
+void progress_label(const char *label_param) {
+  if(strlen(label_param) < bBAR_WIDTHdefault - 5) {
+    label = label_param;
+    bBAR_WIDTH = min(1, (int) bBAR_WIDTHdefault - (int)strlen(label_param));
+    iBAR_WIDTH = min(1, (int) iBAR_WIDTHdefault - (int)strlen(label_param));
+  }
+  fBAR_WIDTH = (float)iBAR_WIDTH;
+  bfBAR_WIDTH = (float)bBAR_WIDTH;
+}
+void progress_annotate(unsigned int spoo) {
+  bAnnotate = TRUE;
+  spoonum = spoo;
+}
+
+static struct timeval start;
+
+void progress_bytes_of_bytes(unsigned long int bytes, 
+			     unsigned long int total ) {
+  struct timeval now;
+  if(bytes > total) return;
+  if(!bEnabled) return;
+  if(isatty(fileno(stderr)) == 0) return;
+  if(bytes == 0) {
+    gettimeofday(&start, NULL);
+    fprintf(stderr, "\r>");
+    fnext = 0.01;
+  } else {
+    float f = (float)bytes/(float)total;
+    if(f >= fnext || bytes >= total) {
+      float dt;
+      unsigned int thisint = (unsigned int)(f*bfBAR_WIDTH);
+      fnext = f+0.01;
+      gettimeofday(&now, NULL);
+      dt = diffTime(now,start);
+      progress_ratestring((double)bytes / (double)dt, "B");
+      progress_timestring(dt*((float)total-bytes)/((float)bytes));
+      snprintf(fmtstring, sizeof(fmtstring), "\r%s:%3.0f%%%% %%-%ds| %9s eta %6s", 
+	       label, f*100.0, bBAR_WIDTH, ratestring, timestring);
+      if(thisint > 0 )barstore[thisint-1]='>';
+      barstore[thisint]='\0';
+      fprintf(stderr, fmtstring, barstore);
+      //fprintf(stderr, "\r%s>", barstore);
+      barstore[thisint]='=';
+      if(thisint > 0 )barstore[thisint-1]='=';
+    }
+  }
+  if(bytes == total){
+    float dt = diffTime(now,start);
+    fprintf(stderr,"\n");
+    if(dt > 2) {
+      progress_timestring(dt);
+      fprintf(stderr, "%s process rate: %s for %s\n", label, ratestring, timestring);
+    }
+  }
+}
+
+void progress_n_of(unsigned int n, 
+                   unsigned int total ) {
+  struct timeval now;
+  float f = (float)n/(float)total;
+  if(n > total) return;
+  if(!bEnabled) return;
+  if(isatty(fileno(stderr)) == 0) return;
+  if(n == 0) {
+    gettimeofday(&start, NULL);
+    fprintf(stderr, "\r>");
+    fnext = 0;
+    progress_ratestring(0, "");
+    progress_timestring(0);
+  } 
+  if(f >= fnext || n >= total) {
+    float dt;
+    unsigned int thisint = (unsigned int)(f*bfBAR_WIDTH);
+    fnext = f+0.01;
+    if(n != 0) {
+      gettimeofday(&now, NULL);
+      dt = diffTime(now,start);
+      progress_ratestring((double)n / (double)dt, "");
+      progress_timestring(dt*((float)total-n)/((float)n));
+    }
+    snprintf(fmtstring, sizeof(fmtstring), "\r%s:%3.0f%%%% %%-%ds| %9s eta %6s", 
+             label, f*100.0, bBAR_WIDTH, ratestring, timestring);
+    if(thisint != 0 ) barstore[thisint-1]='>';
+    barstore[thisint]='\0';
+    fprintf(stderr, fmtstring, barstore);
+    //fprintf(stderr, "\r%s>", barstore);
+    barstore[thisint]='=';
+    if(thisint > 0 )barstore[thisint-1]='=';
+  }
+  if(n == total){
+    float dt = diffTime(now,start);
+    fprintf(stderr,"\n");
+    if(dt > 2) {
+      progress_timestring(dt);
+      fprintf(stderr, "%s process rate: %s for %s\n", label, ratestring, timestring);
+    }
+  }
+}
+
+/* technique stolen from ncftp. */
+#define KByte 1024u
+#define MByte (1024u*KByte)
+#define GByte (1024u*MByte)
+/* haha */
+
+
+static void progress_timestring(float timeInSeconds) {
+  unsigned int hours=0;
+  unsigned int minutes=0;
+  unsigned int seconds=0;
+  unsigned int deciseconds=0;
+  hours = ((unsigned int)timeInSeconds) / 3600;
+  timeInSeconds -= hours*3600;
+  minutes = ((unsigned int)timeInSeconds) / 60;
+  timeInSeconds -= minutes*60;
+  seconds = ((unsigned int)timeInSeconds);
+  timeInSeconds-=seconds;
+  deciseconds = ((unsigned int)(timeInSeconds*10.0))%10;
+  if(hours >0) {
+    snprintf(timestring, sizeof(timestring), "%uh%02um", hours,minutes);
+  } else if(minutes >0) {
+    snprintf(timestring, sizeof(timestring), "%um%02us", minutes,seconds);
+  } else {
+    snprintf(timestring, sizeof(timestring), "%u.%01us", seconds, deciseconds);
+  }
+}
+
+const char * progress_ratestring(float rate, const char *units) {
+  char suff;
+  if(rate > 999.5 * GByte) {
+    suff = 'T';
+    rate = rate / GByte / 1024.0;
+  } else if(rate > 999.5 * MByte) {
+    suff = 'G';
+    rate /= GByte;
+  } else if(rate > 999.5 * KByte) {
+    suff = 'M';
+    rate /= MByte;
+    snprintf(ratestring, sizeof(ratestring), 
+	     "%.2fM", (float)rate / (float)MByte);
+  } else if(rate >= 999.5 ) {
+    suff = 'K';
+    rate /= KByte;;
+  } else {
+    suff = ' ';
+    snprintf(ratestring, sizeof(ratestring), 
+	     "%3.0f%s/s", rate, units);
+  }
+  if(rate >= 99.5)  { 
+    snprintf(ratestring, sizeof(ratestring), 
+	     "%3.0f%c%s/s", rate, suff, units);
+  } else if(rate >= 9.5) {
+    snprintf(ratestring, sizeof(ratestring), 
+	     "%4.1f%c%s/s", rate, suff, units);
+  } else {
+    snprintf(ratestring, sizeof(ratestring), 
+	     "%4.2f%c%s/s", rate, suff, units);
+  }
+  return(ratestring);
+}
+
+/*
+vi:ts=2
+*/

data/ext/undns/progress.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2002
+ * Neil Spring and the University of Washington.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author(s) may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.  
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+void progress(const float progress_fraction);
+void progress_label(const char *label_param);
+void progress_annotate(unsigned int spoo);
+
+void progress_bytes_of_bytes(unsigned long int bytes, 
+                             unsigned long int total );
+void progress_n_of(unsigned int n, 
+                   unsigned int total );
+void progress_disable(void);
+void progress_reset(void);
+
+/* internal, but handy */
+const char * progress_ratestring(float rate, const char *units);
+/*
+vi:ts=2
+*/

data/ext/undns/queue.c

@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) 2002
+ * Neil Spring and the University of Washington.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author(s) may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.  
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#ifdef HAVE_LIBPTHREAD
+#include <pthread.h>
+#else 
+// dealt with using AC_NSPRING_NO_PTHREAD typedef void *pthread_mutex_t;
+#define pthread_mutex_lock(x) (0)
+#define pthread_mutex_unlock(x) (0)
+#define pthread_mutex_init(x,y) (0)
+#define pthread_mutex_destroy(x) (0)
+#endif
+#include "queue.h"
+#ifdef HAVE_DMALLOC_H
+#include <dmalloc.h>
+#endif
+
+struct queue_element_struct {
+  const void *value;
+  struct queue_element_struct *next;
+  struct queue_element_struct *prev;
+}; 
+  
+struct queue_struct {
+  q_element head, tail;
+  int (*compare)(const void *v1, const void *v2);
+  void (*release)(void *v); /* aka free */
+  pthread_mutex_t mutex;
+};
+
+/*
+#define LOCK { printf("^"); fflush(stdout); assert(pthread_mutex_lock(&q->mutex)==0); } 
+#define UNLOCK { assert(pthread_mutex_unlock(&q->mutex)==0); printf("."); fflush(stdout); };
+*/
+#define LOCK assert(pthread_mutex_lock(&q->mutex)==0);
+#define UNLOCK assert(pthread_mutex_unlock(&q->mutex)==0);
+
+#define check_invariants(q) check_invariants_internal(q, __FILE__, __LINE__)
+
+static inline void check_invariants_internal(queue q, const char *str, int line) {
+  if(!(q->head == NULL || q->head->prev == NULL)) {
+    fprintf(stderr, "!(q->head == NULL || q->head->prev == NULL)) at %s:%d\n", str, line);
+    abort();
+  }
+  if(!(q->head == NULL || q->head->next == NULL || q->head->next->prev == q->head)) {
+    fprintf(stderr, "!(q->head == NULL || q->head->next == NULL || q->head->next->prev == q->head)) at %s:%d\n", str, line);
+    abort();
+  }
+  if(!(q->tail == NULL || q->tail->next == NULL)) {
+    fprintf(stderr, "!(q->tail == NULL || q->tail->next == NULL)) at %s:%d\n", str, line);
+    abort();
+  }
+  if(!(q->tail == NULL || q->tail->prev == NULL || q->tail->prev->next == q->tail) ) {
+    fprintf(stderr, "!(q->tail == NULL || q->tail->prev == NULL || q->tail->prev->next == q->tail)) at %s:%d\n", str, line);
+    abort();
+  }
+}
+
+/* compare has strcmp semantics */
+queue q_new(int (*compare)(const void *v1, const void *v2),
+            void (*release)(void *v)) {
+  queue q = (queue)malloc(sizeof(struct queue_struct));
+  assert(q!=NULL);
+  memset(q, 0, sizeof(struct queue_struct));
+  q->compare = compare;
+  q->release = release;
+  (void)pthread_mutex_init(&q->mutex, NULL);
+  return(q);
+}
+
+void q_delete(/*@only@*/ queue q) {
+  void *v;
+  v = (void *)q_pop(q);
+  while(v) {
+    if(q->release) q->release(v); /* aka free */
+    v=(void *)q_pop(q);
+  }
+  (void)pthread_mutex_destroy(&q->mutex);
+  free(q);
+}
+
+q_element q_insert_fromdir(queue q, const void *v, boolean scan_backwards);
+q_element q_insert(queue q, const void *v) {
+  return(q_insert_fromdir(q, v, FALSE));
+}
+q_element q_insert_fromdir(queue q, const void *v, boolean scan_backwards) {
+  q_element newelem;
+  assert(q!=NULL);
+  if(q->compare == NULL) {
+    fprintf(stderr, "you used q_insert instead of q_append on an unsorted queue\n");
+    assert(q->compare!=NULL); /* insert is sorted; needs a comparator */
+  }
+
+  newelem = malloc(sizeof(struct queue_element_struct));
+  assert(newelem!=NULL);
+  newelem->value = v;
+
+  LOCK;
+  if(!q->head) {
+    assert(q->tail == NULL);
+    newelem->prev = newelem->next = NULL;
+    q->head = q->tail = newelem;
+  } else {
+    q_element iter;
+    if(scan_backwards) {
+      if(q->compare(q->tail->value, v) <= 0) {
+        /* append */
+        newelem->prev = q->tail;
+        newelem->next = NULL;
+        if(q->tail) { /* should be trivially true, since q->head was non-null... */
+          q->tail->next = newelem;
+        }
+        q->tail=newelem;
+      } else {
+        for(iter = q->tail; 
+            iter!=NULL && q->compare(iter->value, v) >= 0; 
+            iter = iter->prev);
+        if(iter) { // must insert in middle 
+          newelem->prev = iter;
+          newelem->next = iter->next;
+          iter->next = newelem;
+          if(newelem->next) {
+            newelem->next->prev = newelem;
+          } else {
+            q->tail = newelem;
+          }
+        } else {
+          /* prepend */
+          newelem->next = q->head;
+          newelem->prev = NULL;
+          q->head->prev = newelem;
+          q->head=newelem;
+        }
+      }
+    } else {
+      for(iter = q->head; 
+          iter!=NULL && q->compare(iter->value, v) <= 0; 
+          /* <= there should append equal things.  < should prepend equal things */
+          iter = iter->next);
+      if(iter) { // must insert in middle 
+        newelem = malloc(sizeof(struct queue_element_struct));
+        assert(newelem!=NULL);
+        newelem->value = v;
+        newelem->next = iter;
+        newelem->prev = iter->prev;
+        iter->prev = newelem;
+        if(newelem->prev) {
+          newelem->prev->next = newelem;
+        } else {
+          q->head = newelem;
+        }
+      } else {
+        /* append */
+        newelem->prev = q->tail;
+        newelem->next = NULL;
+        if(q->tail) { /* should be trivially true, since q->head was non-null... */
+          q->tail->next = newelem;
+        }
+        q->tail=newelem;
+      }
+    }
+  }
+  UNLOCK;
+  return newelem;
+}
+void q_append(queue q, const void *v) {
+  q_element newelem = malloc(sizeof(struct queue_element_struct));
+  assert(newelem!=NULL);
+  assert(q!=NULL);
+  newelem->value = v;
+  newelem->next = NULL;
+  LOCK;
+  check_invariants(q);
+  newelem->prev = q->tail;
+  if(q->tail) {
+    q->tail->next = newelem;
+  } else {
+    assert(q->head == NULL);
+    q->head = newelem;
+  }
+  q->tail = newelem;
+  check_invariants(q);
+  UNLOCK;
+}
+
+static /*@null@*/ const void *q_top_gotlock(const queue q) {
+  const void * retval = NULL;
+  if(q->head) {
+    retval = q->head->value;
+  }
+  return retval;
+}
+
+/*@null@*/ const void *q_pop(queue q) {
+  const void *retval;
+  q_element freeme;
+  LOCK;
+  check_invariants(q);
+  freeme = q->head;
+  retval = q_top_gotlock(q);
+  if(freeme!=NULL) {
+    q->head = q->head->next;
+    if(q->head)
+      q->head->prev=NULL;
+    else
+      q->tail=NULL;
+    free(freeme);
+  }
+  check_invariants(q);
+  UNLOCK;
+  return(retval);
+}
+      
+/*@null@*/ const void *q_top(const queue q) {
+  const void * retval;
+  LOCK;
+  retval = q_top_gotlock(q);
+  UNLOCK;
+  return(retval);
+}
+
+/* returns true if not interrupted by a false callback return val */
+boolean q_iterate(queue q, q_iterator iterator, void *user) {
+  q_element i;
+  boolean cont = TRUE;
+  LOCK;
+  check_invariants(q);
+  for( i = q->head; i != NULL && cont; i = i->next ) {
+    cont = iterator(i->value, user);
+  }
+  UNLOCK;
+  return cont;
+}
+
+/* returns true if not interrupted by a false callback return val */
+boolean q_iterate_q(queue q, q_iterator_q iterator, void *user) {
+  q_element i;
+  boolean cont = TRUE;
+  LOCK;
+  check_invariants(q);
+  for( i = q->head; i != NULL && cont; i = i->next ) {
+    cont = iterator(q, i->value, user);
+  }
+  UNLOCK;
+  return cont;
+}
+
+static boolean counter(const void *v __attribute__ ((unused)),
+                       void *count) {
+  (*(unsigned long *)count)++;
+  assert((*(unsigned long *)count) < 200000);
+  return TRUE;
+}
+unsigned long q_length(queue q) {
+  unsigned long count=0;
+  (void)q_iterate(q, counter, &count);
+  return count;
+}
+
+static boolean finder(queue q, const void *v, void *user) {
+  void **found = (void **)user;
+  if(q->compare(v, *found) == 0) {
+    *found = (void *)v;
+    return FALSE;
+  }
+  return TRUE;
+}
+
+void *q_find(queue q, const void *findme) {
+  void *found;
+  found = (void *)findme;
+  if(q_iterate_q(q, finder, &found) == 0)
+    return(found);
+  else
+    return(NULL);
+}
+
+void q_expunge(queue q, /*@owned@*/ q_element p) {
+  
+  q_element prev;
+  assert(p!=NULL);
+  prev = p->prev;
+  if(prev != NULL) {
+    prev->next = p->next;
+  } else {
+    q->head = p->next;
+  }
+  if(p->next == NULL) {
+    q->tail = prev;
+  } else {
+    p->next->prev = prev;
+  }
+  free(p);
+}
+
+/* find the element with the value pointer equal to removeme */
+/* then expunge that record. */
+/* caller frees removeme as desired */
+boolean q_remove(queue q, void *removeme) {
+  // q_element prev = NULL;
+  q_element p;  /* the one to remove */
+  check_invariants(q);
+  /* the following should get fixed. */
+  for(p=q->head; 
+      p != NULL && p->value != removeme;
+      // prev = p, 
+        p=p->next);
+  if(p != NULL) {
+    q_expunge(q, p);
+  }
+  check_invariants(q);
+  return(p!=NULL); /* true if found and removed, false otherwise */
+}