/*

* Author: Oleg Grenrus <oleg.grenrus@dynamoid.com>

*

* $Id: igbinary.c,v 1.33 2009/03/18 06:44:13 tricky Exp $

*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "php.h"

#include "php_ini.h"

#include "zend_dynamic_array.h"

#include "zend_alloc.h"

#include "ext/standard/info.h"

#include "ext/session/php_session.h"

#include "ext/standard/php_incomplete_class.h"

#include "php_igbinary.h"

#include "igbinary.h"

#include <assert.h>

#include <inttypes.h>

#include <stdbool.h>

#include <stddef.h>

#include <stdint.h>

#include "hash.h"

/** Session serializer function prototypes. */

PS_SERIALIZER_FUNCS(igbinary);

/* {{{ Types */

enum igbinary_type {

/* 00 */ igbinary_type_null, /**< Null. */

/* 01 */ igbinary_type_ref8, /**< Array reference. */

/* 02 */ igbinary_type_ref16, /**< Array reference. */

/* 03 */ igbinary_type_ref32, /**< Array reference. */

/* 04 */ igbinary_type_bool_false, /**< Boolean true. */

/* 05 */ igbinary_type_bool_true, /**< Boolean false. */

/* 06 */ igbinary_type_long8p, /**< Long 8bit positive. */

/* 07 */ igbinary_type_long8n, /**< Long 8bit negative. */

/* 08 */ igbinary_type_long16p, /**< Long 16bit positive. */

/* 09 */ igbinary_type_long16n, /**< Long 16bit negative. */

/* 0a */ igbinary_type_long32p, /**< Long 32bit positive. */

/* 0b */ igbinary_type_long32n, /**< Long 32bit negative. */

/* 0c */ igbinary_type_double, /**< Double. */

/* 0d */ igbinary_type_string_empty, /**< Empty string. */

/* 0e */ igbinary_type_string_id8, /**< String id. */

/* 0f */ igbinary_type_string_id16, /**< String id. */

/* 10 */ igbinary_type_string_id32, /**< String id. */

/* 11 */ igbinary_type_string8, /**< String. */

/* 12 */ igbinary_type_string16, /**< String. */

/* 13 */ igbinary_type_string32, /**< String. */

/* 14 */ igbinary_type_array8, /**< Array. */

/* 15 */ igbinary_type_array16, /**< Array. */

/* 16 */ igbinary_type_array32, /**< Array. */

/* 17 */ igbinary_type_object8, /**< Object. */

/* 18 */ igbinary_type_object16, /**< Object. */

/* 19 */ igbinary_type_object32, /**< Object. */

/* 1a */ igbinary_type_object_id8, /**< Object string id. */

/* 1b */ igbinary_type_object_id16, /**< Object string id. */

/* 1c */ igbinary_type_object_id32, /**< Object string id. */

/* 1d */ igbinary_type_object_ser8, /**< Object serialized data. */

/* 1e */ igbinary_type_object_ser16, /**< Object serialized data. */

/* 1f */ igbinary_type_object_ser32, /**< Object serialized data. */

/* 20 */ igbinary_type_long64p, /**< Long 64bit positive. */

/* 21 */ igbinary_type_long64n, /**< Long 64bit negative. */

/* 22 */ igbinary_type_objref8, /**< Object reference. */

/* 23 */ igbinary_type_objref16, /**< Object reference. */

/* 24 */ igbinary_type_objref32, /**< Object reference. */

/* 25 */ igbinary_type_ref, /**< Simple reference */

};

/** Serializer data.

* @author Oleg Grenrus <oleg.grenrus@dynamoid.com>

*/

struct igbinary_serialize_data {

uint8_t *buffer; /**< Buffer. */

size_t buffer_size; /**< Buffer size. */

size_t buffer_capacity; /**< Buffer capacity. */

bool scalar; /**< Serializing scalar. */

bool compact_strings; /**< Check for duplicate strings. */

struct hash_si strings; /**< Hash of already serialized strings. */

struct hash_si objects; /**< Hash of already serialized objects. */

int error; /**< Error number. Not used. */

};

/** String/len pair for the igbinary_unserializer_data.

* @author Oleg Grenrus <oleg.grenrus@dynamoid.com>

* @see igbinary_unserialize_data.

*/

struct igbinary_unserialize_string_pair {

char *data; /**< Data. */

size_t len; /**< Data length. */

};

/** Unserializer data.

* @author Oleg Grenrus <oleg.grenrus@dynamoid.com>

*/

struct igbinary_unserialize_data {

uint8_t *buffer; /**< Buffer. */

size_t buffer_size; /**< Buffer size. */

size_t buffer_offset; /**< Current read offset. */

struct igbinary_unserialize_string_pair *strings; /**< Unserialized strings. */

size_t strings_count; /**< Unserialized string count. */

size_t strings_capacity; /**< Unserialized string array capacity. */

void **references; /**< Unserialized Arrays/Objects. */

size_t references_count; /**< Unserialized array/objects count. */

size_t references_capacity; /**< Unserialized array/object array capacity. */

int error; /**< Error number. Not used. */

smart_str string0_buf; /**< Temporary buffer for strings */

};

/* }}} */

/* {{{ Serializing functions prototypes */

inline static int igbinary_serialize_data_init(struct igbinary_serialize_data *igsd, bool scalar TSRMLS_DC);

inline static void igbinary_serialize_data_deinit(struct igbinary_serialize_data *igsd TSRMLS_DC);

inline static int igbinary_serialize_header(struct igbinary_serialize_data *igsd TSRMLS_DC);

inline static int igbinary_serialize8(struct igbinary_serialize_data *igsd, uint8_t i TSRMLS_DC);

inline static int igbinary_serialize16(struct igbinary_serialize_data *igsd, uint16_t i TSRMLS_DC);

inline static int igbinary_serialize32(struct igbinary_serialize_data *igsd, uint32_t i TSRMLS_DC);

inline static int igbinary_serialize64(struct igbinary_serialize_data *igsd, uint64_t i TSRMLS_DC);

inline static int igbinary_serialize_null(struct igbinary_serialize_data *igsd TSRMLS_DC);

inline static int igbinary_serialize_bool(struct igbinary_serialize_data *igsd, int b TSRMLS_DC);

inline static int igbinary_serialize_long(struct igbinary_serialize_data *igsd, long l TSRMLS_DC);

inline static int igbinary_serialize_double(struct igbinary_serialize_data *igsd, double d TSRMLS_DC);

inline static int igbinary_serialize_string(struct igbinary_serialize_data *igsd, char *s, size_t len TSRMLS_DC);

inline static int igbinary_serialize_chararray(struct igbinary_serialize_data *igsd, const char *s, size_t len TSRMLS_DC);

inline static int igbinary_serialize_array(struct igbinary_serialize_data *igsd, zval *z, bool object, bool incomplete_class TSRMLS_DC);

inline static int igbinary_serialize_array_ref(struct igbinary_serialize_data *igsd, zval *z, bool object TSRMLS_DC);

inline static int igbinary_serialize_array_sleep(struct igbinary_serialize_data *igsd, zval *z, HashTable *ht, zend_class_entry *ce, bool incomplete_class TSRMLS_DC);

inline static int igbinary_serialize_object_name(struct igbinary_serialize_data *igsd, const char *name, size_t name_len TSRMLS_DC);

inline static int igbinary_serialize_object(struct igbinary_serialize_data *igsd, zval *z TSRMLS_DC);

static int igbinary_serialize_zval(struct igbinary_serialize_data *igsd, zval *z TSRMLS_DC);

/* }}} */

/* {{{ Unserializing functions prototypes */

inline static int igbinary_unserialize_data_init(struct igbinary_unserialize_data *igsd TSRMLS_DC);

inline static void igbinary_unserialize_data_deinit(struct igbinary_unserialize_data *igsd TSRMLS_DC);

inline static int igbinary_unserialize_header(struct igbinary_unserialize_data *igsd TSRMLS_DC);

inline static uint8_t igbinary_unserialize8(struct igbinary_unserialize_data *igsd TSRMLS_DC);

inline static uint16_t igbinary_unserialize16(struct igbinary_unserialize_data *igsd TSRMLS_DC);

inline static uint32_t igbinary_unserialize32(struct igbinary_unserialize_data *igsd TSRMLS_DC);

inline static uint64_t igbinary_unserialize64(struct igbinary_unserialize_data *igsd TSRMLS_DC);

inline static int igbinary_unserialize_long(struct igbinary_unserialize_data *igsd, enum igbinary_type t, long *ret TSRMLS_DC);

inline static int igbinary_unserialize_double(struct igbinary_unserialize_data *igsd, enum igbinary_type t, double *ret TSRMLS_DC);

inline static int igbinary_unserialize_string(struct igbinary_unserialize_data *igsd, enum igbinary_type t, char **s, size_t *len TSRMLS_DC);

inline static int igbinary_unserialize_chararray(struct igbinary_unserialize_data *igsd, enum igbinary_type t, char **s, size_t *len TSRMLS_DC);

inline static int igbinary_unserialize_array(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval **z, int object TSRMLS_DC);

inline static int igbinary_unserialize_object(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval **z TSRMLS_DC);

inline static int igbinary_unserialize_object_ser(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval **z, zend_class_entry *ce TSRMLS_DC);

inline static int igbinary_unserialize_ref(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval **z TSRMLS_DC);

static int igbinary_unserialize_zval(struct igbinary_unserialize_data *igsd, zval **z TSRMLS_DC);

/* }}} */

/* {{{ igbinary_functions[] */

ZEND_DECLARE_MODULE_GLOBALS(igbinary)

/* {{{ INI entries */

PHP_INI_BEGIN()

STD_PHP_INI_BOOLEAN("igbinary.compact_strings", "1", PHP_INI_ALL, OnUpdateBool, compact_strings, zend_igbinary_globals, igbinary_globals)

PHP_INI_END()

/* }}} */

/* {{{ php_igbinary_init_globals */

static void php_igbinary_init_globals(zend_igbinary_globals *igbinary_globals) {

igbinary_globals->compact_strings = 1;

}

/* }}} */

/* {{{ PHP_MINIT_FUNCTION */

PHP_MINIT_FUNCTION(igbinary) {

(void) type;

(void) module_number;

ZEND_INIT_MODULE_GLOBALS(igbinary, php_igbinary_init_globals, NULL);

#if HAVE_PHP_SESSION

php_session_register_serializer("igbinary",

PS_SERIALIZER_ENCODE_NAME(igbinary),

PS_SERIALIZER_DECODE_NAME(igbinary));

#endif

REGISTER_INI_ENTRIES();

return SUCCESS;

}

/* }}} */

/* {{{ PHP_MSHUTDOWN_FUNCTION */

PHP_MSHUTDOWN_FUNCTION(igbinary) {

(void) type;

(void) module_number;

#ifdef ZTS

ts_free_id(igbinary_globals_id);

#endif

/*

* unregister serializer?

*/

UNREGISTER_INI_ENTRIES();

return SUCCESS;

}

/* }}} */

/* {{{ PHP_MINFO_FUNCTION */

PHP_MINFO_FUNCTION(igbinary) {

(void) zend_module;

php_info_print_table_start();

php_info_print_table_row(2, "igbinary support", "enabled");

php_info_print_table_row(2, "igbinary version", IGBINARY_VERSION);

php_info_print_table_row(2, "igbinary revision", "$Id: igbinary.c,v 1.33 2009/03/18 06:44:13 tricky Exp $");

php_info_print_table_end();

DISPLAY_INI_ENTRIES();

}

/* }}} */

/* {{{ int igbinary_serialize(uint8_t**, size_t*, zval*) */

int igbinary_serialize(uint8_t **ret, size_t *ret_len, zval *z TSRMLS_DC) {

struct igbinary_serialize_data igsd;

if (igbinary_serialize_data_init(&igsd, Z_TYPE_P(z) != IS_OBJECT && Z_TYPE_P(z) != IS_ARRAY TSRMLS_CC)) {

zend_error(E_WARNING, "igbinary_serialize: cannot init igsd");

return 1;

}

if (igbinary_serialize_header(&igsd TSRMLS_CC) != 0) {

igbinary_serialize_data_deinit(&igsd TSRMLS_CC);

return 1;

}

if (igbinary_serialize_zval(&igsd, z TSRMLS_CC) != 0) {

igbinary_serialize_data_deinit(&igsd TSRMLS_CC);

return 1;

}

*ret_len = igsd.buffer_size;

*ret = (uint8_t *) emalloc(igsd.buffer_size);

memcpy(*ret, igsd.buffer, igsd.buffer_size);

igbinary_serialize_data_deinit(&igsd TSRMLS_CC);

return 0;

}

/* }}} */

/* {{{ int igbinary_unserialize(const uint8_t *, size_t, zval **) */

int igbinary_unserialize(const uint8_t *buf, size_t buf_len, zval **z TSRMLS_DC) {

struct igbinary_unserialize_data igsd;

igbinary_unserialize_data_init(&igsd TSRMLS_CC);

igsd.buffer = (uint8_t *) buf;

igsd.buffer_size = buf_len;

if (igbinary_unserialize_header(&igsd TSRMLS_CC)) {

igbinary_unserialize_data_deinit(&igsd TSRMLS_CC);

return 1;

}

if (igbinary_unserialize_zval(&igsd, z TSRMLS_CC)) {

igbinary_unserialize_data_deinit(&igsd TSRMLS_CC);

return 1;

}

igbinary_unserialize_data_deinit(&igsd TSRMLS_CC);

return 0;

}

/* }}} */

/* {{{ proto string igbinary_unserialize(mixed value) */

PHP_FUNCTION(igbinary_unserialize) {

(void) return_value_ptr;

(void) this_ptr;

(void) return_value_used;

char *string;

int string_len;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &string, &string_len) == FAILURE) {

RETURN_NULL();

}

if (string_len <= 0) {

RETURN_NULL();

}

if (igbinary_unserialize((uint8_t *) string, string_len, &return_value TSRMLS_CC)) {

RETURN_NULL();

}

}

/* }}} */

/* {{{ proto mixed igbinary_serialize(string value) */

PHP_FUNCTION(igbinary_serialize) {

(void) return_value_ptr;

(void) this_ptr;

(void) return_value_used;

zval *z;

struct igbinary_serialize_data igsd;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &z) == FAILURE) {

RETURN_NULL();

}

if (igbinary_serialize_data_init(&igsd, Z_TYPE_P(z) != IS_OBJECT && Z_TYPE_P(z) != IS_ARRAY TSRMLS_CC)) {

zend_error(E_WARNING, "igbinary_serialize: cannot init igsd");

RETURN_NULL();

}

igbinary_serialize_header(&igsd TSRMLS_CC);

igbinary_serialize_zval(&igsd, z TSRMLS_CC);

RETVAL_STRINGL((char *)igsd.buffer, igsd.buffer_size, 1);

igbinary_serialize_data_deinit(&igsd TSRMLS_CC);

}

/* }}} */

/* {{{ Serializer encode function */

PS_SERIALIZER_ENCODE_FUNC(igbinary)

{

struct igbinary_serialize_data igsd;

if (igbinary_serialize_data_init(&igsd, false TSRMLS_CC)) {

zend_error(E_WARNING, "igbinary_serialize: cannot init igsd");

return FAILURE;

}

igbinary_serialize_header(&igsd TSRMLS_CC);

igbinary_serialize_array(&igsd, PS(http_session_vars), false, false TSRMLS_CC);

if (newlen)

*newlen = igsd.buffer_size;

*newstr = estrndup((char*)igsd.buffer, igsd.buffer_size);

if (newstr == NULL) {

return FAILURE;

}

igbinary_serialize_data_deinit(&igsd TSRMLS_CC);

return SUCCESS;

}

/* }}} */

/* {{{ Serializer decode function */

PS_SERIALIZER_DECODE_FUNC(igbinary) {

HashPosition tmp_hash_pos;

HashTable *tmp_hash;

char *key_str;

ulong key_long;

int tmp_int;

uint key_len;

zval *z;

zval **d;

struct igbinary_unserialize_data igsd;

if (!val || vallen==0)

return SUCCESS;

igbinary_unserialize_data_init(&igsd TSRMLS_CC);

igsd.buffer = (uint8_t *)val;

igsd.buffer_size = vallen;

if (igbinary_unserialize_header(&igsd TSRMLS_CC)) {

igbinary_unserialize_data_deinit(&igsd TSRMLS_CC);

return FAILURE;

}

ALLOC_INIT_ZVAL(z);

if (igbinary_unserialize_zval(&igsd, &z TSRMLS_CC)) {

igbinary_unserialize_data_deinit(&igsd TSRMLS_CC);

zval_dtor(z);

FREE_ZVAL(z);

return FAILURE;

}

igbinary_unserialize_data_deinit(&igsd TSRMLS_CC);

tmp_hash = HASH_OF(z);

zend_hash_internal_pointer_reset_ex(tmp_hash, &tmp_hash_pos);

while (zend_hash_get_current_data_ex(tmp_hash, (void *) &d, &tmp_hash_pos) == SUCCESS) {

tmp_int = zend_hash_get_current_key_ex(tmp_hash, &key_str, &key_len, &key_long, 0, &tmp_hash_pos);

switch (tmp_int) {

case HASH_KEY_IS_LONG:

/* ??? */

break;

case HASH_KEY_IS_STRING:

php_set_session_var(key_str, key_len-1, *d, NULL TSRMLS_CC);

php_add_session_var(key_str, key_len-1 TSRMLS_CC);

break;

}

zend_hash_move_forward_ex(tmp_hash, &tmp_hash_pos);

}

zval_dtor(z);

FREE_ZVAL(z);

return SUCCESS;

}

/* }}} */

/* {{{ igbinary_serialize_data_init */

/** Inits igbinary_serialize_data. */

inline static int igbinary_serialize_data_init(struct igbinary_serialize_data *igsd, bool scalar TSRMLS_DC) {

int r = 0;

igsd->buffer = NULL;

igsd->buffer_size = 0;

igsd->buffer_capacity = 32;

igsd->error = 0;

igsd->buffer = (uint8_t *) emalloc(igsd->buffer_capacity);

if (igsd->buffer == NULL) {

return 1;

}

igsd->scalar = scalar;

if (!igsd->scalar) {

hash_si_init(&igsd->strings, 16);

hash_si_init(&igsd->objects, 16);

}

igsd->compact_strings = (bool)IGBINARY_G(compact_strings);

return r;

}

/* }}} */

/* {{{ igbinary_serialize_data_deinit */

/** Deinits igbinary_serialize_data. */

inline static void igbinary_serialize_data_deinit(struct igbinary_serialize_data *igsd TSRMLS_DC) {

if (igsd->buffer) {

efree(igsd->buffer);

}

if (!igsd->scalar) {

hash_si_deinit(&igsd->strings);

hash_si_deinit(&igsd->objects);

}

}

/* }}} */

/* {{{ igbinary_serialize_header */

/** Serializes header. */

inline static int igbinary_serialize_header(struct igbinary_serialize_data *igsd TSRMLS_DC) {

igbinary_serialize32(igsd, IGBINARY_FORMAT_VERSION TSRMLS_CC); /* version */

return 0;

}

/* }}} */

/* {{{ igbinary_serialize_resize */

/** Expandes igbinary_serialize_data. */

inline static int igbinary_serialize_resize(struct igbinary_serialize_data *igsd, size_t size TSRMLS_DC) {

if (igsd->buffer_size + size < igsd->buffer_capacity) {

return 0;

}

while (igsd->buffer_size + size >= igsd->buffer_capacity) {

igsd->buffer_capacity *= 2;

}

igsd->buffer = (uint8_t *) erealloc(igsd->buffer, igsd->buffer_capacity);

if (igsd->buffer == NULL)

return 1;

return 0;

}

/* }}} */

/* {{{ igbinary_serialize8 */

/** Serialize 8bit value. */

inline static int igbinary_serialize8(struct igbinary_serialize_data *igsd, uint8_t i TSRMLS_DC) {

if (igbinary_serialize_resize(igsd, 1 TSRMLS_CC)) {

return 1;

}

igsd->buffer[igsd->buffer_size++] = i;

return 0;

}

/* }}} */

/* {{{ igbinary_serialize16 */

/** Serialize 16bit value. */

inline static int igbinary_serialize16(struct igbinary_serialize_data *igsd, uint16_t i TSRMLS_DC) {

if (igbinary_serialize_resize(igsd, 2 TSRMLS_CC)) {

return 1;

}

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 8 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i & 0xff);

return 0;

}

/* }}} */

/* {{{ igbinary_serialize32 */

/** Serialize 32bit value. */

inline static int igbinary_serialize32(struct igbinary_serialize_data *igsd, uint32_t i TSRMLS_DC) {

if (igbinary_serialize_resize(igsd, 4 TSRMLS_CC)) {

return 1;

}

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 24 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 16 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 8 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i & 0xff);

return 0;

}

/* }}} */

/* {{{ igbinary_serialize64 */

/** Serialize 64bit value. */

inline static int igbinary_serialize64(struct igbinary_serialize_data *igsd, uint64_t i TSRMLS_DC) {

if (igbinary_serialize_resize(igsd, 8 TSRMLS_CC)) {

return 1;

}

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 56 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 48 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 40 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 32 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 24 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 16 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i >> 8 & 0xff);

igsd->buffer[igsd->buffer_size++] = (uint8_t) (i & 0xff);

return 0;

}

/* }}} */

/* {{{ igbinary_serialize_null */

/** Serializes null. */

inline static int igbinary_serialize_null(struct igbinary_serialize_data *igsd TSRMLS_DC) {

return igbinary_serialize8(igsd, igbinary_type_null TSRMLS_CC);

}

/* }}} */

/* {{{ igbinary_serialize_bool */

/** Serializes bool. */

inline static int igbinary_serialize_bool(struct igbinary_serialize_data *igsd, int b TSRMLS_DC) {

return igbinary_serialize8(igsd, (uint8_t) (b ? igbinary_type_bool_true : igbinary_type_bool_false) TSRMLS_CC);

}

/* }}} */

/* {{{ igbinary_serialize_long */

/** Serializes long. */

inline static int igbinary_serialize_long(struct igbinary_serialize_data *igsd, long l TSRMLS_DC) {

long k = l >= 0 ? l : -l;

bool p = l >= 0 ? true : false;

/* -LONG_MIN is 0 otherwise. */

if (l == LONG_MIN) {

#if SIZEOF_LONG == 8

igbinary_serialize8(igsd, (uint8_t) igbinary_type_long64n TSRMLS_CC);

igbinary_serialize64(igsd, (uint64_t) 0x8000000000000000 TSRMLS_CC);

#elif SIZEOF_LONG == 4

igbinary_serialize8(igsd, (uint8_t) igbinary_type_long32n TSRMLS_CC);

igbinary_serialize32(igsd, (uint32_t) 0x80000000 TSRMLS_CC);

#else

#error "Strange sizeof(long)."

#endif

return 0;

}

if (k <= 0xff) {

igbinary_serialize8(igsd, (uint8_t) (p ? igbinary_type_long8p : igbinary_type_long8n) TSRMLS_CC);

igbinary_serialize8(igsd, (uint8_t) k TSRMLS_CC);

} else if (k <= 0xffff) {

igbinary_serialize8(igsd, (uint8_t) (p ? igbinary_type_long16p : igbinary_type_long16n) TSRMLS_CC);

igbinary_serialize16(igsd, (uint16_t) k TSRMLS_CC);

#if SIZEOF_LONG == 8

} else if (k <= 0xffffffff) {

igbinary_serialize8(igsd, (uint8_t) (p ? igbinary_type_long32p : igbinary_type_long32n) TSRMLS_CC);

igbinary_serialize32(igsd, (uint32_t) k TSRMLS_CC);

} else {

igbinary_serialize8(igsd, (uint8_t) (p ? igbinary_type_long64p : igbinary_type_long64n) TSRMLS_CC);

igbinary_serialize64(igsd, (uint64_t) k TSRMLS_CC);

}

#elif SIZEOF_LONG == 4

} else {

igbinary_serialize8(igsd, (uint8_t) (p ? igbinary_type_long32p : igbinary_type_long32n) TSRMLS_CC);

igbinary_serialize32(igsd, (uint32_t) k TSRMLS_CC);

}

#else

#error "Strange sizeof(long)."

#endif

return 0;

}

/* }}} */

/* {{{ igbinary_serialize_double */

/** Serializes double. */

inline static int igbinary_serialize_double(struct igbinary_serialize_data *igsd, double d TSRMLS_DC) {

igbinary_serialize8(igsd, igbinary_type_double TSRMLS_CC);

union {

double d;

uint64_t u;

} u;

u.d = d;

igbinary_serialize64(igsd, u.u TSRMLS_CC);

return 0;

}

/* }}} */

/* {{{ igbinary_serialize_string */

/** Serializes string.

* Serializes each string once, after first time uses pointers.

*/

inline static int igbinary_serialize_string(struct igbinary_serialize_data *igsd, char *s, size_t len TSRMLS_DC) {

uint32_t t;

uint32_t *i = &t;

if (len == 0) {

igbinary_serialize8(igsd, igbinary_type_string_empty TSRMLS_CC);

return 0;

}

if (igsd->scalar || !igsd->compact_strings || hash_si_find(&igsd->strings, s, len, i) == 1) {

if (!igsd->scalar && igsd->compact_strings) {

t = hash_si_size(&igsd->strings);

hash_si_insert(&igsd->strings, s, len, t);

}

igbinary_serialize_chararray(igsd, s, len TSRMLS_CC);

} else {

if (*i <= 0xff) {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_string_id8 TSRMLS_CC);

igbinary_serialize8(igsd, (uint8_t) *i TSRMLS_CC);

} else if (*i <= 0xffff) {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_string_id16 TSRMLS_CC);

igbinary_serialize16(igsd, (uint16_t) *i TSRMLS_CC);

} else {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_string_id32 TSRMLS_CC);

igbinary_serialize32(igsd, (uint32_t) *i TSRMLS_CC);

}

}

return 0;

}

/* }}} */

/* {{{ igbinary_serialize_chararray */

/** Serializes string data. */

inline static int igbinary_serialize_chararray(struct igbinary_serialize_data *igsd, const char *s, size_t len TSRMLS_DC) {

if (len <= 0xff) {

igbinary_serialize8(igsd, igbinary_type_string8 TSRMLS_CC);

igbinary_serialize8(igsd, len TSRMLS_CC);

} else if (len <= 0xffff) {

igbinary_serialize8(igsd, igbinary_type_string16 TSRMLS_CC);

igbinary_serialize16(igsd, len TSRMLS_CC);

} else {

igbinary_serialize8(igsd, igbinary_type_string32 TSRMLS_CC);

igbinary_serialize32(igsd, len TSRMLS_CC);

}

if (igbinary_serialize_resize(igsd, len TSRMLS_CC)) {

return 1;

}

memcpy(igsd->buffer+igsd->buffer_size, s, len);

igsd->buffer_size += len;

return 0;

}

/* }}} */

/* {{{ igbinay_serialize_array */

/** Serializes array or objects inner properties. */

inline static int igbinary_serialize_array(struct igbinary_serialize_data *igsd, zval *z, bool object, bool incomplete_class TSRMLS_DC) {

HashTable *h;

HashPosition pos;

size_t n;

zval **d;

char *key;

uint key_len;

int key_type;

ulong key_index;

/* hash */

h = object ? Z_OBJPROP_P(z) : HASH_OF(z);

/* hash size */

n = h ? zend_hash_num_elements(h) : 0;

/* incomplete class magic member */

if (n > 0 && incomplete_class) {

--n;

}

if (!object && igbinary_serialize_array_ref(igsd, z, object TSRMLS_CC) == 0) {

return 0;

}

if (n <= 0xff) {

igbinary_serialize8(igsd, igbinary_type_array8 TSRMLS_CC);

igbinary_serialize8(igsd, n TSRMLS_CC);

} else if (n <= 0xffff) {

igbinary_serialize8(igsd, igbinary_type_array16 TSRMLS_CC);

igbinary_serialize16(igsd, n TSRMLS_CC);

} else {

igbinary_serialize8(igsd, igbinary_type_array32 TSRMLS_CC);

igbinary_serialize32(igsd, n TSRMLS_CC);

}

if (n == 0) {

return 0;

}

/* serialize properties. */

zend_hash_internal_pointer_reset_ex(h, &pos);

for (;; zend_hash_move_forward_ex(h, &pos)) {

key_type = zend_hash_get_current_key_ex(h, &key, &key_len, &key_index, 0, &pos);

/* last */

if (key_type == HASH_KEY_NON_EXISTANT) {

break;

}

/* skip magic member in incomplete classes */

if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {

continue;

}

switch (key_type) {

case HASH_KEY_IS_LONG:

igbinary_serialize_long(igsd, key_index TSRMLS_CC);

break;

case HASH_KEY_IS_STRING:

igbinary_serialize_string(igsd, key, key_len-1 TSRMLS_CC);

break;

default:

zend_error(E_ERROR, "igbinary_serialize_array: key is not string nor array");

/* not reached */

return 1;

}

/* we should still add element even if it's not OK,

* since we already wrote the length of the array before */

if (zend_hash_get_current_data_ex(h, (void *) &d, &pos) != SUCCESS || d == NULL) {

if (igbinary_serialize_null(igsd TSRMLS_CC)) {

return 1;

}

} else {

if (igbinary_serialize_zval(igsd, *d TSRMLS_CC)) {

return 1;

}

}

}

return 0;

}

/* }}} */

/* {{{ igbinary_serialize_array_ref */

/** Serializes array reference. */

inline static int igbinary_serialize_array_ref(struct igbinary_serialize_data *igsd, zval *z, bool object TSRMLS_DC) {

uint32_t t = 0;

uint32_t *i = &t;

union {

zval *z;

struct {

zend_class_entry *ce;

zend_object_handle handle;

} obj;

} key = { 0 };

if (object && Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_class_entry) {

key.obj.ce = Z_OBJCE_P(z);

key.obj.handle = Z_OBJ_HANDLE_P(z);

} else {

key.z = z;

}

if (hash_si_find(&igsd->objects, (char *)&key, sizeof(key), i) == 1) {

t = hash_si_size(&igsd->objects);

hash_si_insert(&igsd->objects, (char *)&key, sizeof(key), t);

return 1;

} else {

enum igbinary_type type;

if (*i <= 0xff) {

type = object ? igbinary_type_objref8 : igbinary_type_ref8;

igbinary_serialize8(igsd, (uint8_t) type TSRMLS_CC);

igbinary_serialize8(igsd, (uint8_t) *i TSRMLS_CC);

} else if (*i <= 0xffff) {

type = object ? igbinary_type_objref16 : igbinary_type_ref16;

igbinary_serialize8(igsd, (uint8_t) type TSRMLS_CC);

igbinary_serialize16(igsd, (uint16_t) *i TSRMLS_CC);

} else {

type = object ? igbinary_type_objref32 : igbinary_type_ref32;

igbinary_serialize8(igsd, (uint8_t) type TSRMLS_CC);

igbinary_serialize32(igsd, (uint32_t) *i TSRMLS_CC);

}

return 0;

}

return 1;

}

/* }}} */

/* {{{ igbinary_serialize_array_sleep */

/** Serializes object's properties array with __sleep -function. */

inline static int igbinary_serialize_array_sleep(struct igbinary_serialize_data *igsd, zval *z, HashTable *h, zend_class_entry *ce, bool incomplete_class TSRMLS_DC) {

HashPosition pos;

size_t n = zend_hash_num_elements(h);

zval **d;

zval **v;

char *key;

uint key_len;

int key_type;

ulong key_index;

/* Decrease array size by one, because of magic member (with class name) */

if (n > 0 && incomplete_class) {

--n;

}

/* Serialize array id. */

if (n <= 0xff) {

igbinary_serialize8(igsd, igbinary_type_array8 TSRMLS_CC);

igbinary_serialize8(igsd, n TSRMLS_CC);

} else if (n <= 0xffff) {

igbinary_serialize8(igsd, igbinary_type_array16 TSRMLS_CC);

igbinary_serialize16(igsd, n TSRMLS_CC);

} else {

igbinary_serialize8(igsd, igbinary_type_array32 TSRMLS_CC);

igbinary_serialize32(igsd, n TSRMLS_CC);

}

if (n == 0) {

return 0;

}

zend_hash_internal_pointer_reset_ex(h, &pos);

for (;; zend_hash_move_forward_ex(h, &pos)) {

key_type = zend_hash_get_current_key_ex(h, &key, &key_len, &key_index, 0, &pos);

/* last */

if (key_type == HASH_KEY_NON_EXISTANT) {

break;

}

/* skip magic member in incomplete classes */

if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {

continue;

}

if (zend_hash_get_current_data_ex(h, (void *) &d, &pos) != SUCCESS || d == NULL || Z_TYPE_PP(d) != IS_STRING) {

php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only "

"containing the names of instance-variables to "

"serialize");

/* we should still add element even if it's not OK,

* since we already wrote the length of the array before

* serialize null as key-value pair */

igbinary_serialize_null(igsd TSRMLS_CC);

} else {

if (zend_hash_find(Z_OBJPROP_P(z), Z_STRVAL_PP(d), Z_STRLEN_PP(d) + 1, (void *) &v) == SUCCESS) {

igbinary_serialize_string(igsd, Z_STRVAL_PP(d), Z_STRLEN_PP(d) TSRMLS_CC);

igbinary_serialize_zval(igsd, *v TSRMLS_CC);

} else if (ce) {

char *prot_name = NULL;

char *priv_name = NULL;

int prop_name_length;

do {

/* try private */

zend_mangle_property_name(&priv_name, &prop_name_length, ce->name, ce->name_length,

Z_STRVAL_PP(d), Z_STRLEN_PP(d), ce->type & ZEND_INTERNAL_CLASS);

if (zend_hash_find(Z_OBJPROP_P(z), priv_name, prop_name_length+1, (void *) &v) == SUCCESS) {

igbinary_serialize_string(igsd, priv_name, prop_name_length TSRMLS_CC);

efree(priv_name);

igbinary_serialize_zval(igsd, *v TSRMLS_CC);

break;

}

efree(priv_name);

/* try protected */

zend_mangle_property_name(&prot_name, &prop_name_length, "*", 1,

Z_STRVAL_PP(d), Z_STRLEN_PP(d), ce->type & ZEND_INTERNAL_CLASS);

if (zend_hash_find(Z_OBJPROP_P(z), prot_name, prop_name_length+1, (void *) &v) == SUCCESS) {

igbinary_serialize_string(igsd, prot_name, prop_name_length TSRMLS_CC);

efree(prot_name);

igbinary_serialize_zval(igsd, *v TSRMLS_CC);

break;

}

efree(prot_name);

/* no win */

igbinary_serialize_string(igsd, Z_STRVAL_PP(d), Z_STRLEN_PP(d) TSRMLS_CC);

igbinary_serialize_null(igsd TSRMLS_CC);

php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_PP(d));

} while (0);

} else {

// if all else fails, just serialize the value in anyway.

igbinary_serialize_string(igsd, Z_STRVAL_PP(d), Z_STRLEN_PP(d) TSRMLS_CC);

igbinary_serialize_zval(igsd, *v TSRMLS_CC);

}

}

}

return 0;

}

/* }}} */

/* {{{ igbinary_serialize_object_name */

/** Serialize object name. */

inline static int igbinary_serialize_object_name(struct igbinary_serialize_data *igsd, const char *class_name, size_t name_len TSRMLS_DC) {

uint32_t t;

uint32_t *i = &t;

if (hash_si_find(&igsd->strings, class_name, name_len, i) == 1) {

t = hash_si_size(&igsd->strings);

hash_si_insert(&igsd->strings, class_name, name_len, t);

if (name_len <= 0xff) {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_object8 TSRMLS_CC);

igbinary_serialize8(igsd, (uint8_t) name_len TSRMLS_CC);

} else if (name_len <= 0xffff) {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_object16 TSRMLS_CC);

igbinary_serialize16(igsd, (uint16_t) name_len TSRMLS_CC);

} else {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_object32 TSRMLS_CC);

igbinary_serialize32(igsd, (uint32_t) name_len TSRMLS_CC);

}

if (igbinary_serialize_resize(igsd, name_len TSRMLS_CC)) {

return 1;

}

memcpy(igsd->buffer+igsd->buffer_size, class_name, name_len);

igsd->buffer_size += name_len;

} else {

/* already serialized string */

if (*i <= 0xff) {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_object_id8 TSRMLS_CC);

igbinary_serialize8(igsd, (uint8_t) *i TSRMLS_CC);

} else if (*i <= 0xffff) {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_object_id16 TSRMLS_CC);

igbinary_serialize16(igsd, (uint16_t) *i TSRMLS_CC);

} else {

igbinary_serialize8(igsd, (uint8_t) igbinary_type_object_id32 TSRMLS_CC);

igbinary_serialize32(igsd, (uint32_t) *i TSRMLS_CC);

}

}

return 0;

}

/* }}} */

/* {{{ igbinary_serialize_object */

/** Serialize object.

* @see ext/standard/var.c

* */

inline static int igbinary_serialize_object(struct igbinary_serialize_data *igsd, zval *z TSRMLS_DC) {

zend_class_entry *ce;

zval f;

zval *h = NULL;

int r = 0;

unsigned char *serialized_data = NULL;

zend_uint serialized_len;

PHP_CLASS_ATTRIBUTES;

if (igbinary_serialize_array_ref(igsd, z, true TSRMLS_CC) == 0) {

return r;

}

ce = Z_OBJCE_P(z);

/* custom serializer */

if (ce && ce->serialize != NULL) {

/* TODO: var_hash? */

if(ce->serialize(z, &serialized_data, &serialized_len, (zend_serialize_data *)NULL TSRMLS_CC) == SUCCESS && !EG(exception)) {

igbinary_serialize_object_name(igsd, ce->name, ce->name_length TSRMLS_CC);