Imported Upstream version 2.1.8.20120216upstream/2.1.8.20120216

10 files changed, 2851 insertions, 0 deletions

diff --git a/utils/cvtutf.c b/utils/cvtutf.c
new file mode 100644
index 0000000..8110c74
--- /dev/null
+++ b/utils/cvtutf.c
@@ -0,0 +1,339 @@
+/* ================================================================ */

+/*

+File:   ConvertUTF.C

+Author: Mark E. Davis

+Copyright (C) 1994 Taligent, Inc. All rights reserved.

+

+This code is copyrighted. Under the copyright laws, this code may not

+be copied, in whole or part, without prior written consent of Taligent. 

+

+Taligent grants the right to use or reprint this code as long as this

+ENTIRE copyright notice is reproduced in the code or reproduction.

+The code is provided AS-IS, AND TALIGENT DISCLAIMS ALL WARRANTIES,

+EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO IMPLIED

+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN

+NO EVENT WILL TALIGENT BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING,

+WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS

+INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY

+LOSS) ARISING OUT OF THE USE OR INABILITY TO USE THIS CODE, EVEN

+IF TALIGENT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

+BECAUSE SOME STATES DO NOT ALLOW THE EXCLUSION OR LIMITATION OF

+LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, THE ABOVE

+LIMITATION MAY NOT APPLY TO YOU.

+

+RESTRICTED RIGHTS LEGEND: Use, duplication, or disclosure by the

+government is subject to restrictions as set forth in subparagraph

+(c)(l)(ii) of the Rights in Technical Data and Computer Software

+clause at DFARS 252.227-7013 and FAR 52.227-19.

+

+This code may be protected by one or more U.S. and International

+Patents.

+

+TRADEMARKS: Taligent and the Taligent Design Mark are registered

+trademarks of Taligent, Inc.

+*/

+/* ================================================================ */

+

+#include "cvtutf.h"

+

+/* ================================================================ */

+

+static const int halfShift             = 10;

+static const UCS4 halfBase             = 0x0010000UL;

+static const UCS4 halfMask             = 0x3FFUL;

+static const UCS4 kSurrogateHighStart  = 0xD800UL;

+static const UCS4 kSurrogateHighEnd    = 0xDBFFUL;

+static const UCS4 kSurrogateLowStart   = 0xDC00UL;

+static const UCS4 kSurrogateLowEnd     = 0xDFFFUL;

+

+/* ================================================================ */

+

+ConversionResult

+ConvertUCS4toUTF16(UCS4** sourceStart, const UCS4* sourceEnd, 

+                   UTF16** targetStart, const UTF16* targetEnd)

+{

+  ConversionResult result = ok;

+  register UCS4* source = *sourceStart;

+  register UTF16* target = *targetStart;

+  while (source < sourceEnd) {

+    register UCS4 ch;

+    if (target >= targetEnd) {

+      result = targetExhausted; break;

+    };

+    ch = *source++;

+    if (ch <= kMaximumUCS2) {

+      *target++ = ch;

+    } else if (ch > kMaximumUTF16) {

+      *target++ = kReplacementCharacter;

+    } else {

+      if (target + 1 >= targetEnd) {

+        result = targetExhausted; break;

+      };

+      ch -= halfBase;

+      *target++ = (ch >> halfShift) + kSurrogateHighStart;

+      *target++ = (ch & halfMask) + kSurrogateLowStart;

+    };

+  };

+  *sourceStart = source;

+  *targetStart = target;

+  return result;

+};

+

+/* ================================================================ */

+

+ConversionResult ConvertUTF16toUCS4(UTF16** sourceStart, UTF16* sourceEnd, 

+                                    UCS4** targetStart, const UCS4* targetEnd)

+{

+  ConversionResult result = ok;

+  register UTF16* source = *sourceStart;

+  register UCS4* target = *targetStart;

+  while (source < sourceEnd) {

+    register UCS4 ch;

+    ch = *source++;

+    if (ch >= kSurrogateHighStart &&

+        ch <= kSurrogateHighEnd &&

+        source < sourceEnd) {

+      register UCS4 ch2 = *source;

+      if (ch2 >= kSurrogateLowStart && ch2 <= kSurrogateLowEnd) {

+        ch = ((ch - kSurrogateHighStart) << halfShift)

+          + (ch2 - kSurrogateLowStart) + halfBase;

+        ++source;

+      };

+    };

+    if (target >= targetEnd) {

+      result = targetExhausted; break;

+    };

+    *target++ = ch;

+  };

+  *sourceStart = source;

+  *targetStart = target;

+  return result;

+};

+

+/* ================================================================ */

+

+static UCS4 offsetsFromUTF8[6] = {

+  0x00000000UL, 0x00003080UL, 0x000E2080UL, 

+  0x03C82080UL, 0xFA082080UL, 0x82082080UL

+};

+static char bytesFromUTF8[256] = {

+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5

+};

+

+static UTF8 firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};

+

+/* ================================================================ */

+/*      This code is similar in effect to making successive calls on the

+mbtowc and wctomb routines in FSS-UTF. However, it is considerably

+different in code:

+* it is adapted to be consistent with UTF16,

+* the interface converts a whole buffer to avoid function-call overhead

+* constants have been gathered.

+* loops & conditionals have been removed as much as possible for

+efficiency, in favor of drop-through switch statements.

+*/

+

+/* ================================================================ */

+int NSConvertUTF16toUTF8(unichar             **sourceStart,

+                         const unichar       *sourceEnd, 

+                         unsigned char       **targetStart,

+                         const unsigned char *targetEnd)

+{

+  ConversionResult result = ok;

+  register UTF16* source = *sourceStart;

+  register UTF8* target = *targetStart;

+  while (source < sourceEnd) {

+    register UCS4 ch;

+    register unsigned short bytesToWrite = 0;

+    register const UCS4 byteMask = 0xBF;

+    register const UCS4 byteMark = 0x80; 

+    ch = *source++;

+    if (ch >= kSurrogateHighStart && ch <= kSurrogateHighEnd

+        && source < sourceEnd) {

+      register UCS4 ch2 = *source;

+      if (ch2 >= kSurrogateLowStart && ch2 <= kSurrogateLowEnd) {

+        ch = ((ch - kSurrogateHighStart) << halfShift)

+          + (ch2 - kSurrogateLowStart) + halfBase;

+        ++source;

+      };

+    };

+    if (ch < 0x80) {                    bytesToWrite = 1;

+    } else if (ch < 0x800) {            bytesToWrite = 2;

+    } else if (ch < 0x10000) {          bytesToWrite = 3;

+    } else if (ch < 0x200000) {         bytesToWrite = 4;

+    } else if (ch < 0x4000000) {        bytesToWrite = 5;

+    } else if (ch <= kMaximumUCS4){     bytesToWrite = 6;

+    } else {                                            bytesToWrite = 2;

+    ch = kReplacementCharacter;

+    }; /* I wish there were a smart way to avoid this conditional */

+                

+    target += bytesToWrite;

+    if (target > targetEnd) {

+      target -= bytesToWrite; result = targetExhausted; break;

+    };

+    switch (bytesToWrite) {     /* note: code falls through cases! */

+      case 6:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 5:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 4:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 3:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 2:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 1:   *--target =  ch | firstByteMark[bytesToWrite];

+    };

+    target += bytesToWrite;

+  };

+  *sourceStart = source;

+  *targetStart = target;

+

+  return result;

+};

+

+/* ================================================================ */

+

+int NSConvertUTF8toUTF16(unsigned char **sourceStart, unsigned char *sourceEnd, 

+                         unichar **targetStart, const unichar *targetEnd)

+{

+  ConversionResult result = ok;

+  register UTF8  *source = *sourceStart;

+  register UTF16 *target = *targetStart;

+  

+  while (source < sourceEnd) {

+    register UCS4 ch = 0;

+    register unsigned short extraBytesToWrite = bytesFromUTF8[*source];

+

+    if (source + extraBytesToWrite > sourceEnd) {

+      result = sourceExhausted; break;

+    };

+    switch(extraBytesToWrite) { /* note: code falls through cases! */

+      case 5:   ch += *source++; ch <<= 6;

+      case 4:   ch += *source++; ch <<= 6;

+      case 3:   ch += *source++; ch <<= 6;

+      case 2:   ch += *source++; ch <<= 6;

+      case 1:   ch += *source++; ch <<= 6;

+      case 0:   ch += *source++;

+    };

+    ch -= offsetsFromUTF8[extraBytesToWrite];

+    

+    if (target >= targetEnd) {

+      result = targetExhausted; break;

+    };

+    if (ch <= kMaximumUCS2) {

+      *target++ = ch;

+    } else if (ch > kMaximumUTF16) {

+      *target++ = kReplacementCharacter;

+    } else {

+      if (target + 1 >= targetEnd) {

+        result = targetExhausted; break;

+      };

+      ch -= halfBase;

+      *target++ = (ch >> halfShift) + kSurrogateHighStart;

+      *target++ = (ch & halfMask) + kSurrogateLowStart;

+    };

+  };

+  *sourceStart = source;

+  *targetStart = target;

+  

+  return result;

+};

+

+/* ================================================================ */

+ConversionResult ConvertUCS4toUTF8 ( UCS4** sourceStart, const UCS4* sourceEnd, 

+                                     UTF8** targetStart, const UTF8* targetEnd)

+{

+  ConversionResult result = ok;

+  register UCS4* source = *sourceStart;

+  register UTF8* target = *targetStart;

+  while (source < sourceEnd) {

+    register UCS4 ch;

+    register unsigned short bytesToWrite = 0;

+    register const UCS4 byteMask = 0xBF;

+    register const UCS4 byteMark = 0x80; 

+    ch = *source++;

+    if (ch >= kSurrogateHighStart && ch <= kSurrogateHighEnd

+        && source < sourceEnd) {

+      register UCS4 ch2 = *source;

+      if (ch2 >= kSurrogateLowStart && ch2 <= kSurrogateLowEnd) {

+        ch = ((ch - kSurrogateHighStart) << halfShift)

+          + (ch2 - kSurrogateLowStart) + halfBase;

+        ++source;

+      };

+    };

+    if (ch < 0x80) {                            bytesToWrite = 1;

+    } else if (ch < 0x800) {            bytesToWrite = 2;

+    } else if (ch < 0x10000) {          bytesToWrite = 3;

+    } else if (ch < 0x200000) {         bytesToWrite = 4;

+    } else if (ch < 0x4000000) {        bytesToWrite = 5;

+    } else if (ch <= kMaximumUCS4){     bytesToWrite = 6;

+    } else {                                            bytesToWrite = 2;

+    ch = kReplacementCharacter;

+    }; /* I wish there were a smart way to avoid this conditional */

+                

+    target += bytesToWrite;

+    if (target > targetEnd) {

+      target -= bytesToWrite; result = targetExhausted; break;

+    };

+    switch (bytesToWrite) {     /* note: code falls through cases! */

+      case 6:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 5:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 4:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 3:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 2:   *--target = (ch | byteMark) & byteMask; ch >>= 6;

+      case 1:   *--target =  ch | firstByteMark[bytesToWrite];

+    };

+    target += bytesToWrite;

+  };

+  *sourceStart = source;

+  *targetStart = target;

+  return result;

+};

+

+/* ================================================================ */

+

+ConversionResult ConvertUTF8toUCS4 (UTF8** sourceStart, UTF8* sourceEnd, 

+                                    UCS4** targetStart, const UCS4* targetEnd)

+{

+  ConversionResult result = ok;

+  register UTF8* source = *sourceStart;

+  register UCS4* target = *targetStart;

+  while (source < sourceEnd) {

+    register UCS4 ch = 0;

+    register unsigned short extraBytesToWrite = bytesFromUTF8[*source];

+    if (source + extraBytesToWrite > sourceEnd) {

+      result = sourceExhausted; break;

+    };

+    switch(extraBytesToWrite) { /* note: code falls through cases! */

+      case 5:   ch += *source++; ch <<= 6;

+      case 4:   ch += *source++; ch <<= 6;

+      case 3:   ch += *source++; ch <<= 6;

+      case 2:   ch += *source++; ch <<= 6;

+      case 1:   ch += *source++; ch <<= 6;

+      case 0:   ch += *source++;

+    };

+    ch -= offsetsFromUTF8[extraBytesToWrite];

+

+    if (target >= targetEnd) {

+      result = targetExhausted; break;

+    };

+    if (ch <= kMaximumUCS2) {

+      *target++ = ch;

+    } else if (ch > kMaximumUCS4) {

+      *target++ = kReplacementCharacter;

+    } else {

+      if (target + 1 >= targetEnd) {

+        result = targetExhausted; break;

+      };

+      ch -= halfBase;

+      *target++ = (ch >> halfShift) + kSurrogateHighStart;

+      *target++ = (ch & halfMask) + kSurrogateLowStart;

+    };

+  };

+  *sourceStart = source;

+  *targetStart = target;

+  return result;

+};

diff --git a/utils/cvtutf.h b/utils/cvtutf.h
new file mode 100644
index 0000000..1d9f8ec
--- /dev/null
+++ b/utils/cvtutf.h
@@ -0,0 +1,110 @@
+/* ================================================================ */

+/*

+File:	ConvertUTF.h

+Author: Mark E. Davis

+Copyright (C) 1994 Taligent, Inc. All rights reserved.

+

+This code is copyrighted. Under the copyright laws, this code may not

+be copied, in whole or part, without prior written consent of Taligent. 

+

+Taligent grants the right to use or reprint this code as long as this

+ENTIRE copyright notice is reproduced in the code or reproduction.

+The code is provided AS-IS, AND TALIGENT DISCLAIMS ALL WARRANTIES,

+EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO IMPLIED

+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN

+NO EVENT WILL TALIGENT BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING,

+WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS

+INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY

+LOSS) ARISING OUT OF THE USE OR INABILITY TO USE THIS CODE, EVEN

+IF TALIGENT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

+BECAUSE SOME STATES DO NOT ALLOW THE EXCLUSION OR LIMITATION OF

+LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, THE ABOVE

+LIMITATION MAY NOT APPLY TO YOU.

+

+RESTRICTED RIGHTS LEGEND: Use, duplication, or disclosure by the

+government is subject to restrictions as set forth in subparagraph

+(c)(l)(ii) of the Rights in Technical Data and Computer Software

+clause at DFARS 252.227-7013 and FAR 52.227-19.

+

+This code may be protected by one or more U.S. and International

+Patents.

+

+TRADEMARKS: Taligent and the Taligent Design Mark are registered

+trademarks of Taligent, Inc.

+*/

+/* ================================================================ */

+

+#ifndef __cvtutf_H__

+#define __cvtutf_H__

+

+#include <stdio.h>

+#include <stdlib.h>

+// #include <types.h>

+#include <string.h>

+

+/* ================================================================ */

+/*	The following 4 definitions are compiler-specific.

+	I would use wchar_t for UCS2/UTF16, except that the C standard

+	does not guarantee that it has at least 16 bits, so wchar_t is

+	no less portable than unsigned short!

+*/

+

+typedef unsigned long	UCS4;

+typedef unsigned short	UCS2;

+typedef unsigned short	UTF16;

+typedef unsigned char	UTF8;

+#define unichar UTF16

+

+//typedef enum {false, true} Boolean;

+

+static const UCS4 kReplacementCharacter = 0x0000FFFDUL;

+static const UCS4 kMaximumUCS2          = 0x0000FFFFUL;

+static const UCS4 kMaximumUTF16         = 0x0010FFFFUL;

+static const UCS4 kMaximumUCS4          = 0x7FFFFFFFUL;

+

+/* ================================================================ */

+/*	Each of these routines converts the text between *sourceStart and 

+sourceEnd, putting the result into the buffer between *targetStart and

+targetEnd. Note: the end pointers are *after* the last item: e.g. 

+*(sourceEnd - 1) is the last item.

+

+	The return result indicates whether the conversion was successful,

+and if not, whether the problem was in the source or target buffers.

+

+	After the conversion, *sourceStart and *targetStart are both

+updated to point to the end of last text successfully converted in

+the respective buffers.

+*/

+

+typedef enum {

+	ok, 				/* conversion successful */

+	sourceExhausted,	/* partial character in source, but hit end */

+	targetExhausted		/* insuff. room in target for conversion */

+} ConversionResult;

+

+ConversionResult ConvertUCS4toUTF16 (

+		UCS4** sourceStart, const UCS4* sourceEnd, 

+		UTF16** targetStart, const UTF16* targetEnd);

+

+ConversionResult ConvertUTF16toUCS4 (

+		UTF16** sourceStart, UTF16* sourceEnd, 

+		UCS4** targetStart, const UCS4* targetEnd);

+

+int NSConvertUTF16toUTF8(unichar             **sourceStart,

+                         const unichar       *sourceEnd, 

+                         unsigned char       **targetStart,

+                         const unsigned char *targetEnd);

+int NSConvertUTF8toUTF16(unsigned char **sourceStart, unsigned char *sourceEnd, 

+                         unichar **targetStart, const unichar *targetEnd);

+

+ConversionResult ConvertUCS4toUTF8 (

+		UCS4** sourceStart, const UCS4* sourceEnd, 

+		UTF8** targetStart, const UTF8* targetEnd);

+		

+ConversionResult ConvertUTF8toUCS4 (

+		UTF8** sourceStart, UTF8* sourceEnd, 

+		UCS4** targetStart, const UCS4* targetEnd);

+

+/* ================================================================ */

+

+#endif /* __cvtutf_H__ */

diff --git a/utils/md5.c b/utils/md5.c
new file mode 100644
index 0000000..b0f715e
--- /dev/null
+++ b/utils/md5.c
@@ -0,0 +1,382 @@
+/*
+  Copyright (C) 1999, 2000, 2002 Aladdin Enterprises.  All rights reserved.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  L. Peter Deutsch
+  ghost@aladdin.com
+
+ */
+/* $Id: md5.c 15582 2010-06-15 17:50:08Z patrick $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321, whose
+  text is available at
+	http://www.ietf.org/rfc/rfc1321.txt
+  The code is derived from the text of the RFC, including the test suite
+  (section A.5) but excluding the rest of Appendix A.  It does not include
+  any code or documentation that is identified in the RFC as being
+  copyrighted.
+
+  The original and principal author of md5.c is L. Peter Deutsch
+  <ghost@aladdin.com>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
+	either statically or dynamically; added missing #include <string.h>
+	in library.
+  2002-03-11 lpd Corrected argument list for main(), and added int return
+	type, in test program and T value program.
+  2002-02-21 lpd Added missing #include <stdio.h> in test program.
+  2000-07-03 lpd Patched to eliminate warnings about "constant is
+	unsigned in ANSI C, signed in traditional"; made test program
+	self-checking.
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
+  1999-05-03 lpd Original version.
+ */
+
+#include "../stdafx.h"
+#include "md5.h"
+#include <string.h>
+
+#undef BYTE_ORDER	/* 1 = big-endian, -1 = little-endian, 0 = unknown */
+#ifdef ARCH_IS_BIG_ENDIAN
+#  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#else
+#  define BYTE_ORDER 0
+#endif
+
+#define T_MASK ((md5_word_t)~0)
+#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
+#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
+#define T3    0x242070db
+#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
+#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
+#define T6    0x4787c62a
+#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
+#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
+#define T9    0x698098d8
+#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
+#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
+#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
+#define T13    0x6b901122
+#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
+#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
+#define T16    0x49b40821
+#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
+#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
+#define T19    0x265e5a51
+#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
+#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
+#define T22    0x02441453
+#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
+#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
+#define T25    0x21e1cde6
+#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
+#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
+#define T28    0x455a14ed
+#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
+#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
+#define T31    0x676f02d9
+#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
+#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
+#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
+#define T35    0x6d9d6122
+#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
+#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
+#define T38    0x4bdecfa9
+#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
+#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
+#define T41    0x289b7ec6
+#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
+#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
+#define T44    0x04881d05
+#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
+#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
+#define T47    0x1fa27cf8
+#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
+#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
+#define T50    0x432aff97
+#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
+#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
+#define T53    0x655b59c3
+#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
+#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
+#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
+#define T57    0x6fa87e4f
+#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
+#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
+#define T60    0x4e0811a1
+#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
+#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
+#define T63    0x2ad7d2bb
+#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
+
+
+static void
+md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
+{
+    md5_word_t
+	a = pms->abcd[0], b = pms->abcd[1],
+	c = pms->abcd[2], d = pms->abcd[3];
+    md5_word_t t;
+#if BYTE_ORDER > 0
+    /* Define storage only for big-endian CPUs. */
+    md5_word_t X[16];
+#else
+    /* Define storage for little-endian or both types of CPUs. */
+    md5_word_t xbuf[16];
+    const md5_word_t *X;
+#endif
+
+    {
+#if BYTE_ORDER == 0
+	/*
+	 * Determine dynamically whether this is a big-endian or
+	 * little-endian machine, since we can use a more efficient
+	 * algorithm on the latter.
+	 */
+	static const int w = 1;
+
+	if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
+#endif
+#if BYTE_ORDER <= 0		/* little-endian */
+	{
+	    /*
+	     * On little-endian machines, we can process properly aligned
+	     * data without copying it.
+	     */
+	    if (!((data - (const md5_byte_t *)0) & 3)) {
+		/* data are properly aligned */
+		X = (const md5_word_t *)data;
+	    } else {
+		/* not aligned */
+		memcpy(xbuf, data, 64);
+		X = xbuf;
+	    }
+	}
+#endif
+#if BYTE_ORDER == 0
+	else			/* dynamic big-endian */
+#endif
+#if BYTE_ORDER >= 0		/* big-endian */
+	{
+	    /*
+	     * On big-endian machines, we must arrange the bytes in the
+	     * right order.
+	     */
+	    const md5_byte_t *xp = data;
+	    int i;
+
+#  if BYTE_ORDER == 0
+	    X = xbuf;		/* (dynamic only) */
+#  else
+#    define xbuf X		/* (static only) */
+#  endif
+	    for (i = 0; i < 16; ++i, xp += 4)
+		xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+	}
+#endif
+    }
+
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+    /* Round 1. */
+    /* Let [abcd k s i] denote the operation
+       a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + F(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+    /* Do the following 16 operations. */
+    SET(a, b, c, d,  0,  7,  T1);
+    SET(d, a, b, c,  1, 12,  T2);
+    SET(c, d, a, b,  2, 17,  T3);
+    SET(b, c, d, a,  3, 22,  T4);
+    SET(a, b, c, d,  4,  7,  T5);
+    SET(d, a, b, c,  5, 12,  T6);
+    SET(c, d, a, b,  6, 17,  T7);
+    SET(b, c, d, a,  7, 22,  T8);
+    SET(a, b, c, d,  8,  7,  T9);
+    SET(d, a, b, c,  9, 12, T10);
+    SET(c, d, a, b, 10, 17, T11);
+    SET(b, c, d, a, 11, 22, T12);
+    SET(a, b, c, d, 12,  7, T13);
+    SET(d, a, b, c, 13, 12, T14);
+    SET(c, d, a, b, 14, 17, T15);
+    SET(b, c, d, a, 15, 22, T16);
+#undef SET
+
+     /* Round 2. */
+     /* Let [abcd k s i] denote the operation
+          a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + G(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  1,  5, T17);
+    SET(d, a, b, c,  6,  9, T18);
+    SET(c, d, a, b, 11, 14, T19);
+    SET(b, c, d, a,  0, 20, T20);
+    SET(a, b, c, d,  5,  5, T21);
+    SET(d, a, b, c, 10,  9, T22);
+    SET(c, d, a, b, 15, 14, T23);
+    SET(b, c, d, a,  4, 20, T24);
+    SET(a, b, c, d,  9,  5, T25);
+    SET(d, a, b, c, 14,  9, T26);
+    SET(c, d, a, b,  3, 14, T27);
+    SET(b, c, d, a,  8, 20, T28);
+    SET(a, b, c, d, 13,  5, T29);
+    SET(d, a, b, c,  2,  9, T30);
+    SET(c, d, a, b,  7, 14, T31);
+    SET(b, c, d, a, 12, 20, T32);
+#undef SET
+
+     /* Round 3. */
+     /* Let [abcd k s t] denote the operation
+          a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + H(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  5,  4, T33);
+    SET(d, a, b, c,  8, 11, T34);
+    SET(c, d, a, b, 11, 16, T35);
+    SET(b, c, d, a, 14, 23, T36);
+    SET(a, b, c, d,  1,  4, T37);
+    SET(d, a, b, c,  4, 11, T38);
+    SET(c, d, a, b,  7, 16, T39);
+    SET(b, c, d, a, 10, 23, T40);
+    SET(a, b, c, d, 13,  4, T41);
+    SET(d, a, b, c,  0, 11, T42);
+    SET(c, d, a, b,  3, 16, T43);
+    SET(b, c, d, a,  6, 23, T44);
+    SET(a, b, c, d,  9,  4, T45);
+    SET(d, a, b, c, 12, 11, T46);
+    SET(c, d, a, b, 15, 16, T47);
+    SET(b, c, d, a,  2, 23, T48);
+#undef SET
+
+     /* Round 4. */
+     /* Let [abcd k s t] denote the operation
+          a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + I(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  0,  6, T49);
+    SET(d, a, b, c,  7, 10, T50);
+    SET(c, d, a, b, 14, 15, T51);
+    SET(b, c, d, a,  5, 21, T52);
+    SET(a, b, c, d, 12,  6, T53);
+    SET(d, a, b, c,  3, 10, T54);
+    SET(c, d, a, b, 10, 15, T55);
+    SET(b, c, d, a,  1, 21, T56);
+    SET(a, b, c, d,  8,  6, T57);
+    SET(d, a, b, c, 15, 10, T58);
+    SET(c, d, a, b,  6, 15, T59);
+    SET(b, c, d, a, 13, 21, T60);
+    SET(a, b, c, d,  4,  6, T61);
+    SET(d, a, b, c, 11, 10, T62);
+    SET(c, d, a, b,  2, 15, T63);
+    SET(b, c, d, a,  9, 21, T64);
+#undef SET
+
+     /* Then perform the following additions. (That is increment each
+        of the four registers by the value it had before this block
+        was started.) */
+    pms->abcd[0] += a;
+    pms->abcd[1] += b;
+    pms->abcd[2] += c;
+    pms->abcd[3] += d;
+}
+
+void
+md5_init(md5_state_t *pms)
+{
+    pms->count[0] = pms->count[1] = 0;
+    pms->abcd[0] = 0x67452301;
+    pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
+    pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
+    pms->abcd[3] = 0x10325476;
+}
+
+void
+md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
+{
+    const md5_byte_t *p = data;
+    int left = nbytes;
+    int offset = (pms->count[0] >> 3) & 63;
+    md5_word_t nbits = (md5_word_t)(nbytes << 3);
+
+    if (nbytes <= 0)
+	return;
+
+    /* Update the message length. */
+    pms->count[1] += nbytes >> 29;
+    pms->count[0] += nbits;
+    if (pms->count[0] < nbits)
+	pms->count[1]++;
+
+    /* Process an initial partial block. */
+    if (offset) {
+	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+	memcpy(pms->buf + offset, p, copy);
+	if (offset + copy < 64)
+	    return;
+	p += copy;
+	left -= copy;
+	md5_process(pms, pms->buf);
+    }
+
+    /* Process full blocks. */
+    for (; left >= 64; p += 64, left -= 64)
+	md5_process(pms, p);
+
+    /* Process a final partial block. */
+    if (left)
+	memcpy(pms->buf, p, left);
+}
+
+void
+md5_finish(md5_state_t *pms, md5_byte_t digest[16])
+{
+    static const md5_byte_t pad[64] = {
+	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    md5_byte_t data[8];
+    int i;
+
+    /* Save the length before padding. */
+    for (i = 0; i < 8; ++i)
+	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+    /* Pad to 56 bytes mod 64. */
+    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+    /* Append the length. */
+    md5_append(pms, data, 8);
+    for (i = 0; i < 16; ++i)
+	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}
diff --git a/utils/md5.h b/utils/md5.h
new file mode 100644
index 0000000..f944245
--- /dev/null
+++ b/utils/md5.h
@@ -0,0 +1,91 @@
+/*
+  Copyright (C) 1999, 2002 Aladdin Enterprises.  All rights reserved.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  L. Peter Deutsch
+  ghost@aladdin.com
+
+ */
+/* $Id: md5.h 15572 2010-06-15 17:23:44Z patrick $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321, whose
+  text is available at
+	http://www.ietf.org/rfc/rfc1321.txt
+  The code is derived from the text of the RFC, including the test suite
+  (section A.5) but excluding the rest of Appendix A.  It does not include
+  any code or documentation that is identified in the RFC as being
+  copyrighted.
+
+  The original and principal author of md5.h is L. Peter Deutsch
+  <ghost@aladdin.com>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  2002-04-13 lpd Removed support for non-ANSI compilers; removed
+	references to Ghostscript; clarified derivation from RFC 1321;
+	now handles byte order either statically or dynamically.
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
+	added conditionalization for C++ compilation from Martin
+	Purschke <purschke@bnl.gov>.
+  1999-05-03 lpd Original version.
+ */
+
+#ifndef md5_INCLUDED
+#  define md5_INCLUDED
+
+/*
+ * This package supports both compile-time and run-time determination of CPU
+ * byte order.  If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
+ * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
+ * defined as non-zero, the code will be compiled to run only on big-endian
+ * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
+ * run on either big- or little-endian CPUs, but will run slightly less
+ * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
+ */
+
+typedef unsigned char md5_byte_t; /* 8-bit byte */
+typedef unsigned int md5_word_t; /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+    md5_word_t count[2];	/* message length in bits, lsw first */
+    md5_word_t abcd[4];		/* digest buffer */
+    md5_byte_t buf[64];		/* accumulate block */
+} md5_state_t;
+
+//#ifdef __cplusplus
+//extern "C" 
+//{
+//#endif
+
+/* Initialize the algorithm. */
+void md5_init(md5_state_t *pms);
+
+/* Append a string to the message. */
+void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
+
+/* Finish the message and return the digest. */
+void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+
+//#ifdef __cplusplus
+//}  /* end extern "C" */
+//#endif
+
+#endif /* md5_INCLUDED */
diff --git a/utils/plist.c b/utils/plist.c
new file mode 100644
index 0000000..daca93c
--- /dev/null
+++ b/utils/plist.c
@@ -0,0 +1,151 @@
+#include "../stdafx.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "plist.h"
+
+/*
+ * A plist is a double-linked list of key-value pairs
+ * It can be circular or not.
+ */
+
+/*
+ * This is a node in a plist
+ */
+struct plist_node {
+	void *pn_key;
+	void *pn_value;
+	struct plist_node *pn_next;
+	struct plist_node *pn_prev;
+};
+
+/*
+ * Adds a new entry into a plist.
+ * if !*root it creates a node where prev and next point to itself
+ * else, inserts itself in the list before *root
+ * returns 1 on success, 0 on NOMEM failure.
+ */
+int
+plist_add(void *k, void *v, plist_node_t **root)
+{
+	plist_node_t *n;
+
+	if (!(n = malloc(sizeof (*n))))
+		return 0;
+	n->pn_key = k;
+	n->pn_value = v;
+	if (!*root) {
+		n->pn_next = n;
+		n->pn_prev = n;
+		*root = n;
+	} else {
+		n->pn_prev = (*root)->pn_prev;
+		n->pn_next = (*root);
+		(*root)->pn_prev->pn_next = n;
+		(*root)->pn_prev = n;
+	}
+	return 1;
+}
+
+/*
+ * traverse list until cur == *root or cur == 0, freeing each node
+ * (list could be either circular or not)
+ * note that the key and value pointers are still valid.
+ */
+void
+plist_clear(plist_node_t **root)
+{
+	plist_node_t *cur;
+	plist_node_t *fr;
+
+	cur = *root;
+	while (cur) {
+		fr = cur;
+		cur = cur->pn_next;
+		free(fr); fr = NULL;
+		if (cur == *root) {
+			*root = NULL;
+			return;
+		}
+	}
+}
+
+/*
+ * removes a node from a plist where the key pointer == k
+ * if ov is not null, it will point to the old value from the removed node
+ * This only removes the 1st occurance of k.
+ * returns 1 on success, 0 if k was not in the list
+ */
+int
+plist_remove(void *k, plist_node_t **rootp, void **ov)
+{
+	plist_node_t *cur;
+
+	cur = *rootp;
+	while (cur) {
+		if (cur->pn_key == k) {
+			if (ov)
+				*ov = cur->pn_value;
+			cur->pn_prev->pn_next = cur->pn_next;
+			cur->pn_next->pn_prev = cur->pn_prev;
+			if (cur->pn_next == cur)
+				*rootp = NULL;
+			else if (*rootp == cur)
+				*rootp = cur->pn_next;
+			free(cur); cur = NULL;
+			return 1;
+		}
+		cur = cur->pn_next;
+		if (cur == *rootp)
+			return 0;
+	}
+	return 0;
+}
+
+/*
+ * finds k in plist.
+ * if ov != 0, it will be set to the value pointer
+ * returns 1 when the key is found, 0 if not found.
+ */
+int
+plist_contains(void *k, plist_node_t *root, void **ov)
+{
+	plist_node_t *cur;
+
+	cur = root;
+	while (cur) {
+		if (cur->pn_key == k) {
+			if (ov)
+				*ov = cur->pn_value;
+			return 1;
+		}
+		cur = cur->pn_next;
+		if (cur == root)
+			return 0;
+	}
+	return 0;
+}
+
+/*
+ * traverses the plist from start, until we get back to start or next==0
+ * runs func with key, val, arg.
+ * if func returns 0, stops traversing and returns 0
+ * else returns 1 for success
+ */
+int
+plist_walk(plist_node_t *start, int (*func)(const void *k, const void *v,
+    void *arg), void *arg)
+{
+	plist_node_t *cur;
+	int res;
+
+	cur = start;
+	while (cur) {
+		if (!(res = func(cur->pn_key, cur->pn_value, arg)))
+			return res;
+		cur = cur->pn_next;
+		if (cur == start)
+			return 1;
+	}
+	return 1;
+}
diff --git a/utils/plist.h b/utils/plist.h
new file mode 100644
index 0000000..52207a7
--- /dev/null
+++ b/utils/plist.h
@@ -0,0 +1,13 @@
+#ifndef _PLIST_H_
+#define _PLIST_H_
+
+typedef struct plist_node plist_node_t;
+
+int plist_contains(void *k, plist_node_t *root, void **nodeval);
+int plist_remove(void *k, plist_node_t **root, void **ov);
+int plist_add(void *k, void *v, plist_node_t **root);
+void plist_clear(plist_node_t **root);
+int plist_walk(plist_node_t *start, int(*func)(const void *k, const void *v,
+    void *arg), void *arg);
+
+#endif
diff --git a/utils/ptree.c b/utils/ptree.c
new file mode 100644
index 0000000..f632e78
--- /dev/null
+++ b/utils/ptree.c
@@ -0,0 +1,460 @@
+#include "../stdafx.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "ptree.h"
+
+//#define VERIFY_TREE
+
+struct ptree_node {
+	void *pn_value;
+	struct ptree_node *pn_parent;
+	struct ptree_node *pn_left;
+	struct ptree_node *pn_right;
+};
+
+static int
+_walk_to(void *v, 
+		 struct ptree_node **startp, 
+		 struct ptree_node ***pp,
+		 int (*cmp)(const void *v1, const void *v2))
+{
+	struct ptree_node **nextp;
+	int c = -1;
+
+	nextp = startp;
+	while (*nextp)
+	{
+		c = cmp(v, (*nextp)->pn_value);
+		*startp = *nextp;
+		if (c == 0)
+			break;
+		if (c < 0)
+			nextp = &(*nextp)->pn_left;
+		else
+			nextp = &(*nextp)->pn_right;
+		if (pp)
+			*pp = nextp;
+	}
+
+	return c;
+}
+
+
+static ptree_walk_res_t
+_visit(struct ptree_node *pn, 
+	   int level, 
+	   void *arg1, 
+	   void *arg2)
+{
+	ptree_walk_res_t (*func)(const void *, int, void *, void *) = arg1;
+	
+	return func(pn->pn_value, level, arg2, pn);
+}
+
+static ptree_node_t *
+_find_min(ptree_node_t *pn, 
+		  int *levelp)
+{
+	while (pn->pn_left)
+	{
+		pn = pn->pn_left;
+		if (levelp)
+			(*levelp)++;
+	}
+	return pn;
+}
+
+static ptree_node_t *
+_find_succ(ptree_node_t *pn, 
+		   int *levelp)
+{
+	if (pn->pn_right)
+	{
+		pn = pn->pn_right;
+		if (levelp)
+			(*levelp)++;
+		while (pn->pn_left)
+		{
+			pn = pn->pn_left;
+			if (levelp)
+				(*levelp)++;
+		}
+	}
+	else
+	{
+		while (pn->pn_parent && pn->pn_parent->pn_right == pn)
+		{
+			pn = pn->pn_parent;
+			if (levelp)
+				(*levelp)--;
+		}
+		pn = pn->pn_parent;
+		if (levelp)
+			(*levelp)--;
+	}
+		
+	return pn;
+}
+
+static int
+_walk_int(struct ptree_node *pn, 
+		  ptree_order_t order, 
+		  int level,
+		  ptree_walk_res_t (*func)(struct ptree_node *, int level, void *, void *),
+		  void *arg1, 
+		  void *arg2)
+{
+	ptree_walk_res_t res;
+	ptree_node_t *next;
+
+	if (!pn)
+		return PTREE_WALK_CONTINUE;
+
+	if (order == PTREE_INORDER)
+	{
+		int nlevel;
+
+		pn = _find_min(pn, &level);
+		while (pn) 
+		{
+			nlevel = level;
+			next = _find_succ(pn, &nlevel);
+			if ((res = func(pn, level, arg1, arg2)) != PTREE_WALK_CONTINUE)
+				return res;
+			level = nlevel;
+			if (level < 0)
+				level = 0;
+			pn = next;
+		}
+		return PTREE_WALK_CONTINUE;
+	}
+	if (order == PTREE_PREORDER && (res = func(pn, level, arg1, arg2)) != PTREE_WALK_CONTINUE)
+		return res;
+	if ((res = _walk_int(pn->pn_left, order, level + 1, func, arg1, arg2)) != PTREE_WALK_CONTINUE)
+		return res;
+	if ((res = _walk_int(pn->pn_right, order, level + 1, func, arg1, arg2)) != PTREE_WALK_CONTINUE)
+		return res;
+	if (order == PTREE_POSTORDER && (res = func(pn, level, arg1, arg2)) != PTREE_WALK_CONTINUE)
+		return res;
+	return PTREE_WALK_CONTINUE;
+}
+
+#ifdef VERIFY_TREE
+static ptree_walk_res_t
+_count(struct ptree_node *pn, 
+	   int level, 
+	   void *arg1, 
+	   void *arg2)
+{
+	int *counter = arg1;
+	(*counter)++;
+	return PTREE_WALK_CONTINUE;
+}
+
+//counts the number of nodes
+static int
+_count_nodes(ptree_node_t **rootp)
+{
+	int counter = 0;
+	_walk_int(*rootp, PTREE_INORDER, 0, _count, &counter, 0);
+	return counter;	
+}
+
+static ptree_walk_res_t
+_verify_node(struct ptree_node *pn, 
+	   int level, 
+	   void *arg1, 
+	   void *arg2)
+{
+	int (*cmp)(const void *v1, const void *v2) = arg1;
+	struct ptree_node **prev_pn_p = (struct ptree_node **)arg2;
+	struct ptree_node *prev_pn = *prev_pn_p;
+	
+	if(pn->pn_left != NULL && pn->pn_left->pn_parent != pn)
+   		return PTREE_WALK_STOP;
+	if(pn->pn_right != NULL && pn->pn_right->pn_parent != pn)
+   		return PTREE_WALK_STOP;
+
+	if(prev_pn != NULL)
+	{
+		//this value should always be greater then the last value
+		if(cmp(pn->pn_value, prev_pn->pn_value) <= 0)
+   			return PTREE_WALK_STOP;
+	}
+	*prev_pn_p = pn;
+		   
+   return PTREE_WALK_CONTINUE;
+}
+
+//static int
+//pdecmp(const void *sv, const void *dv)
+//{
+//	int res;
+//	
+//	char *str1 = *(char **)sv;
+//	char *str2 = *(char **)dv;
+//	
+//	res = strcmp(str1, str2);
+//	
+//	if(res <= 0)
+//		return res;
+//	
+//	return res;
+//}
+
+//Verifies that the tree is a valid Binary search tree
+static int
+_verify_tree(ptree_node_t **rootp, int (*cmp)(const void *v1, const void *v2))
+{
+	struct ptree_node *prev_pn = NULL;
+	if(_walk_int(*rootp, PTREE_INORDER, 0, _verify_node, cmp, &prev_pn) == PTREE_WALK_STOP)
+		return 0;
+	return 1;
+}
+#endif
+
+static void
+_remove_node(ptree_node_t **rootp, 
+			 ptree_node_t *pn, 
+			 void **oldval)
+{
+	ptree_node_t **pp;
+	ptree_node_t **predp;
+	ptree_node_t *pred;
+	
+#ifdef VERIFY_TREE
+	int countStart = _count_nodes(rootp), countEnd=0;
+#endif
+
+	//Find pn in the tree
+	if (!pn->pn_parent)
+	{
+		assert(rootp && pn == *rootp);
+		pp = rootp;
+	}
+	else
+	{
+		if (pn->pn_parent->pn_left == pn)
+			pp = &pn->pn_parent->pn_left;
+		else
+			pp = &pn->pn_parent->pn_right;
+	}
+	
+	//pp should now point at the location where pn is stored in the tree
+	assert(pp);
+	
+	//Best case - only one child, on no children, just remove as in a list
+	if (!pn->pn_left)
+	{
+		*pp = pn->pn_right;
+		if (pn->pn_right)
+			pn->pn_right->pn_parent = pn->pn_parent;
+	}
+	else if (!pn->pn_right)
+	{
+		*pp = pn->pn_left;
+		if (pn->pn_left)
+			pn->pn_left->pn_parent = pn->pn_parent;
+	}
+
+	//Worst case: pn contains both left and right children
+	else 
+	{
+		for (predp = &pn->pn_left; (*predp)->pn_right; )
+			predp = &(*predp)->pn_right;
+		pred = *predp;
+
+		//pred either has a left child or no child
+		if (pred->pn_parent->pn_left == pred)
+			pred->pn_parent->pn_left = pred->pn_left;
+		else
+			pred->pn_parent->pn_right = pred->pn_left;
+		if(pred->pn_left)
+			pred->pn_left->pn_parent = pred->pn_parent;
+
+		*pp = pred;
+
+		pred->pn_parent = pn->pn_parent;
+		pred->pn_left = pn->pn_left;
+		pred->pn_right = pn->pn_right;
+
+		if (pn->pn_left)
+			pn->pn_left->pn_parent = pred;
+		pn->pn_right->pn_parent = pred;
+	}
+
+	//Return the value of the removed node
+	if (oldval)
+		*oldval = pn->pn_value;
+
+	free(pn);
+	
+#ifdef VERIFY_TREE
+	countEnd = _count_nodes(rootp);
+	countStart--;
+	assert(countEnd == countStart);
+#endif
+}
+
+int
+ptree_inorder_walk_remove(ptree_node_t **rootp, 
+						  void **oldval, 
+						  void *pn,
+						  int (*cmp)(const void *v1, const void *v2))
+{
+	assert(pn);
+	if (!pn)
+		return 0;
+#ifdef VERIFY_TREE
+	assert(_verify_tree(rootp, cmp));
+#endif
+	_remove_node(rootp, pn, oldval);
+#ifdef VERIFY_TREE
+	assert(_verify_tree(rootp, cmp));
+#endif
+	return 1;
+}
+
+ptree_walk_res_t
+ptree_walk(ptree_node_t *start, 
+		   ptree_order_t order,
+		   ptree_walk_res_t (*func)(const void *v1, int level, void *arg, void *ptree_inorder_walking_remove_arg), 
+		   int (*cmp)(const void *v1, const void *v2),
+		   void *arg)
+{
+#ifdef VERIFY_TREE
+	ptree_node_t *start_p = start;
+	if(cmp != NULL)
+		assert(_verify_tree(&start_p, cmp));
+#endif
+
+	return _walk_int((struct ptree_node *)start, order, 0, _visit, (void *)func, arg);
+}
+
+ptree_walk_res_t
+ptree_clear_func(struct ptree_node *pn, 
+				 int level, 
+				 void *arg1, 
+				 void *arg2)
+{
+	free(pn); pn = NULL;
+
+	return PTREE_WALK_CONTINUE;
+}
+
+void
+ptree_clear(ptree_node_t **rootp)
+{
+	_walk_int(*rootp, PTREE_POSTORDER, 0, ptree_clear_func, 0, 0);
+	*rootp = 0;
+}
+
+int
+ptree_remove(void *v, 
+			 ptree_node_t **rootp, 
+			 int (*cmp)(const void *v1, const void *v2), 
+			 void **oldval)
+{
+	struct ptree_node *cur;
+	
+#ifdef VERIFY_TREE
+	assert(_verify_tree(rootp, cmp));
+#endif
+
+	cur = *rootp;
+	if (_walk_to(v, &cur, NULL, cmp) != 0)
+		return 0;
+	_remove_node(rootp, cur, oldval);
+	
+#ifdef VERIFY_TREE
+	assert(_verify_tree(rootp, cmp));
+#endif
+
+	return 1;
+}
+
+int
+ptree_replace(void *v, 
+			  ptree_node_t **rootp, 
+			  int (*cmp)(const void *v1, const void *v2), 
+			  void **oldval)
+{
+	struct ptree_node **parentpp;
+	struct ptree_node *parentp;
+	struct ptree_node *pn;
+	int c;
+	
+#ifdef VERIFY_TREE
+	int countStart = _count_nodes(rootp), countEnd=0;
+#endif
+	
+	parentp = *rootp;
+	parentpp = rootp;
+	
+#ifdef VERIFY_TREE
+	assert(_verify_tree(rootp, cmp));
+#endif
+
+	//if we find v in the tree, replace it
+	if ((c = _walk_to(v, &parentp, &parentpp, cmp)) == 0)
+	{
+		if (oldval)
+			*oldval = parentp->pn_value;
+		parentp->pn_value = v;
+	
+#ifdef VERIFY_TREE
+	assert(_verify_tree(rootp, cmp));
+#endif
+	
+#ifdef VERIFY_TREE
+	countEnd = _count_nodes(rootp);
+	assert(countEnd == countStart);
+#endif
+		
+		return 1;
+	}
+	
+	//otherwise, add it to the tree
+	if (!(pn = malloc(sizeof (*pn))))
+		return 0;
+	
+	memset(pn, 0, sizeof (*pn));
+	pn->pn_value = v;
+	pn->pn_parent = parentp;
+	*parentpp = pn;
+	if (oldval)
+		*oldval = 0;
+	
+#ifdef VERIFY_TREE
+	assert(_verify_tree(rootp, cmp));
+#endif
+	
+#ifdef VERIFY_TREE
+	countEnd = _count_nodes(rootp);
+	countStart++;
+	assert(countEnd == countStart);
+#endif
+
+	return 1;
+}
+
+int
+ptree_contains(void *v, 
+			   ptree_node_t *parentp, 
+			   int (*cmp)(const void *v1, const void *v2), 
+			   void **nodeval)
+{
+	int c;
+
+	if ((c = _walk_to(v, &parentp, NULL, cmp)) == 0)
+	{
+		if (nodeval)
+			*nodeval = parentp->pn_value;
+		return 1;
+	}
+	if (nodeval)
+		*nodeval = 0;
+	return 0;
+}
\ No newline at end of file
diff --git a/utils/ptree.h b/utils/ptree.h
new file mode 100644
index 0000000..62166ac
--- /dev/null
+++ b/utils/ptree.h
@@ -0,0 +1,33 @@
+#ifndef _PTREE_H_
+#define _PTREE_H_
+
+typedef struct ptree_node ptree_node_t;
+
+typedef enum {
+	PTREE_PREORDER = 1,
+	PTREE_INORDER = 2,
+	PTREE_POSTORDER = 3
+}  ptree_order_t;
+
+typedef enum {
+	PTREE_WALK_STOP = 0,
+	PTREE_WALK_CONTINUE = 1
+} ptree_walk_res_t;
+
+int ptree_contains(void *v, ptree_node_t *root, int(*)(const void *sv,
+    const void *tv), void **nodeval);
+int ptree_remove(void *v, ptree_node_t **root, int(*)(const void *sv,
+    const void *tv), void **oltval);
+int ptree_replace(void *v, ptree_node_t **root, int(*)(const void *sv,
+    const void *tv), void **oltval);
+void ptree_clear(ptree_node_t **root);
+ptree_walk_res_t
+ptree_walk(ptree_node_t *start, 
+		   ptree_order_t order,
+		   ptree_walk_res_t (*func)(const void *v1, int level, void *arg, void *ptree_inorder_walking_remove_arg), 
+		   int (*cmp)(const void *v1, const void *v2),
+		   void *arg);
+int ptree_inorder_walk_remove(ptree_node_t **rootp, void **oldval, void *piwra,
+						  int (*cmp)(const void *v1, const void *v2));
+
+#endif
diff --git a/utils/utils.c b/utils/utils.c
new file mode 100644
index 0000000..57611f2
--- /dev/null
+++ b/utils/utils.c
@@ -0,0 +1,1223 @@
+#include "../stdafx.h"
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <regex.h>
+#include <assert.h>
+#if !defined(_WINDOWS) || defined(__CYGWIN__)
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+//#include <arpa/inet.h>
+#include <sys/poll.h>
+#else
+#include "wincompat.h"
+#endif
+#if defined(__CYGWIN__) || defined(__MINGW32_VERSION)
+#include "getaddrinfo.h"
+#endif
+#ifndef _MSC_EXTENSIONS
+#include <unistd.h>
+#endif
+#include "utils.h"
+
+#if defined(_MACOSX) || defined(_LINUX)
+// Use IPv6 on Mac OS and Linux
+#define _ENABLE_IPv6
+#endif
+
+/* character escaping */
+#define PASSTHRU(c) (isalnum((unsigned char)c)/* || c == ' '*/ || c == '.' || c == '/' || c == ':' || c == '%')
+
+#ifndef _WINDOWS
+#define SET_ERRDESC(errdesc, errdesclen) (errdesc ? snprintf(errdesc, \
+	errdesclen, "%s", strerror(errno)) : 0);
+#else
+#define SET_ERRDESC(errdesc, errdesclen) wsa_set_errdesc(errdesc, errdesclen);
+#endif
+
+/* size of first buffer malloc; start small to exercise grow routines */
+#define	FIRSTSIZE	128
+
+int logging_enabled = FALSE;
+#ifndef USE_PHIDGET21_LOGGING
+static FILE *log_stream = 0;
+static const char *log_pname = 0;
+#endif
+
+#if defined(_WINDOWS) && !defined(_CYGWIN)
+static void
+wsa_set_errdesc(char *errdesc, int len)
+{
+	int err;
+
+	if (!errdesc)
+		return;
+	switch (err = WSAGetLastError()) {
+		case 10038:
+			snprintf(errdesc, len, "Socket operation on non-socket");
+			return;
+		case 10061:
+			snprintf(errdesc, len, "Connection refused");
+			return;
+		default:
+			snprintf(errdesc, len, "WSA error %d", err);
+			return;
+	}
+}
+#endif
+
+
+/* Modified to work properly on ALL systems, not just UNIX */
+int
+pvasprintf(char **ret, const char *fmt, va_list ap)
+{
+	char *buf = NULL;
+	size_t bufsize = 0;
+	char *newbuf = NULL;
+	size_t nextsize = 0;
+	int outsize = 0;
+
+	bufsize = 0;
+	for (;;) {
+		if (bufsize == 0) {
+			if ((buf = (char *)malloc(FIRSTSIZE)) == NULL) {
+				*ret = NULL;
+				return -1;
+			}
+			bufsize = 1;
+		} else if ((newbuf = (char *)realloc(buf, nextsize)) != NULL) {
+			buf = newbuf;
+			bufsize = nextsize;
+		} else {
+			free(buf); buf = NULL;
+			*ret = NULL;
+			return -1;
+		}
+
+#ifdef _WINDOWS
+		outsize = _vsnprintf(buf, bufsize, fmt, ap);
+#else
+		{
+			va_list copy;
+			va_copy(copy, ap);
+			outsize = vsnprintf(buf, bufsize, fmt, copy);
+			va_end(copy);
+		}
+#endif
+
+		if (outsize == -1) {
+			/* Clear indication that output was truncated, but no
+			* clear indication of how big buffer needs to be, so
+			* simply double existing buffer size for next time.
+			*/
+			nextsize = (int)bufsize * 2;
+
+		} else if (outsize == (int)bufsize) {
+			/* Output was truncated (since at least the \0 could
+			* not fit), but no indication of how big the buffer
+			* needs to be, so just double existing buffer size
+			* for next time.
+			*/
+			nextsize = (int)bufsize * 2;
+
+		} else if (outsize > (int)bufsize) {
+			/* Output was truncated, but we were told exactly how
+			* big the buffer needs to be next time. Add two chars
+			* to the returned size. One for the \0, and one to
+			* prevent ambiguity in the next case below.
+			*/
+			nextsize = outsize + 2;
+
+		} else if (outsize == (int)bufsize - 1) {
+			/* This is ambiguous. May mean that the output string
+			* exactly fits, but on some systems the output string
+			* may have been trucated. We can't tell.
+			* Just double the buffer size for next time.
+			*/
+			nextsize = (int)bufsize * 2;
+
+		} else {
+			/* Output was not truncated */
+			break;
+		}
+	}
+	*ret = buf;
+	return (int)strlen(buf);
+}
+
+int
+pasprintf(char **ret, const char *fmt, ...)
+{
+	va_list args;
+	int outsize = 0;
+
+	va_start(args, fmt);
+	outsize = pvasprintf(ret, fmt, args);
+	va_end(args);
+
+	return outsize;
+}
+
+int
+pd_getline(char *buf, unsigned int bufsize, int *bufcur,
+		   int *buflen, int(*readfunc)(int, void *, unsigned int, char *,
+		   int), int(*closefunc)(int, char *, int), int readfd, char **line,
+		   char *errdesc, int errlen)
+{
+	char *eol;
+	unsigned int srcsize;
+	int linelen;
+	int linesize = 1024;
+
+	linelen = 0;
+	if (!(*line = malloc(linesize))) {
+		/* no memory */
+		if (closefunc)
+			(void) closefunc(readfd, errdesc, errlen);
+		return 0;
+	}
+	**line = 0;
+
+top:
+	/* this loops until buf is empty, or we hit the end of a line */
+	while (*bufcur < *buflen) {
+
+		/* looking for eol - \n or \0 
+		* eol points to the line ending \0, or NULL if line continues.
+		* srcsize set to number of chars to copy into line. */
+		if (!(eol = strchr(buf + *bufcur, '\n')))
+		{
+			if (!(eol = memchr(buf + *bufcur, '\0', *buflen - *bufcur)))
+			{
+				/* couldn't find '\n' or '\0' */
+				srcsize = *buflen - *bufcur; 
+			}
+			else
+			{
+				/* found '\0' */
+				srcsize = eol - buf - *bufcur + 1;
+			}
+		}
+		else
+		{ 
+			/* found '\n' */
+			srcsize = eol - buf - *bufcur + 1;
+			/* change \n into \0 */
+			*eol = 0;
+		}
+
+		/* double size of *line until it's big enough for srcsize characters */
+		while ((int)srcsize > (linesize - linelen))
+		{
+			char *newline;
+
+			linesize *= 2;
+
+			if (!(newline = realloc(*line, linesize))) {
+				/* not enough memory */
+				free(*line);
+				*line = NULL;
+				if (closefunc)
+					(void) closefunc(readfd, errdesc, errlen);
+				return 0;
+			}
+
+			*line = newline;
+		}
+
+		/* copy buf into line and modify pointers */
+		memcpy(*line + linelen, buf + *bufcur, srcsize);
+		linelen += srcsize;
+		*bufcur += srcsize;
+
+		/* Are we at the end of the string? */
+		if (eol)
+		{
+			/* change the first \r into a \0
+			* This handles when they send \r\n but not \n\r */
+			if ((eol = strchr(*line, '\r')) != NULL)
+				*eol = 0;
+
+			/* This is the (only) happy return from this function */
+			return 1;
+		}
+	} //while (*bufcur < *buflen)
+
+	/* we get here when there wasn't the end of a string in the buffer */
+	*bufcur = 0;
+	/* read in some data */
+	if ((*buflen = readfunc(readfd, buf, bufsize - 1, errdesc, errlen)) <= 0)
+	{
+		/* read either errored, or the socket is closed */
+		free(*line);
+		*line = NULL;
+		if (closefunc)
+			(void) closefunc(readfd, errdesc, errlen);
+		return 0;
+	}
+	/* null terminate - so strchr knows when to stop */
+	buf[*buflen] = 0;
+	/* go process it */
+	goto top;
+}
+
+/*int
+pd_getline_simple(int fd, char **line)
+{
+int bufcur = 0;
+int buflen = 0;
+char buf[2];
+
+return pd_getline(buf, sizeof (buf), &bufcur, &buflen, pu_read, 0, fd,
+line, 0, 0);
+}*/
+
+int
+getmatchsub(const char *line, char **subp, const regmatch_t pmatch[], int n)
+{
+	int len;
+
+	len = (pmatch[n].rm_so >= 0) ? pmatch[n].rm_eo - pmatch[n].rm_so : 0;
+	if (subp) {
+		if (len) {
+			if (!(*subp = malloc(len + 1)))
+				return len;
+			memcpy(*subp, line + pmatch[n].rm_so, len);
+			subp[0][len] = 0;
+		} else {
+			*subp = NULL;
+		}
+	}
+
+	return len;
+}
+
+static int waitForConnect(int s, int cancel)
+{
+	int 		err;
+	fd_set 		readFDs;
+	fd_set 		writeFDs;
+	fd_set 		errorFDs;
+	int			selectResult;
+	int			maxFD = s;
+
+	FD_ZERO(&readFDs);
+	FD_ZERO(&writeFDs);
+	FD_ZERO(&errorFDs);
+
+	// We always want the cancel socket in the read FD set.
+#ifndef _WINDOWS
+	if (cancel >= 0) 
+#else
+	if (cancel != INVALID_SOCKET) 
+#endif
+		FD_SET(cancel, &readFDs);
+	FD_SET(s, &readFDs);
+	FD_SET(s, &writeFDs);
+	FD_SET(s, &errorFDs);
+	
+#ifndef _WINDOWS
+	if (cancel >= 0 && cancel > s) 
+#else
+	if (cancel != INVALID_SOCKET && cancel > s) 
+#endif
+		maxFD = cancel;
+
+	// Do the select, looping while we get EINTR errors.
+	err = 0;
+	do {
+#ifndef _WINDOWS
+		selectResult = select(maxFD + 1, &readFDs, &writeFDs, NULL, NULL);
+#else
+		//Windows reports a failed connect in errorFDs
+		selectResult = select(maxFD + 1, &readFDs, &writeFDs, &errorFDs, NULL);
+#endif
+
+		if (selectResult < 0) {
+#ifndef _WINDOWS
+			err = errno;
+#else
+			err = WSAGetLastError();
+#endif
+		}
+	} while (err == EINTR);
+
+	if (err == 0) {
+		// We have an infinite timeout, so a result of 0 should be impossible, 
+		// so assert that selectResult is positive.
+		assert(selectResult > 0);
+
+		// Check for cancellation first.
+#ifndef _WINDOWS
+		if (cancel >= 0) 
+#else
+		if (cancel != INVALID_SOCKET) 
+#endif
+		{
+			if ( FD_ISSET(cancel, &readFDs) ) {
+				err = ECANCELED;
+			}
+		}
+	}
+
+	return err;
+}
+
+int cancelConnect(int cancelSocket)
+{
+	int	err;
+	ssize_t bytesWritten;
+	static const char kCancelMessage = 0;
+
+	err = 0;
+
+#ifndef _WINDOWS
+	bytesWritten = write(cancelSocket, &kCancelMessage, sizeof(kCancelMessage));
+#else
+	bytesWritten = send(cancelSocket, &kCancelMessage, sizeof(kCancelMessage), MSG_NOSIGNAL);
+#endif
+	if (bytesWritten < 0) {
+		err = errno;
+	} 
+	return err;
+}
+
+int CCONV
+stream_server_connect(const char *dest, const char *svcname, int *fdp, int *cancelSocket, char *errdesc, int errdesclen)
+{
+	struct addrinfo hints, *res, *res0 = NULL;
+	int err, cancelled = 0;
+	SOCKET s = INVALID_SOCKET;
+	int tmpSock[2];
+	int cancelRecvSocket = INVALID_SOCKET;
+#ifdef _WINDOWS
+	u_long nNonBlocking = TRUE;
+#endif
+#ifdef _MACOSX
+	int opt;
+#endif
+
+	memset(&hints, 0, sizeof(hints));
+	//hints.ai_family = AF_INET;
+	hints.ai_family = PF_UNSPEC; //any family (including IPV6)
+	hints.ai_socktype = SOCK_STREAM;
+#ifndef WINCE
+	hints.ai_flags = AI_ADDRCONFIG;
+#endif
+
+	if ((err = getaddrinfo(dest, svcname, &hints, &res0)) != 0) {
+		if (errdesc)
+			snprintf(errdesc, errdesclen, "getaddrinfo: %s", gai_strerror(err));
+		freeaddrinfo(res0);
+		return 0;
+	}
+
+	//setup cancel socket
+	err = socketpair(AF_UNIX, SOCK_STREAM, 0, tmpSock);
+	if (err < 0) {
+		SET_ERRDESC(errdesc, errdesclen);
+		*cancelSocket = INVALID_SOCKET;
+		pu_log(PUL_WARN, 0, "Unable to create a cancel socket: %s",errdesc);
+		return 0;
+	} else {
+		*cancelSocket = tmpSock[0];
+		cancelRecvSocket = tmpSock[1];
+	}
+
+	for (res = res0; res; res = res->ai_next) {
+		if(cancelled)
+			break;
+
+		// sometimes on mac, we get 0.0.0.0 ??!! - just ignore it
+		// I think this is IPv6 - don't ignore...
+		//if(((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr == 0) 
+		//{
+		//	continue;
+		//}
+
+		s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+#ifndef _WINDOWS
+		if (s < 0) 
+#else
+		if (s == INVALID_SOCKET) 
+#endif
+		{
+			SET_ERRDESC(errdesc, errdesclen);
+			continue;
+		}
+
+		//Make the socket non-blocking
+#ifndef _WINDOWS
+		if (fcntl(s, F_SETFL, O_NONBLOCK) < 0) {
+			SET_ERRDESC(errdesc, errdesclen);
+			s = INVALID_SOCKET;	
+			continue;
+		}
+#else
+		if (ioctlsocket(s, FIONBIO, (u_long FAR *) & nNonBlocking))
+		{
+			s = INVALID_SOCKET;	
+			continue;
+		}
+#endif
+
+		if((err = connect(s, res->ai_addr, (int) res->ai_addrlen)) != 0)
+		{
+			//Connection in progress - wait for completion or cancelation
+#ifndef _WINDOWS
+			if(errno == EINPROGRESS)
+#else
+			err = WSAGetLastError();
+			if(err == WSAEINPROGRESS || err == WSAEWOULDBLOCK)
+#endif
+			{
+				err = waitForConnect(s, cancelRecvSocket);
+
+				// Not cancelled, so must have either connected or failed.  
+				// Check to see if we're connected by calling getpeername.
+				if (err == 0) {
+					socklen_t 	len = sizeof(struct sockaddr);
+					struct sockaddr name;
+					err = getpeername(s, &name, &len);
+
+					// The connection failed.  Get the error associated with 
+					// the connection attempt.
+					if (err < 0) {
+						char tmpErr;
+#ifdef _WINDOWS
+						err = WSAGetLastError();
+#endif
+						len = sizeof(tmpErr);
+						err = getsockopt(s, SOL_SOCKET, SO_ERROR, &tmpErr, &len);
+						if (err < 0) {
+#ifdef _WINDOWS
+							err = WSAGetLastError();
+#else
+							err = errno;
+#endif
+						} else {
+							assert(tmpErr != 0);
+							err = tmpErr;
+						}
+					}
+					//connection good
+					else
+						break;
+				}
+				//cancelled
+				else if(err==ECANCELED)
+				{
+					cancelled = 1;
+				}
+
+#ifdef _WINDOWS
+				WSASetLastError(err);
+#else
+				errno = err;
+#endif
+			}
+			//Error
+			SET_ERRDESC(errdesc, errdesclen);
+#ifndef _WINDOWS
+			close(s);
+#else
+			closesocket(s);
+#endif
+			s = INVALID_SOCKET;	
+			continue;
+		}
+		break;
+	}
+
+	//cleanup cancel socket - not needed anymore
+	if (tmpSock[0] != -1)
+#ifndef _WINDOWS
+		close(tmpSock[0]);
+#else
+		closesocket(tmpSock[0]);
+#endif
+	if (tmpSock[1] != -1)
+#ifndef _WINDOWS
+		close(tmpSock[1]);
+#else
+		closesocket(tmpSock[1]);
+#endif
+	*cancelSocket = INVALID_SOCKET;
+
+#ifndef _WINDOWS
+	if (s < 0)
+#else
+	if (s == INVALID_SOCKET)
+#endif
+	{
+		SET_ERRDESC(errdesc, errdesclen);
+		freeaddrinfo(res0);
+		return 0;
+	}
+	
+#ifdef _MACOSX
+	opt = 1;
+	setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
+#endif
+	if (fdp)
+		*fdp = s;
+	freeaddrinfo(res0);
+	return 1;
+}
+
+
+#ifndef _ENABLE_IPv6
+/*
+* Accepts a TCP connection on a given port and invokes the given
+* callback to handle it. This is where the main server thread sits.
+*	IPv4 Version
+*/
+int
+stream_server_accept(int port, void(*clfunc)(int fd, const char *addr,
+					 int port), char *errdesc, int errdesclen)
+{
+	struct sockaddr_in sin = { 0 };
+	struct sockaddr_in cin = { 0 };
+	const int opt = 1;
+	socklen_t cl;
+	char *addr;
+	int fd;
+	int s;
+	int errcount=0;
+	//#ifdef _WINDOWS
+	//	u_long nNonBlocking = TRUE;
+	//#endif
+
+	if (!(s = (int)socket(PF_INET, SOCK_STREAM, 0))) {
+		SET_ERRDESC(errdesc, errdesclen);
+		return 0;
+	}
+	setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void *)&opt, sizeof (opt));
+#ifdef _MACOSX
+	setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, (void *)&opt, sizeof (opt));
+#endif
+	sin.sin_family = AF_INET;
+	sin.sin_port = htons(port);
+	sin.sin_addr.s_addr = INADDR_ANY;
+	if (bind(s, (struct sockaddr *)&sin, sizeof (sin)) != 0) {
+		SET_ERRDESC(errdesc, errdesclen);
+		return 0;
+	}
+	if (listen(s, 5) != 0) {
+		SET_ERRDESC(errdesc, errdesclen);
+		return 0;
+	}
+	for (;;) {
+		cl = sizeof(cin);
+		while ((fd = (int)accept(s, (struct sockaddr *)&cin, &cl)) < 0 &&
+			errno == EAGAIN)
+			;
+		if (fd < 0) {
+			SET_ERRDESC(errdesc, errdesclen);
+			pu_log(PUL_WARN, 0, "Error in stream_server_accept: %s",errdesc);
+			if(errcount < 10)
+			{
+				SLEEP(50);
+				continue;
+			}
+			else
+			{
+				pu_log(PUL_CRIT, 0, "Too many errors in stream_server_accept, exiting.");
+				return 0;
+			}
+		}
+		errcount = 0;
+		setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&opt, sizeof (opt));
+
+#ifdef _MACOSX
+		// otherwise we get SIGPIPEs that aren't important
+		setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&opt, sizeof (opt));
+#endif
+
+		addr = strdup(inet_ntoa(cin.sin_addr));
+		clfunc(fd, addr, ntohs(cin.sin_port));
+		free(addr); addr = NULL;
+	}
+	/*NOTREACHED*/
+}
+
+#else
+
+/*
+* Accepts a TCP connection on a given port and invokes the given
+* callback to handle it. This is where the main server thread sits.
+* 	IPv6 version! - doesn't work with Windows yet...
+*/
+int
+stream_server_accept(int port, 
+					 void(*clfunc)(int fd, const char *addr,int port), 
+					 char *errdesc, 
+					 int errdesclen)
+{
+	struct addrinfo *ai, *runp;
+	struct addrinfo hints;
+	int e, nfds;
+	char portStr[20];
+	struct pollfd *fds;
+	int opt;
+
+	// Get a list of interfaces to Bind to
+	memset(&hints, '\0', sizeof(hints));
+	hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
+	hints.ai_socktype = SOCK_STREAM;
+	//hints.ai_family = PF_UNSPEC;
+
+	snprintf(portStr, 20, "%d", port);
+	if((e = getaddrinfo(NULL, portStr, &hints, &ai)) != 0)
+	{
+		(errdesc ? snprintf(errdesc, errdesclen, "getaddrinfo: %s", gai_strerror(e)) : 0);
+		return 0;
+	}
+
+	// Malloc array
+	nfds = 0;
+	runp = ai;
+	while(runp)
+	{
+		nfds++;
+		runp = runp->ai_next;
+	}
+	fds = (struct pollfd *)malloc(nfds * sizeof(struct pollfd));
+	
+	pu_log(PUL_INFO, 0, "Found %d interfaces to Bind to.", nfds);
+
+	// Bind to interfaces
+	for(nfds = 0, runp = ai; runp; runp = runp->ai_next)
+	{
+		pu_log(PUL_INFO, 0, "Setting up interface %d: Family:%d, Socktype:%d, Protocol:%d", nfds, runp->ai_family, runp->ai_socktype, runp->ai_protocol);
+		
+		if((fds[nfds].fd = socket(runp->ai_family, runp->ai_socktype, runp->ai_protocol)) < 0)
+		{
+			pu_log(PUL_WARN, 0, "Error on socket: %s", strerror(errno));
+			continue;
+		}
+
+		fds[nfds].events = POLLIN;
+		opt = 1;
+		setsockopt(fds[nfds].fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+#ifdef _MACOSX
+		opt = 1;
+		setsockopt(fds[nfds].fd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
+#endif
+
+		if(bind(fds[nfds].fd, runp->ai_addr, runp->ai_addrlen) != 0)
+		{
+			if(errno != EADDRINUSE)
+			{
+				pu_log(PUL_WARN, 0, "Error on bind: %s", strerror(errno));
+				continue;
+			}
+			else
+				close(fds[nfds].fd);
+		}
+		else //bind was successfull
+		{
+			if(listen(fds[nfds].fd, SOMAXCONN) != 0)
+			{
+				pu_log(PUL_WARN, 0, "Error on listen: %s", strerror(errno));
+				continue;
+			}
+			else //listen was successfull
+				nfds++;
+		}
+
+	}
+	freeaddrinfo(ai);
+
+	// didn't bind to anything!
+	if(nfds == 0)
+	{
+		(errdesc ? snprintf(errdesc, errdesclen, "Couldn't bind to any interfaces!") : 0);
+		return 0;
+	}
+
+	while(1)
+	{
+		if(poll(fds, nfds, -1) > 0)
+		{
+			int i;
+			for(i = 0; i < nfds; i++)
+			{
+				if(fds[i].revents & POLLIN)
+				{
+					struct sockaddr_storage rem;
+					socklen_t remlen = sizeof(rem);
+					int fd;
+					char addr[200];
+
+					while((fd = accept(fds[i].fd, (struct sockaddr *) &rem, &remlen)) < 0 && errno == EAGAIN);
+
+					if(fd < 0)
+					{
+						SET_ERRDESC(errdesc, errdesclen);
+						return 0;
+					}
+
+					opt = 1;
+					setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&opt, sizeof (opt));
+#ifdef _MACOSX
+					opt = 1;
+					setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&opt, sizeof (opt));
+#endif
+
+					(void)getnameinfo((struct sockaddr *)&rem, remlen, addr, sizeof(addr), NULL, 0, NI_NUMERICHOST);
+					clfunc(fd, addr, ntohs(((struct sockaddr_in *)&rem)->sin_port));
+				}
+			}
+		}
+	}
+	/*NOTREACHED*/
+}
+#endif
+
+int
+pu_write(int fd, const void *buf, unsigned int len, char *errdesc, int edlen)
+{
+	//why a static mutex instead of a per-socket one???
+	//Why a mutex at all?? I'm oging to disable and see what happens...
+	//static pthread_mutex_t *writelock = 0;
+	int res = 0;
+	int olen = len;
+#ifdef _WINDOWS
+	int bytesSent = 0;
+	WSABUF DataBuf;
+#endif
+
+	if (fd == -1)
+		return len;
+
+	pu_log(PUL_VERB, 0, "Sending: \"%s\"",(char *)buf);
+
+	//if (!writelock) {
+	//	if (!(writelock = malloc(sizeof (*writelock))))
+	//		return 0;
+	//	pthread_mutex_init(writelock, NULL);
+	//}
+	//pthread_mutex_lock(writelock);
+	do {
+		if (res > 0) {
+#ifdef _WINDOWS
+			(unsigned char *)buf += res;
+#else
+			buf += res;
+#endif
+			len -= res;
+		}
+		if (len)
+		{
+tryagain:
+#ifdef _WINDOWS
+			DataBuf.buf = (char *)buf;
+			DataBuf.len = len;
+
+			res = WSASend(fd, &DataBuf, 1, &bytesSent, 0, NULL, NULL);
+			if(res)
+				res = -1;
+			else
+				res = bytesSent;
+#else
+			res = send(fd, buf, len, MSG_NOSIGNAL);
+#endif
+			//Error
+			if(res == -1)
+			{
+#ifdef _WINDOWS
+				switch(WSAGetLastError())
+				{
+					//non-blocking, try again
+				case WSAEWOULDBLOCK:
+					SLEEP(10);
+					goto tryagain;
+					//any other error, don't try again
+				default:
+					break;
+				}
+#else
+				switch(errno)
+				{
+					//Interrupted, try again
+				case EINTR:
+					//non-blocking, try again
+				case EAGAIN:
+					SLEEP(10);
+					goto tryagain;
+					//any other error, don't try again
+				default:
+					break;
+				}
+#endif
+			}
+		}
+		else
+			res = olen;
+	} while (len && res >= 0);
+	//pthread_mutex_unlock(writelock);
+
+	if (res != olen) {
+		SET_ERRDESC(errdesc, edlen);
+		return 0;
+	} else
+		return 1;
+}
+
+int
+pu_read(int fd, void *buf, unsigned int len, char *errdesc, int edlen)
+{
+	int res=0;
+	if (fd == -1)
+		return 0;
+
+tryagain:
+	res = recv(fd, buf, len, 0);
+	//Error
+	if(res == -1)
+	{
+#ifdef _WINDOWS
+		switch(WSAGetLastError())
+		{
+			//non-blocking, try again
+		case WSAEWOULDBLOCK:
+			SLEEP(10);
+			goto tryagain;
+			//any other error, don't try again
+		default:
+			break;
+		}
+#else
+		switch(errno)
+		{
+			//Interrupted, try again
+		case EINTR:
+			//non-blocking, try again
+		case EAGAIN:
+			SLEEP(10);
+			goto tryagain;
+			//any other error, don't try again
+		default:
+			break;
+		}
+#endif
+	}
+	if (res <= 0) {
+		SET_ERRDESC(errdesc, edlen);
+		return 0;
+	} else
+	{
+		pu_log(PUL_VERB,0,"Recieved: \"%s\"", (char *)buf);
+		return res;
+	}
+}
+
+int
+pu_close(int fd, char *errdesc, int edlen)
+{
+	int res=0;
+	if(fd == -1) return 0;
+#ifndef _WINDOWS
+	res = close(fd);
+#else
+	res = closesocket(fd);
+#endif
+	SET_ERRDESC(errdesc, edlen);
+	return res;
+}
+
+// We want to use phidget21 logging not utils.c logging
+#ifndef USE_PHIDGET21_LOGGING
+static const char *
+pu_log_level_str(pu_log_level_t l)
+{
+	switch (l) {
+		case PUL_ERR:
+			return "ERR";
+		case PUL_CRIT:
+			return "CRIT";
+		case PUL_WARN:
+			return "WARN";
+		case PUL_INFO:
+			return "INFO";
+		case PUL_DEBUG:
+			return "DEBUG";
+		case PUL_VERB:
+			return "VERBOSE";
+	}
+	return "???";
+}
+
+void
+pu_log_stream(FILE *str)
+{
+	log_stream = str;
+}
+
+void
+pu_log_pname(const char *newname)
+{
+	log_pname = newname;
+}
+
+void
+pu_log(pu_log_level_t l, int s, const char *fmt, ...)
+{
+	static pthread_mutex_t logLock;
+	static int logLockInitialized = FALSE;
+	va_list va;
+
+	if(!logLockInitialized)
+	{
+		pthread_mutex_init(&logLock, NULL);
+		logLockInitialized = TRUE;
+	}
+	pthread_mutex_lock(&logLock);
+
+#ifndef DEBUG
+	if(logging_enabled)
+#endif
+	{
+#ifdef WINCE
+		if (!log_stream)
+			log_stream = stdout;
+		fprintf(log_stream, "%s%s%d/%s ", log_pname ? log_pname : "",
+			log_pname ? " " : "", s, pu_log_level_str(l));
+		va_start(va, fmt);
+		vfprintf(log_stream, fmt, va);
+		va_end(va);
+		fprintf(log_stream, "\n");
+		fflush(log_stream);
+#else
+		char date[50];
+		struct tm *tm;
+		time_t t;
+
+		if (!log_stream)
+			log_stream = stdout;
+
+		time(&t);
+		tm = localtime(&t);
+		if (!strftime(date, sizeof (date), "%c", tm))
+			strncpy(date, "?", sizeof (date));
+		fprintf(log_stream, "%s %s%s%d/%s ", date, log_pname ? log_pname :
+			"", log_pname ? " " : "", s, pu_log_level_str(l));
+		va_start(va, fmt);
+		vfprintf(log_stream, fmt, va);
+		va_end(va);
+		fprintf(log_stream, "\n");
+		fflush(log_stream);
+#endif
+	}
+	pthread_mutex_unlock(&logLock);
+}
+#else
+void
+pu_log(pu_log_level_t l, int s, const char *fmt, ...)
+{
+	CPhidgetLog_level level;
+	char msg[2048], id[10];
+	va_list va;
+
+	switch(l)
+	{
+		case PUL_ERR:
+			level = PHIDGET_LOG_ERROR;
+			break;
+		case PUL_CRIT:
+			level = PHIDGET_LOG_CRITICAL;
+			break;
+		case PUL_WARN:
+			level = PHIDGET_LOG_WARNING;
+			break;
+		case PUL_INFO:
+			level = PHIDGET_LOG_INFO;
+			break;
+		case PUL_DEBUG:
+			level = PHIDGET_LOG_DEBUG;
+			break;
+		case PUL_VERB:
+		default:
+			level = PHIDGET_LOG_VERBOSE;
+			break;
+	}
+
+	va_start(va, fmt);
+#ifdef WINCE
+	vsprintf(msg, fmt, va);
+#else
+	vsnprintf(msg, 2048, fmt, va);
+#endif
+	va_end(va);
+
+	snprintf(id, 10, "%d", s);
+	CPhidget_log(level, id, msg);
+}
+#endif
+
+int
+hexval(unsigned char c)
+{
+	if (isdigit(c))
+		return c - '0';
+	c = tolower(c);
+	if (c <= 'f' && c >= 'a')
+		return c - 'a' + 10;
+	return -1;
+}
+
+int
+unescape(const char *src, char **dstp, unsigned int *dlenp)
+{
+	char *dst;
+	size_t slen;
+	size_t dlen;
+	size_t i;
+
+	for (i = 0, dlen = 0, slen = strlen(src); i < slen; i++, dlen++)
+		if (src[i] == '\\')
+			i += 3;
+
+	if (!(dst = malloc(dlen + 1)))
+		return 0;
+	for (i = 0, dlen = 0, slen = strlen(src); i < slen; i++, dlen++)
+		if (src[i] == '\\') {
+			dst[dlen] = hexval((unsigned)src[i + 2]) * 16 +
+				hexval((unsigned)src[i + 3]);
+			i += 3;
+		} else
+			dst[dlen] = src[i];
+		if (dlenp)
+			*dlenp = (unsigned int)dlen;
+		dst[dlen] = 0;
+
+		*dstp = dst;
+		return 1;
+}
+
+static unsigned char
+hexchar(unsigned char c)
+{
+	if (c > 16)
+		return 'f';
+	if (c >= 10)
+		return c - 10 + 'a';
+	return c + '0';
+}
+
+
+int
+escape2(const char *src, unsigned int slen, char **dstp, int escbacks)
+{
+	char *dst;
+	size_t dlen;
+	size_t i;
+
+	if (!slen)
+		slen = (int)strlen(src);
+	for (i = 0, dlen = 0; i < slen; i++)
+		if (PASSTHRU(src[i]))
+			dlen++;
+		else
+			if(escbacks)
+				dlen += 6;
+			else
+				dlen += 4;
+
+	if (!(dst = malloc(dlen + 1)))
+		return 0;
+	for (i = 0, dlen = 0; i < slen; i++)
+		if (!PASSTHRU(src[i])) {
+			dst[dlen++] = '\\';
+			if(escbacks)
+				dst[dlen++] = '\\';
+			dst[dlen++] = 'x';
+			dst[dlen++] = hexchar((unsigned char)src[i] / 16);
+			dst[dlen++] = hexchar((unsigned char)src[i] % 16);
+		} else {
+			dst[dlen++] = src[i];
+		}
+		dst[dlen++] = 0;
+
+		*dstp = dst;
+		return 1;
+}
+
+int
+escape(const char *src, unsigned int slen, char **dstp)
+{
+	return escape2(src, slen, dstp, PFALSE);
+}
+
+int byteArrayToString(unsigned char *bytes, int length, char *string)
+{
+	int i;
+	for(i=0;i<length;i++)
+	{
+		sprintf(string+(i*2), "%02x", bytes[i]);
+	}
+	return EPHIDGET_OK;
+}
+
+int stringToByteArray(char *string, unsigned char *bytes, int *length)
+{
+	int i;
+
+	if(strlen(string) > (size_t)((*length)*2))
+		return EPHIDGET_INVALIDARG;
+
+	for(i=0;i<(int)strlen(string);i+=2)
+	{
+		if(hexval(string[i])==-1)
+			break;
+		if((i/2)>*length)
+			return EPHIDGET_INVALIDARG;
+		bytes[i/2] = (hexval(string[i])<<4)+hexval(string[i+1]);
+	}
+	*length = i/2;
+
+	return EPHIDGET_OK;
+}
+
+//up to 1048575 (0xFFFFF) per int (not full 32-bit!)
+//IR max is 327670
+int wordArrayToString(int *words, int length, char *string)
+{
+	int i;
+	for(i=0;i<length;i++)
+	{
+		if(words[i] > 0xFFFFF)
+			sprintf(string+(i*5), "fffff");
+		else
+			sprintf(string+(i*5), "%05x", words[i]);
+	}
+	return EPHIDGET_OK;
+}
+
+//up to 1048575 (0xFFFFF) per int (not full 32-bit!)
+int stringToWordArray(char *string, int *words, int *length)
+{
+	int i;
+
+	for(i=0;i<(int)strlen(string);i+=5)
+	{
+		if(hexval(string[i])==-1)
+			break;
+		if((i/5)>*length)
+			return EPHIDGET_INVALIDARG;
+		words[i/5] = (hexval(string[i])<<16)+
+			(hexval(string[i+1])<<12)+
+			(hexval(string[i+2])<<8)+
+			(hexval(string[i+3])<<4)+
+			hexval(string[i+4]);
+		if(words[i/5] == 0xfffff)
+			words[i/5] = PUNK_INT;
+	}
+	*length = i/5;
+
+	return EPHIDGET_OK;
+}
diff --git a/utils/utils.h b/utils/utils.h
new file mode 100644
index 0000000..cbc6309
--- /dev/null
+++ b/utils/utils.h
@@ -0,0 +1,49 @@
+#ifndef _UTILS_H_
+#define _UTILS_H_
+#include <regex.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+typedef enum {
+	PUL_ERR = 1,
+	PUL_CRIT,
+	PUL_WARN,
+	PUL_INFO,
+	PUL_DEBUG,
+	PUL_VERB
+} pu_log_level_t;
+
+int pasprintf(char **ret, const char *fmt, ...);
+int pvasprintf(char **ret, const char *fmt, va_list ap);
+
+int pd_getline(char *buf, unsigned int bufsize, int *bufcur, int *buflen,
+    int(*readfunc)(int, void *, unsigned int, char *errdesc, int errlen),
+    int(*closefunc)(int, char *errdesc, int errlen), int readfd,
+    char **line, char *errdesc, int errlen);
+//int pd_getline_simple(int fd, char **line);
+
+int getmatchsub(const char *line, char **subp, const regmatch_t pmatch[],
+    int n);
+int stream_server_accept(int port, void(*clfunc)(int fd, const char *addr,
+    int port), char *errdesc, int errlen);
+int CCONV stream_server_connect(const char *dest, const char *svcname, 
+								int *fdp, int *cancelSocket, char *errdesc, int errdesclen);
+
+int pu_write(int fd, const void *buf, unsigned int len, char *errdesc,
+    int edlen);
+int pu_read(int fd, void *buf, unsigned int len, char *errdesc, int edlen);
+int pu_close(int fd, char *errdesc, int edlen);
+extern int logging_enabled;
+void pu_log_stream(FILE *);
+void pu_log(pu_log_level_t l, int s, const char *fmt, ...);
+int escape(const char *src, unsigned int srclen, char **dstp);
+int escape2(const char *src, unsigned int slen, char **dstp, int escbacks);
+int unescape(const char *src, char **dstp, unsigned int *dstlenp);
+int cancelConnect(int cancelSocket);
+
+int byteArrayToString(unsigned char *bytes, int length, char *string);
+int stringToByteArray(char *string, unsigned char *bytes, int *length);
+int wordArrayToString(int *words, int length, char *string);
+int stringToWordArray(char *string, int *words, int *length);
+
+#endif