low level name and packet parsing was added (You may edit external dependency to OpenSSL in root wscript file)
diff --git a/model/ccn_indexbuf.cc b/model/ccn_indexbuf.cc
new file mode 100644
index 0000000..3d04e13
--- /dev/null
+++ b/model/ccn_indexbuf.cc
@@ -0,0 +1,236 @@
+/*
+ * ccn_indexbuf.cc
+ * Abstraction
+ *
+ * Created by Ilya on 7/29/11.
+ * Copyright 2011 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include "ccn_indexbuf.h"
+
+/**
+ * @file ccn_indexbuf.c
+ * @brief Support for expandable buffer of non-negative values.
+ *
+ * Part of the CCNx C Library.
+ *
+ * Copyright (C) 2008, 2009 Palo Alto Research Center, Inc.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 2.1
+ * as published by the Free Software Foundation.
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received
+ * a copy of the GNU Lesser General Public License along with this library;
+ * if not, write to the Free Software Foundation, Inc., 51 Franklin Street,
+ * Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ELEMENT size_t
+
+/**
+ * Create a new indexbuf.
+ */
+struct ccn_indexbuf *
+ccn_indexbuf_create(void)
+{
+ struct ccn_indexbuf *c;
+ c = (ccn_indexbuf*)calloc(1, sizeof(*c));
+ return(c);
+}
+
+/**
+ * Deallocate indexbuf.
+ */
+void
+ccn_indexbuf_destroy(struct ccn_indexbuf **cbp)
+{
+ struct ccn_indexbuf *c = *cbp;
+ if (c != NULL) {
+ if (c->buf != NULL) {
+ free(c->buf);
+ }
+ free(c);
+ *cbp = NULL;
+ }
+}
+
+/**
+ * Expand buffer as necessary to hold at least n more values.
+ * @returns pointer to reserved space
+ */
+ELEMENT *
+ccn_indexbuf_reserve(struct ccn_indexbuf *c, size_t n)
+{
+ size_t newlim = n + c->n;
+ size_t oldlim = c->limit;
+ ELEMENT *buf = c->buf;
+ if (newlim < n)
+ return(NULL);
+ if (newlim > oldlim) {
+ if (2 * oldlim > newlim)
+ newlim = 2 * oldlim;
+ buf = (size_t*)realloc(c->buf, newlim * sizeof(ELEMENT));
+ if (buf == NULL)
+ return(NULL);
+ memset(buf + oldlim, 0, (newlim - oldlim) * sizeof(ELEMENT));
+ c->buf = buf;
+ c->limit = newlim;
+ }
+ buf += c->n;
+ return(buf);
+}
+
+/**
+ * Append multiple elements to the indexbuf.
+ * @returns 0 for success, -1 for failure.
+ */
+int
+ccn_indexbuf_append(struct ccn_indexbuf *c, const ELEMENT *p, size_t n)
+{
+ ELEMENT *dst = ccn_indexbuf_reserve(c, n);
+ if (dst == NULL)
+ return(-1);
+ memcpy(dst, p, n * sizeof(ELEMENT));
+ c->n += n;
+ return(0);
+}
+
+/**
+ * Append v to the indexbuf
+ * @returns 0 for success, -1 for failure.
+ */
+int
+ccn_indexbuf_append_element(struct ccn_indexbuf *c, ELEMENT v)
+{
+ ELEMENT *dst = ccn_indexbuf_reserve(c, 1);
+ if (dst == NULL)
+ return(-1);
+ *dst = v;
+ c->n += 1;
+ return(0);
+}
+
+/**
+ * @returns index at which the element was found or appended, or -1 if not found.
+ */
+int
+ccn_indexbuf_member(struct ccn_indexbuf *x, ELEMENT val)
+{
+ int i;
+ if (x == NULL)
+ return (-1);
+ for (i = x->n - 1; i >= 0; i--)
+ if (x->buf[i] == val)
+ return(i);
+ return(-1);
+}
+
+/**
+ * Removes up to one instance of val from the indexbuf.
+ * Order of elements not preserved.
+ */
+void
+ccn_indexbuf_remove_element(struct ccn_indexbuf *x, ELEMENT val)
+{
+ int i;
+ if (x == NULL) return;
+ for (i = x->n - 1; i >= 0; i--)
+ if (x->buf[i] == val) {
+ x->buf[i] = x->buf[--x->n]; /* move last element into vacant spot */
+ return;
+ }
+}
+
+/**
+ * @returns index at which the element was found or appended,
+ * or -1 in case of error.
+ */
+int
+ccn_indexbuf_set_insert(struct ccn_indexbuf *x, ELEMENT val)
+{
+ int i;
+ if (x == NULL)
+ return (-1);
+ for (i = 0; i < (int)x->n; i++)
+ if (x->buf[i] == val)
+ return(i);
+ if (ccn_indexbuf_append_element(x, val) < 0)
+ return(-1);
+ return(i);
+}
+
+/**
+ * Removes first occurrence of val, preserving order
+ * @returns index at which the element was found,
+ * or -1 if the element was not found.
+ */
+int
+ccn_indexbuf_remove_first_match(struct ccn_indexbuf *x, ELEMENT val)
+{
+ int i;
+ int n;
+ if (x == NULL)
+ return (-1);
+ for (i = 0, n = x->n; i < n; i++) {
+ if (x->buf[i] == val) {
+ if (i + 1 < n)
+ memmove(&(x->buf[i]),
+ &(x->buf[i + 1]),
+ sizeof(x->buf[i]) * (n - i - 1));
+ x->n--;
+ return(i);
+ }
+ }
+ return(-1);
+}
+
+/**
+ * If val is present in the indexbuf, move it to the final place.
+ */
+void
+ccn_indexbuf_move_to_end(struct ccn_indexbuf *x, ELEMENT val)
+{
+ int i;
+ int n;
+ if (x == NULL)
+ return;
+ for (i = 0, n = x->n; i + 1 < n; i++) {
+ if (x->buf[i] == val) {
+ memmove(&(x->buf[i]),
+ &(x->buf[i + 1]),
+ sizeof(x->buf[i]) * (n - i - 1));
+ x->buf[n - 1] = val;
+ return;
+ }
+ }
+}
+
+/**
+ * If val is present in the indexbuf, move it to the first place.
+ */
+void
+ccn_indexbuf_move_to_front(struct ccn_indexbuf *x, ELEMENT val)
+{
+ int i;
+ int n;
+ if (x == NULL)
+ return;
+ for (i = 0, n = x->n; i < n; i++) {
+ if (x->buf[i] == val) {
+ memmove(&(x->buf[1]),
+ &(x->buf[0]),
+ sizeof(x->buf[i]) * i);
+ x->buf[0] = val;
+ return;
+ }
+ }
+
+}
+