celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From abroekh...@apache.org
Subject svn commit: r1339082 - in /incubator/celix/trunk/hessian: ./ private/ private/src/ private/test/ public/ public/include/
Date Wed, 16 May 2012 09:34:45 GMT
Author: abroekhuis
Date: Wed May 16 09:34:44 2012
New Revision: 1339082

URL: http://svn.apache.org/viewvc?rev=1339082&view=rev
Log:
Added hessian

Added:
    incubator/celix/trunk/hessian/
    incubator/celix/trunk/hessian/CMakeLists.txt
    incubator/celix/trunk/hessian/private/
    incubator/celix/trunk/hessian/private/src/
    incubator/celix/trunk/hessian/private/src/hessian_in.c
    incubator/celix/trunk/hessian/private/src/hessian_out.c
    incubator/celix/trunk/hessian/private/test/
    incubator/celix/trunk/hessian/private/test/test_hessian_out.c
    incubator/celix/trunk/hessian/private/test/test_service.h
    incubator/celix/trunk/hessian/private/test/test_service_proxy.c
    incubator/celix/trunk/hessian/private/test/test_service_skeleton.c
    incubator/celix/trunk/hessian/public/
    incubator/celix/trunk/hessian/public/include/
    incubator/celix/trunk/hessian/public/include/hessian_2.0.h
    incubator/celix/trunk/hessian/public/include/hessian_2.0_in.h
    incubator/celix/trunk/hessian/public/include/hessian_2.0_out.h
    incubator/celix/trunk/hessian/public/include/hessian_constants.h
    incubator/celix/trunk/hessian/test.c

Added: incubator/celix/trunk/hessian/CMakeLists.txt
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/CMakeLists.txt?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/CMakeLists.txt (added)
+++ incubator/celix/trunk/hessian/CMakeLists.txt Wed May 16 09:34:44 2012
@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+include_directories("${PROJECT_SOURCE_DIR}/utils/public/include")
+include_directories("private/include")
+include_directories("public/include")
+
+add_library(hessian STATIC private/src/hessian_out private/src/hessian_in)
+target_link_libraries(hessian utils)
+
+include_directories(${CUNIT_INCLUDE_DIRS})
+add_executable(test_hessian_out private/test/test_hessian_out.c)
+target_link_libraries(test_hessian_out hessian ${CUNIT_LIBRARIES})
+
+run_test(test_hessian_out)

Added: incubator/celix/trunk/hessian/private/src/hessian_in.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/private/src/hessian_in.c?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/private/src/hessian_in.c (added)
+++ incubator/celix/trunk/hessian/private/src/hessian_in.c Wed May 16 09:34:44 2012
@@ -0,0 +1,483 @@
+/*
+ * hessian_in.c
+ *
+ *  Created on: Aug 1, 2011
+ *      Author: alexander
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "hessian_2.0.h"
+
+static int END_OF_DATA = -2;
+
+int hessian_parseChar(hessian_in_t in, char *c);
+int hessian_parseLong(hessian_in_t in, long *value);
+int hessian_parseInt16(hessian_in_t in, int *value);
+int hessian_parseInt(hessian_in_t in, int *value);
+
+char hessian_read(hessian_in_t in) {
+	return (in->buffer[in->offset++] & 0xFF);
+}
+
+int hessian_readBoolean(hessian_in_t in, bool *value) {
+	char tag = hessian_read(in);
+
+	switch (tag) {
+		case 'T':
+			*value = true;
+			break;
+		case 'F':
+		default:
+			*value = false;
+			break;
+	}
+
+	return 0;
+}
+
+int hessian_readInt(hessian_in_t in, int *value) {
+	unsigned char tag = hessian_read(in);
+
+	switch (tag) {
+		// direct integer
+		case 0x80: case 0x81: case 0x82: case 0x83:
+		case 0x84: case 0x85: case 0x86: case 0x87:
+		case 0x88: case 0x89: case 0x8a: case 0x8b:
+		case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+		case 0x90: case 0x91: case 0x92: case 0x93:
+		case 0x94: case 0x95: case 0x96: case 0x97:
+		case 0x98: case 0x99: case 0x9a: case 0x9b:
+		case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+		case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+		case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+		case 0xa8: case 0xa9: case 0xaa: case 0xab:
+		case 0xac: case 0xad: case 0xae: case 0xaf:
+
+		case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+		case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+		case 0xb8: case 0xb9: case 0xba: case 0xbb:
+		case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+			*value = tag - INT_ZERO;
+			break;
+
+		/* byte int */
+		case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+		case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+		case 0xc8: case 0xc9: case 0xca: case 0xcb:
+		case 0xcc: case 0xcd: case 0xce: case 0xcf:
+			*value = ((tag - INT_BYTE_ZERO) << 8) + hessian_read(in);
+			break;
+
+		/* short int */
+		case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+		case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+			*value = ((tag - INT_SHORT_ZERO) << 16) + 256 * hessian_read(in) + hessian_read(in);
+			break;
+
+		case 'I':
+			hessian_readInt(in, value);
+			break;
+
+		default:
+			*value = 0;
+			break;
+	}
+
+	return 1;
+}
+
+int hessian_readLong(hessian_in_t in, long *value) {
+	unsigned char tag = hessian_read(in);
+
+	switch (tag) {
+		// direct long
+		case 0xd8: case 0xd9: case 0xda: case 0xdb:
+		case 0xdc: case 0xdd: case 0xde: case 0xdf:
+
+		case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+		case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+		case 0xe8: case 0xe9: case 0xea: case 0xeb:
+		case 0xec: case 0xed: case 0xee: case 0xef:
+			*value = tag - LONG_ZERO;
+			break;
+
+		/* byte long */
+		case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+		case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+		case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+		case 0xfc: case 0xfd: case 0xfe: case 0xff:
+			*value = ((tag - LONG_BYTE_ZERO) << 8) + hessian_read(in);
+			break;
+
+		/* short long */
+		case 0x38: case 0x39: case 0x3a: case 0x3b:
+		case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+			*value = ((tag - LONG_SHORT_ZERO) << 16) + 256
+					* hessian_read(in) + hessian_read(in);
+			break;
+
+		case 'L':
+			hessian_parseLong(in, value);
+			break;
+		default:
+			return 0l;
+	}
+
+	return 0;
+}
+
+int hessian_readDouble(hessian_in_t in, double *value) {
+	unsigned char tag = hessian_read(in);
+
+	long l;
+	int i;
+	double *d;
+	switch (tag) {
+		case 0x67:
+			*value = 0;
+			break;
+	    case 0x68:
+	    	*value = 1;
+	    	break;
+	    case 0x69:
+	    	*value = (double) hessian_read(in);
+	    	break;
+	    case 0x6a:
+	    	*value = (short) (256 * hessian_read(in) + hessian_read(in));
+	    	break;
+	    case 0x6b:
+	    	hessian_parseInt(in, &i);
+
+	    	*value = (double) *((float *) &i);
+	    	break;
+	    case 'D':
+	    	hessian_parseLong(in, &l);
+
+	    	d = (double *) &l;
+
+	    	*value = *d;
+	    	break;
+	}
+
+	return 0;
+}
+
+int hessian_readUTCDate(hessian_in_t in, long *value) {
+	unsigned char tag = hessian_read(in);
+
+	if (tag == 'd') {
+		hessian_parseLong(in, value);
+	}
+
+	return 0;
+}
+
+int hessian_readNull(hessian_in_t in) {
+	unsigned char tag = hessian_read(in);
+
+	switch (tag) {
+		case 'N':
+			break;
+		default:
+			break;
+	}
+
+	return 0;
+}
+
+int hessian_readChar(hessian_in_t in, char *value) {
+	char *readC;
+	unsigned int read;
+	hessian_readNString(in, 0, 1, &readC, &read);
+	*value = readC[0];
+
+	return 0;
+}
+
+int hessian_readString(hessian_in_t in, char **value, unsigned int *readLength) {
+	return hessian_readNString(in, 0, -1, value, readLength);
+}
+
+int hessian_readNString(hessian_in_t in, int offset, int length, char **value, unsigned int
*readLength) {
+	*readLength = 0;
+
+	bool done = false;
+	if (in->chunkLength == END_OF_DATA) {
+		done = true;
+	} else if (in->chunkLength == 0) {
+		unsigned char tag = hessian_read(in);
+
+		switch (tag) {
+			case 'N':
+				in->chunkLength = 0;
+				in->lastChunk = true;
+				break;
+			case 'S':
+			case 's':
+				in->lastChunk = tag == 'S';
+				hessian_parseInt16(in, &(in->chunkLength));
+				break;
+
+			case 0x00: case 0x01: case 0x02: case 0x03:
+			case 0x04: case 0x05: case 0x06: case 0x07:
+			case 0x08: case 0x09: case 0x0a: case 0x0b:
+			case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+			case 0x10: case 0x11: case 0x12: case 0x13:
+			case 0x14: case 0x15: case 0x16: case 0x17:
+			case 0x18: case 0x19: case 0x1a: case 0x1b:
+			case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+				in->chunkLength = tag - 0x00;
+				in->lastChunk = true;
+				break;
+
+			case 0x30: case 0x31: case 0x32: case 0x33:
+				in->chunkLength = (tag - 0x30) * 256 + hessian_read(in);
+				in->lastChunk = true;
+				break;
+
+			default:
+				in->chunkLength = 0;
+				in->lastChunk = true;
+				break;
+		}
+	}
+
+	while (!done) {
+		unsigned int newSize = *readLength + in->chunkLength + 1;
+		*value = realloc(*value, sizeof(char) * (*readLength + in->chunkLength + 1));
+
+		if (in->chunkLength > 0) {
+			char c;
+			hessian_parseChar(in, &c);
+			(*value)[(*readLength) + offset] = c;
+			(*value)[(*readLength) + offset + 1] = '\0';
+			in->chunkLength--;
+			(*readLength)++;
+			length--;
+
+			if (length == 0) {
+				done = true;
+			}
+
+		} else if (in->lastChunk) {
+			done = true;
+			if (*readLength != 0) {
+				in->chunkLength = END_OF_DATA;
+			}
+		} else {
+			unsigned char tag = hessian_read(in);
+			switch (tag) {
+				case 'S':
+				case 's':
+					done = tag == 'S';
+
+					hessian_parseInt16(in, &in->chunkLength);
+					break;
+
+				case 0x00: case 0x01: case 0x02: case 0x03:
+				case 0x04: case 0x05: case 0x06: case 0x07:
+				case 0x08: case 0x09: case 0x0a: case 0x0b:
+				case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+				case 0x10: case 0x11: case 0x12: case 0x13:
+				case 0x14: case 0x15: case 0x16: case 0x17:
+				case 0x18: case 0x19: case 0x1a: case 0x1b:
+				case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+					in->chunkLength = tag - 0x00;
+					in->lastChunk = true;
+					break;
+
+				case 0x30: case 0x31: case 0x32: case 0x33:
+					in->chunkLength = (tag - 0x30) * 256 + hessian_read(in);
+					in->lastChunk = true;
+					break;
+
+				default:
+					in->chunkLength = 0;
+					in->lastChunk = true;
+				break;
+			}
+		}
+	}
+
+	if (in->lastChunk && in->chunkLength == 0) {
+		in->chunkLength = END_OF_DATA;
+	}
+
+	return 0;
+}
+
+int hessian_readByte(hessian_in_t in, unsigned char *value) {
+	unsigned char *readC;
+	unsigned int read;
+	hessian_readNBytes(in, 0, 1, &readC, &read);
+	*value = readC[0];
+
+	return 0;
+}
+
+int hessian_readBytes(hessian_in_t in, unsigned char **value, unsigned int *readLength) {
+	return hessian_readNBytes(in, 0, -1, value, readLength);
+}
+
+int hessian_readNBytes(hessian_in_t in, int offset, int length, unsigned char **value, unsigned
int *readLength) {
+	*readLength = 0;
+
+	bool done = false;
+	if (in->chunkLength == END_OF_DATA) {
+		done = true;
+	} else if (in->chunkLength == 0) {
+		unsigned char tag = hessian_read(in);
+
+		switch (tag) {
+			case 'N':
+				in->chunkLength = 0;
+				in->lastChunk = true;
+				break;
+			case 'B':
+			case 'b':
+				in->lastChunk = tag == 'B';
+				hessian_parseInt16(in, &(in->chunkLength));
+				break;
+
+			case 0x20: case 0x21: case 0x22: case 0x23:
+			case 0x24: case 0x25: case 0x26: case 0x27:
+			case 0x28: case 0x29: case 0x2a: case 0x2b:
+			case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+				in->chunkLength = tag - 0x20;
+				in->lastChunk = true;
+				break;
+
+			default:
+				in->chunkLength = 0;
+				in->lastChunk = true;
+				break;
+		}
+	}
+
+	while (!done) {
+		unsigned int newSize = *readLength + in->chunkLength;
+		*value = realloc(*value, sizeof(char) * (*readLength + in->chunkLength));
+
+		if (in->chunkLength > 0) {
+			unsigned char c = hessian_read(in);
+			(*value)[(*readLength) + offset] = c;
+			in->chunkLength--;
+			(*readLength)++;
+			length--;
+
+			if (length == 0) {
+				done = true;
+			}
+
+		} else if (in->lastChunk) {
+			done = true;
+			if (*readLength != 0) {
+				in->chunkLength = END_OF_DATA;
+			}
+		} else {
+			unsigned char tag = hessian_read(in);
+			switch (tag) {
+				case 'B':
+				case 'b':
+					done = tag == 'S';
+
+					hessian_parseInt16(in, &in->chunkLength);
+					break;
+
+				case 0x20: case 0x21: case 0x22: case 0x23:
+				case 0x24: case 0x25: case 0x26: case 0x27:
+				case 0x28: case 0x29: case 0x2a: case 0x2b:
+				case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+					in->chunkLength = tag - 0x20;
+					in->lastChunk = true;
+					break;
+
+				default:
+					in->chunkLength = 0;
+					in->lastChunk = true;
+				break;
+			}
+		}
+	}
+
+	if (in->lastChunk && in->chunkLength == 0) {
+		in->chunkLength = END_OF_DATA;
+	}
+
+	return 0;
+}
+
+int hessian_parseChar(hessian_in_t in, char *c) {
+	unsigned char ch = hessian_read(in);
+
+	if (ch < 0x80) {
+		*c = ch;
+	} else if ((ch & 0xe0) == 0xc0) {
+		char ch1 = hessian_read(in);
+
+		*c = ((ch & 0x1f) << 6) + (ch1 & 0x3f);
+	} else if ((ch & 0xf0) == 0xe0) {
+		char ch1 = hessian_read(in);
+		char ch2 = hessian_read(in);
+
+		*c = ((ch & 0x0f) << 12) + ((ch1 & 0x3f) << 6) + (ch2 & 0x3f);
+	} else {
+		*c = '\0';
+	}
+
+	return 0;
+}
+
+int hessian_parseInt16(hessian_in_t in, int *value) {
+	int b16 = hessian_read(in) & 0xFF;
+	int b8 = hessian_read(in) & 0xFF;
+
+	*value = (b16 << 8)
+			+ b8;
+
+	return 0;
+}
+
+int hessian_parseInt(hessian_in_t in, int *value) {
+	int b32 = hessian_read(in) & 0xFF;
+	int b24 = hessian_read(in) & 0xFF;
+	int b16 = hessian_read(in) & 0xFF;
+	int b8 = hessian_read(in) & 0xFF;
+
+	*value = (b32 << 24)
+			+ (b24 << 16)
+			+ (b16 << 8)
+			+ b8;
+
+	return 0;
+}
+
+int hessian_parseLong(hessian_in_t in, long *value) {
+	long b64 = hessian_read(in) & 0xFF;
+	long b56 = hessian_read(in) & 0xFF;
+	long b48 = hessian_read(in) & 0xFF;
+	long b40 = hessian_read(in) & 0xFF;
+	long b32 = hessian_read(in) & 0xFF;
+	long b24 = hessian_read(in) & 0xFF;
+	long b16 = hessian_read(in) & 0xFF;
+	long b8 = hessian_read(in) & 0xFF;
+
+	long v = (b64 << 56)
+			+ (b56 << 48)
+			+ (b48 << 40)
+			+ (b40 << 32)
+			+ (b32 << 24)
+			+ (b24 << 16)
+			+ (b16 << 8)
+			+ b8;
+
+	*value = v;
+
+	return 0;
+}

Added: incubator/celix/trunk/hessian/private/src/hessian_out.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/private/src/hessian_out.c?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/private/src/hessian_out.c (added)
+++ incubator/celix/trunk/hessian/private/src/hessian_out.c Wed May 16 09:34:44 2012
@@ -0,0 +1,382 @@
+/*
+ * hessian.c
+ *
+ *  Created on: Jul 31, 2011
+ *      Author: alexander
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "hessian_2.0.h"
+
+void hessian_ensureCapacity(hessian_out_t obj, int capacity);
+
+int hessian_printString(hessian_out_t out, char *value);
+int hessian_printNString(hessian_out_t out, char *value, int offset, int length);
+
+int hessian_writeType(hessian_out_t out, char *type);
+
+int hessian_write(hessian_out_t out, unsigned char byte);
+int hessian_writeP(hessian_out_t out, unsigned char *byte);
+
+int hessian_writeBoolean(hessian_out_t out, bool value) {
+	hessian_ensureCapacity(out, out->offset + 1);
+
+	if (value) {
+		char c = 'T';
+		hessian_writeP(out, &c);
+	} else {
+		out->buffer[out->offset++] = 'F';
+		out->length++;
+	}
+
+	return 0;
+}
+
+int hessian_writeInt(hessian_out_t out, int value) {
+	hessian_ensureCapacity(out, out->offset + 5);
+
+	if (INT_DIRECT_MIN <= value && value <= INT_DIRECT_MAX)
+		hessian_write(out, (char) (value + INT_ZERO));
+	else if (INT_BYTE_MIN <= value && value <= INT_BYTE_MAX) {
+		hessian_write(out, (char) (INT_BYTE_ZERO + (value >> 8)));
+		hessian_write(out, (char) (value));
+	} else if (INT_SHORT_MIN <= value && value <= INT_SHORT_MAX) {
+		hessian_write(out, (char)(INT_SHORT_ZERO + (value >> 16)));
+		hessian_write(out, (char)(value >> 8));
+		hessian_write(out, (char)(value));
+	} else {
+		hessian_write(out, (char)('I'));
+		hessian_write(out, (char)(value >> 24));
+		hessian_write(out, (char)(value >> 16));
+		hessian_write(out, (char)(value >> 8));
+		hessian_write(out, (char)(value));
+	}
+
+	return 0;
+}
+
+int hessian_writeLong(hessian_out_t out, long value) {
+	hessian_ensureCapacity(out, out->offset + 9);
+
+	if (LONG_DIRECT_MIN <= value && value <= LONG_DIRECT_MAX) {
+		hessian_write(out, (char)(value + LONG_ZERO));
+	} else if (LONG_BYTE_MIN <= value && value <= LONG_BYTE_MAX) {
+		hessian_write(out, (char)(LONG_BYTE_ZERO + (value >> 8)));
+		hessian_write(out, (char)(value));
+	} else if (LONG_SHORT_MIN <= value && value <= LONG_SHORT_MAX) {
+		hessian_write(out, (char)(LONG_SHORT_ZERO + (value >> 16)));
+		hessian_write(out, (char)(value >> 8));
+		hessian_write(out, (char)(value));
+	} else if (-0x80000000L <= value && value <= 0x7fffffffL) {
+		hessian_write(out, (char) LONG_INT);
+		hessian_write(out, (char)(value >> 24));
+		hessian_write(out, (char)(value >> 16));
+		hessian_write(out, (char)(value >> 8));
+		hessian_write(out, (char)(value));
+	} else {
+		hessian_write(out, (char) 'L');
+		hessian_write(out, (char)(value >> 56));
+		hessian_write(out, (char)(value >> 48));
+		hessian_write(out, (char)(value >> 40));
+		hessian_write(out, (char)(value >> 32));
+		hessian_write(out, (char)(value >> 24));
+		hessian_write(out, (char)(value >> 16));
+		hessian_write(out, (char)(value >> 8));
+		hessian_write(out, (char)(value));
+	}
+
+	return 0;
+}
+
+int hessian_writeDouble(hessian_out_t out, double value) {
+	hessian_ensureCapacity(out, out->offset + 9);
+
+	int intValue = (int) value;
+
+	if (intValue == value) {
+		if (intValue == 0) {
+			hessian_write(out, (char) DOUBLE_ZERO);
+		} else if (intValue == 1) {
+			hessian_write(out, (char) DOUBLE_ONE);
+		} else if (-0x80 <= intValue && intValue < 0x80) {
+			hessian_write(out, (char) DOUBLE_BYTE);
+			hessian_write(out, (char) intValue);
+		} else if (-0x8000 <= intValue && intValue < 0x8000) {
+			hessian_write(out, (char) DOUBLE_SHORT);
+			hessian_write(out, (char) ((intValue >> 8) & 0xFF));
+			hessian_write(out, (char) (intValue & 0xFF));
+		}
+	} else {
+		float f = (float) value;
+
+		if (f == value) {
+			float f = value;
+			int bits = *((int *) &f);
+
+			hessian_write(out, (char)(DOUBLE_FLOAT));
+			hessian_write(out, (char)(bits >> 24));
+			hessian_write(out, (char)(bits >> 16));
+			hessian_write(out, (char)(bits >> 8));
+			hessian_write(out, (char)(bits));
+		} else {
+			long bits = *((long *) &value);
+
+			hessian_write(out, (char) 'D');
+			hessian_write(out, (char)(bits >> 56) & 0x00000000000000FF);
+			hessian_write(out, (char)(bits >> 48) & 0x00000000000000FF);
+			hessian_write(out, (char)(bits >> 40) & 0x00000000000000FF);
+			hessian_write(out, (char)(bits >> 32) & 0x00000000000000FF);
+			hessian_write(out, (char)(bits >> 24) & 0x00000000000000FF);
+			hessian_write(out, (char)(bits >> 16) & 0x00000000000000FF);
+			hessian_write(out, (char)(bits >> 8) & 0x00000000000000FF);
+			hessian_write(out, (char)(bits) & 0x00000000000000FF);
+		}
+	}
+
+	return 0;
+}
+
+int hessian_writeUTCDate(hessian_out_t out, long value) {
+	hessian_ensureCapacity(out, out->offset + 9);
+
+	hessian_write(out, (int) ('d'));
+	hessian_write(out, ((int) (value >> 56)));
+	hessian_write(out, ((int) (value >> 48)));
+	hessian_write(out, ((int) (value >> 40)));
+	hessian_write(out, ((int) (value >> 32)));
+	hessian_write(out, ((int) (value >> 24)));
+	hessian_write(out, ((int) (value >> 16)));
+	hessian_write(out, ((int) (value >> 8)));
+	hessian_write(out, ((int) (value)));
+
+	return 0;
+}
+
+int hessian_writeNull(hessian_out_t out) {
+	hessian_ensureCapacity(out, out->offset + 1);
+
+	hessian_write(out, (int) ('N'));
+
+	return 0;
+}
+
+int hessian_writeString(hessian_out_t out, char *value) {
+	int length = strlen(value);
+	return hessian_writeNString(out, value, 0, length);
+}
+
+int hessian_writeNString(hessian_out_t out, char *value, int offset, int length) {
+	if (value == NULL) {
+		hessian_writeNull(out);
+	} else {
+		while (length > 0x8000) {
+			int sublen = 0x8000;
+
+			// chunk can't end in high surrogate
+			int tail = value[offset + sublen - 1];
+
+			if (0xd800 <= tail && tail <= 0xdbff)
+				sublen--;
+
+			hessian_ensureCapacity(out, out->offset + 3);
+
+			hessian_write(out, (int) 's');
+			hessian_write(out, (int)(sublen >> 8));
+			hessian_write(out, (int)(sublen));
+
+			hessian_printNString(out, value, offset, sublen);
+
+			length -= sublen;
+			offset += sublen;
+		}
+
+		if (length <= STRING_DIRECT_MAX) {
+			hessian_ensureCapacity(out, out->offset + 2);
+
+			hessian_write(out, (int)(STRING_DIRECT + length));
+		} else {
+			hessian_ensureCapacity(out, out->offset + 3);
+
+			hessian_write(out, (int)('S'));
+			hessian_write(out, (int)(length >> 8));
+			hessian_write(out, (int)(length));
+		}
+
+		hessian_printNString(out, value, offset, length);
+	}
+
+	return 0;
+}
+
+int hessian_writeBytes(hessian_out_t out, unsigned char value[], int length) {
+	return hessian_writeNBytes(out, value, 0, length);
+}
+
+int hessian_writeNBytes(hessian_out_t out, unsigned char value[], int offset, int length)
{
+	if (value == NULL) {
+		hessian_writeNull(out);
+	} else {
+		while (length > 0x8000) {
+			int sublen = 0x8000;
+
+			hessian_ensureCapacity(out, out->offset + 3);
+
+			hessian_write(out, (int) 'b');
+			hessian_write(out, (int)(sublen >> 8));
+			hessian_write(out, (int) sublen);
+
+			hessian_ensureCapacity(out, out->offset + sublen);
+			memcpy(out->buffer+out->offset, value+offset, sublen);
+			out->offset += sublen;
+
+			length -= sublen;
+			offset += sublen;
+		}
+
+		if (length < 0x10) {
+			hessian_ensureCapacity(out, out->offset + 1);
+			hessian_write(out, (int)(BYTES_DIRECT + length));
+		} else {
+			hessian_ensureCapacity(out, out->offset + 3);
+			hessian_write(out, (int) 'B');
+			hessian_write(out, (int)(length >> 8));
+			hessian_write(out, (int)(length));
+		}
+
+		hessian_ensureCapacity(out, out->offset + length);
+		memcpy(out->buffer+out->offset, value+offset, length);
+
+		out->offset += length;
+	}
+
+	return 0;
+}
+
+int hessian_writeListBegin(hessian_out_t out, int length, char *type) {
+	hessian_ensureCapacity(out, out->offset + 1);
+	if (length < 0) {
+		if (type != NULL) {
+			hessian_write(out, (char) BC_LIST_VARIABLE);
+			hessian_writeType(out, type);
+		} else {
+			hessian_write(out, (char) BC_LIST_VARIABLE_UNTYPED);
+		}
+
+		return true;
+	} else if (length <= LIST_DIRECT_MAX) {
+		if (type != NULL) {
+			hessian_write(out, (char)(BC_LIST_DIRECT + length));
+			hessian_writeType(out, type);
+		} else {
+			hessian_write(out, (char)(BC_LIST_DIRECT_UNTYPED + length));
+		}
+
+		return false;
+	} else {
+		if (type != NULL) {
+			hessian_write(out, (char) BC_LIST_FIXED);
+			hessian_writeType(out, type);
+		} else {
+			hessian_write(out, (char) BC_LIST_FIXED_UNTYPED);
+		}
+
+		hessian_writeInt(out, length);
+
+		return false;
+	}
+
+	return 0;
+}
+
+int hessian_writeListEnd(hessian_out_t out) {
+	hessian_ensureCapacity(out, out->offset + 1);
+	hessian_write(out, (char) BC_END);
+
+	return 0;
+}
+
+int hessian_writeType(hessian_out_t out, char *type) {
+	int len = strlen(type);
+	if (len == 0) {
+		return 1;
+	}
+
+	// Do something with refs here
+	return hessian_writeString(out, type);
+}
+
+int hessian_startCall(hessian_out_t out, char *method, int length) {
+	hessian_ensureCapacity(out, out->offset + 1);
+	hessian_write(out, 'C');
+
+	hessian_writeString(out, method);
+	hessian_writeInt(out, length);
+
+	return 0;
+}
+
+int hessian_completeCall(hessian_out_t out) {
+	return 0;
+}
+
+int hessian_printString(hessian_out_t out, char *value) {
+	return hessian_printNString(out, value, 0, strlen(value));
+}
+
+int hessian_printNString(hessian_out_t out, char *value, int offset, int length) {
+	hessian_ensureCapacity(out, out->offset + length);
+
+	for (int i = 0; i < length; i++) {
+		int ch = value[i + offset];
+
+		if (ch < 0x80) {
+			hessian_write(out, (int)(ch));
+			out->length++;
+		} else if (ch < 0x800) {
+			hessian_write(out, (int)(0xc0 + ((ch >> 6) & 0x1f)));
+			out->length++;
+			hessian_write(out, (int)(0x80 + (ch & 0x3f)));
+			out->length++;
+		} else {
+			hessian_write(out, (int)(0xe0 + ((ch >> 12) & 0xf)));
+			out->length++;
+			hessian_write(out, (int)(0x80 + ((ch >> 6) & 0x3f)));
+			out->length++;
+			hessian_write(out, (int)(0x80 + (ch & 0x3f)));
+			out->length++;
+		}
+	}
+
+	return 0;
+}
+
+void hessian_ensureCapacity(hessian_out_t obj, int capacity) {
+	char *newArray;
+	int oldCapacity;
+	oldCapacity = obj->capacity;
+	if (capacity > oldCapacity) {
+		int newCapacity = (oldCapacity * 3) / 2 + 1;
+		if (newCapacity < capacity) {
+			newCapacity = capacity;
+		}
+		newArray = (char *) realloc(obj->buffer, sizeof(char *) * newCapacity);
+		obj->capacity = newCapacity;
+		obj->buffer = newArray;
+	}
+}
+
+int hessian_write(hessian_out_t out, unsigned char byte) {
+	out->buffer[out->offset++] = byte;
+	out->length++;
+
+	return 0;
+}
+
+int hessian_writeP(hessian_out_t out, unsigned char *byte) {
+	out->buffer[out->offset++] = *byte;
+	out->length++;
+
+	return 0;
+}

Added: incubator/celix/trunk/hessian/private/test/test_hessian_out.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/private/test/test_hessian_out.c?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/private/test/test_hessian_out.c (added)
+++ incubator/celix/trunk/hessian/private/test/test_hessian_out.c Wed May 16 09:34:44 2012
@@ -0,0 +1,77 @@
+/*
+ * test_hessian_out.c
+ *
+ *  Created on: Aug 4, 2011
+ *      Author: alexander
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <Automated.h>
+
+#include "hessian_2.0_out.h"
+
+hessian_out_t out;
+
+int setup() {
+	out = malloc(sizeof(*out));
+
+	return 0;
+}
+
+void test_hessian_writeBoolean() {
+	out = malloc(sizeof(*out));
+
+	hessian_writeBoolean(out, true);
+
+	CU_ASSERT_EQUAL(out->length, 1);
+	CU_ASSERT_EQUAL(out->buffer[0], 'T');
+}
+
+void test_hessian_writeInt() {
+	out = malloc(sizeof(*out));
+
+	hessian_writeInt(out, 0);
+
+	unsigned char c1 = out->buffer[0];
+	unsigned char expect = 0x90;
+	CU_ASSERT_EQUAL(out->length, 1);
+	CU_ASSERT_EQUAL(c1, expect);
+
+	hessian_writeInt(out, -256);
+
+	unsigned char c2[] =  { out->buffer[1], out->buffer[2] };
+	unsigned char expect2[] = { 0xC7, 0x00 };
+	CU_ASSERT_EQUAL(out->length, 3);
+	// CU_ASSERT_EQUAL(c2, expect2);
+}
+
+int main (int argc, char** argv) {
+	CU_pSuite pSuite = NULL;
+
+	/* initialize the CUnit test registry */
+	if (CUE_SUCCESS != CU_initialize_registry())
+	  return CU_get_error();
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("Hessian output", setup, NULL);
+	if (NULL == pSuite) {
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (
+			NULL == CU_add_test(pSuite, "test boolean", test_hessian_writeBoolean)
+			|| NULL == CU_add_test(pSuite, "test int", test_hessian_writeInt)
+		) {
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	CU_set_output_filename(argv[1]);
+	CU_list_tests_to_file();
+	CU_automated_run_tests();
+	CU_cleanup_registry();
+	return CU_get_error();
+}

Added: incubator/celix/trunk/hessian/private/test/test_service.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/private/test/test_service.h?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/private/test/test_service.h (added)
+++ incubator/celix/trunk/hessian/private/test/test_service.h Wed May 16 09:34:44 2012
@@ -0,0 +1,16 @@
+/*
+ * test_service.h
+ *
+ *  Created on: Aug 5, 2011
+ *      Author: alexander
+ */
+
+#ifndef TEST_SERVICE_H_
+#define TEST_SERVICE_H_
+
+typedef struct test_service *test_service_t;
+
+void testService_sayHello(test_service_t testService, char *message);
+
+
+#endif /* TEST_SERVICE_H_ */

Added: incubator/celix/trunk/hessian/private/test/test_service_proxy.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/private/test/test_service_proxy.c?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/private/test/test_service_proxy.c (added)
+++ incubator/celix/trunk/hessian/private/test/test_service_proxy.c Wed May 16 09:34:44 2012
@@ -0,0 +1,16 @@
+/*
+ * test_encoder.c
+ *
+ *  Created on: Aug 5, 2011
+ *      Author: alexander
+ */
+
+#include "hessian_2.0_out.h"
+
+void testServiceProxy_sayHello(char *message) {
+	hessian_out_t out = malloc(sizeof(*out));
+
+	hessian_writeString(out, message);
+
+	// tcp send out->buffer;
+}

Added: incubator/celix/trunk/hessian/private/test/test_service_skeleton.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/private/test/test_service_skeleton.c?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/private/test/test_service_skeleton.c (added)
+++ incubator/celix/trunk/hessian/private/test/test_service_skeleton.c Wed May 16 09:34:44
2012
@@ -0,0 +1,31 @@
+/*
+ * test_sercice_skeleton.c
+ *
+ *  Created on: Aug 5, 2011
+ *      Author: alexander
+ */
+
+#include "hessian_2.0_in.h"
+
+void testServiceSkeleton_sayHello(hessian_in_t in);
+
+void testServiceSkeleton_handleData(hessian_in_t in) {
+	char *method = NULL;
+	hessian_readCall(in, &method);
+
+	switch (method) {
+		case "sayHello":
+			testServiceSkeleton_sayHello(in);
+			break;
+		default:
+			break;
+	}
+}
+
+void testServiceSkeleton_sayHello(hessian_in_t in) {
+	char *message = NULL;
+	int read;
+	hessian_readString(in, &message, &read);
+
+	testService_sayHello(NULL, message);
+}

Added: incubator/celix/trunk/hessian/public/include/hessian_2.0.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/public/include/hessian_2.0.h?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/public/include/hessian_2.0.h (added)
+++ incubator/celix/trunk/hessian/public/include/hessian_2.0.h Wed May 16 09:34:44 2012
@@ -0,0 +1,27 @@
+/*
+ * hessian_2.0.h
+ *
+ *  Created on: Aug 1, 2011
+ *      Author: alexander
+ */
+
+#ifndef HESSIAN_2_0_H_
+#define HESSIAN_2_0_H_
+
+#include "hessian_2.0_in.h"
+#include "hessian_2.0_out.h"
+
+#include "hessian_constants.h"
+
+struct hessian {
+	long offset;
+	long length;
+	long capacity;
+
+	unsigned char *buffer;
+
+	bool lastChunk;
+	unsigned int chunkLength;
+};
+
+#endif /* HESSIAN_2_0_H_ */

Added: incubator/celix/trunk/hessian/public/include/hessian_2.0_in.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/public/include/hessian_2.0_in.h?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/public/include/hessian_2.0_in.h (added)
+++ incubator/celix/trunk/hessian/public/include/hessian_2.0_in.h Wed May 16 09:34:44 2012
@@ -0,0 +1,31 @@
+/*
+ * hessian_2.0_in.h
+ *
+ *  Created on: Aug 1, 2011
+ *      Author: alexander
+ */
+
+#ifndef HESSIAN_2_0_IN_H_
+#define HESSIAN_2_0_IN_H_
+
+#include <stdbool.h>
+
+#include "hessian_2.0.h"
+
+typedef struct hessian * hessian_in_t;
+
+int hessian_readBoolean(hessian_in_t in, bool *value);
+int hessian_readInt(hessian_in_t in, int *value);
+int hessian_readLong(hessian_in_t in, long *value);
+int hessian_readDouble(hessian_in_t in, double *value);
+int hessian_readUTCDate(hessian_in_t in, long *value);
+int hessian_readNull(hessian_in_t in);
+int hessian_readChar(hessian_in_t in, char *value);
+int hessian_readString(hessian_in_t in, char **value, unsigned int *readLength);
+int hessian_readNString(hessian_in_t in, int offset, int length, char **value, unsigned int
*readLength);
+int hessian_readByte(hessian_in_t in, unsigned char *value);
+int hessian_readBytes(hessian_in_t in, unsigned char **value, unsigned int *readLength);
+int hessian_readNBytes(hessian_in_t in, int offset, int length, unsigned char **value, unsigned
int *readLength);
+
+
+#endif /* HESSIAN_2_0_IN_H_ */

Added: incubator/celix/trunk/hessian/public/include/hessian_2.0_out.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/public/include/hessian_2.0_out.h?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/public/include/hessian_2.0_out.h (added)
+++ incubator/celix/trunk/hessian/public/include/hessian_2.0_out.h Wed May 16 09:34:44 2012
@@ -0,0 +1,42 @@
+/*
+ * hessian_2.0.h
+ *
+ *  Created on: Jul 31, 2011
+ *      Author: alexander
+ */
+
+#ifndef HESSIAN_2_0_OUT_H_
+#define HESSIAN_2_0_OUT_H_
+
+#include <stdbool.h>
+
+#include "linkedlist.h"
+#include "array_list.h"
+#include "hessian_2.0.h"
+
+typedef struct hessian * hessian_out_t;
+
+int hessian_writeBoolean(hessian_out_t out, bool value);
+int hessian_writeInt(hessian_out_t out, int value);
+int hessian_writeLong(hessian_out_t out, long value);
+int hessian_writeDouble(hessian_out_t out, double value);
+int hessian_writeUTCDate(hessian_out_t out, long value);
+int hessian_writeNull(hessian_out_t out);
+int hessian_writeString(hessian_out_t out, char *value);
+int hessian_writeNString(hessian_out_t out, char *value, int offset, int length);
+int hessian_writeBytes(hessian_out_t out, unsigned char value[], int length);
+int hessian_writeNBytes(hessian_out_t out, unsigned char value[], int offset, int length);
+
+int hessian_writeListBegin(hessian_out_t out, int size, char *type);
+int hessian_writeListEnd(hessian_out_t out);
+
+int hessian_writeObjectBegin(hessian_out_t out, char *type);
+int hessian_writeObjectDefinition(hessian_out_t out, char **fieldNames, int fields);
+int hessian_writeObjectEnd(hessian_out_t out);
+
+int hessian_startCall(hessian_out_t out, char *method, int length);
+int hessian_completeCall(hessian_out_t out);
+
+
+
+#endif /* HESSIAN_2_0_OUT_H_ */

Added: incubator/celix/trunk/hessian/public/include/hessian_constants.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/public/include/hessian_constants.h?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/public/include/hessian_constants.h (added)
+++ incubator/celix/trunk/hessian/public/include/hessian_constants.h Wed May 16 09:34:44 2012
@@ -0,0 +1,66 @@
+/*
+ * hessian_constants.h
+ *
+ *  Created on: Jul 31, 2011
+ *      Author: alexander
+ */
+
+#ifndef HESSIAN_CONSTANTS_H_
+#define HESSIAN_CONSTANTS_H_
+
+static int INT_DIRECT_MIN = -0x10;
+static int INT_DIRECT_MAX = 0x2f;
+static int INT_ZERO = 0x90;
+
+static int INT_BYTE_MIN = -0x800;
+static int INT_BYTE_MAX = 0x7ff;
+static int INT_BYTE_ZERO = 0xc8;
+
+static int INT_SHORT_MIN = -0x40000;
+static int INT_SHORT_MAX = 0x3ffff;
+static int INT_SHORT_ZERO = 0xd4;
+
+static long LONG_DIRECT_MIN = -0x08;
+static long LONG_DIRECT_MAX =  0x0f;
+static int LONG_ZERO = 0xe0;
+
+static long LONG_BYTE_MIN = -0x800;
+static long LONG_BYTE_MAX =  0x7ff;
+static int LONG_BYTE_ZERO = 0xf8;
+
+static int LONG_SHORT_MIN = -0x40000;
+static int LONG_SHORT_MAX = 0x3ffff;
+static int LONG_SHORT_ZERO = 0x3c;
+
+static int STRING_DIRECT_MAX = 0x1f;
+static int STRING_DIRECT = 0x00;
+
+static int BYTES_DIRECT_MAX = 0x0f;
+static int BYTES_DIRECT = 0x20;
+  // 0x30-0x37 is reserved
+
+static int LONG_INT = 0x77;
+
+static int DOUBLE_ZERO = 0x67;
+static int DOUBLE_ONE = 0x68;
+static int DOUBLE_BYTE = 0x69;
+static int DOUBLE_SHORT = 0x6a;
+static int DOUBLE_FLOAT = 0x6b;
+
+static int BC_END = 'Z';
+
+static int BC_LIST_VARIABLE = 0x55;
+static int BC_LIST_FIXED = 'V';
+static int BC_LIST_VARIABLE_UNTYPED = 0x57;
+static int BC_LIST_FIXED_UNTYPED = 0x58;
+
+static int BC_LIST_DIRECT = 0x70;
+static int BC_LIST_DIRECT_UNTYPED = 0x78;
+static int LIST_DIRECT_MAX = 0x7;
+
+static int REF_BYTE = 0x4a;
+static int REF_SHORT = 0x4b;
+
+static int TYPE_REF = 0x75;
+
+#endif /* HESSIAN_CONSTANTS_H_ */

Added: incubator/celix/trunk/hessian/test.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/hessian/test.c?rev=1339082&view=auto
==============================================================================
--- incubator/celix/trunk/hessian/test.c (added)
+++ incubator/celix/trunk/hessian/test.c Wed May 16 09:34:44 2012
@@ -0,0 +1,74 @@
+/*
+ * test.c
+ *
+ *  Created on: Jul 31, 2011
+ *      Author: alexander
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "hessian_2.0_out.h"
+#include "hessian_2.0_in.h"
+
+int main(int argc, char **argv) {
+	hessian_out_t out = malloc(sizeof(*out));
+
+//	hessian_writeDouble(out, 12.25);
+//	hessian_writeUTCDate(out, 894621091000l);
+//	hessian_writeLong(out, 1324123l);
+//	hessian_writeString(out, "hello");
+	unsigned char b[22];
+	int i = 0;
+	b[i++] = 'a';b[i++] = 'b';b[i++] = 'c';b[i++] = 'd';b[i++] = 'e';b[i++] = 'f';b[i++] = 'g';b[i++]
= 'h';b[i++] = 'i';b[i++] = 'j';b[i++] = 'k';
+	b[i++] = 'l';b[i++] = 'm';b[i++] = 'n';b[i++] = 'o';b[i++] = 'p';b[i++] = 'q';b[i++] = 'r';b[i++]
= 's';b[i++] = 't';b[i++] = 'u';b[i++] = 'v';
+
+	hessian_writeBytes(out, b, 22);
+//	hessian_writeListBegin(out, 1, "string");
+//	hessian_writeString(out, "test");
+//	hessian_writeListEnd(out);
+
+	//4832798725635008448
+
+	double d = 81273459184.123;
+	char *langeString = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
+
+//	printf("Stringl: %d\n", strlen(langeString));
+
+//	hessian_writeString(out, langeString);
+
+
+	for (i = 0; i < out->offset; i++) {
+		printf("%X ", out->buffer[i]);
+	}
+	printf("\n");
+
+
+	FILE *fp = fopen("mybinfile.ttt", "wb");
+
+	//the string length + 1 for the null terminator
+	fwrite(out->buffer, sizeof(char), out->offset, fp);
+
+	fclose(fp);
+
+	out->offset = 0;
+	unsigned char *rb = NULL;
+	int read;
+	rb = NULL;
+	hessian_readNBytes(out, 0, 10, &rb, &read);
+	printf("Read: %s\n", rb);
+	char ch;
+	hessian_readByte(out, &ch);
+	printf("Read: %c\n", ch);
+	hessian_readByte(out, &ch);
+		printf("Read: %c\n", ch);
+		hessian_readByte(out, &ch);
+			printf("Read: %c\n", ch);
+			hessian_readByte(out, &ch);
+				printf("Read: %c\n", ch);
+				rb = NULL;
+					hessian_readNBytes(out, 0, 10, &rb, &read);
+					printf("Read: %s\n", rb);
+	printf("Read: %d\n", read);
+}
+



Mime
View raw message