vendor/krb5/1.15.1

42 files changed, 5064 insertions, 0 deletions

diff --git a/src/ccapi/common/Makefile.in b/src/ccapi/common/Makefile.in
new file mode 100644
index 000000000000..b51cfe2bce34
--- /dev/null
+++ b/src/ccapi/common/Makefile.in
@@ -0,0 +1,65 @@
+mydir=ccapi$(S)common
+BUILDTOP=$(REL)..$(S)..
+SUBDIRS=unix
+
+SRCS= \
+	cci_array_internal.c \
+	cci_cred_union.c \
+	cci_debugging.c \
+	cci_identifier.c \
+	cci_message.c \
+	cci_stream.c
+
+STLIBOBJS= \
+	cci_array_internal.o \
+	cci_cred_union.o \
+	cci_debugging.o \
+	cci_identifier.o \
+	cci_message.o \
+	cci_stream.o
+
+OBJS= \
+	$(OUTPRE)cci_array_internal.$(OBJEXT) \
+	$(OUTPRE)cci_cred_union.$(OBJEXT) \
+	$(OUTPRE)cci_debugging.$(OBJEXT) \
+	$(OUTPRE)cci_identifier.$(OBJEXT) \
+	$(OUTPRE)cci_message.$(OBJEXT) \
+	$(OUTPRE)cci_stream.$(OBJEXT)
+
+all-unix: all-libobjs
+clean-unix:: clean-libobjs
+
+@libobj_frag@
+
+# +++ Dependency line eater +++
+# 
+# Makefile dependencies follow.  This must be the last section in
+# the Makefile.in file
+#
+cci_array_internal.so cci_array_internal.po $(OUTPRE)cci_array_internal.$(OBJEXT): \
+  $(COM_ERR_DEPS) $(top_srcdir)/include/CredentialsCache.h \
+  cci_array_internal.c cci_array_internal.h cci_common.h \
+  cci_cred_union.h cci_debugging.h cci_identifier.h cci_message.h \
+  cci_stream.h cci_types.h
+cci_cred_union.so cci_cred_union.po $(OUTPRE)cci_cred_union.$(OBJEXT): \
+  $(COM_ERR_DEPS) $(top_srcdir)/include/CredentialsCache.h \
+  cci_common.h cci_cred_union.c cci_cred_union.h cci_debugging.h \
+  cci_identifier.h cci_message.h cci_stream.h cci_types.h
+cci_debugging.so cci_debugging.po $(OUTPRE)cci_debugging.$(OBJEXT): \
+  $(COM_ERR_DEPS) $(top_srcdir)/include/CredentialsCache.h \
+  cci_common.h cci_cred_union.h cci_debugging.c cci_debugging.h \
+  cci_identifier.h cci_message.h cci_os_debugging.h cci_stream.h \
+  cci_types.h
+cci_identifier.so cci_identifier.po $(OUTPRE)cci_identifier.$(OBJEXT): \
+  $(COM_ERR_DEPS) $(top_srcdir)/include/CredentialsCache.h \
+  cci_common.h cci_cred_union.h cci_debugging.h cci_identifier.c \
+  cci_identifier.h cci_message.h cci_os_identifier.h \
+  cci_stream.h cci_types.h
+cci_message.so cci_message.po $(OUTPRE)cci_message.$(OBJEXT): \
+  $(COM_ERR_DEPS) $(top_srcdir)/include/CredentialsCache.h \
+  cci_common.h cci_cred_union.h cci_debugging.h cci_identifier.h \
+  cci_message.c cci_message.h cci_stream.h cci_types.h
+cci_stream.so cci_stream.po $(OUTPRE)cci_stream.$(OBJEXT): \
+  $(COM_ERR_DEPS) $(top_srcdir)/include/CredentialsCache.h \
+  cci_common.h cci_cred_union.h cci_debugging.h cci_identifier.h \
+  cci_message.h cci_stream.c cci_stream.h cci_types.h
diff --git a/src/ccapi/common/cci_array_internal.c b/src/ccapi/common/cci_array_internal.c
new file mode 100644
index 000000000000..7a205d7201cc
--- /dev/null
+++ b/src/ccapi/common/cci_array_internal.c
@@ -0,0 +1,312 @@
+/* ccapi/common/cci_array_internal.c */
+/*
+ * Copyright 2006, 2007 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include "cci_common.h"
+#include "cci_array_internal.h"
+
+#ifdef WIN32
+#include "k5-platform.h"
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+struct cci_array_d {
+    cci_array_object_t *objects;
+    cc_uint64 count;
+    cc_uint64 max_count;
+
+    cci_array_object_release_t object_release;
+};
+
+struct cci_array_d cci_array_initializer = { NULL, 0, 0, NULL };
+
+#define CCI_ARRAY_COUNT_INCREMENT 16
+
+/* ------------------------------------------------------------------------ */
+
+static cc_int32 cci_array_resize (cci_array_t io_array,
+                                  cc_uint64   in_new_count)
+{
+    cc_int32 err = ccNoError;
+    cc_uint64 new_max_count = 0;
+
+    if (!io_array) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        cc_uint64 old_max_count = io_array->max_count;
+        new_max_count = io_array->max_count;
+
+        if (in_new_count > old_max_count) {
+            /* Expand the array */
+            while (in_new_count > new_max_count) {
+                new_max_count += CCI_ARRAY_COUNT_INCREMENT;
+            }
+
+        } else if ((in_new_count + CCI_ARRAY_COUNT_INCREMENT) < old_max_count) {
+            /* Shrink the array, but never drop below CC_ARRAY_COUNT_INCREMENT */
+            while ((in_new_count + CCI_ARRAY_COUNT_INCREMENT) < new_max_count &&
+                   (new_max_count > CCI_ARRAY_COUNT_INCREMENT)) {
+                new_max_count -= CCI_ARRAY_COUNT_INCREMENT;
+            }
+        }
+    }
+
+    if (!err && io_array->max_count != new_max_count) {
+        cci_array_object_t *objects = io_array->objects;
+
+        if (!objects) {
+            objects = malloc (new_max_count * sizeof (*objects));
+        } else {
+            objects = realloc (objects, new_max_count * sizeof (*objects));
+        }
+        if (!objects) { err = cci_check_error (ccErrNoMem); }
+
+        if (!err) {
+            io_array->objects = objects;
+            io_array->max_count = new_max_count;
+        }
+    }
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_array_new (cci_array_t                *out_array,
+                        cci_array_object_release_t  in_array_object_release)
+{
+    cc_int32 err = ccNoError;
+    cci_array_t array = NULL;
+
+    if (!out_array) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        array = malloc (sizeof (*array));
+        if (array) {
+            *array = cci_array_initializer;
+            array->object_release = in_array_object_release;
+        } else {
+            err = cci_check_error (ccErrNoMem);
+        }
+    }
+
+    if (!err) {
+        *out_array = array;
+        array = NULL;
+    }
+
+    cci_array_release (array);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_array_release (cci_array_t io_array)
+{
+    cc_int32 err = ccNoError;
+
+    if (!err && io_array) {
+        cc_uint64 i;
+
+        if (io_array->object_release) {
+	    for (i = 0; i < io_array->count; i++) {
+		io_array->object_release (io_array->objects[i]);
+	    }
+	}
+        free (io_array->objects);
+        free (io_array);
+    }
+
+    return err;
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint64 cci_array_count (cci_array_t in_array)
+{
+    return in_array ? in_array->count : 0;
+}
+
+/* ------------------------------------------------------------------------ */
+
+cci_array_object_t cci_array_object_at_index (cci_array_t io_array,
+                                              cc_uint64   in_position)
+{
+    if (io_array && in_position < io_array->count) {
+        return io_array->objects[in_position];
+    } else {
+        if (!io_array) {
+            cci_debug_printf ("%s() got NULL array", __FUNCTION__);
+        } else {
+            cci_debug_printf ("%s() got bad index %lld (count = %lld)", __FUNCTION__,
+                              in_position, io_array->count);
+        }
+        return NULL;
+    }
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_array_insert (cci_array_t        io_array,
+                           cci_array_object_t in_object,
+                           cc_uint64          in_position)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_array ) { err = cci_check_error (ccErrBadParam); }
+    if (!in_object) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        /* Don't try to insert past the end and don't overflow the array */
+        if (in_position > io_array->count || io_array->count == UINT64_MAX) {
+            err = cci_check_error (ccErrBadParam);
+        }
+    }
+
+    if (!err) {
+        err = cci_array_resize (io_array, io_array->count + 1);
+    }
+
+    if (!err) {
+        cc_uint64 move_count = io_array->count - in_position;
+
+        if (move_count > 0) {
+            memmove (&io_array->objects[in_position + 1], &io_array->objects[in_position],
+                     move_count * sizeof (*io_array->objects));
+        }
+
+        io_array->objects[in_position] = in_object;
+        io_array->count++;
+    }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_array_remove (cci_array_t io_array,
+                           cc_uint64   in_position)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_array) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err && in_position >= io_array->count) {
+        err = cci_check_error (ccErrBadParam);
+    }
+
+    if (!err) {
+        cc_uint64 move_count = io_array->count - in_position - 1;
+        cci_array_object_t object = io_array->objects[in_position];
+
+        if (move_count > 0) {
+            memmove (&io_array->objects[in_position], &io_array->objects[in_position + 1],
+                     move_count * sizeof (*io_array->objects));
+        }
+        io_array->count--;
+
+        if (io_array->object_release) { io_array->object_release (object); }
+
+        cci_array_resize (io_array, io_array->count);
+     }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_array_move (cci_array_t  io_array,
+                         cc_uint64    in_position,
+                         cc_uint64    in_new_position,
+                         cc_uint64   *out_real_new_position)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_array             ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_real_new_position) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err && in_position >= io_array->count) {
+        err = cci_check_error (ccErrBadParam);
+    }
+
+    if (!err && in_new_position > io_array->count) {
+        err = cci_check_error (ccErrBadParam);
+    }
+    if (!err) {
+        cc_uint64 move_from = 0;
+        cc_uint64 move_to = 0;
+        cc_uint64 move_count = 0;
+        cc_uint64 real_new_position = 0;
+
+        if (in_position < in_new_position) {
+            /* shift right, making an empty space so the
+             * actual new position is one less in_new_position */
+            move_from = in_position + 1;
+            move_to = in_position;
+            move_count = in_new_position - in_position - 1;
+            real_new_position = in_new_position - 1;
+
+        } else if (in_position > in_new_position) {
+            /* shift left */
+            move_from = in_new_position;
+            move_to = in_new_position + 1;
+            move_count = in_position - in_new_position;
+            real_new_position = in_new_position;
+
+        } else {
+            real_new_position = in_new_position;
+        }
+
+        if (move_count > 0) {
+            cci_array_object_t object = io_array->objects[in_position];
+
+            memmove (&io_array->objects[move_to], &io_array->objects[move_from],
+                     move_count * sizeof (*io_array->objects));
+            io_array->objects[real_new_position] = object;
+        }
+
+        *out_real_new_position = real_new_position;
+    }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_array_push_front (cci_array_t io_array,
+                               cc_uint64   in_position)
+{
+    cc_uint64 real_new_position = 0;
+    return cci_array_move (io_array, in_position, 0, &real_new_position);
+}
diff --git a/src/ccapi/common/cci_array_internal.h b/src/ccapi/common/cci_array_internal.h
new file mode 100644
index 000000000000..364de7670543
--- /dev/null
+++ b/src/ccapi/common/cci_array_internal.h
@@ -0,0 +1,65 @@
+/* ccapi/common/cci_array_internal.h */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_ARRAY_INTERNAL_H
+#define CCI_ARRAY_INTERNAL_H
+
+#include "cci_types.h"
+
+struct cci_array_object_d;
+typedef struct cci_array_object_d *cci_array_object_t;
+
+typedef cc_int32 (*cci_array_object_release_t) (cci_array_object_t);
+
+struct cci_array_d;
+typedef struct cci_array_d *cci_array_t;
+
+cc_int32 cci_array_new (cci_array_t                *out_array,
+                        cci_array_object_release_t  in_array_object_release);
+
+cc_int32 cci_array_release (cci_array_t io_array);
+
+cc_uint64 cci_array_count (cci_array_t in_array);
+
+cci_array_object_t cci_array_object_at_index (cci_array_t io_array,
+                                              cc_uint64   in_position);
+
+cc_int32 cci_array_insert (cci_array_t        io_array,
+                           cci_array_object_t in_object,
+                           cc_uint64          in_position);
+
+cc_int32 cci_array_remove (cci_array_t io_array,
+                           cc_uint64   in_position);
+
+cc_int32 cci_array_move (cci_array_t  io_array,
+                         cc_uint64    in_position,
+                         cc_uint64    in_new_position,
+                         cc_uint64   *out_real_new_position);
+
+cc_int32 cci_array_push_front (cci_array_t io_array,
+                               cc_uint64   in_position);
+
+
+#endif /* CCI_ARRAY_INTERNAL_H */
diff --git a/src/ccapi/common/cci_common.h b/src/ccapi/common/cci_common.h
new file mode 100644
index 000000000000..ec9d10b9409d
--- /dev/null
+++ b/src/ccapi/common/cci_common.h
@@ -0,0 +1,56 @@
+/* ccapi/common/cci_common.h */
+/*
+ * Copyright 2006, 2007 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_COMMON_H
+#define CCI_COMMON_H
+
+#include <CredentialsCache.h>
+
+#include <sys/types.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <com_err.h>
+
+#if TARGET_OS_MAC
+#include <unistd.h>
+#define VECTOR_FUNCTIONS_INITIALIZER ,NULL
+#else
+#include "win-mac.h"
+#define VECTOR_FUNCTIONS_INITIALIZER
+#endif
+
+#define k_cci_context_initial_ccache_name "Initial default ccache"
+
+#include "cci_cred_union.h"
+#include "cci_debugging.h"
+#include "cci_identifier.h"
+#include "cci_message.h"
+
+#include "k5-ipc_stream.h"
+
+#endif /* CCI_COMMON_H */
diff --git a/src/ccapi/common/cci_cred_union.c b/src/ccapi/common/cci_cred_union.c
new file mode 100644
index 000000000000..4c8981610771
--- /dev/null
+++ b/src/ccapi/common/cci_cred_union.c
@@ -0,0 +1,1114 @@
+/* ccapi/common/cci_cred_union.c */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include "cci_common.h"
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_credentials_v4_release (cc_credentials_v4_t *io_v4creds)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_v4creds) { err = ccErrBadParam; }
+
+    if (!err) {
+        memset (io_v4creds, 0, sizeof (*io_v4creds));
+        free (io_v4creds);
+    }
+
+    return err;
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_credentials_v4_read (cc_credentials_v4_t **out_v4creds,
+                                          k5_ipc_stream          io_stream)
+{
+    cc_int32 err = ccNoError;
+    cc_credentials_v4_t *v4creds = NULL;
+
+    if (!io_stream  ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_v4creds) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        v4creds = malloc (sizeof (*v4creds));
+        if (!v4creds) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &v4creds->version);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read (io_stream, v4creds->principal, cc_v4_name_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read (io_stream, v4creds->principal_instance, cc_v4_instance_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read (io_stream, v4creds->service, cc_v4_name_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read (io_stream, v4creds->service_instance, cc_v4_instance_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read (io_stream, v4creds->realm, cc_v4_realm_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read (io_stream, v4creds->session_key, cc_v4_key_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_int32 (io_stream, &v4creds->kvno);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_int32 (io_stream, &v4creds->string_to_key_type);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_time (io_stream, &v4creds->issue_date);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_int32 (io_stream, &v4creds->lifetime);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &v4creds->address);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_int32 (io_stream, &v4creds->ticket_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read (io_stream, v4creds->ticket, cc_v4_ticket_size);
+    }
+
+    if (!err) {
+        *out_v4creds = v4creds;
+        v4creds = NULL;
+    }
+
+    free (v4creds);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_credentials_v4_write (cc_credentials_v4_t *in_v4creds,
+                                           k5_ipc_stream         io_stream)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_stream ) { err = cci_check_error (ccErrBadParam); }
+    if (!in_v4creds) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_uint32 (io_stream, in_v4creds->version);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write (io_stream, in_v4creds->principal, cc_v4_name_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write (io_stream, in_v4creds->principal_instance, cc_v4_instance_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write (io_stream, in_v4creds->service, cc_v4_name_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write (io_stream, in_v4creds->service_instance, cc_v4_instance_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write (io_stream, in_v4creds->realm, cc_v4_realm_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write (io_stream, in_v4creds->session_key, cc_v4_key_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_int32 (io_stream, in_v4creds->kvno);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_int32 (io_stream, in_v4creds->string_to_key_type);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_time (io_stream, in_v4creds->issue_date);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_int32 (io_stream, in_v4creds->lifetime);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_uint32 (io_stream, in_v4creds->address);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_int32 (io_stream, in_v4creds->ticket_size);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write (io_stream, in_v4creds->ticket, cc_v4_ticket_size);
+    }
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_contents_release (cc_data *io_ccdata)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_ccdata && io_ccdata->data) { err = ccErrBadParam; }
+
+    if (!err) {
+        if (io_ccdata->length) {
+            memset (io_ccdata->data, 0, io_ccdata->length);
+        }
+        free (io_ccdata->data);
+    }
+
+    return err;
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_release (cc_data *io_ccdata)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_ccdata) { err = ccErrBadParam; }
+
+    if (!err) {
+        cci_cc_data_contents_release (io_ccdata);
+        free (io_ccdata);
+    }
+
+    return err;
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_read (cc_data      *io_ccdata,
+                                   k5_ipc_stream io_stream)
+{
+    cc_int32 err = ccNoError;
+    cc_uint32 type = 0;
+    cc_uint32 length = 0;
+    char *data = NULL;
+
+    if (!io_stream) { err = cci_check_error (ccErrBadParam); }
+    if (!io_ccdata) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &type);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &length);
+    }
+
+    if (!err && length > 0) {
+        data = malloc (length);
+        if (!data) { err = cci_check_error (ccErrNoMem); }
+
+        if (!err) {
+            err = krb5int_ipc_stream_read (io_stream, data, length);
+        }
+    }
+
+    if (!err) {
+        io_ccdata->type = type;
+        io_ccdata->length = length;
+        io_ccdata->data = data;
+        data = NULL;
+    }
+
+    free (data);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_write (cc_data      *in_ccdata,
+                                    k5_ipc_stream io_stream)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_stream) { err = cci_check_error (ccErrBadParam); }
+    if (!in_ccdata) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_uint32 (io_stream, in_ccdata->type);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_uint32 (io_stream, in_ccdata->length);
+    }
+
+    if (!err && in_ccdata->length > 0) {
+        err = krb5int_ipc_stream_write (io_stream, in_ccdata->data, in_ccdata->length);
+    }
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_array_release (cc_data **io_ccdata_array)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_ccdata_array) { err = ccErrBadParam; }
+
+    if (!err) {
+        cc_uint32 i;
+
+        for (i = 0; io_ccdata_array && io_ccdata_array[i]; i++) {
+            cci_cc_data_release (io_ccdata_array[i]);
+        }
+        free (io_ccdata_array);
+    }
+
+    return err;
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_array_read (cc_data      ***io_ccdata_array,
+                                         k5_ipc_stream    io_stream)
+{
+    cc_int32 err = ccNoError;
+    cc_uint32 count = 0;
+    cc_data **array = NULL;
+    cc_uint32 i;
+
+    if (!io_stream      ) { err = cci_check_error (ccErrBadParam); }
+    if (!io_ccdata_array) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &count);
+    }
+
+    if (!err && count > 0) {
+        array = malloc ((count + 1) * sizeof (*array));
+        if (array) {
+            for (i = 0; i <= count; i++) { array[i] = NULL; }
+        } else {
+            err = cci_check_error (ccErrNoMem);
+        }
+    }
+
+    if (!err) {
+        for (i = 0; !err && i < count; i++) {
+            array[i] = malloc (sizeof (cc_data));
+            if (!array[i]) { err = cci_check_error (ccErrNoMem); }
+
+            if (!err) {
+                err = cci_cc_data_read (array[i], io_stream);
+            }
+        }
+    }
+
+    if (!err) {
+        *io_ccdata_array = array;
+        array = NULL;
+    }
+
+    cci_cc_data_array_release (array);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_array_write (cc_data      **in_ccdata_array,
+                                          k5_ipc_stream   io_stream)
+{
+    cc_int32 err = ccNoError;
+    cc_uint32 count = 0;
+
+    if (!io_stream) { err = cci_check_error (ccErrBadParam); }
+    /* in_ccdata_array may be NULL */
+
+    if (!err) {
+        for (count = 0; in_ccdata_array && in_ccdata_array[count]; count++);
+
+        err = krb5int_ipc_stream_write_uint32 (io_stream, count);
+    }
+
+    if (!err) {
+        cc_uint32 i;
+
+        for (i = 0; !err && i < count; i++) {
+            err = cci_cc_data_write (in_ccdata_array[i], io_stream);
+        }
+    }
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+cc_credentials_v5_t cci_credentials_v5_initializer = {
+    NULL,
+    NULL,
+    { 0, 0, NULL },
+    0, 0, 0, 0, 0, 0,
+    NULL,
+    { 0, 0, NULL },
+    { 0, 0, NULL },
+    NULL
+};
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_credentials_v5_release (cc_credentials_v5_t *io_v5creds)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_v5creds) { err = ccErrBadParam; }
+
+    if (!err) {
+        free (io_v5creds->client);
+        free (io_v5creds->server);
+        cci_cc_data_contents_release (&io_v5creds->keyblock);
+        cci_cc_data_array_release (io_v5creds->addresses);
+        cci_cc_data_contents_release (&io_v5creds->ticket);
+        cci_cc_data_contents_release (&io_v5creds->second_ticket);
+        cci_cc_data_array_release (io_v5creds->authdata);
+        free (io_v5creds);
+    }
+
+    return err;
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_credentials_v5_read (cc_credentials_v5_t **out_v5creds,
+                                          k5_ipc_stream          io_stream)
+{
+    cc_int32 err = ccNoError;
+    cc_credentials_v5_t *v5creds = NULL;
+
+    if (!io_stream  ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_v5creds) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        v5creds = malloc (sizeof (*v5creds));
+        if (v5creds) {
+            *v5creds = cci_credentials_v5_initializer;
+        } else {
+            err = cci_check_error (ccErrNoMem);
+        }
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_string (io_stream, &v5creds->client);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_string (io_stream, &v5creds->server);
+    }
+
+    if (!err) {
+        err = cci_cc_data_read (&v5creds->keyblock, io_stream);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_time (io_stream, &v5creds->authtime);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_time (io_stream, &v5creds->starttime);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_time (io_stream, &v5creds->endtime);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_time (io_stream, &v5creds->renew_till);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &v5creds->is_skey);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &v5creds->ticket_flags);
+    }
+
+    if (!err) {
+        err = cci_cc_data_array_read (&v5creds->addresses, io_stream);
+    }
+
+    if (!err) {
+        err = cci_cc_data_read (&v5creds->ticket, io_stream);
+    }
+
+    if (!err) {
+        err = cci_cc_data_read (&v5creds->second_ticket, io_stream);
+    }
+
+    if (!err) {
+        err = cci_cc_data_array_read (&v5creds->authdata, io_stream);
+    }
+
+    if (!err) {
+        *out_v5creds = v5creds;
+        v5creds = NULL;
+    }
+
+    cci_credentials_v5_release (v5creds);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_credentials_v5_write (cc_credentials_v5_t *in_v5creds,
+                                           k5_ipc_stream         io_stream)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_stream ) { err = cci_check_error (ccErrBadParam); }
+    if (!in_v5creds) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_string (io_stream, in_v5creds->client);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_string (io_stream, in_v5creds->server);
+    }
+
+    if (!err) {
+        err = cci_cc_data_write (&in_v5creds->keyblock, io_stream);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_time (io_stream, in_v5creds->authtime);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_time (io_stream, in_v5creds->starttime);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_time (io_stream, in_v5creds->endtime);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_time (io_stream, in_v5creds->renew_till);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_uint32 (io_stream, in_v5creds->is_skey);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_uint32 (io_stream, in_v5creds->ticket_flags);
+    }
+
+    if (!err) {
+        err = cci_cc_data_array_write (in_v5creds->addresses, io_stream);
+    }
+
+    if (!err) {
+        err = cci_cc_data_write (&in_v5creds->ticket, io_stream);
+    }
+
+    if (!err) {
+        err = cci_cc_data_write (&in_v5creds->second_ticket, io_stream);
+    }
+
+    if (!err) {
+        err = cci_cc_data_array_write (in_v5creds->authdata, io_stream);
+    }
+
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_credentials_union_release (cc_credentials_union *io_cred_union)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_cred_union) { err = ccErrBadParam; }
+
+    if (!err) {
+        if (io_cred_union->version == cc_credentials_v4) {
+            cci_credentials_v4_release (io_cred_union->credentials.credentials_v4);
+        } else if (io_cred_union->version == cc_credentials_v5) {
+            cci_credentials_v5_release (io_cred_union->credentials.credentials_v5);
+        }
+        free (io_cred_union);
+    }
+
+    return err;
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_credentials_union_read (cc_credentials_union **out_credentials_union,
+                                      k5_ipc_stream           io_stream)
+{
+    cc_int32 err = ccNoError;
+    cc_credentials_union *credentials_union = NULL;
+
+    if (!io_stream            ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_credentials_union) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        credentials_union = calloc (1, sizeof (*credentials_union));
+        if (!credentials_union) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &credentials_union->version);
+    }
+
+    if (!err) {
+        if (credentials_union->version == cc_credentials_v4) {
+            err = cci_credentials_v4_read (&credentials_union->credentials.credentials_v4,
+                                           io_stream);
+
+        } else if (credentials_union->version == cc_credentials_v5) {
+            err = cci_credentials_v5_read (&credentials_union->credentials.credentials_v5,
+                                           io_stream);
+
+
+        } else {
+            err = ccErrBadCredentialsVersion;
+        }
+    }
+
+    if (!err) {
+        *out_credentials_union = credentials_union;
+        credentials_union = NULL;
+    }
+
+    if (credentials_union) { cci_credentials_union_release (credentials_union); }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_credentials_union_write (const cc_credentials_union *in_credentials_union,
+                                       k5_ipc_stream                io_stream)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_stream           ) { err = cci_check_error (ccErrBadParam); }
+    if (!in_credentials_union) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_uint32 (io_stream, in_credentials_union->version);
+    }
+
+    if (!err) {
+        if (in_credentials_union->version == cc_credentials_v4) {
+            err = cci_credentials_v4_write (in_credentials_union->credentials.credentials_v4,
+                                            io_stream);
+
+        } else if (in_credentials_union->version == cc_credentials_v5) {
+            err = cci_credentials_v5_write (in_credentials_union->credentials.credentials_v5,
+                                            io_stream);
+
+        } else {
+            err = ccErrBadCredentialsVersion;
+        }
+    }
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#pragma mark -- CCAPI v2 Compat --
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+cc_credentials_v5_compat cci_credentials_v5_compat_initializer = {
+    NULL,
+    NULL,
+    { 0, 0, NULL },
+    0, 0, 0, 0, 0, 0,
+    NULL,
+    { 0, 0, NULL },
+    { 0, 0, NULL },
+    NULL
+};
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_cred_union_release (cred_union *io_cred_union)
+{
+    cc_int32 err = ccNoError;
+
+    if (!io_cred_union) { err = ccErrBadParam; }
+
+    if (!err) {
+        if (io_cred_union->cred_type == CC_CRED_V4) {
+            memset (io_cred_union->cred.pV4Cred, 0, sizeof (cc_credentials_v4_compat));
+            free (io_cred_union->cred.pV4Cred);
+
+        } else if (io_cred_union->cred_type == CC_CRED_V5) {
+            free (io_cred_union->cred.pV5Cred->client);
+            free (io_cred_union->cred.pV5Cred->server);
+            cci_cc_data_contents_release (&io_cred_union->cred.pV5Cred->keyblock);
+            cci_cc_data_array_release (io_cred_union->cred.pV5Cred->addresses);
+            cci_cc_data_contents_release (&io_cred_union->cred.pV5Cred->ticket);
+            cci_cc_data_contents_release (&io_cred_union->cred.pV5Cred->second_ticket);
+            cci_cc_data_array_release (io_cred_union->cred.pV5Cred->authdata);
+            free (io_cred_union->cred.pV5Cred);
+        }
+        free (io_cred_union);
+    }
+
+    return err;
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_copy_contents (cc_data      *io_ccdata,
+                                            cc_data      *in_ccdata)
+{
+    cc_int32 err = ccNoError;
+    char *data = NULL;
+
+    if (!io_ccdata) { err = cci_check_error (ccErrBadParam); }
+    if (!in_ccdata) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err && in_ccdata->length > 0) {
+        data = malloc (in_ccdata->length);
+        if (data) {
+            memcpy (data, in_ccdata->data, in_ccdata->length);
+        } else {
+            err = cci_check_error (ccErrNoMem);
+        }
+    }
+
+    if (!err) {
+        io_ccdata->type = in_ccdata->type;
+        io_ccdata->length = in_ccdata->length;
+        io_ccdata->data = data;
+        data = NULL;
+    }
+
+    free (data);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_uint32 cci_cc_data_array_copy (cc_data      ***io_ccdata_array,
+                                         cc_data       **in_ccdata_array)
+{
+    cc_int32 err = ccNoError;
+    cc_uint32 count = 0;
+    cc_data **array = NULL;
+    cc_uint32 i;
+
+    if (!io_ccdata_array) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        for (count = 0; in_ccdata_array && in_ccdata_array[count]; count++);
+    }
+
+    if (!err && count > 0) {
+        array = malloc ((count + 1) * sizeof (*array));
+        if (array) {
+            for (i = 0; i <= count; i++) { array[i] = NULL; }
+        } else {
+            err = cci_check_error (ccErrNoMem);
+        }
+    }
+
+    if (!err) {
+        for (i = 0; !err && i < count; i++) {
+            array[i] = malloc (sizeof (cc_data));
+            if (!array[i]) { err = cci_check_error (ccErrNoMem); }
+
+            if (!err) {
+                err = cci_cc_data_copy_contents (array[i], in_ccdata_array[i]);
+            }
+        }
+    }
+
+    if (!err) {
+        *io_ccdata_array = array;
+        array = NULL;
+    }
+
+    cci_cc_data_array_release (array);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_credentials_union_to_cred_union (const cc_credentials_union  *in_credentials_union,
+                                               cred_union                 **out_cred_union)
+{
+    cc_int32 err = ccNoError;
+    cred_union *compat_cred_union = NULL;
+
+    if (!in_credentials_union) { err = cci_check_error (ccErrBadParam); }
+    if (!out_cred_union      ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        compat_cred_union = calloc (1, sizeof (*compat_cred_union));
+        if (!compat_cred_union) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        if (in_credentials_union->version == cc_credentials_v4) {
+            cc_credentials_v4_compat *compat_v4creds = NULL;
+
+            compat_v4creds = malloc (sizeof (*compat_v4creds));
+            if (!compat_v4creds) { err = cci_check_error (ccErrNoMem); }
+
+            if (!err) {
+                cc_credentials_v4_t *v4creds = in_credentials_union->credentials.credentials_v4;
+
+                compat_cred_union->cred_type = CC_CRED_V4;
+                compat_cred_union->cred.pV4Cred = compat_v4creds;
+
+                compat_v4creds->kversion = v4creds->version;
+                strncpy (compat_v4creds->principal,          v4creds->principal,          KRB_NAME_SZ+1);
+                strncpy (compat_v4creds->principal_instance, v4creds->principal_instance, KRB_INSTANCE_SZ+1);
+                strncpy (compat_v4creds->service,            v4creds->service,            KRB_NAME_SZ+1);
+                strncpy (compat_v4creds->service_instance,   v4creds->service_instance,   KRB_INSTANCE_SZ+1);
+                strncpy (compat_v4creds->realm,              v4creds->realm,              KRB_REALM_SZ+1);
+                memcpy (compat_v4creds->session_key, v4creds->session_key, 8);
+                compat_v4creds->kvno       = v4creds->kvno;
+                compat_v4creds->str_to_key = v4creds->string_to_key_type;
+                compat_v4creds->issue_date = v4creds->issue_date;
+                compat_v4creds->lifetime   = v4creds->lifetime;
+                compat_v4creds->address    = v4creds->address;
+                compat_v4creds->ticket_sz  = v4creds->ticket_size;
+                memcpy (compat_v4creds->ticket, v4creds->ticket, MAX_V4_CRED_LEN);
+                compat_v4creds->oops = 0;
+            }
+
+        } else if (in_credentials_union->version == cc_credentials_v5) {
+            cc_credentials_v5_t *v5creds = in_credentials_union->credentials.credentials_v5;
+            cc_credentials_v5_compat *compat_v5creds = NULL;
+
+            compat_v5creds = malloc (sizeof (*compat_v5creds));
+            if (compat_v5creds) {
+                *compat_v5creds = cci_credentials_v5_compat_initializer;
+            } else {
+                err = cci_check_error (ccErrNoMem);
+            }
+
+            if (!err) {
+                if (!v5creds->client) {
+                    err = cci_check_error (ccErrBadParam);
+                } else {
+                    compat_v5creds->client = strdup (v5creds->client);
+                    if (!compat_v5creds->client) { err = cci_check_error (ccErrNoMem); }
+                }
+            }
+
+            if (!err) {
+                if (!v5creds->server) {
+                    err = cci_check_error (ccErrBadParam);
+                } else {
+                    compat_v5creds->server = strdup (v5creds->server);
+                    if (!compat_v5creds->server) { err = cci_check_error (ccErrNoMem); }
+                }
+            }
+
+            if (!err) {
+                err = cci_cc_data_copy_contents (&compat_v5creds->keyblock, &v5creds->keyblock);
+            }
+
+            if (!err) {
+                err = cci_cc_data_array_copy (&compat_v5creds->addresses, v5creds->addresses);
+            }
+
+            if (!err) {
+                err = cci_cc_data_copy_contents (&compat_v5creds->ticket, &v5creds->ticket);
+            }
+
+            if (!err) {
+                err = cci_cc_data_copy_contents (&compat_v5creds->second_ticket, &v5creds->second_ticket);
+            }
+
+            if (!err) {
+                err = cci_cc_data_array_copy (&compat_v5creds->authdata, v5creds->authdata);
+            }
+
+            if (!err) {
+                compat_cred_union->cred_type = CC_CRED_V5;
+                compat_cred_union->cred.pV5Cred = compat_v5creds;
+
+                compat_v5creds->keyblock      = v5creds->keyblock;
+                compat_v5creds->authtime      = v5creds->authtime;
+                compat_v5creds->starttime     = v5creds->starttime;
+                compat_v5creds->endtime       = v5creds->endtime;
+                compat_v5creds->renew_till    = v5creds->renew_till;
+                compat_v5creds->is_skey       = v5creds->is_skey;
+                compat_v5creds->ticket_flags  = v5creds->ticket_flags;
+            }
+        } else {
+            err = cci_check_error (ccErrBadCredentialsVersion);
+        }
+    }
+
+    if (!err) {
+        *out_cred_union = compat_cred_union;
+        compat_cred_union = NULL;
+    }
+
+    if (compat_cred_union) { cci_cred_union_release (compat_cred_union); }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_cred_union_to_credentials_union (const cred_union      *in_cred_union,
+                                               cc_credentials_union **out_credentials_union)
+{
+    cc_int32 err = ccNoError;
+    cc_credentials_union *creds_union = NULL;
+
+    if (!in_cred_union        ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_credentials_union) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        creds_union = calloc (1, sizeof (*creds_union));
+        if (!creds_union) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        if (in_cred_union->cred_type == CC_CRED_V4) {
+            cc_credentials_v4_compat *compat_v4creds = in_cred_union->cred.pV4Cred;
+            cc_credentials_v4_t *v4creds = NULL;
+
+            if (!err) {
+                v4creds = malloc (sizeof (*v4creds));
+                if (!v4creds) { err = cci_check_error (ccErrNoMem); }
+            }
+
+            if (!err) {
+                creds_union->version = cc_credentials_v4;
+                creds_union->credentials.credentials_v4 = v4creds;
+
+                v4creds->version = compat_v4creds->kversion;
+                strncpy (v4creds->principal,          compat_v4creds->principal,          KRB_NAME_SZ);
+                strncpy (v4creds->principal_instance, compat_v4creds->principal_instance, KRB_INSTANCE_SZ);
+                strncpy (v4creds->service,            compat_v4creds->service,            KRB_NAME_SZ);
+                strncpy (v4creds->service_instance,   compat_v4creds->service_instance,   KRB_INSTANCE_SZ);
+                strncpy (v4creds->realm,              compat_v4creds->realm,              KRB_REALM_SZ);
+                memcpy (v4creds->session_key, compat_v4creds->session_key, 8);
+                v4creds->kvno               = compat_v4creds->kvno;
+                v4creds->string_to_key_type = compat_v4creds->str_to_key;
+                v4creds->issue_date         = compat_v4creds->issue_date;
+                v4creds->lifetime           = compat_v4creds->lifetime;
+                v4creds->address            = compat_v4creds->address;
+                v4creds->ticket_size        = compat_v4creds->ticket_sz;
+                memcpy (v4creds->ticket, compat_v4creds->ticket, MAX_V4_CRED_LEN);
+            }
+
+        } else if (in_cred_union->cred_type == CC_CRED_V5) {
+            cc_credentials_v5_compat *compat_v5creds = in_cred_union->cred.pV5Cred;
+            cc_credentials_v5_t *v5creds = NULL;
+
+            if (!err) {
+                v5creds = malloc (sizeof (*v5creds));
+                if (v5creds) {
+                    *v5creds = cci_credentials_v5_initializer;
+                } else {
+                    err = cci_check_error (ccErrNoMem);
+                }
+            }
+
+            if (!err) {
+                if (!compat_v5creds->client) {
+                    err = cci_check_error (ccErrBadParam);
+                } else {
+                    v5creds->client = strdup (compat_v5creds->client);
+                    if (!v5creds->client) { err = cci_check_error (ccErrNoMem); }
+                }
+            }
+
+            if (!err) {
+                if (!compat_v5creds->server) {
+                    err = cci_check_error (ccErrBadParam);
+                } else {
+                    v5creds->server = strdup (compat_v5creds->server);
+                    if (!v5creds->server) { err = cci_check_error (ccErrNoMem); }
+                }
+            }
+
+            if (!err) {
+                err = cci_cc_data_copy_contents (&v5creds->keyblock, &compat_v5creds->keyblock);
+            }
+
+            if (!err) {
+                err = cci_cc_data_array_copy (&v5creds->addresses, compat_v5creds->addresses);
+            }
+
+            if (!err) {
+                err = cci_cc_data_copy_contents (&v5creds->ticket, &compat_v5creds->ticket);
+            }
+
+            if (!err) {
+                err = cci_cc_data_copy_contents (&v5creds->second_ticket, &compat_v5creds->second_ticket);
+            }
+
+            if (!err) {
+                err = cci_cc_data_array_copy (&v5creds->authdata, compat_v5creds->authdata);
+            }
+
+            if (!err) {
+                creds_union->version = cc_credentials_v5;
+                creds_union->credentials.credentials_v5 = v5creds;
+
+                v5creds->authtime      = compat_v5creds->authtime;
+                v5creds->starttime     = compat_v5creds->starttime;
+                v5creds->endtime       = compat_v5creds->endtime;
+                v5creds->renew_till    = compat_v5creds->renew_till;
+                v5creds->is_skey       = compat_v5creds->is_skey;
+                v5creds->ticket_flags  = compat_v5creds->ticket_flags;
+            }
+
+        } else {
+            err = cci_check_error (ccErrBadCredentialsVersion);
+        }
+    }
+
+    if (!err) {
+        *out_credentials_union = creds_union;
+        creds_union = NULL;
+    }
+
+    if (creds_union) { cci_credentials_union_release (creds_union); }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_cred_union_compare_to_credentials_union (const cred_union           *in_cred_union_compat,
+                                                       const cc_credentials_union *in_credentials_union,
+                                                       cc_uint32                  *out_equal)
+{
+    cc_int32 err = ccNoError;
+    cc_uint32 equal = 0;
+
+    if (!in_cred_union_compat) { err = cci_check_error (ccErrBadParam); }
+    if (!in_credentials_union) { err = cci_check_error (ccErrBadParam); }
+    if (!out_equal           ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        if (in_cred_union_compat->cred_type == CC_CRED_V4 &&
+            in_credentials_union->version == cc_credentials_v4) {
+            cc_credentials_v4_compat *old_creds_v4 = in_cred_union_compat->cred.pV4Cred;
+            cc_credentials_v4_t *new_creds_v4 = in_credentials_union->credentials.credentials_v4;
+
+            if (old_creds_v4 && new_creds_v4 &&
+                !strcmp (old_creds_v4->principal,
+                         new_creds_v4->principal) &&
+                !strcmp (old_creds_v4->principal_instance,
+                         new_creds_v4->principal_instance) &&
+                !strcmp (old_creds_v4->service,
+                         new_creds_v4->service) &&
+                !strcmp (old_creds_v4->service_instance,
+                         new_creds_v4->service_instance) &&
+                !strcmp (old_creds_v4->realm, new_creds_v4->realm) &&
+                (old_creds_v4->issue_date == (long) new_creds_v4->issue_date)) {
+                equal = 1;
+            }
+
+        } else if (in_cred_union_compat->cred_type == CC_CRED_V5 &&
+                   in_credentials_union->version == cc_credentials_v5) {
+            cc_credentials_v5_compat *old_creds_v5 = in_cred_union_compat->cred.pV5Cred;
+            cc_credentials_v5_t *new_creds_v5 = in_credentials_union->credentials.credentials_v5;
+
+            /* Really should use krb5_parse_name and krb5_principal_compare */
+            if (old_creds_v5 && new_creds_v5 &&
+                !strcmp (old_creds_v5->client, new_creds_v5->client) &&
+                !strcmp (old_creds_v5->server, new_creds_v5->server) &&
+                (old_creds_v5->starttime == new_creds_v5->starttime)) {
+                equal = 1;
+            }
+        }
+    }
+
+    if (!err) {
+        *out_equal = equal;
+    }
+
+    return cci_check_error (err);
+}
diff --git a/src/ccapi/common/cci_cred_union.h b/src/ccapi/common/cci_cred_union.h
new file mode 100644
index 000000000000..2e40476caa52
--- /dev/null
+++ b/src/ccapi/common/cci_cred_union.h
@@ -0,0 +1,52 @@
+/* ccapi/common/cci_cred_union.h */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_CRED_UNION_H
+#define CCI_CRED_UNION_H
+
+#include "cci_types.h"
+#include <CredentialsCache2.h>
+
+cc_uint32 cci_credentials_union_release (cc_credentials_union *io_credentials);
+
+cc_uint32 cci_credentials_union_read (cc_credentials_union **out_credentials_union,
+                                      k5_ipc_stream           io_stream);
+
+cc_uint32 cci_credentials_union_write (const cc_credentials_union *in_credentials_union,
+                                       k5_ipc_stream                io_stream);
+
+cc_uint32 cci_cred_union_release (cred_union *io_cred_union);
+
+cc_uint32 cci_credentials_union_to_cred_union (const cc_credentials_union  *in_credentials_union,
+                                               cred_union                 **out_cred_union);
+
+cc_uint32 cci_cred_union_to_credentials_union (const cred_union      *in_cred_union,
+                                               cc_credentials_union **out_credentials_union);
+
+cc_uint32 cci_cred_union_compare_to_credentials_union (const cred_union           *in_cred_union_compat,
+                                                       const cc_credentials_union *in_credentials_union,
+                                                       cc_uint32                  *out_equal);
+
+#endif /* CCI_CRED_UNION_H */
diff --git a/src/ccapi/common/cci_debugging.c b/src/ccapi/common/cci_debugging.c
new file mode 100644
index 000000000000..42d8a7726281
--- /dev/null
+++ b/src/ccapi/common/cci_debugging.c
@@ -0,0 +1,54 @@
+/* ccapi/common/cci_debugging.c */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include "cci_common.h"
+#include "cci_os_debugging.h"
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 _cci_check_error (cc_int32    in_error,
+                           const char *in_function,
+                           const char *in_file,
+                           int         in_line)
+{
+    /* Do not log for flow control errors or when there is no error at all */
+    if (in_error != ccNoError && in_error != ccIteratorEnd) {
+        cci_debug_printf ("%s() got %d at %s: %d", in_function,
+                          in_error, in_file, in_line);
+    }
+
+    return in_error;
+}
+
+/* ------------------------------------------------------------------------ */
+
+void cci_debug_printf (const char *in_format, ...)
+{
+    va_list args;
+
+    va_start (args, in_format);
+    cci_os_debug_vprintf (in_format, args);
+    va_end (args);
+}
diff --git a/src/ccapi/common/cci_debugging.h b/src/ccapi/common/cci_debugging.h
new file mode 100644
index 000000000000..64413e2348ed
--- /dev/null
+++ b/src/ccapi/common/cci_debugging.h
@@ -0,0 +1,43 @@
+/* ccapi/common/cci_debugging.h */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_DEBUGGING_H
+#define CCI_DEBUGGING_H
+
+#include "cci_types.h"
+
+cc_int32 _cci_check_error (cc_int32    in_err,
+                           const char *in_function,
+                           const char *in_file,
+                           int         in_line);
+#define cci_check_error(err) _cci_check_error(err, __FUNCTION__, __FILE__, __LINE__)
+
+void cci_debug_printf (const char *in_format, ...)
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
+__attribute__ ((__format__ (__printf__, 1, 2)))
+#endif
+;
+
+#endif /* CCI_DEBUGGING_H */
diff --git a/src/ccapi/common/cci_identifier.c b/src/ccapi/common/cci_identifier.c
new file mode 100644
index 000000000000..a672c18f0de6
--- /dev/null
+++ b/src/ccapi/common/cci_identifier.c
@@ -0,0 +1,290 @@
+/* ccapi/common/cci_identifier.c */
+/*
+ * Copyright 2006, 2007 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include "cci_common.h"
+#include "cci_os_identifier.h"
+
+struct cci_identifier_d {
+    cci_uuid_string_t server_id;
+    cci_uuid_string_t object_id;
+};
+
+struct cci_identifier_d cci_identifier_initializer = { NULL, NULL };
+
+#define cci_uninitialized_server_id "NEEDS_SYNC"
+#define cci_uninitialized_object_id "NEEDS_SYNC"
+
+struct cci_identifier_d cci_identifier_uninitialized_d = {
+    cci_uninitialized_server_id,
+    cci_uninitialized_object_id
+};
+const cci_identifier_t cci_identifier_uninitialized = &cci_identifier_uninitialized_d;
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_identifier_new_uuid (cci_uuid_string_t *out_uuid_string)
+{
+    return cci_os_identifier_new_uuid (out_uuid_string);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static cc_int32 cci_identifier_alloc (cci_identifier_t *out_identifier,
+                                      cci_uuid_string_t in_server_id,
+                                      cci_uuid_string_t in_object_id)
+{
+    cc_int32 err = ccNoError;
+    cci_identifier_t identifier = NULL;
+
+    if (!out_identifier) { err = cci_check_error (ccErrBadParam); }
+    if (!in_server_id  ) { err = cci_check_error (ccErrBadParam); }
+    if (!in_object_id  ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        identifier = malloc (sizeof (*identifier));
+        if (identifier) {
+            *identifier = cci_identifier_initializer;
+        } else {
+            err = cci_check_error (ccErrNoMem);
+        }
+    }
+
+    if (!err) {
+        identifier->server_id = strdup (in_server_id);
+        if (!identifier->server_id) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        identifier->object_id = strdup (in_object_id);
+        if (!identifier->object_id) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        *out_identifier = identifier;
+        identifier = NULL; /* take ownership */
+    }
+
+    cci_identifier_release (identifier);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_identifier_new (cci_identifier_t *out_identifier,
+                             cci_uuid_string_t in_server_id)
+{
+    cc_int32 err = ccNoError;
+    cci_uuid_string_t object_id = NULL;
+
+    if (!out_identifier) { err = cci_check_error (ccErrBadParam); }
+    if (!in_server_id  ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = cci_os_identifier_new_uuid (&object_id);
+    }
+
+    if (!err) {
+        err = cci_identifier_alloc (out_identifier, in_server_id, object_id);
+    }
+
+    if (object_id) { free (object_id); }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_identifier_copy (cci_identifier_t *out_identifier,
+                              cci_identifier_t  in_identifier)
+{
+    cc_int32 err = ccNoError;
+
+    if (!out_identifier) { err = cci_check_error (ccErrBadParam); }
+    if (!in_identifier ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = cci_identifier_alloc (out_identifier,
+                                    in_identifier->server_id,
+                                    in_identifier->object_id);
+    }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_identifier_release (cci_identifier_t in_identifier)
+{
+    cc_int32 err = ccNoError;
+
+    /* Do not free the static "uninitialized" identifier */
+    if (!err && in_identifier && in_identifier != cci_identifier_uninitialized) {
+        free (in_identifier->server_id);
+        free (in_identifier->object_id);
+        free (in_identifier);
+    }
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_identifier_compare (cci_identifier_t  in_identifier,
+                                 cci_identifier_t  in_compare_to_identifier,
+                                 cc_uint32        *out_equal)
+{
+    cc_int32 err = ccNoError;
+
+    if (!in_identifier           ) { err = cci_check_error (ccErrBadParam); }
+    if (!in_compare_to_identifier) { err = cci_check_error (ccErrBadParam); }
+    if (!out_equal               ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        *out_equal = (!strcmp (in_identifier->object_id,
+                               in_compare_to_identifier->object_id) &&
+                      !strcmp (in_identifier->server_id,
+                               in_compare_to_identifier->server_id));
+    }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_identifier_is_for_server (cci_identifier_t  in_identifier,
+                                       cci_uuid_string_t in_server_id,
+                                       cc_uint32        *out_is_for_server)
+{
+    cc_int32 err = ccNoError;
+
+    if (!in_identifier    ) { err = cci_check_error (ccErrBadParam); }
+    if (!in_server_id     ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_is_for_server) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        *out_is_for_server = (!strcmp (in_identifier->server_id, in_server_id) ||
+                              !strcmp (in_identifier->server_id, cci_uninitialized_server_id));
+    }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_identifier_compare_server_id (cci_identifier_t  in_identifier,
+                                           cci_identifier_t  in_compare_to_identifier,
+                                           cc_uint32        *out_equal_server_id)
+{
+    cc_int32 err = ccNoError;
+
+    if (!in_identifier           ) { err = cci_check_error (ccErrBadParam); }
+    if (!in_compare_to_identifier) { err = cci_check_error (ccErrBadParam); }
+    if (!out_equal_server_id     ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        *out_equal_server_id = (!strcmp (in_identifier->server_id,
+                                         in_compare_to_identifier->server_id));
+    }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_identifier_is_initialized (cci_identifier_t  in_identifier,
+                                        cc_uint32        *out_is_initialized)
+{
+    cc_int32 err = ccNoError;
+
+    if (!in_identifier     ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_is_initialized) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        *out_is_initialized = (strcmp (in_identifier->server_id,
+                                       cci_uninitialized_server_id) != 0);
+    }
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_identifier_read (cci_identifier_t *out_identifier,
+                               k5_ipc_stream      io_stream)
+{
+    cc_int32 err = ccNoError;
+    cci_uuid_string_t server_id = NULL;
+    cci_uuid_string_t object_id = NULL;
+
+    if (!out_identifier) { err = cci_check_error (ccErrBadParam); }
+    if (!io_stream     ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_string (io_stream, &server_id);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_string (io_stream, &object_id);
+    }
+
+    if (!err) {
+        err = cci_identifier_alloc (out_identifier, server_id, object_id);
+    }
+
+    krb5int_ipc_stream_free_string (server_id);
+    krb5int_ipc_stream_free_string (object_id);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_uint32 cci_identifier_write (cci_identifier_t in_identifier,
+                                k5_ipc_stream     io_stream)
+{
+    cc_int32 err = ccNoError;
+
+    if (!in_identifier) { err = cci_check_error (ccErrBadParam); }
+    if (!io_stream    ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_string (io_stream, in_identifier->server_id);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_string (io_stream, in_identifier->object_id);
+    }
+
+    return cci_check_error (err);
+}
diff --git a/src/ccapi/common/cci_identifier.h b/src/ccapi/common/cci_identifier.h
new file mode 100644
index 000000000000..d5e1da4fdd58
--- /dev/null
+++ b/src/ccapi/common/cci_identifier.h
@@ -0,0 +1,64 @@
+/* ccapi/common/cci_identifier.h */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_IDENTIFIER_H
+#define CCI_IDENTIFIER_H
+
+#include "cci_types.h"
+
+extern const cci_identifier_t cci_identifier_uninitialized;
+
+cc_int32 cci_identifier_new_uuid (cci_uuid_string_t *out_uuid_string);
+
+cc_int32 cci_identifier_new (cci_identifier_t *out_identifier,
+                             cci_uuid_string_t in_server_id);
+
+cc_int32 cci_identifier_copy (cci_identifier_t *out_identifier,
+                              cci_identifier_t  in_handle);
+
+cc_int32 cci_identifier_release (cci_identifier_t in_identifier);
+
+cc_int32 cci_identifier_compare (cci_identifier_t  in_identifier,
+                                 cci_identifier_t  in_compare_to_identifier,
+                                 cc_uint32        *out_equal);
+
+cc_int32 cci_identifier_is_for_server (cci_identifier_t  in_identifier,
+                                       cci_uuid_string_t in_server_id,
+                                       cc_uint32        *out_is_for_server);
+
+cc_int32 cci_identifier_compare_server_id (cci_identifier_t  in_identifier,
+                                           cci_identifier_t  in_compare_to_identifier,
+                                           cc_uint32        *out_equal_server_id);
+
+cc_int32 cci_identifier_is_initialized (cci_identifier_t  in_identifier,
+                                        cc_uint32        *out_is_initialized);
+
+cc_uint32 cci_identifier_read (cci_identifier_t *out_identifier,
+                               k5_ipc_stream      io_stream);
+
+cc_uint32 cci_identifier_write (cci_identifier_t in_identifier,
+                                k5_ipc_stream     io_stream);
+
+#endif /* CCI_IDENTIFIER_H */
diff --git a/src/ccapi/common/cci_message.c b/src/ccapi/common/cci_message.c
new file mode 100644
index 000000000000..3f6107594e6e
--- /dev/null
+++ b/src/ccapi/common/cci_message.c
@@ -0,0 +1,213 @@
+/* ccapi/common/cci_message.c */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include "cci_common.h"
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_message_invalid_object_err (enum cci_msg_id_t in_request_name)
+{
+    cc_int32 err = ccNoError;
+
+    if (in_request_name > cci_context_first_msg_id &&
+        in_request_name < cci_context_last_msg_id) {
+        err = ccErrInvalidContext;
+
+    } else if (in_request_name > cci_ccache_first_msg_id &&
+               in_request_name < cci_ccache_last_msg_id) {
+        err = ccErrInvalidCCache;
+
+    } else if (in_request_name > cci_ccache_iterator_first_msg_id &&
+               in_request_name < cci_ccache_iterator_last_msg_id) {
+        err = ccErrInvalidCCacheIterator;
+
+    } else if (in_request_name > cci_credentials_iterator_first_msg_id &&
+               in_request_name < cci_credentials_iterator_last_msg_id) {
+        err = ccErrInvalidCredentialsIterator;
+
+    } else {
+        err = ccErrBadInternalMessage;
+    }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_message_new_request_header (k5_ipc_stream      *out_request,
+                                         enum cci_msg_id_t  in_request_name,
+                                         cci_identifier_t   in_identifier)
+{
+    cc_int32 err = ccNoError;
+    k5_ipc_stream request = NULL;
+
+    if (!out_request) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_new (&request);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_uint32 (request, in_request_name);
+    }
+
+    if (!err) {
+        err = cci_identifier_write (in_identifier, request);
+    }
+
+    if (!err) {
+        *out_request = request;
+        request = NULL;
+    }
+
+    krb5int_ipc_stream_release (request);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_message_read_request_header (k5_ipc_stream       in_request,
+                                          enum cci_msg_id_t *out_request_name,
+                                          cci_identifier_t  *out_identifier)
+{
+    cc_int32 err = ccNoError;
+    cc_uint32 request_name;
+    cci_identifier_t identifier = NULL;
+
+    if (!in_request      ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_request_name) { err = cci_check_error (ccErrBadParam); }
+    if (!out_identifier  ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_uint32 (in_request, &request_name);
+    }
+
+    if (!err) {
+        err = cci_identifier_read (&identifier, in_request);
+    }
+
+    if (!err) {
+        *out_request_name = request_name;
+        *out_identifier = identifier;
+        identifier = NULL; /* take ownership */
+    }
+
+    cci_identifier_release (identifier);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_message_new_reply_header (k5_ipc_stream     *out_reply,
+                                       cc_int32          in_error)
+{
+    cc_int32 err = ccNoError;
+    k5_ipc_stream reply = NULL;
+
+    if (!out_reply) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_new (&reply);
+    }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_int32 (reply, in_error);
+    }
+
+    if (!err) {
+        *out_reply = reply;
+        reply = NULL;
+    }
+
+    krb5int_ipc_stream_release (reply);
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_message_read_reply_header (k5_ipc_stream      in_reply,
+                                        cc_int32         *out_reply_error)
+{
+    cc_int32 err = ccNoError;
+    cc_int32 reply_err = 0;
+
+    if (!in_reply       ) { err = cci_check_error (ccErrBadParam); }
+    if (!out_reply_error) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_int32 (in_reply, &reply_err);
+    }
+
+    if (!err) {
+        *out_reply_error = reply_err;
+    }
+
+    return cci_check_error (err);
+}
+
+#ifdef TARGET_OS_MAC
+#pragma mark -
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+uint32_t krb5int_ipc_stream_read_time (k5_ipc_stream  io_stream,
+                                  cc_time_t     *out_time)
+{
+    int32_t err = 0;
+    int64_t t = 0;
+
+    if (!io_stream) { err = cci_check_error (ccErrBadParam); }
+    if (!out_time ) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_read_int64 (io_stream, &t);
+    }
+
+    if (!err) {
+        *out_time = t;
+    }
+
+    return cci_check_error (err);
+}
+
+/* ------------------------------------------------------------------------ */
+
+uint32_t krb5int_ipc_stream_write_time (k5_ipc_stream io_stream,
+					cc_time_t     in_time)
+{
+    int32_t err = 0;
+
+    if (!io_stream) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        err = krb5int_ipc_stream_write_int64 (io_stream, in_time);
+    }
+
+    return cci_check_error (err);
+}
diff --git a/src/ccapi/common/cci_message.h b/src/ccapi/common/cci_message.h
new file mode 100644
index 000000000000..6babb5606c7f
--- /dev/null
+++ b/src/ccapi/common/cci_message.h
@@ -0,0 +1,52 @@
+/* ccapi/common/cci_message.h */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_MESSAGE_H
+#define CCI_MESSAGE_H
+
+#include "cci_types.h"
+
+cc_int32 cci_message_invalid_object_err (enum cci_msg_id_t in_request_name);
+
+cc_int32 cci_message_new_request_header (k5_ipc_stream     *out_request,
+                                         enum cci_msg_id_t in_request_name,
+                                         cci_identifier_t  in_identifier);
+
+cc_int32 cci_message_read_request_header (k5_ipc_stream       in_request,
+                                          enum cci_msg_id_t *out_request_name,
+                                          cci_identifier_t  *out_identifier);
+
+cc_int32 cci_message_new_reply_header (k5_ipc_stream     *out_reply,
+                                       cc_int32          in_error);
+
+cc_int32 cci_message_read_reply_header (k5_ipc_stream in_reply,
+                                        cc_int32     *out_reply_error);
+
+uint32_t krb5int_ipc_stream_read_time (k5_ipc_stream  io_stream,
+				       cc_time_t     *out_time);
+uint32_t krb5int_ipc_stream_write_time (k5_ipc_stream io_stream,
+					cc_time_t     in_time);
+
+#endif /* CCI_MESSAGE_H */
diff --git a/src/ccapi/common/cci_os_debugging.h b/src/ccapi/common/cci_os_debugging.h
new file mode 100644
index 000000000000..c99c79a91490
--- /dev/null
+++ b/src/ccapi/common/cci_os_debugging.h
@@ -0,0 +1,34 @@
+/* ccapi/common/cci_os_debugging.h */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_OS_DEBUGGING_H
+#define CCI_OS_DEBUGGING_H
+
+#include "cci_types.h"
+#include <stdarg.h>
+
+void cci_os_debug_vprintf (const char *in_format, va_list in_args);
+
+#endif /* CCI_OS_DEBUGGING_H */
diff --git a/src/ccapi/common/cci_os_identifier.h b/src/ccapi/common/cci_os_identifier.h
new file mode 100644
index 000000000000..7ee67eb38c2a
--- /dev/null
+++ b/src/ccapi/common/cci_os_identifier.h
@@ -0,0 +1,33 @@
+/* ccapi/common/cci_os_identifier.h */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_OS_IDENTIFIER_H
+#define CCI_OS_IDENTIFIER_H
+
+#include "cci_types.h"
+
+cc_int32 cci_os_identifier_new_uuid (cci_uuid_string_t *out_uuid_string);
+
+#endif /* CCI_OS_IDENTIFIER_H */
diff --git a/src/ccapi/common/cci_types.h b/src/ccapi/common/cci_types.h
new file mode 100644
index 000000000000..87597d441b6d
--- /dev/null
+++ b/src/ccapi/common/cci_types.h
@@ -0,0 +1,102 @@
+/* ccapi/common/cci_types.h */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef CCI_TYPES_H
+#define CCI_TYPES_H
+
+#include <CredentialsCache.h>
+#include <k5-ipc_stream.h>
+
+typedef char *cci_uuid_string_t;
+
+struct cci_identifier_d;
+typedef struct cci_identifier_d *cci_identifier_t;
+
+enum cci_msg_id_t {
+    /* cc_context_t */
+    cci_context_first_msg_id,
+
+    cci_context_unused_release_msg_id,  /* Unused. Handle for old clients. */
+    cci_context_sync_msg_id,
+    cci_context_get_change_time_msg_id,
+    cci_context_wait_for_change_msg_id,
+    cci_context_get_default_ccache_name_msg_id,
+    cci_context_open_ccache_msg_id,
+    cci_context_open_default_ccache_msg_id,
+    cci_context_create_ccache_msg_id,
+    cci_context_create_default_ccache_msg_id,
+    cci_context_create_new_ccache_msg_id,
+    cci_context_new_ccache_iterator_msg_id,
+    cci_context_lock_msg_id,
+    cci_context_unlock_msg_id,
+
+    cci_context_last_msg_id,
+
+    /* cc_ccache_t */
+    cci_ccache_first_msg_id,
+
+    cci_ccache_destroy_msg_id,
+    cci_ccache_set_default_msg_id,
+    cci_ccache_get_credentials_version_msg_id,
+    cci_ccache_get_name_msg_id,
+    cci_ccache_get_principal_msg_id,
+    cci_ccache_set_principal_msg_id,
+    cci_ccache_store_credentials_msg_id,
+    cci_ccache_remove_credentials_msg_id,
+    cci_ccache_new_credentials_iterator_msg_id,
+    cci_ccache_move_msg_id,
+    cci_ccache_lock_msg_id,
+    cci_ccache_unlock_msg_id,
+    cci_ccache_get_last_default_time_msg_id,
+    cci_ccache_get_change_time_msg_id,
+    cci_ccache_wait_for_change_msg_id,
+    cci_ccache_get_kdc_time_offset_msg_id,
+    cci_ccache_set_kdc_time_offset_msg_id,
+    cci_ccache_clear_kdc_time_offset_msg_id,
+
+    cci_ccache_last_msg_id,
+
+    /* cc_ccache_iterator_t */
+    cci_ccache_iterator_first_msg_id,
+
+    cci_ccache_iterator_release_msg_id,
+    cci_ccache_iterator_next_msg_id,
+    cci_ccache_iterator_clone_msg_id,
+
+    cci_ccache_iterator_last_msg_id,
+
+    /* cc_credentials_iterator_t */
+    cci_credentials_iterator_first_msg_id,
+
+    cci_credentials_iterator_release_msg_id,
+    cci_credentials_iterator_next_msg_id,
+    cci_credentials_iterator_clone_msg_id,
+
+    cci_credentials_iterator_last_msg_id,
+
+    cci_max_msg_id  /* must be last! */
+};
+
+#endif /* CCI_TYPES_H */
diff --git a/src/ccapi/common/mac/cci_os_debugging.c b/src/ccapi/common/mac/cci_os_debugging.c
new file mode 100644
index 000000000000..e5280451bbc4
--- /dev/null
+++ b/src/ccapi/common/mac/cci_os_debugging.c
@@ -0,0 +1,35 @@
+/* ccapi/common/mac/cci_os_debugging.c */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+
+#include "cci_os_debugging.h"
+#include <Kerberos/KerberosDebug.h>
+
+/* ------------------------------------------------------------------------ */
+
+void cci_os_debug_vprintf (const char *in_format, va_list in_args)
+{
+    dvprintf (in_format, in_args);
+}
diff --git a/src/ccapi/common/mac/cci_os_identifier.c b/src/ccapi/common/mac/cci_os_identifier.c
new file mode 100644
index 000000000000..be7b5bdc46f2
--- /dev/null
+++ b/src/ccapi/common/mac/cci_os_identifier.c
@@ -0,0 +1,78 @@
+/* ccapi/common/mac/cci_os_identifier.c */
+/*
+ * Copyright 2006 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include "cci_common.h"
+#include "cci_os_identifier.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_os_identifier_new_uuid (cci_uuid_string_t *out_uuid_string)
+{
+    cc_int32 err = ccNoError;
+    cci_uuid_string_t uuid_string = NULL;
+    CFUUIDRef uuid = NULL;
+    CFStringRef uuid_stringref = NULL;
+    CFStringEncoding encoding = kCFStringEncodingUTF8;
+    CFIndex length = 0;
+
+    if (!out_uuid_string) { err = cci_check_error (ccErrBadParam); }
+
+    if (!err) {
+        uuid = CFUUIDCreate (kCFAllocatorDefault);
+        if (!uuid) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        uuid_stringref = CFUUIDCreateString (kCFAllocatorDefault, uuid);
+        if (!uuid_stringref) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        length = CFStringGetMaximumSizeForEncoding (CFStringGetLength (uuid_stringref),
+                                                    encoding) + 1;
+
+        uuid_string = malloc (length);
+        if (!uuid_string) { err = cci_check_error (ccErrNoMem); }
+    }
+
+    if (!err) {
+        if (!CFStringGetCString (uuid_stringref, uuid_string, length, encoding)) {
+            err = cci_check_error (ccErrNoMem);
+        }
+    }
+
+    if (!err) {
+        *out_uuid_string = uuid_string;
+        uuid_string = NULL; /* take ownership */
+    }
+
+    if (uuid_string   ) { free (uuid_string); }
+    if (uuid_stringref) { CFRelease (uuid_stringref); }
+    if (uuid          ) { CFRelease (uuid); }
+
+    return cci_check_error (err);
+}
diff --git a/src/ccapi/common/unix/Makefile.in b/src/ccapi/common/unix/Makefile.in
new file mode 100644
index 000000000000..ecacabd60f0a
--- /dev/null
+++ b/src/ccapi/common/unix/Makefile.in
@@ -0,0 +1,13 @@
+mydir=ccapi$(S)common$(S)unix
+BUILDTOP=$(REL)..$(S)..$(S)..
+
+STLIBOBJS=
+OBJS=
+SRCS=
+
+all-unix: all-libobjs
+clean-unix:: clean-libobjs
+
+@libobj_frag@
+
+# +++ Dependency line eater +++
diff --git a/src/ccapi/common/win/OldCC/autolock.hxx b/src/ccapi/common/win/OldCC/autolock.hxx
new file mode 100644
index 000000000000..b88172d2ae03
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/autolock.hxx
@@ -0,0 +1,66 @@
+/* ccapi/common/win/OldCC/autolock.hxx */
+/*
+ * Copyright (C) 1998 by Danilo Almeida.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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
+ * COPYRIGHT HOLDER OR CONTRIBUTORS 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.
+ */
+
+#ifndef __AUTOLOCK_HXX__
+#define __AUTOLOCK_HXX__
+
+#include <windows.h>
+
+class CcOsLock {
+    CRITICAL_SECTION cs;
+    bool valid;
+public:
+    CcOsLock()      {InitializeCriticalSection(&cs);   valid = true; }
+    ~CcOsLock()     {DeleteCriticalSection(&cs);       valid = false;}
+    void lock()     {if (valid) EnterCriticalSection(&cs);}
+    void unlock()   {if (valid) LeaveCriticalSection(&cs);}
+    bool trylock()  {return valid ? (TryEnterCriticalSection(&cs) ? true : false)
+                                  : false; }
+};
+
+class CcAutoLock {
+    CcOsLock& m_lock;
+public:
+    static void Start(CcAutoLock*& a, CcOsLock& lock) { a = new CcAutoLock(lock); };
+    static void Stop (CcAutoLock*& a) { delete a; a = 0; };
+    CcAutoLock(CcOsLock& lock):m_lock(lock) { m_lock.lock(); }
+    ~CcAutoLock() { m_lock.unlock(); }
+};
+
+class CcAutoTryLock {
+    CcOsLock& m_lock;
+    bool m_locked;
+public:
+    CcAutoTryLock(CcOsLock& lock):m_lock(lock) { m_locked = m_lock.trylock(); }
+    ~CcAutoTryLock() { if (m_locked) m_lock.unlock(); m_locked = false; }
+    bool IsLocked() const { return m_locked; }
+};
+
+#endif /* __AUTOLOCK_HXX */
diff --git a/src/ccapi/common/win/OldCC/ccutil.cxx b/src/ccapi/common/win/OldCC/ccutil.cxx
new file mode 100644
index 000000000000..729104de7ed3
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/ccutil.cxx
@@ -0,0 +1,187 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include <windows.h>
+#include "init.hxx"
+#include "secure.hxx"
+
+extern "C" {
+#include "cci_debugging.h"
+    }
+
+
+CcOsLock Init::s_lock;
+DWORD Init::s_refcount = 0;
+DWORD Init::s_error = ERROR_INVALID_HANDLE;
+bool Init::s_init = false;
+Init::InitInfo Init::s_info = { 0 };
+HINSTANCE Init::s_hRpcDll = 0;
+
+#define INIT "INIT: "
+
+static
+void
+ShowInfo(
+    Init::InitInfo& info
+    );
+
+DWORD
+Init::Info(
+    InitInfo& info
+    )
+{
+    // This funciton will not do automatic initialization.
+    CcAutoLock AL(s_lock);
+    if (!s_init) {
+        memset(&info, 0, sizeof(info));
+        return s_error ? s_error : ERROR_INVALID_HANDLE;
+    } else {
+        info = s_info;
+        return 0;
+    }
+}
+
+DWORD
+Init::Initialize() {
+    CcAutoLock AL(s_lock);
+    cci_debug_printf("%s s_init:%d", __FUNCTION__, s_init);
+    if (s_init) {
+        s_refcount++;
+        return 0;
+        }
+    SecureClient s;
+    DWORD status = 0;
+    OSVERSIONINFO osvi;
+    BOOL isSupportedVersion = FALSE;
+    memset(&s_info, 0, sizeof(s_info));
+    memset(&osvi, 0, sizeof(osvi));
+    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+
+    status = !GetVersionEx(&osvi);       // Returns a boolean.  Invert to 0 is OK.
+
+    if (!status) {
+        switch(osvi.dwPlatformId) {
+        case VER_PLATFORM_WIN32_WINDOWS:
+            s_info.isNT = FALSE;
+            isSupportedVersion = TRUE;
+            break;
+        case VER_PLATFORM_WIN32_NT:
+            s_info.isNT = TRUE;
+            isSupportedVersion = TRUE;
+            break;
+        case VER_PLATFORM_WIN32s:
+        default:
+            s_info.isNT = FALSE;
+            break;
+            }
+    
+        if (!isSupportedVersion) {
+            cci_debug_printf("%s Trying to run on an unsupported version of Windows", __FUNCTION__);
+            status  = 1;
+            }
+        }
+
+    if (!status) {status  = !s_info.isNT;}
+
+    if (!status) {status = !(s_hRpcDll = LoadLibrary(TEXT("rpcrt4.dll")));}
+
+    if (!status) {
+        s_info.fRpcBindingSetAuthInfoEx = (FP_RpcBindingSetAuthInfoEx)
+            GetProcAddress(s_hRpcDll, TEXT(FN_RpcBindingSetAuthInfoEx));
+        if (!s_info.fRpcBindingSetAuthInfoEx) {
+            cci_debug_printf("  Running on NT but could not find RpcBindinSetAuthInfoEx");
+            status = 1;
+            }
+        }
+    
+    if (!status) {
+        s_info.fRpcServerRegisterIfEx = (FP_RpcServerRegisterIfEx)
+            GetProcAddress(s_hRpcDll, TEXT(FN_RpcServerRegisterIfEx));
+        if (!s_info.fRpcServerRegisterIfEx) {
+            cci_debug_printf("  Running on NT but could not find RpcServerRegisterIfEx");
+            status = 1;
+            }
+        }
+
+    if (!status) {
+        status = SecureClient::Attach();
+        if (status) {
+            cci_debug_printf("  SecureClient::Attach() failed (%u)", status);
+            }
+        }
+
+    if (status) {
+        memset(&s_info, 0, sizeof(s_info));
+        if (s_hRpcDll) {
+            FreeLibrary(s_hRpcDll);
+            s_hRpcDll = 0;
+        }
+        cci_debug_printf("  Init::Attach() failed (%u)", status);
+    } else {
+        s_refcount++;
+        s_init = true;
+        ShowInfo(s_info);
+    }
+    s_error = status;
+    return status;
+}
+
+DWORD
+Init::Cleanup(
+    )
+{
+    CcAutoLock AL(s_lock);
+    s_refcount--;
+    if (s_refcount) return 0;
+    if (!s_init) return 0;
+    DWORD error = 0;
+    if (s_hRpcDll) {
+        FreeLibrary(s_hRpcDll);
+        s_hRpcDll = 0;
+    }
+    error = SecureClient::Detach();
+    memset(&s_info, 0, sizeof(s_info));
+    s_init = false;
+    s_error = 0;
+    if (error) {
+        cci_debug_printf("  Init::Detach() had an error (%u)", error);
+        }
+    return error;
+}
+
+static
+void
+ShowInfo(
+    Init::InitInfo& info
+    )
+{
+    if (info.isNT) {
+        cci_debug_printf("  Running on Windows NT using secure mode");
+    } else {
+        cci_debug_printf("  Running insecurely on non-NT Windows");
+    }
+    return;
+}
diff --git a/src/ccapi/common/win/OldCC/ccutil.def b/src/ccapi/common/win/OldCC/ccutil.def
new file mode 100644
index 000000000000..57113f094ea3
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/ccutil.def
@@ -0,0 +1,5 @@
+;LIBRARY		COMERR32
+HEAPSIZE	8192
+
+EXPORTS
+    
\ No newline at end of file
diff --git a/src/ccapi/common/win/OldCC/ccutils.c b/src/ccapi/common/win/OldCC/ccutils.c
new file mode 100644
index 000000000000..13f72cbe09d1
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/ccutils.c
@@ -0,0 +1,139 @@
+/* ccapi/common/win/OldCC/ccutils.c */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include <windows.h>
+#include <stdlib.h>
+#include <malloc.h>
+
+#include "cci_debugging.h"
+#include "util.h"
+
+BOOL isNT() {
+    OSVERSIONINFO osvi;
+    DWORD   status              = 0;
+    BOOL    bSupportedVersion   = FALSE;
+    BOOL    bIsNT               = FALSE;
+
+    memset(&osvi, 0, sizeof(osvi));
+    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+
+    status = !GetVersionEx(&osvi);       // Returns a boolean.  Invert to 0 is OK.
+
+    if (!status) {
+        switch(osvi.dwPlatformId) {
+        case VER_PLATFORM_WIN32_WINDOWS:
+            bIsNT = FALSE;
+            bSupportedVersion = TRUE;
+            break;
+        case VER_PLATFORM_WIN32_NT:
+            bIsNT = TRUE;
+            bSupportedVersion = TRUE;
+            break;
+        case VER_PLATFORM_WIN32s:
+        default:
+            bIsNT = FALSE;
+            break;
+            }
+
+        if (!bSupportedVersion) {
+            cci_debug_printf("%s Running on an unsupported version of Windows", __FUNCTION__);
+            status  = 1;
+            }
+        }
+
+    return (!status && bIsNT && bSupportedVersion);
+    }
+
+char*   allocEventName(char* uuid_string, char* suffix) {
+    LPSTR       event_name      = NULL;
+    cc_int32    err             = ccNoError;
+
+    event_name = malloc(strlen(uuid_string) + strlen(suffix) + 3);
+    if (!event_name) err = cci_check_error(ccErrNoMem);
+
+    if (!err) {
+        strcpy(event_name, uuid_string);
+        strcat(event_name, "_");
+        strcat(event_name, suffix);
+        }
+
+    return event_name;
+    }
+
+HANDLE createThreadEvent(char* uuid, char* suffix) {
+    LPSTR                   event_name  = NULL;
+    HANDLE                  hEvent      = NULL;
+    PSECURITY_ATTRIBUTES    psa         = 0;        // Everything having to do with
+    SECURITY_ATTRIBUTES     sa          = { 0 };    // sa, psa, security is copied
+    DWORD                   status      = 0;        // from the previous implementation.
+
+    psa = isNT() ? &sa : 0;
+
+    if (isNT()) {
+        sa.nLength = sizeof(sa);
+        status = alloc_own_security_descriptor_NT(&sa.lpSecurityDescriptor);
+        cci_check_error(status);
+        }
+
+    if (!status) {
+        event_name = allocEventName(uuid, suffix);
+        if (!event_name) status = cci_check_error(ccErrNoMem);
+        }
+#if 0
+    cci_debug_printf("%s event_name:%s", __FUNCTION__, event_name);
+#endif
+    if (!status) {
+        hEvent = CreateEvent(psa, FALSE, FALSE, event_name);
+        if (!hEvent)     status = cci_check_error(GetLastError());
+        }
+
+    if (!status) ResetEvent(hEvent);
+
+
+    if (event_name) free(event_name);
+    if (isNT())     free(sa.lpSecurityDescriptor);
+
+    return hEvent;
+    }
+
+HANDLE openThreadEvent(char* uuid, char* suffix) {
+    LPSTR   event_name  = NULL;
+    HANDLE  hEvent      = NULL;
+    DWORD   status      = 0;
+
+    event_name = allocEventName(uuid, suffix);
+    if (!event_name) status = cci_check_error(ccErrNoMem);
+#if 0
+    cci_debug_printf("%s event_name:%s", __FUNCTION__, event_name);
+#endif
+    if (!status) {
+        hEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, event_name);
+        if (!hEvent) status = cci_check_error(GetLastError());
+        }
+
+    if (event_name) free(event_name);
+
+    return hEvent;
+    }
diff --git a/src/ccapi/common/win/OldCC/ccutils.h b/src/ccapi/common/win/OldCC/ccutils.h
new file mode 100644
index 000000000000..f91c7770214e
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/ccutils.h
@@ -0,0 +1,48 @@
+/* ccapi/common/win/OldCC/ccutils.h */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef __CCUTILS_H__
+#define __CCUTILS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if 0
+}
+#endif
+
+#define REPLY_SUFFIX    (char*)"reply"
+#define LISTEN_SUFFIX   (char*)"listen"
+
+BOOL    isNT();
+char*   allocEventName   (char* uuid, char* suffix);
+HANDLE  createThreadEvent(char* uuid, char* suffix);
+HANDLE  openThreadEvent  (char* uuid, char* suffix);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CCUTILS_H__ */
diff --git a/src/ccapi/common/win/OldCC/init.cxx b/src/ccapi/common/win/OldCC/init.cxx
new file mode 100644
index 000000000000..feb7ad3ad957
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/init.cxx
@@ -0,0 +1,187 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include <windows.h>
+#include "init.hxx"
+#include "secure.hxx"
+
+extern "C" {
+#include "cci_debugging.h"
+    }
+
+
+CcOsLock Init::s_lock;
+DWORD Init::s_refcount = 0;
+DWORD Init::s_error = ERROR_INVALID_HANDLE;
+bool Init::s_init = false;
+Init::InitInfo Init::s_info = { 0 };
+HINSTANCE Init::s_hRpcDll = 0;
+
+#define INIT "INIT: "
+
+static
+void
+ShowInfo(
+    Init::InitInfo& info
+    );
+
+DWORD
+Init::Info(
+    InitInfo& info
+    )
+{
+    // This funciton will not do automatic initialization.
+    CcAutoLock AL(s_lock);
+    if (!s_init) {
+        memset(&info, 0, sizeof(info));
+        return s_error ? s_error : ERROR_INVALID_HANDLE;
+    } else {
+        info = s_info;
+        return 0;
+    }
+}
+
+DWORD
+Init::Initialize() {
+    CcAutoLock AL(s_lock);
+//    cci_debug_printf("%s s_init:%d", __FUNCTION__, s_init);
+    if (s_init) {
+        s_refcount++;
+        return 0;
+        }
+    SecureClient s;
+    DWORD status = 0;
+    OSVERSIONINFO osvi;
+    BOOL isSupportedVersion = FALSE;
+    memset(&s_info, 0, sizeof(s_info));
+    memset(&osvi, 0, sizeof(osvi));
+    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+
+    status = !GetVersionEx(&osvi);       // Returns a boolean.  Invert to 0 is OK.
+
+    if (!status) {
+        switch(osvi.dwPlatformId) {
+        case VER_PLATFORM_WIN32_WINDOWS:
+            s_info.isNT = FALSE;
+            isSupportedVersion = TRUE;
+            break;
+        case VER_PLATFORM_WIN32_NT:
+            s_info.isNT = TRUE;
+            isSupportedVersion = TRUE;
+            break;
+        case VER_PLATFORM_WIN32s:
+        default:
+            s_info.isNT = FALSE;
+            break;
+            }
+    
+        if (!isSupportedVersion) {
+            cci_debug_printf("%s Trying to run on an unsupported version of Windows", __FUNCTION__);
+            status  = 1;
+            }
+        }
+
+    if (!status) {status  = !s_info.isNT;}
+
+    if (!status) {status = !(s_hRpcDll = LoadLibrary(TEXT("rpcrt4.dll")));}
+
+    if (!status) {
+        s_info.fRpcBindingSetAuthInfoEx = (FP_RpcBindingSetAuthInfoEx)
+            GetProcAddress(s_hRpcDll, TEXT(FN_RpcBindingSetAuthInfoEx));
+        if (!s_info.fRpcBindingSetAuthInfoEx) {
+            cci_debug_printf("  Running on NT but could not find RpcBindinSetAuthInfoEx");
+            status = 1;
+            }
+        }
+    
+    if (!status) {
+        s_info.fRpcServerRegisterIfEx = (FP_RpcServerRegisterIfEx)
+            GetProcAddress(s_hRpcDll, TEXT(FN_RpcServerRegisterIfEx));
+        if (!s_info.fRpcServerRegisterIfEx) {
+            cci_debug_printf("  Running on NT but could not find RpcServerRegisterIfEx");
+            status = 1;
+            }
+        }
+
+    if (!status) {
+        status = SecureClient::Attach();
+        if (status) {
+            cci_debug_printf("  SecureClient::Attach() failed (%u)", status);
+            }
+        }
+
+    if (status) {
+        memset(&s_info, 0, sizeof(s_info));
+        if (s_hRpcDll) {
+            FreeLibrary(s_hRpcDll);
+            s_hRpcDll = 0;
+        }
+        cci_debug_printf("  Init::Attach() failed (%u)", status);
+    } else {
+        s_refcount++;
+        s_init = true;
+        ShowInfo(s_info);
+    }
+    s_error = status;
+    return status;
+}
+
+DWORD
+Init::Cleanup(
+    )
+{
+    CcAutoLock AL(s_lock);
+    s_refcount--;
+    if (s_refcount) return 0;
+    if (!s_init) return 0;
+    DWORD error = 0;
+    if (s_hRpcDll) {
+        FreeLibrary(s_hRpcDll);
+        s_hRpcDll = 0;
+    }
+    error = SecureClient::Detach();
+    memset(&s_info, 0, sizeof(s_info));
+    s_init = false;
+    s_error = 0;
+    if (error) {
+        cci_debug_printf("  Init::Detach() had an error (%u)", error);
+        }
+    return error;
+}
+
+static
+void
+ShowInfo(
+    Init::InitInfo& info
+    )
+{
+    if (info.isNT) {
+        cci_debug_printf("  Running on Windows NT using secure mode");
+    } else {
+        cci_debug_printf("  Running insecurely on non-NT Windows");
+    }
+    return;
+}
diff --git a/src/ccapi/common/win/OldCC/init.hxx b/src/ccapi/common/win/OldCC/init.hxx
new file mode 100644
index 000000000000..9bac7f8f9e25
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/init.hxx
@@ -0,0 +1,102 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#pragma once
+#include "autolock.hxx"
+#include <rpc.h>
+
+typedef RPC_STATUS (RPC_ENTRY *FP_RpcBindingSetAuthInfoExA)(
+    IN RPC_BINDING_HANDLE Binding,
+    IN unsigned char __RPC_FAR * ServerPrincName,
+    IN unsigned long AuthnLevel,
+    IN unsigned long AuthnSvc,
+    IN RPC_AUTH_IDENTITY_HANDLE AuthIdentity, OPTIONAL
+    IN unsigned long AuthzSvc,
+    IN RPC_SECURITY_QOS *SecurityQos OPTIONAL
+    );
+
+typedef RPC_STATUS (RPC_ENTRY *FP_RpcBindingSetAuthInfoExW)(
+    IN RPC_BINDING_HANDLE Binding,
+    IN unsigned short __RPC_FAR * ServerPrincName,
+    IN unsigned long AuthnLevel,
+    IN unsigned long AuthnSvc,
+    IN RPC_AUTH_IDENTITY_HANDLE AuthIdentity, OPTIONAL
+    IN unsigned long AuthzSvc, OPTIONAL
+    IN RPC_SECURITY_QOS *SecurityQOS
+    );
+
+typedef RPC_STATUS (RPC_ENTRY *FP_RpcServerRegisterIfEx)(
+    IN RPC_IF_HANDLE IfSpec,
+    IN UUID __RPC_FAR * MgrTypeUuid,
+    IN RPC_MGR_EPV __RPC_FAR * MgrEpv,
+    IN unsigned int Flags,
+    IN unsigned int MaxCalls,
+    IN RPC_IF_CALLBACK_FN __RPC_FAR *IfCallback
+    );
+
+#ifdef UNICODE
+#define FP_RpcBindingSetAuthInfoEx FP_RpcBindingSetAuthInfoExW
+#define FN_RpcBindingSetAuthInfoEx "RpcBindingSetAuthInfoExW"
+#else
+#define FP_RpcBindingSetAuthInfoEx FP_RpcBindingSetAuthInfoExA
+#define FN_RpcBindingSetAuthInfoEx "RpcBindingSetAuthInfoExA"
+#endif
+
+#define FN_RpcServerRegisterIfEx   "RpcServerRegisterIfEx"
+
+class Init
+{
+public:
+    struct InitInfo {
+        BOOL isNT;
+        FP_RpcBindingSetAuthInfoEx fRpcBindingSetAuthInfoEx;
+        FP_RpcServerRegisterIfEx fRpcServerRegisterIfEx;
+    };
+
+    static DWORD Initialize();
+    static DWORD Cleanup();
+    static DWORD Info(InitInfo& info);
+
+    static bool Initialized() { return s_init; }
+
+private:
+    static CcOsLock s_lock;
+    static DWORD s_refcount;
+    static DWORD s_error;
+    static bool s_init;
+    static InitInfo s_info;
+    static HINSTANCE s_hRpcDll;
+};
+
+#define INIT_INIT_EX(trap, error) \
+do \
+{ \
+    if (!Init::Initialized()) \
+    { \
+        DWORD rc = Init::Initialize(); \
+        if (rc) return (trap) ? (error) : rc; \
+    } \
+} while(0)
diff --git a/src/ccapi/common/win/OldCC/name.h b/src/ccapi/common/win/OldCC/name.h
new file mode 100644
index 000000000000..66ca3a9f86b5
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/name.h
@@ -0,0 +1,34 @@
+/* ccapi/common/win/OldCC/name.h */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#pragma once
+
+#ifdef _WIN64
+#define CCAPI_MODULE "krbcc64"
+#else
+#define CCAPI_MODULE "krbcc32"
+#endif
+#define CCAPI_DLL CCAPI_MODULE ".dll"
+#define CCAPI_EXE   "ccapiserver.exe"
\ No newline at end of file
diff --git a/src/ccapi/common/win/OldCC/opts.cxx b/src/ccapi/common/win/OldCC/opts.cxx
new file mode 100644
index 000000000000..bd5f503ea63f
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/opts.cxx
@@ -0,0 +1,188 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <opts.hxx>
+
+#if 0
+const struct Opts*
+GetOpts(
+    )
+{
+    bool done = false;
+    struct Opts* o;
+    if (!(o = new Opts))
+        goto cleanup;
+    if (!(o->pszString = new char[lstrlenA(opts.pszString) + 1]))
+        goto cleanup;
+    if (!(o->pszEndpoint = new char[lstrlenA(opts.pszEndpoint) + 1]))
+        goto cleanup;
+    strcpy(o->pszString, opts.pszString);
+    strcpy(o->pszEndpoint, opts.pszEndpoint);
+    done = true;
+ cleanup:
+    if (!done) {
+        FreeOpts(o);
+        o = 0;
+    }
+    return o;
+}
+
+void
+FreeOpts(
+    struct Opts* o
+    )
+{
+    if (o) {
+        if (o->pszString)
+            delete [] o->pszString;
+        if (o->pszEndpoint)
+            delete [] o->pszEndpoint;
+        delete o;
+    }
+}
+#endif
+
+bool
+ParseOpts::IsValidOpt(
+    char ch
+    )
+{
+    return (m_ValidOpts[ch % 256] != 0);
+}
+
+void
+ParseOpts::PrintOpt(
+    char ch,
+    char* text
+    )
+{
+    if (IsValidOpt(ch))
+        fprintf(stderr, "  -%c %s\n", ch, text);
+}
+
+void
+ParseOpts::UsageOpts(
+    char * program,
+    int code
+    )
+{
+    fprintf(stderr, "Usage: %s [options]\n", program);
+    PrintOpt('k', "stop server");
+#ifdef CCAPI_TEST_OPTIONS
+    PrintOpt('s', "string");
+    PrintOpt('e', "endpoint");
+    PrintOpt('m', "maxcalls");
+    PrintOpt('n', "mincalls");
+    PrintOpt('f', "flag_wait_op");
+    PrintOpt('u', "unprotected");
+    PrintOpt('b', "use security callback");
+#endif
+    PrintOpt('c', "output debug info to console");
+    exit(code);
+}
+
+void
+ParseOpts::SetValidOpts(
+    char* valid_opts
+    )
+{
+    memset(m_ValidOpts, 0, sizeof(m_ValidOpts));
+    char *p = valid_opts;
+    for (p = valid_opts; *p; p++) {
+        m_ValidOpts[*p % sizeof(m_ValidOpts)] = 1;
+    }
+}
+
+void
+ParseOpts::Parse(
+    Opts& opts,
+    int argc,
+    char **argv
+    )
+{
+    int i;
+    for (i = 1; i < argc; i++) {
+        if ((*argv[i] == '-') || (*argv[i] == '/')) {
+            char ch = tolower(*(argv[i]+1));
+            if (!IsValidOpt(ch))
+                UsageOpts(argv[0]);
+            switch (ch) {
+            case 'k':
+                opts.bShutdown = TRUE;
+                break;
+#ifdef CCAPI_TEST_OPTIONS
+            case 's':
+                opts.pszString = argv[++i];
+                break;
+            case 'e':
+                opts.pszEndpoint = argv[++i];
+                break;
+            case 'm':
+                opts.cMaxCalls = (unsigned int) atoi(argv[++i]);
+                break;
+            case 'n':
+                opts.cMinCalls = (unsigned int) atoi(argv[++i]);
+                break;
+            case 'f':
+                opts.fDontWait = (unsigned int) atoi(argv[++i]);
+                break;
+            case 'u':
+                opts.bDontProtect = TRUE;
+                break;
+            case 'b':
+                opts.bSecCallback = TRUE;
+                break;
+#endif
+            case 'c':
+                opts.bConsole = TRUE;
+                break;
+            case 'h':
+            case '?':
+            default:
+                UsageOpts(argv[0]);
+            }
+        }
+        else
+            UsageOpts(argv[0]);
+    }
+
+}
+
+ParseOpts::ParseOpts(char* valid_opts)
+{
+    SetValidOpts(valid_opts);
+}
+
+ParseOpts::ParseOpts()
+{
+}
+
+ParseOpts::~ParseOpts()
+{
+}
diff --git a/src/ccapi/common/win/OldCC/opts.hxx b/src/ccapi/common/win/OldCC/opts.hxx
new file mode 100644
index 000000000000..755ce4ae609a
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/opts.hxx
@@ -0,0 +1,56 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#pragma once
+
+class ParseOpts
+{
+public:
+    struct Opts {
+        char* pszString;
+        char* pszEndpoint;
+        unsigned int cMinCalls;
+        unsigned int cMaxCalls;
+        unsigned int fDontWait;
+        bool bDontProtect;
+        bool bShutdown;
+        bool bSecCallback;
+        bool bConsole;
+    };
+
+    ParseOpts(char* valid_opts);
+    ParseOpts();
+    ~ParseOpts();
+    void SetValidOpts(char* valid_opts);
+    void Parse(Opts& opts, int argc, char **argv);
+
+private:
+    bool IsValidOpt(char ch);
+    void PrintOpt(char ch, char* text);
+    void UsageOpts(char* program, int code = 0);
+
+    char m_ValidOpts[256];
+};
diff --git a/src/ccapi/common/win/OldCC/secure.cxx b/src/ccapi/common/win/OldCC/secure.cxx
new file mode 100644
index 000000000000..99ba08a25dd4
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/secure.cxx
@@ -0,0 +1,161 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include <windows.h>
+#include "secure.hxx"
+
+extern "C" {
+#include "cci_debugging.h"
+    }
+
+CcOsLock SecureClient::s_lock;
+DWORD SecureClient::s_refcount = 0;
+DWORD SecureClient::s_error = 0;
+HANDLE SecureClient::s_hToken = 0;
+
+#include "util.h"
+
+#define SC "SecureClient::"
+
+DWORD
+SecureClient::Attach(
+    )
+{
+    CcAutoLock AL(s_lock);
+    if (s_hToken) {
+        s_refcount++;
+        return 0;
+    }
+    if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, 
+                         &s_hToken)) {
+        s_refcount++;
+        s_error = 0;
+    } else {
+        s_hToken = 0;
+        s_error = GetLastError();
+    }
+    return s_error;
+}
+
+DWORD
+SecureClient::Detach(
+    )
+{
+    CcAutoLock AL(s_lock);
+    s_refcount--;
+    if (s_refcount) return 0;
+    if (!s_hToken) return 0;
+    DWORD error = 0;
+    if (!CloseHandle(s_hToken))
+        error = GetLastError();
+    s_hToken = 0;
+    s_error = 0;
+    return error;
+}
+
+DWORD SecureClient::Token(HANDLE& hToken) {
+    // This function will not do automatic initialization.
+    CcAutoLock AL(s_lock);
+    hToken = 0;
+    if (!s_hToken) {
+        cci_debug_printf("%s no process token initialized (%u)", __FUNCTION__, s_error);
+        return s_error ? s_error : ERROR_INVALID_HANDLE;
+        } 
+    else {
+        DWORD status = 0;
+        if (!DuplicateHandle(GetCurrentProcess(), s_hToken, 
+                             GetCurrentProcess(), &hToken, 0, FALSE, 
+                             DUPLICATE_SAME_ACCESS)) {
+            status = GetLastError();
+            cci_debug_printf("  Could not duplicate handle (%u)", status);
+            }
+        return status;
+        }
+    }
+
+void
+SecureClient::Start(SecureClient*& s) {
+    s = new SecureClient;
+}
+
+void
+SecureClient::Stop(SecureClient*& s) {
+    delete s;
+    s = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/* This constructor turns off impersonation.
+ * It is OK for OpenThreadToken to return an error -- that just means impersonation
+ * is off.
+ */
+SecureClient::SecureClient():
+    m_Error(0),
+    m_hToken(0),
+    m_NeedRestore(false) {
+
+    HANDLE hThread = GetCurrentThread();
+    HANDLE hThDuplicate;
+    
+    int status  = DuplicateHandle(  GetCurrentProcess(),
+                                    hThread,
+                                    GetCurrentProcess(),
+                                    &hThDuplicate,
+                                    TOKEN_ALL_ACCESS,
+                                    FALSE,
+                                    0);
+    if (!status) return;
+
+    if (!OpenThreadToken(hThDuplicate, TOKEN_ALL_ACCESS, FALSE, &m_hToken)) {
+        m_Error = GetLastError();
+        return;
+        }
+    if (SetThreadToken(&hThDuplicate, NULL)) {
+        m_NeedRestore = true;
+    } else {
+        m_Error = GetLastError();
+        }
+    CloseHandle(hThDuplicate);
+    }
+
+SecureClient::~SecureClient() {
+    if (m_NeedRestore) {
+        HANDLE hThread = GetCurrentThread();
+        if (!SetThreadToken(&hThread, m_hToken)) {
+            m_Error = cci_check_error(GetLastError());
+            }
+        }
+    if (m_hToken) {
+        if (!CloseHandle(m_hToken)) {
+            m_Error = cci_check_error(GetLastError());
+            }
+        }
+    }
+
+DWORD SecureClient::Error() {
+    return m_Error;
+    }
\ No newline at end of file
diff --git a/src/ccapi/common/win/OldCC/secure.hxx b/src/ccapi/common/win/OldCC/secure.hxx
new file mode 100644
index 000000000000..3714c6f84723
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/secure.hxx
@@ -0,0 +1,60 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#pragma once
+
+#include <windows.h>
+#include "autolock.hxx"
+
+class SecureClient
+{
+public:
+    static DWORD Attach();
+    static DWORD Detach();
+    static DWORD Token(HANDLE& hToken);
+    static void Start(SecureClient*& s);
+    static void Stop(SecureClient*& s);
+
+#if 0
+    static DWORD CheckImpersonation();
+    static bool IsImp();
+    static DWORD DuplicateImpAsPrimary(HANDLE& hPrimary);
+#endif
+
+    SecureClient();
+    ~SecureClient();
+    DWORD Error();
+
+private:
+    static CcOsLock s_lock;
+    static DWORD s_refcount;
+    static DWORD s_error;
+    static HANDLE s_hToken;
+
+    DWORD m_Error;
+    HANDLE m_hToken;
+    bool m_NeedRestore;
+};
diff --git a/src/ccapi/common/win/OldCC/util.cxx b/src/ccapi/common/win/OldCC/util.cxx
new file mode 100644
index 000000000000..dd4a2694ac6b
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/util.cxx
@@ -0,0 +1,520 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include <windows.h>
+#include <stdio.h>  // for _snprintf
+#include <malloc.h>
+#include <stdlib.h>
+
+extern "C" {
+#include "cci_debugging.h"
+#include "ccutils.h"
+    }
+
+#include "util.h"
+#include "secure.hxx"
+
+
+void* malloc_alloc_p(size_t size) {
+    return malloc(size);
+    }
+
+void free_alloc_p(void *pptr) {
+    void **real_pptr = (void**)pptr;
+    if (*real_pptr) {
+        free(*real_pptr);
+        *real_pptr = 0;
+        }
+    }
+
+extern "C" DWORD alloc_textual_sid(
+    PSID pSid,          // binary Sid
+    LPSTR *pTextualSid  // buffer for Textual representaion of Sid
+    ) {
+    PSID_IDENTIFIER_AUTHORITY psia;
+    DWORD dwSubAuthorities;
+    DWORD dwSidRev = SID_REVISION;
+    DWORD dwCounter;
+    DWORD dwSidSize;
+
+    *pTextualSid = 0;
+
+    //
+    // test if Sid passed in is valid
+    //
+    if(!IsValidSid(pSid)) return ERROR_INVALID_PARAMETER;
+
+    // obtain SidIdentifierAuthority
+    psia = GetSidIdentifierAuthority(pSid);
+ 
+    // obtain sidsubauthority count
+    dwSubAuthorities =* GetSidSubAuthorityCount(pSid);
+ 
+    //
+    // compute buffer length
+    // S-SID_REVISION- + identifierauthority- + subauthorities- + NULL
+    //
+    dwSidSize = (15 + 12 + (12 * dwSubAuthorities) + 1) * sizeof(TCHAR);
+    *pTextualSid = (LPSTR)malloc_alloc_p(dwSidSize);
+    if (!*pTextualSid)
+        return GetLastError();
+
+    LPSTR TextualSid = *pTextualSid;
+
+    //
+    // prepare S-SID_REVISION-
+    //
+    wsprintf(TextualSid, TEXT("S-%lu-"), dwSidRev );
+ 
+    //
+    // prepare SidIdentifierAuthority
+    //
+    if ( (psia->Value[0] != 0) || (psia->Value[1] != 0) )
+    {
+        wsprintf(TextualSid + lstrlen(TextualSid),
+                 TEXT("0x%02hx%02hx%02hx%02hx%02hx%02hx"),
+                 (USHORT)psia->Value[0],
+                 (USHORT)psia->Value[1],
+                 (USHORT)psia->Value[2],
+                 (USHORT)psia->Value[3],
+                 (USHORT)psia->Value[4],
+                 (USHORT)psia->Value[5]);
+    }
+    else
+    {
+        wsprintf(TextualSid + lstrlen(TextualSid), TEXT("%lu"),
+                 (ULONG)(psia->Value[5]      )   +
+                 (ULONG)(psia->Value[4] <<  8)   +
+                 (ULONG)(psia->Value[3] << 16)   +
+                 (ULONG)(psia->Value[2] << 24)   );
+    }
+ 
+    //
+    // loop through SidSubAuthorities
+    //
+    for (dwCounter=0 ; dwCounter < dwSubAuthorities ; dwCounter++)
+    {
+        wsprintf(TextualSid + lstrlen(TextualSid), TEXT("-%lu"),
+                 *GetSidSubAuthority(pSid, dwCounter) );
+    }
+    return 0;
+}
+
+DWORD alloc_token_user(HANDLE hToken, PTOKEN_USER *pptu) {
+    DWORD status = 0;
+    DWORD size = 0;
+    *pptu = 0;
+
+    GetTokenInformation(hToken, TokenUser, *pptu, 0, &size);
+    if (size == 0) status = GetLastError();
+
+    if (!status) {
+        if (!(*pptu = (PTOKEN_USER)malloc_alloc_p(size)))
+            status = GetLastError();
+        }
+
+    if (!status) {
+        if (!GetTokenInformation(hToken, TokenUser, *pptu, size, &size))
+            status = GetLastError();
+        }
+
+    if (status && *pptu) {
+        free_alloc_p(pptu);
+        }
+    return status;
+    }
+
+DWORD
+alloc_username(
+    PSID Sid,
+    LPSTR* pname,
+    LPSTR* pdomain = 0
+    )
+{
+    DWORD status = 0;
+    DWORD name_len = 0;
+    DWORD domain_len = 0;
+    SID_NAME_USE snu;
+    LPSTR name = 0;
+    LPSTR domain = 0;
+
+    *pname = 0;
+    if (pdomain) *pdomain = 0;
+
+    LookupAccountSidA(NULL, Sid, 0, &name_len, 0, &domain_len, &snu);
+    if ((name_len == 0) || (domain_len == 0)) status = GetLastError();
+
+    if (!status) {
+        if (!(name = (LPSTR)malloc_alloc_p(name_len))) status = GetLastError();
+        }
+
+    if (!status) {
+        if (!(domain = (LPSTR)malloc_alloc_p(domain_len))) status = GetLastError();
+        }
+
+    if (!status) {
+        if (!LookupAccountSidA(NULL, Sid, name, &name_len, domain, &domain_len, &snu)) status = GetLastError();
+        }
+
+    if (status) {
+        if (name)   free_alloc_p(&name);
+        if (domain) free_alloc_p(&domain);
+        } 
+    else {
+        if (pdomain) {
+            *pname = name;
+            *pdomain = domain;
+            } 
+        else {
+            DWORD size = name_len + domain_len + 1;
+            *pname = (LPSTR)malloc_alloc_p(size);
+            if (!*pname) status = GetLastError();
+            else _snprintf(*pname, size, "%s\\%s", name, domain);
+            }
+        }
+    return status;
+    }
+
+DWORD get_authentication_id(HANDLE hToken, LUID* pAuthId) {
+    TOKEN_STATISTICS ts;
+    DWORD len;
+
+    if (!GetTokenInformation(hToken, TokenStatistics, &ts, sizeof(ts), &len))
+        return GetLastError();
+    *pAuthId = ts.AuthenticationId;
+    return 0;
+    }
+
+DWORD
+alloc_name_9x(
+    LPSTR* pname,
+    LPSTR postfix
+    )
+{
+    char prefix[] = "krbcc";
+    DWORD len = (sizeof(prefix) - 1) + 1 + strlen(postfix) + 1;
+
+    *pname = (LPSTR)malloc_alloc_p(len);
+    if (!*pname) return GetLastError();
+    _snprintf(*pname, len, "%s.%s", prefix, postfix);
+    return 0;
+}
+
+DWORD alloc_name_NT(LPSTR* pname, LPSTR postfix) {
+    DWORD status = 0;
+    HANDLE hToken = 0;
+    LUID auth_id;
+#ifdef _DEBUG
+    PTOKEN_USER ptu = 0;
+    LPSTR name = 0;
+    LPSTR domain = 0;
+    LPSTR sid = 0;
+#endif
+    char prefix[] = "krbcc";
+    // Play it safe and say 3 characters are needed per 8 bits (byte).
+    // Note that 20 characters are needed for a 64-bit number in
+    // decimal (plus one for the string termination.
+    // and include room for sessionId.
+    char lid[3*sizeof(LUID)+1+5];
+    DWORD sessionId;
+    DWORD len = 0;
+
+    *pname = 0;
+
+    status = SecureClient::Token(hToken);
+
+    if (!status) {
+        status = get_authentication_id(hToken, &auth_id);
+        }
+
+    if (!status) {
+        if (!ProcessIdToSessionId(GetCurrentProcessId(), &sessionId))
+	        sessionId = 0;
+        }
+
+#ifdef _DEBUG
+    if (!status) {status = alloc_token_user(hToken, &ptu);}
+    if (!status) {status = alloc_username(ptu->User.Sid, &name, &domain);}
+    if (!status) {status = alloc_textual_sid(ptu->User.Sid, &sid);}
+#endif
+
+    if (!status) {
+        _snprintf(lid, sizeof(lid), "%I64u.%u", auth_id, sessionId);
+        lid[sizeof(lid)-1] = 0; // be safe
+
+        len = (sizeof(prefix) - 1) + 1 + strlen(lid) + 1 + strlen(postfix) + 1;
+        *pname = (LPSTR)malloc_alloc_p(len);
+        if (!*pname) status = GetLastError();
+        }
+
+    //
+    // We used to allocate a name of the form:
+    // "prefix.domain.name.sid.lid.postfix" (usually under 80
+    // characters, depending on username).  However, XP thought this
+    // was "invalid" (too long?) for some reason.
+    //
+    // Therefore, we now use "prefix.lid.postfix"
+    // and for Terminal server we use "prefix.lid.sessionId.postfix"
+    //
+
+    if (!status) {
+        _snprintf(*pname, len, "%s.%s.%s", prefix, lid, postfix);
+        }
+
+#ifdef _DEBUG
+    if (sid)
+        free_alloc_p(&sid);
+    if (name)
+        free_alloc_p(&name);
+    if (domain)
+        free_alloc_p(&domain);
+    if (ptu)
+        free_alloc_p(&ptu);
+#endif
+    if (hToken && hToken != INVALID_HANDLE_VALUE)
+        CloseHandle(hToken);
+    if (status && *pname)
+        free_alloc_p(pname);
+    return status;
+}
+
+extern "C" DWORD alloc_name(LPSTR* pname, LPSTR postfix, BOOL isNT) {
+    return isNT ? alloc_name_NT(pname, postfix) : 
+        alloc_name_9x(pname, postfix);
+    }
+
+extern "C" DWORD alloc_own_security_descriptor_NT(PSECURITY_DESCRIPTOR* ppsd) {
+    DWORD status = 0;
+    HANDLE hToken = 0;
+    PTOKEN_USER ptu = 0;
+    PSID pSid = 0;
+    PACL pAcl = 0;
+    DWORD size = 0;
+    SECURITY_DESCRIPTOR sd;
+
+    *ppsd = 0;
+
+    if (!status) {status = SecureClient::Token(hToken);}
+
+    // Get SID:
+    if (!status) {status = alloc_token_user(hToken, &ptu);}
+
+    if (!status) {
+        size = GetLengthSid(ptu->User.Sid);
+        pSid = (PSID) malloc_alloc_p(size);
+        if (!pSid) status = GetLastError();
+        }
+    if (!status) {
+        if (!CopySid(size, pSid, ptu->User.Sid)) status = GetLastError();
+        }
+
+    if (!status) {
+        // Prepare ACL:
+        size = sizeof(ACL);
+        // Add an ACE:
+        size += sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(pSid);
+        pAcl = (PACL) malloc_alloc_p(size);
+        if (!pAcl) status = GetLastError();
+        }
+
+    if (!status) {
+        if (!InitializeAcl(pAcl, size, ACL_REVISION)) status = GetLastError();
+        }
+
+    if (!status) {
+        if (!AddAccessAllowedAce(pAcl, ACL_REVISION, GENERIC_ALL, pSid)) status = GetLastError();
+        }
+
+    if (!status) {
+        // Prepare SD itself:
+        if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION)) status = GetLastError();
+        }
+
+    if (!status) {
+        if (!SetSecurityDescriptorDacl(&sd, TRUE, pAcl, FALSE)) status = GetLastError();
+        }
+
+    if (!status) {
+        if (!SetSecurityDescriptorOwner(&sd, pSid, FALSE)) status = GetLastError();
+        }
+
+    if (!status) {
+        if (!IsValidSecurityDescriptor(&sd)) status = ERROR_INVALID_PARAMETER;
+        }
+
+    if (!status) {
+        // We now have a SD.  Let's copy it.
+        {
+            // This should not succeed.  Instead it should give us the size.
+            BOOL ok = MakeSelfRelativeSD(&sd, 0, &size);
+            }
+        if (size == 0) status = GetLastError();
+        }
+
+    if (!status) {
+        *ppsd = (PSECURITY_DESCRIPTOR) malloc_alloc_p(size);
+        if (!*ppsd) status = GetLastError();
+        }
+
+    if (!status) {
+        if (!MakeSelfRelativeSD(&sd, *ppsd, &size)) status = GetLastError();
+        }
+
+    if (ptu)                free_alloc_p(&ptu);
+    if (pSid)               free_alloc_p(&pSid);
+    if (pAcl)               free_alloc_p(&pAcl);
+    if (hToken && hToken != INVALID_HANDLE_VALUE)   CloseHandle(hToken);
+    if (status && *ppsd)    free_alloc_p(ppsd);
+    return status;
+}
+
+DWORD
+alloc_module_file_name(
+    char* module,
+    char** pname
+    )
+{
+    const DWORD max = 8192;
+    DWORD status = 0;
+    DWORD got = 0;
+    DWORD size = 512; // use low number to test...
+    HMODULE h = 0;
+    BOOL ok = FALSE;
+    char* name = 0;
+
+    if (!pname)
+        return ERROR_INVALID_PARAMETER;
+    *pname = 0;
+
+    h = GetModuleHandle(module);
+
+    if (!h) return GetLastError();
+
+    // We assume size < max and size > 0
+    while (!status && !ok) {
+        if (size > max) {
+            // XXX - Assert?
+            status = ERROR_INVALID_DATA;
+            continue;
+        }
+        if (name) free_alloc_p(&name);
+        name = (char*)malloc_alloc_p(size + 1);
+        if (!name) {
+            status = ERROR_NOT_ENOUGH_MEMORY;
+            continue;
+        }
+        name[size] = 0;
+        got = GetModuleFileName(h, name, size);
+        if (!got) {
+            status = GetLastError();
+            // sanity check:
+            if (!status) {
+                // XXX - print nasty message...assert?
+                status = ERROR_INVALID_DATA;
+            }
+            continue;
+        }
+        // To know we're ok, we need to verify that what we got
+        // was bigger than GetModuleSize thought it got.
+        ok = got && (got < size) && !name[got];
+        size *= 2;
+    }
+    if (status && name)
+        free_alloc_p(&name);
+    else
+        *pname = name;
+    return status;
+}
+
+DWORD
+alloc_module_dir_name(
+    char* module,
+    char** pname
+    )
+{
+    DWORD status = alloc_module_file_name(module, pname);
+    if (!status) {
+        char* name = *pname;
+        char* p = name + strlen(name);
+        while ((p >= name) && (*p != '\\') && (*p != '/')) p--;
+        if (p < name) {
+            free_alloc_p(pname);
+            status = ERROR_INVALID_DATA;
+        } else {
+            *p = 0;
+        }
+    }
+    return status;
+}
+
+DWORD
+alloc_module_dir_name_with_file(
+    char* module,
+    char* file,
+    char** pname
+    )
+{
+    DWORD status = alloc_module_dir_name(module, pname);
+    if (!status) {
+        char* name = *pname;
+        size_t name_size = strlen(name);
+        size_t size = name_size + 1 + strlen(file) + 1;
+        char* result = (char*)malloc_alloc_p(size);
+        if (!result) {
+            status = ERROR_NOT_ENOUGH_MEMORY;
+            free_alloc_p(pname);
+        } else {
+            strcpy(result, name);
+            result[name_size] = '\\';
+            strcpy(result + name_size + 1, file);
+            free_alloc_p(pname);
+            *pname = result;
+        }
+    }
+    return status;
+}
+
+DWORD alloc_cmdline_2_args(char* prog,
+                           char* arg1,
+                           char* arg2,
+                           char** pname) {
+    DWORD   status  = 0;
+    size_t  size    = strlen(prog) + strlen(arg1) + strlen(arg2) + 4;
+    char*   result  = (char*)malloc_alloc_p(size);
+    if (!result) {
+        status = ERROR_NOT_ENOUGH_MEMORY;
+        } 
+    else {
+        strcpy(result, prog);
+        strcat(result, " ");
+        strcat(result, arg1);
+        strcat(result, " ");
+        strcat(result, arg2);
+        *pname = result;
+        }
+    cci_debug_printf("%s made <%s>", __FUNCTION__, result);
+    return status;
+    }
diff --git a/src/ccapi/common/win/OldCC/util.h b/src/ccapi/common/win/OldCC/util.h
new file mode 100644
index 000000000000..082f6080b2dd
--- /dev/null
+++ b/src/ccapi/common/win/OldCC/util.h
@@ -0,0 +1,88 @@
+/* ccapi/common/win/OldCC/util.h */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef __UTIL_H__
+#define __UTIL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if 0
+}
+#endif
+
+BOOL isNT();
+
+void*
+user_allocate(
+    size_t size
+    );
+
+void
+user_free(
+    void* ptr
+    );
+
+void
+free_alloc_p(
+    void* pptr
+    );
+
+DWORD
+alloc_name(
+    LPSTR* pname,
+    LPSTR postfix,
+    BOOL isNT
+    );
+
+DWORD
+alloc_own_security_descriptor_NT(
+    PSECURITY_DESCRIPTOR* ppsd
+    );
+
+DWORD
+alloc_module_dir_name(
+    char* module,
+    char** pname
+    );
+
+DWORD
+alloc_module_dir_name_with_file(
+    char* module,
+    char* file,
+    char** pname
+    );
+
+DWORD alloc_cmdline_2_args(
+    char* prog,
+    char* arg1,
+    char* arg2,
+    char** pname);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __UTIL_H__ */
diff --git a/src/ccapi/common/win/cci_os_debugging.c b/src/ccapi/common/win/cci_os_debugging.c
new file mode 100644
index 000000000000..597ac8560534
--- /dev/null
+++ b/src/ccapi/common/win/cci_os_debugging.c
@@ -0,0 +1,40 @@
+/* ccapi/common/win/cci_os_debugging.c */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "cci_os_debugging.h"
+#include "win-utils.h"
+
+/* ------------------------------------------------------------------------ */
+
+void cci_os_debug_vprintf (const char *in_format, va_list in_args) {
+#ifdef DEBUG
+    printf  ( "%s %ld ", timestamp(), GetCurrentThreadId() );
+    vprintf ( in_format, in_args );
+    printf  ( "\n" );
+#endif
+    }
diff --git a/src/ccapi/common/win/cci_os_identifier.c b/src/ccapi/common/win/cci_os_identifier.c
new file mode 100644
index 000000000000..4be2638bd0ee
--- /dev/null
+++ b/src/ccapi/common/win/cci_os_identifier.c
@@ -0,0 +1,57 @@
+/* ccapi/common/win/cci_os_identifier.c */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include "cci_common.h"
+#include "cci_os_identifier.h"
+
+#include <rpc.h>
+
+/* ------------------------------------------------------------------------ */
+
+cc_int32 cci_os_identifier_new_uuid (cci_uuid_string_t *out_uuid_string) {
+    cc_int32        err = ccNoError;
+    UUID            uuid;
+    char*           uuidStringTemp;
+
+    err = UuidCreate(&uuid);
+
+    if (!err) {
+        err = UuidToString(&uuid, &uuidStringTemp);
+        }
+
+    if (!err) {
+        *out_uuid_string = malloc(1+strlen(uuidStringTemp));
+
+        if (*out_uuid_string) {
+            strcpy(*out_uuid_string, uuidStringTemp);
+            }
+
+        RpcStringFree(&uuidStringTemp);
+        }
+
+    cci_debug_printf("cci_os_identifier_new_uuid returning %s", *out_uuid_string);
+
+    return cci_check_error (err);
+    }
\ No newline at end of file
diff --git a/src/ccapi/common/win/ccs_reply.Acf b/src/ccapi/common/win/ccs_reply.Acf
new file mode 100644
index 000000000000..aea44d74c62f
--- /dev/null
+++ b/src/ccapi/common/win/ccs_reply.Acf
@@ -0,0 +1,31 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+[implicit_handle(handle_t ccs_reply_IfHandle)]
+
+interface ccs_reply {
+    [async] ccapi_listen();
+    }
diff --git a/src/ccapi/common/win/ccs_reply.Idl b/src/ccapi/common/win/ccs_reply.Idl
new file mode 100644
index 000000000000..73e818682eb7
--- /dev/null
+++ b/src/ccapi/common/win/ccs_reply.Idl
@@ -0,0 +1,60 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+[ uuid (6E3B5060-CA46-1067-B31A-00DD010662DA),
+  version(1.0),
+  pointer_default(unique)
+]
+
+/* This interface sends a cci_stream via rpc.
+ */
+
+interface ccs_reply {
+    const long HSIZE = 8;
+
+/* The reply from the server to a request from the client: */
+void ccs_rpc_request_reply(
+    [in]                    const long              rpcmsg,         /* Message type */
+    [in, size_is(HSIZE)]    const char              tsphandle[],
+    [in, string]            const char*             uuid,
+    [in]                    const long              srvStartTime,   /* Server Start Time */
+    [in]                    const long              cbIn,           /* Length of buffer */
+    [in,  size_is(cbIn)]    const unsigned char     chIn[],         /* Data buffer */
+    [out]                   long*                   status );       /* Return code */
+
+void ccs_rpc_connect_reply(
+    [in]                    const long      rpcmsg,         /* Message type */
+    [in, size_is(HSIZE)]    const char      tsphandle[],
+    [in, string]            const char*     uuid,
+    [in]                    const long      srvStartTime,   /* Server Start Time */
+    [out]                   long*           status );       /* Return code */
+
+void ccapi_listen(
+    handle_t                hBinding,   
+    [in]                    const long rpcmsg,              /* Message type */
+    [out]                   long* status );                 /* Return code */
+
+    }
diff --git a/src/ccapi/common/win/ccs_request.Acf b/src/ccapi/common/win/ccs_request.Acf
new file mode 100644
index 000000000000..625bcce6532b
--- /dev/null
+++ b/src/ccapi/common/win/ccs_request.Acf
@@ -0,0 +1,31 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+[implicit_handle(handle_t ccs_request_IfHandle)]
+interface ccs_request
+{
+
+}
diff --git a/src/ccapi/common/win/ccs_request.idl b/src/ccapi/common/win/ccs_request.idl
new file mode 100644
index 000000000000..cad5e4444860
--- /dev/null
+++ b/src/ccapi/common/win/ccs_request.idl
@@ -0,0 +1,58 @@
+/*
+ * $Header$
+ *
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+[ uuid (906B0CE0-C70B-1067-B317-00DD010662DA),
+  version(1.0),
+  pointer_default(unique)
+]
+
+interface ccs_request {
+
+typedef char CC_CHAR;
+typedef unsigned char CC_UCHAR;
+typedef int CC_INT32;
+typedef unsigned int CC_UINT32;
+
+const long HSIZE = 8;
+
+void ccs_rpc_request(
+    [in]                        const long  rpcmsg,         /* Message type */
+    [in, size_is(HSIZE)]        const char  tsphandle[],
+    [in,  string]               const char* pszUUID,        /* Requestor's UUID */
+    [in]                        const long  lenRequest,     /* Length of buffer */
+    [in,  size_is(lenRequest)]  const char* pszRequest,     /* Data buffer */
+    [in]                        const long  serverStartTime,/* Which server session we're talking to */
+    [out]                       long*       status );       /* Return code */
+
+void ccs_rpc_connect(
+    [in]                        const long  rpcmsg,         /* Message type */
+    [in, size_is(HSIZE)]        const char  tsphandle[],
+    [in,  string]               const char* pszUUID,        /* Requestor's UUID */
+    [out]                       long*       status );       /* Return code */
+
+CC_UINT32 ccs_authenticate(
+    [in, string]                const CC_CHAR* name );
+}
diff --git a/src/ccapi/common/win/tls.c b/src/ccapi/common/win/tls.c
new file mode 100644
index 000000000000..6c13d5a98151
--- /dev/null
+++ b/src/ccapi/common/win/tls.c
@@ -0,0 +1,77 @@
+/* ccapi/common/win/tls.c */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include "string.h"
+#include <stdlib.h>
+#include <malloc.h>
+
+#include "tls.h"
+
+void tspdata_setUUID(struct tspdata* p, unsigned char __RPC_FAR* uuidString) {
+    strncpy(p->_uuid, uuidString, UUID_SIZE-1);
+    };
+
+void         tspdata_setListening (struct tspdata* p, BOOL b)           {p->_listening = b;}
+
+void         tspdata_setConnected (struct tspdata* p, BOOL b)           {p->_CCAPI_Connected = b;}
+
+void         tspdata_setReplyEvent(struct tspdata* p, HANDLE h)         {p->_replyEvent = h;}
+
+void         tspdata_setRpcAState (struct tspdata* p, RPC_ASYNC_STATE* rpcState) {
+    p->_rpcState = rpcState;}
+
+void         tspdata_setSST       (struct tspdata* p, time_t t)         {p->_sst = t;}
+
+void         tspdata_setStream    (struct tspdata* p, k5_ipc_stream s)   {p->_stream = s;}
+
+BOOL         tspdata_getListening (const struct tspdata* p)         {return p->_listening;}
+
+BOOL         tspdata_getConnected (const struct tspdata* p)         {return p->_CCAPI_Connected;}
+
+HANDLE       tspdata_getReplyEvent(const struct tspdata* p)         {return p->_replyEvent;}
+
+time_t       tspdata_getSST       (const struct tspdata* p)         {return p->_sst;}
+
+k5_ipc_stream tspdata_getStream    (const struct tspdata* p)         {return p->_stream;}
+
+char*        tspdata_getUUID      (const struct tspdata* p)         {return p->_uuid;}
+
+RPC_ASYNC_STATE* tspdata_getRpcAState (const struct tspdata* p)     {return p->_rpcState;}
+
+
+BOOL WINAPI GetTspData(DWORD dwTlsIndex, struct tspdata**  pdw) {
+    struct tspdata*  pData;      // The stored memory pointer
+
+    pData = (struct tspdata*)TlsGetValue(dwTlsIndex);
+    if (pData == NULL) {
+        pData = malloc(sizeof(*pData));
+        if (pData == NULL)
+            return FALSE;
+        memset(pData, 0, sizeof(*pData));
+        TlsSetValue(dwTlsIndex, pData);
+    }
+    (*pdw) = pData;
+    return TRUE;
+    }
diff --git a/src/ccapi/common/win/tls.h b/src/ccapi/common/win/tls.h
new file mode 100644
index 000000000000..bd2bb9e1e0d4
--- /dev/null
+++ b/src/ccapi/common/win/tls.h
@@ -0,0 +1,71 @@
+/* ccapi/common/win/tls.h */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+/* Thread local storage for client threads. */
+
+#ifndef _tls_h
+#define _tls_h
+
+#include "windows.h"
+#include "time.h"
+#include "rpc.h"
+
+#include "k5-ipc_stream.h"
+
+#define UUID_SIZE   128
+
+/* The client code can be run in any client thread.
+   The thread-specific data is defined here.
+ */
+
+struct tspdata {
+    BOOL                _listening;
+    BOOL                _CCAPI_Connected;
+    RPC_ASYNC_STATE*    _rpcState;
+    HANDLE              _replyEvent;
+    time_t              _sst;
+    k5_ipc_stream        _stream;
+    char                _uuid[UUID_SIZE];
+    };
+
+void            tspdata_setListening (struct tspdata* p, BOOL b);
+void            tspdata_setConnected (struct tspdata* p, BOOL b);
+void            tspdata_setReplyEvent(struct tspdata* p, HANDLE h);
+void            tspdata_setRpcAState (struct tspdata* p, RPC_ASYNC_STATE* rpcState);
+void            tspdata_setSST       (struct tspdata* p, time_t t);
+void            tspdata_setStream    (struct tspdata* p, k5_ipc_stream s);
+void            tspdata_setUUID      (struct tspdata* p, unsigned char __RPC_FAR* uuidString);
+HANDLE          tspdata_getReplyEvent(const struct tspdata* p);
+
+BOOL             tspdata_getListening(const struct tspdata* p);
+BOOL             tspdata_getConnected(const struct tspdata* p);
+RPC_ASYNC_STATE* tspdata_getRpcAState(const struct tspdata* p);
+time_t           tspdata_getSST      (const struct tspdata* p);
+k5_ipc_stream     tspdata_getStream   (const struct tspdata* p);
+char*            tspdata_getUUID     (const struct tspdata* p);
+
+BOOL WINAPI GetTspData(DWORD tlsIndex, struct tspdata** pdw);
+
+#endif _tls_h
diff --git a/src/ccapi/common/win/win-utils.c b/src/ccapi/common/win/win-utils.c
new file mode 100644
index 000000000000..b49cca85f037
--- /dev/null
+++ b/src/ccapi/common/win/win-utils.c
@@ -0,0 +1,68 @@
+/* ccapi/common/win/win-utils.c */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "windows.h"
+#include <stdlib.h>
+#include <malloc.h>
+
+
+#include "win-utils.h"
+#include "cci_debugging.h"
+
+#pragma warning (disable : 4996)
+
+#define UUID_SIZE   128
+
+char*           clientPrefix        = "CCAPI_CLIENT_";
+char*           serverPrefix        = "CCS_LISTEN_";
+unsigned char*  pszProtocolSequence = "ncalrpc";
+
+#define         MAX_TIMESTAMP   40
+char            _ts[MAX_TIMESTAMP];
+
+char* clientEndpoint(const char* UUID) {
+    char* _clientEndpoint   = (char*)malloc(strlen(UUID) + strlen(clientPrefix) + 2);
+    strcpy(_clientEndpoint, clientPrefix);
+    strncat(_clientEndpoint, UUID, UUID_SIZE);
+//    cci_debug_printf("%s returning %s", __FUNCTION__, _clientEndpoint);
+    return _clientEndpoint;
+    }
+
+char* serverEndpoint(const char* user) {
+    char* _serverEndpoint   = (char*)malloc(strlen(user) + strlen(serverPrefix) + 2);
+    strcpy(_serverEndpoint, serverPrefix);
+    strncat(_serverEndpoint, user, UUID_SIZE);
+    return _serverEndpoint;
+    }
+
+char* timestamp() {
+    SYSTEMTIME  _stime;
+    GetSystemTime(&_stime);
+    GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, &_stime, "HH:mm:ss", _ts, sizeof(_ts)-1);
+    return _ts;
+    }
diff --git a/src/ccapi/common/win/win-utils.h b/src/ccapi/common/win/win-utils.h
new file mode 100644
index 000000000000..41cab24dcdff
--- /dev/null
+++ b/src/ccapi/common/win/win-utils.h
@@ -0,0 +1,55 @@
+/* ccapi/common/win/win-utils.h */
+/*
+ * Copyright 2008 Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ * require a specific license from the United States Government.
+ * It is the responsibility of any person or organization contemplating
+ * export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation, and that
+ * the name of M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ */
+
+#ifndef _win_utils_h
+#define _win_utils_h
+
+#ifndef TRUE
+#define TRUE    (1==1)
+#endif
+
+#ifndef FALSE
+#define FALSE   (1==0)
+#endif
+
+static enum ccapiMsgType {
+    CCMSG_INVALID   = 0,
+    CCMSG_CONNECT,
+    CCMSG_REQUEST,
+    CCMSG_CONNECT_REPLY,
+    CCMSG_REQUEST_REPLY,
+    CCMSG_DISCONNECT,
+    CCMSG_LISTEN,
+    CCMSG_PING,
+    CCMSG_QUIT
+    };
+
+char*                   clientEndpoint(const char* UUID);
+char*                   serverEndpoint(const char* UUID);
+extern unsigned char*   pszProtocolSequence;
+
+char* timestamp();
+
+#endif // _win_utils_h
\ No newline at end of file