src/third_party/protobuf-3/php/ext/google/protobuf/message.c - cobalt - Git at Google

 // Protocol Buffers - Google's data interchange format
 // Copyright 2014 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // 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.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // 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
 // OWNER 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.

 #include <php.h>

 #include "protobuf.h"

 // -----------------------------------------------------------------------------
 // Class/module creation from msgdefs and enumdefs, respectively.
 // -----------------------------------------------------------------------------

 void* message_data(void* msg) {
   return ((uint8_t *)msg) + sizeof(MessageHeader);
 }

 void message_set_property(zval* object, zval* field_name, zval* value,
                           const zend_literal* key TSRMLS_DC) {
   const upb_fielddef* field;

   MessageHeader* self = zend_object_store_get_object(object TSRMLS_CC);

   CHECK_TYPE(field_name, IS_STRING);
   field = upb_msgdef_ntofz(self->descriptor->msgdef, Z_STRVAL_P(field_name));
   if (field == NULL) {
     zend_error(E_ERROR, "Unknown field: %s", Z_STRVAL_P(field_name));
   }
   layout_set(self->descriptor->layout, message_data(self), field, value);
 }

 zval* message_get_property(zval* object, zval* member, int type,
                              const zend_literal* key TSRMLS_DC) {
   MessageHeader* self =
       (MessageHeader*)zend_object_store_get_object(object TSRMLS_CC);
   CHECK_TYPE(member, IS_STRING);

   const upb_fielddef* field;
   field = upb_msgdef_ntofz(self->descriptor->msgdef, Z_STRVAL_P(member));
   if (field == NULL) {
     return EG(uninitialized_zval_ptr);
   }
   zval* retval = layout_get(self->descriptor->layout, message_data(self), field TSRMLS_CC);
   return retval;
 }

 static  zend_function_entry message_methods[] = {
   PHP_ME(Message, encode, NULL, ZEND_ACC_PUBLIC)
   {NULL, NULL, NULL}
 };

 /* stringsink *****************************************************************/

 // This should probably be factored into a common upb component.

 typedef struct {
   upb_byteshandler handler;
   upb_bytessink sink;
   char *ptr;
   size_t len, size;
 } stringsink;

 static void *stringsink_start(void *_sink, const void *hd, size_t size_hint) {
   stringsink *sink = _sink;
   sink->len = 0;
   return sink;
 }

 static size_t stringsink_string(void *_sink, const void *hd, const char *ptr,
                                 size_t len, const upb_bufhandle *handle) {
   stringsink *sink = _sink;
   size_t new_size = sink->size;

   UPB_UNUSED(hd);
   UPB_UNUSED(handle);

   while (sink->len + len > new_size) {
     new_size *= 2;
   }

   if (new_size != sink->size) {
     sink->ptr = realloc(sink->ptr, new_size);
     sink->size = new_size;
   }

   memcpy(sink->ptr + sink->len, ptr, len);
   sink->len += len;

   return len;
 }

 void stringsink_init(stringsink *sink) {
   upb_byteshandler_init(&sink->handler);
   upb_byteshandler_setstartstr(&sink->handler, stringsink_start, NULL);
   upb_byteshandler_setstring(&sink->handler, stringsink_string, NULL);

   upb_bytessink_reset(&sink->sink, &sink->handler, sink);

   sink->size = 32;
   sink->ptr = malloc(sink->size);
   sink->len = 0;
 }

 void stringsink_uninit(stringsink *sink) { free(sink->ptr); }

 // Stack-allocated context during an encode/decode operation. Contains the upb
 // environment and its stack-based allocator, an initial buffer for allocations
 // to avoid malloc() when possible, and a template for PHP exception messages
 // if any error occurs.
 #define STACK_ENV_STACKBYTES 4096
 typedef struct {
   upb_env env;
   upb_seededalloc alloc;
   const char *php_error_template;
   char allocbuf[STACK_ENV_STACKBYTES];
 } stackenv;

 static void stackenv_init(stackenv* se, const char* errmsg);
 static void stackenv_uninit(stackenv* se);

 // Callback invoked by upb if any error occurs during parsing or serialization.
 static bool env_error_func(void* ud, const upb_status* status) {
     stackenv* se = ud;
     // Free the env -- rb_raise will longjmp up the stack past the encode/decode
     // function so it would not otherwise have been freed.
     stackenv_uninit(se);

     // TODO(teboring): have a way to verify that this is actually a parse error,
     // instead of just throwing "parse error" unconditionally.
     zend_error(E_ERROR, se->php_error_template);
     // Never reached.
     return false;
 }

 static void stackenv_init(stackenv* se, const char* errmsg) {
   se->php_error_template = errmsg;
   upb_env_init(&se->env);
   upb_seededalloc_init(&se->alloc, &se->allocbuf, STACK_ENV_STACKBYTES);
   upb_env_setallocfunc(&se->env, upb_seededalloc_getallocfunc(&se->alloc),
                        &se->alloc);
   upb_env_seterrorfunc(&se->env, env_error_func, se);
 }

 static void stackenv_uninit(stackenv* se) {
   upb_env_uninit(&se->env);
   upb_seededalloc_uninit(&se->alloc);
 }

 // -----------------------------------------------------------------------------
 // Message
 // -----------------------------------------------------------------------------

 static const upb_handlers* msgdef_pb_serialize_handlers(Descriptor* desc) {
   if (desc->pb_serialize_handlers == NULL) {
     desc->pb_serialize_handlers =
         upb_pb_encoder_newhandlers(desc->msgdef, &desc->pb_serialize_handlers);
   }
   return desc->pb_serialize_handlers;
 }

 PHP_METHOD(Message, encode) {
   Descriptor* desc = (Descriptor*)zend_object_store_get_object(
       CE_STATIC_MEMBERS(Z_OBJCE_P(getThis()))[0] TSRMLS_CC);

   stringsink sink;
   stringsink_init(&sink);

   {
     const upb_handlers* serialize_handlers = msgdef_pb_serialize_handlers(desc);

     stackenv se;
     upb_pb_encoder* encoder;

     stackenv_init(&se, "Error occurred during encoding: %s");
     encoder = upb_pb_encoder_create(&se.env, serialize_handlers, &sink.sink);

     putmsg(getThis(), desc, upb_pb_encoder_input(encoder), 0);

     RETVAL_STRINGL(sink.ptr, sink.len, 1);

     stackenv_uninit(&se);
     stringsink_uninit(&sink);
   }
 }

 void message_free(void * object TSRMLS_DC) {
   FREE(object);
 }

 zend_object_value message_create(zend_class_entry* ce TSRMLS_DC) {
   zend_object_value return_value;

   zval* php_descriptor = get_def_obj(ce);

   Descriptor* desc = zend_object_store_get_object(php_descriptor TSRMLS_CC);
   MessageHeader* msg = (MessageHeader*)ALLOC_N(
       uint8_t, sizeof(MessageHeader) + desc->layout->size);
   memset(message_data(msg), 0, desc->layout->size);

   // We wrap first so that everything in the message object is GC-rooted in case
   // a collection happens during object creation in layout_init().
   msg->descriptor = desc;

   layout_init(desc->layout, message_data(msg));
   zend_object_std_init(&msg->std, ce TSRMLS_CC);

   return_value.handle = zend_objects_store_put(
       msg, (zend_objects_store_dtor_t)zend_objects_destroy_object,
       message_free, NULL TSRMLS_CC);

   return_value.handlers = PROTOBUF_G(message_handlers);
   return return_value;
 }

 const zend_class_entry* build_class_from_descriptor(
     zval* php_descriptor TSRMLS_DC) {
   Descriptor* desc = php_to_descriptor(php_descriptor);
   if (desc->layout == NULL) {
     MessageLayout* layout = create_layout(desc->msgdef);
     desc->layout = layout;
   }
   // TODO(teboring): Add it back.
   // if (desc->fill_method == NULL) {
   //   desc->fill_method = new_fillmsg_decodermethod(desc, &desc->fill_method);
   // }

   const char* name = upb_msgdef_fullname(desc->msgdef);
   if (name == NULL) {
     zend_error(E_ERROR, "Descriptor does not have assigned name.");
   }

   zend_class_entry class_entry;
   INIT_CLASS_ENTRY_EX(class_entry, name, strlen(name), message_methods);
   zend_class_entry* registered_ce =
       zend_register_internal_class(&class_entry TSRMLS_CC);

   add_def_obj(registered_ce, php_descriptor);

   if (PROTOBUF_G(message_handlers) == NULL) {
     PROTOBUF_G(message_handlers) = ALLOC(zend_object_handlers);
     memcpy(PROTOBUF_G(message_handlers), zend_get_std_object_handlers(),
            sizeof(zend_object_handlers));
     PROTOBUF_G(message_handlers)->write_property = message_set_property;
     PROTOBUF_G(message_handlers)->read_property = message_get_property;
   }

   registered_ce->create_object = message_create;
 }
	// Protocol Buffers - Google's data interchange format
	// Copyright 2014 Google Inc. All rights reserved.
	// https://developers.google.com/protocol-buffers/
	//
	// 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.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// 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
	// OWNER 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.

	#include <php.h>

	#include "protobuf.h"

	// -----------------------------------------------------------------------------
	// Class/module creation from msgdefs and enumdefs, respectively.
	// -----------------------------------------------------------------------------

	void* message_data(void* msg) {
	return ((uint8_t *)msg) + sizeof(MessageHeader);
	}

	void message_set_property(zval* object, zval* field_name, zval* value,
	const zend_literal* key TSRMLS_DC) {
	const upb_fielddef* field;

	MessageHeader* self = zend_object_store_get_object(object TSRMLS_CC);

	CHECK_TYPE(field_name, IS_STRING);
	field = upb_msgdef_ntofz(self->descriptor->msgdef, Z_STRVAL_P(field_name));
	if (field == NULL) {
	zend_error(E_ERROR, "Unknown field: %s", Z_STRVAL_P(field_name));
	}
	layout_set(self->descriptor->layout, message_data(self), field, value);
	}

	zval* message_get_property(zval* object, zval* member, int type,
	const zend_literal* key TSRMLS_DC) {
	MessageHeader* self =
	(MessageHeader*)zend_object_store_get_object(object TSRMLS_CC);
	CHECK_TYPE(member, IS_STRING);

	const upb_fielddef* field;
	field = upb_msgdef_ntofz(self->descriptor->msgdef, Z_STRVAL_P(member));
	if (field == NULL) {
	return EG(uninitialized_zval_ptr);
	}
	zval* retval = layout_get(self->descriptor->layout, message_data(self), field TSRMLS_CC);
	return retval;
	}

	static zend_function_entry message_methods[] = {
	PHP_ME(Message, encode, NULL, ZEND_ACC_PUBLIC)
	{NULL, NULL, NULL}
	};

	/* stringsink *****************************************************************/

	// This should probably be factored into a common upb component.

	typedef struct {
	upb_byteshandler handler;
	upb_bytessink sink;
	char *ptr;
	size_t len, size;
	} stringsink;

	static void stringsink_start(void _sink, const void *hd, size_t size_hint) {
	stringsink *sink = _sink;
	sink->len = 0;
	return sink;
	}

	static size_t stringsink_string(void _sink, const void hd, const char *ptr,
	size_t len, const upb_bufhandle *handle) {
	stringsink *sink = _sink;
	size_t new_size = sink->size;

	UPB_UNUSED(hd);
	UPB_UNUSED(handle);

	while (sink->len + len > new_size) {
	new_size *= 2;
	}

	if (new_size != sink->size) {
	sink->ptr = realloc(sink->ptr, new_size);
	sink->size = new_size;
	}

	memcpy(sink->ptr + sink->len, ptr, len);
	sink->len += len;

	return len;
	}

	void stringsink_init(stringsink *sink) {
	upb_byteshandler_init(&sink->handler);
	upb_byteshandler_setstartstr(&sink->handler, stringsink_start, NULL);
	upb_byteshandler_setstring(&sink->handler, stringsink_string, NULL);

	upb_bytessink_reset(&sink->sink, &sink->handler, sink);

	sink->size = 32;
	sink->ptr = malloc(sink->size);
	sink->len = 0;
	}

	void stringsink_uninit(stringsink *sink) { free(sink->ptr); }

	// Stack-allocated context during an encode/decode operation. Contains the upb
	// environment and its stack-based allocator, an initial buffer for allocations
	// to avoid malloc() when possible, and a template for PHP exception messages
	// if any error occurs.
	#define STACK_ENV_STACKBYTES 4096
	typedef struct {
	upb_env env;
	upb_seededalloc alloc;
	const char *php_error_template;
	char allocbuf[STACK_ENV_STACKBYTES];
	} stackenv;

	static void stackenv_init(stackenv* se, const char* errmsg);
	static void stackenv_uninit(stackenv* se);

	// Callback invoked by upb if any error occurs during parsing or serialization.
	static bool env_error_func(void* ud, const upb_status* status) {
	stackenv* se = ud;
	// Free the env -- rb_raise will longjmp up the stack past the encode/decode
	// function so it would not otherwise have been freed.
	stackenv_uninit(se);

	// TODO(teboring): have a way to verify that this is actually a parse error,
	// instead of just throwing "parse error" unconditionally.
	zend_error(E_ERROR, se->php_error_template);
	// Never reached.
	return false;
	}

	static void stackenv_init(stackenv* se, const char* errmsg) {
	se->php_error_template = errmsg;
	upb_env_init(&se->env);
	upb_seededalloc_init(&se->alloc, &se->allocbuf, STACK_ENV_STACKBYTES);
	upb_env_setallocfunc(&se->env, upb_seededalloc_getallocfunc(&se->alloc),
	&se->alloc);
	upb_env_seterrorfunc(&se->env, env_error_func, se);
	}

	static void stackenv_uninit(stackenv* se) {
	upb_env_uninit(&se->env);
	upb_seededalloc_uninit(&se->alloc);
	}

	// -----------------------------------------------------------------------------
	// Message
	// -----------------------------------------------------------------------------

	static const upb_handlers* msgdef_pb_serialize_handlers(Descriptor* desc) {
	if (desc->pb_serialize_handlers == NULL) {
	desc->pb_serialize_handlers =
	upb_pb_encoder_newhandlers(desc->msgdef, &desc->pb_serialize_handlers);
	}
	return desc->pb_serialize_handlers;
	}

	PHP_METHOD(Message, encode) {
	Descriptor* desc = (Descriptor*)zend_object_store_get_object(
	CE_STATIC_MEMBERS(Z_OBJCE_P(getThis()))[0] TSRMLS_CC);

	stringsink sink;
	stringsink_init(&sink);

	{
	const upb_handlers* serialize_handlers = msgdef_pb_serialize_handlers(desc);

	stackenv se;
	upb_pb_encoder* encoder;

	stackenv_init(&se, "Error occurred during encoding: %s");
	encoder = upb_pb_encoder_create(&se.env, serialize_handlers, &sink.sink);

	putmsg(getThis(), desc, upb_pb_encoder_input(encoder), 0);

	RETVAL_STRINGL(sink.ptr, sink.len, 1);

	stackenv_uninit(&se);
	stringsink_uninit(&sink);
	}
	}

	void message_free(void * object TSRMLS_DC) {
	FREE(object);
	}

	zend_object_value message_create(zend_class_entry* ce TSRMLS_DC) {
	zend_object_value return_value;

	zval* php_descriptor = get_def_obj(ce);

	Descriptor* desc = zend_object_store_get_object(php_descriptor TSRMLS_CC);
	MessageHeader* msg = (MessageHeader*)ALLOC_N(
	uint8_t, sizeof(MessageHeader) + desc->layout->size);
	memset(message_data(msg), 0, desc->layout->size);

	// We wrap first so that everything in the message object is GC-rooted in case
	// a collection happens during object creation in layout_init().
	msg->descriptor = desc;

	layout_init(desc->layout, message_data(msg));
	zend_object_std_init(&msg->std, ce TSRMLS_CC);

	return_value.handle = zend_objects_store_put(
	msg, (zend_objects_store_dtor_t)zend_objects_destroy_object,
	message_free, NULL TSRMLS_CC);

	return_value.handlers = PROTOBUF_G(message_handlers);
	return return_value;
	}

	const zend_class_entry* build_class_from_descriptor(
	zval* php_descriptor TSRMLS_DC) {
	Descriptor* desc = php_to_descriptor(php_descriptor);
	if (desc->layout == NULL) {
	MessageLayout* layout = create_layout(desc->msgdef);
	desc->layout = layout;
	}
	// TODO(teboring): Add it back.
	// if (desc->fill_method == NULL) {
	// desc->fill_method = new_fillmsg_decodermethod(desc, &desc->fill_method);
	// }

	const char* name = upb_msgdef_fullname(desc->msgdef);
	if (name == NULL) {
	zend_error(E_ERROR, "Descriptor does not have assigned name.");
	}

	zend_class_entry class_entry;
	INIT_CLASS_ENTRY_EX(class_entry, name, strlen(name), message_methods);
	zend_class_entry* registered_ce =
	zend_register_internal_class(&class_entry TSRMLS_CC);

	add_def_obj(registered_ce, php_descriptor);

	if (PROTOBUF_G(message_handlers) == NULL) {
	PROTOBUF_G(message_handlers) = ALLOC(zend_object_handlers);
	memcpy(PROTOBUF_G(message_handlers), zend_get_std_object_handlers(),
	sizeof(zend_object_handlers));
	PROTOBUF_G(message_handlers)->write_property = message_set_property;
	PROTOBUF_G(message_handlers)->read_property = message_get_property;
	}

	registered_ce->create_object = message_create;
	}