| /* |
| * |
| * Copyright 2015, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * 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 "call.h" |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include "php.h" |
| #include "php_ini.h" |
| #include "ext/standard/info.h" |
| #include "ext/spl/spl_exceptions.h" |
| #include "php_grpc.h" |
| |
| #include "zend_exceptions.h" |
| #include "zend_hash.h" |
| |
| #include <stdbool.h> |
| |
| #include "grpc/support/log.h" |
| #include "grpc/support/alloc.h" |
| #include "grpc/grpc.h" |
| |
| #include "timeval.h" |
| #include "channel.h" |
| #include "byte_buffer.h" |
| |
| zend_class_entry *grpc_ce_call; |
| |
| /* Frees and destroys an instance of wrapped_grpc_call */ |
| void free_wrapped_grpc_call(void *object TSRMLS_DC) { |
| wrapped_grpc_call *call = (wrapped_grpc_call *)object; |
| grpc_event *event; |
| if (call->owned && call->wrapped != NULL) { |
| if (call->queue != NULL) { |
| grpc_completion_queue_shutdown(call->queue); |
| event = grpc_completion_queue_next(call->queue, gpr_inf_future); |
| while (event != NULL) { |
| if (event->type == GRPC_QUEUE_SHUTDOWN) { |
| break; |
| } |
| event = grpc_completion_queue_next(call->queue, gpr_inf_future); |
| } |
| grpc_completion_queue_destroy(call->queue); |
| } |
| grpc_call_destroy(call->wrapped); |
| } |
| efree(call); |
| } |
| |
| /* Initializes an instance of wrapped_grpc_call to be associated with an object |
| * of a class specified by class_type */ |
| zend_object_value create_wrapped_grpc_call(zend_class_entry *class_type |
| TSRMLS_DC) { |
| zend_object_value retval; |
| wrapped_grpc_call *intern; |
| |
| intern = (wrapped_grpc_call *)emalloc(sizeof(wrapped_grpc_call)); |
| memset(intern, 0, sizeof(wrapped_grpc_call)); |
| |
| zend_object_std_init(&intern->std, class_type TSRMLS_CC); |
| object_properties_init(&intern->std, class_type); |
| retval.handle = zend_objects_store_put( |
| intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, |
| free_wrapped_grpc_call, NULL TSRMLS_CC); |
| retval.handlers = zend_get_std_object_handlers(); |
| return retval; |
| } |
| |
| /* Wraps a grpc_call struct in a PHP object. Owned indicates whether the struct |
| should be destroyed at the end of the object's lifecycle */ |
| zval *grpc_php_wrap_call(grpc_call *wrapped, grpc_completion_queue *queue, |
| bool owned) { |
| zval *call_object; |
| MAKE_STD_ZVAL(call_object); |
| object_init_ex(call_object, grpc_ce_call); |
| wrapped_grpc_call *call = |
| (wrapped_grpc_call *)zend_object_store_get_object(call_object TSRMLS_CC); |
| call->wrapped = wrapped; |
| call->queue = queue; |
| return call_object; |
| } |
| |
| /* Creates and returns a PHP array object with the data in a |
| * grpc_metadata_array. Returns NULL on failure */ |
| zval *grpc_parse_metadata_array(grpc_metadata_array *metadata_array) { |
| int count = metadata_array->count; |
| grpc_metadata *elements = metadata_array->metadata; |
| int i; |
| zval *array; |
| zval **data = NULL; |
| HashTable *array_hash; |
| zval *inner_array; |
| char *str_key; |
| char *str_val; |
| size_t key_len; |
| MAKE_STD_ZVAL(array); |
| array_init(array); |
| array_hash = Z_ARRVAL_P(array); |
| grpc_metadata *elem; |
| for (i = 0; i < count; i++) { |
| elem = &elements[i]; |
| key_len = strlen(elem->key); |
| str_key = ecalloc(key_len + 1, sizeof(char)); |
| memcpy(str_key, elem->key, key_len); |
| str_val = ecalloc(elem->value_length + 1, sizeof(char)); |
| memcpy(str_val, elem->value, elem->value_length); |
| if (zend_hash_find(array_hash, str_key, key_len, (void **)data) == |
| SUCCESS) { |
| if (Z_TYPE_P(*data) != IS_ARRAY) { |
| zend_throw_exception(zend_exception_get_default(), |
| "Metadata hash somehow contains wrong types.", |
| 1 TSRMLS_CC); |
| efree(str_key); |
| efree(str_val); |
| return NULL; |
| } |
| add_next_index_stringl(*data, str_val, elem->value_length, false); |
| } else { |
| MAKE_STD_ZVAL(inner_array); |
| array_init(inner_array); |
| add_next_index_stringl(inner_array, str_val, elem->value_length, false); |
| add_assoc_zval(array, str_key, inner_array); |
| } |
| } |
| return array; |
| } |
| |
| /* Populates a grpc_metadata_array with the data in a PHP array object. |
| Returns true on success and false on failure */ |
| bool create_metadata_array(zval *array, grpc_metadata_array *metadata) { |
| zval **inner_array; |
| zval **value; |
| HashTable *array_hash; |
| HashPosition array_pointer; |
| HashTable *inner_array_hash; |
| HashPosition inner_array_pointer; |
| char *key; |
| uint key_len; |
| ulong index; |
| if (Z_TYPE_P(array) != IS_ARRAY) { |
| return false; |
| } |
| grpc_metadata_array_init(metadata); |
| array_hash = Z_ARRVAL_P(array); |
| for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); |
| zend_hash_get_current_data_ex(array_hash, (void**)&inner_array, |
| &array_pointer) == SUCCESS; |
| zend_hash_move_forward_ex(array_hash, &array_pointer)) { |
| if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, |
| &array_pointer) != HASH_KEY_IS_STRING) { |
| return false; |
| } |
| if (Z_TYPE_P(*inner_array) != IS_ARRAY) { |
| return false; |
| } |
| inner_array_hash = Z_ARRVAL_P(*inner_array); |
| metadata->capacity += zend_hash_num_elements(inner_array_hash); |
| } |
| metadata->metadata = gpr_malloc(metadata->capacity * sizeof(grpc_metadata)); |
| for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); |
| zend_hash_get_current_data_ex(array_hash, (void**)&inner_array, |
| &array_pointer) == SUCCESS; |
| zend_hash_move_forward_ex(array_hash, &array_pointer)) { |
| if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, |
| &array_pointer) != HASH_KEY_IS_STRING) { |
| return false; |
| } |
| inner_array_hash = Z_ARRVAL_P(*inner_array); |
| for (zend_hash_internal_pointer_reset_ex(inner_array_hash, |
| &inner_array_pointer); |
| zend_hash_get_current_data_ex(inner_array_hash, (void**)&value, |
| &inner_array_pointer) == SUCCESS; |
| zend_hash_move_forward_ex(inner_array_hash, &inner_array_pointer)) { |
| if (Z_TYPE_P(*value) != IS_STRING) { |
| return false; |
| } |
| metadata->metadata[metadata->count].key = key; |
| metadata->metadata[metadata->count].value = Z_STRVAL_P(*value); |
| metadata->metadata[metadata->count].value_length = Z_STRLEN_P(*value); |
| metadata->count += 1; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Constructs a new instance of the Call class. |
| * @param Channel $channel The channel to associate the call with. Must not be |
| * closed. |
| * @param string $method The method to call |
| * @param Timeval $absolute_deadline The deadline for completing the call |
| */ |
| PHP_METHOD(Call, __construct) { |
| wrapped_grpc_call *call = |
| (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC); |
| zval *channel_obj; |
| char *method; |
| int method_len; |
| zval *deadline_obj; |
| /* "OsO" == 1 Object, 1 string, 1 Object */ |
| if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO", &channel_obj, |
| grpc_ce_channel, &method, &method_len, |
| &deadline_obj, grpc_ce_timeval) == FAILURE) { |
| zend_throw_exception( |
| spl_ce_InvalidArgumentException, |
| "Call expects a Channel, a String, and a Timeval", |
| 1 TSRMLS_CC); |
| return; |
| } |
| wrapped_grpc_channel *channel = |
| (wrapped_grpc_channel *)zend_object_store_get_object( |
| channel_obj TSRMLS_CC); |
| if (channel->wrapped == NULL) { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "Call cannot be constructed from a closed Channel", |
| 1 TSRMLS_CC); |
| return; |
| } |
| add_property_zval(getThis(), "channel", channel_obj); |
| wrapped_grpc_timeval *deadline = |
| (wrapped_grpc_timeval *)zend_object_store_get_object( |
| deadline_obj TSRMLS_CC); |
| call->queue = grpc_completion_queue_create(); |
| call->wrapped = grpc_channel_create_call( |
| channel->wrapped, call->queue, method, channel->target, |
| deadline->wrapped); |
| } |
| |
| /** |
| * Start a batch of RPC actions. |
| * @param array batch Array of actions to take |
| * @return object Object with results of all actions |
| */ |
| PHP_METHOD(Call, start_batch) { |
| wrapped_grpc_call *call = |
| (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC); |
| grpc_op ops[8]; |
| size_t op_num = 0; |
| zval *array; |
| zval **value; |
| zval **inner_value; |
| HashTable *array_hash; |
| HashPosition array_pointer; |
| HashTable *status_hash; |
| char *key; |
| uint key_len; |
| ulong index; |
| grpc_metadata_array metadata; |
| grpc_metadata_array trailing_metadata; |
| grpc_metadata_array recv_metadata; |
| grpc_metadata_array recv_trailing_metadata; |
| grpc_status_code status; |
| char *status_details = NULL; |
| size_t status_details_capacity = 0; |
| grpc_byte_buffer *message; |
| int cancelled; |
| grpc_call_error error; |
| grpc_event *event; |
| zval *result; |
| char *message_str; |
| size_t message_len; |
| zval *recv_status; |
| grpc_metadata_array_init(&metadata); |
| grpc_metadata_array_init(&trailing_metadata); |
| grpc_metadata_array_init(&recv_metadata); |
| grpc_metadata_array_init(&recv_trailing_metadata); |
| MAKE_STD_ZVAL(result); |
| object_init(result); |
| /* "a" == 1 array */ |
| if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == |
| FAILURE) { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "start_batch expects an array", 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| array_hash = Z_ARRVAL_P(array); |
| for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); |
| zend_hash_get_current_data_ex(array_hash, (void**)&value, |
| &array_pointer) == SUCCESS; |
| zend_hash_move_forward_ex(array_hash, &array_pointer)) { |
| if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, |
| &array_pointer) != HASH_KEY_IS_LONG) { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "batch keys must be integers", 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| switch(index) { |
| case GRPC_OP_SEND_INITIAL_METADATA: |
| if (!create_metadata_array(*value, &metadata)) { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "Bad metadata value given", 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| ops[op_num].data.send_initial_metadata.count = |
| metadata.count; |
| ops[op_num].data.send_initial_metadata.metadata = |
| metadata.metadata; |
| break; |
| case GRPC_OP_SEND_MESSAGE: |
| if (Z_TYPE_PP(value) != IS_STRING) { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "Expected a string for send message", |
| 1 TSRMLS_CC); |
| } |
| ops[op_num].data.send_message = |
| string_to_byte_buffer(Z_STRVAL_PP(value), Z_STRLEN_PP(value)); |
| break; |
| case GRPC_OP_SEND_CLOSE_FROM_CLIENT: |
| break; |
| case GRPC_OP_SEND_STATUS_FROM_SERVER: |
| status_hash = Z_ARRVAL_PP(value); |
| if (zend_hash_find(status_hash, "metadata", sizeof("metadata"), |
| (void **)&inner_value) == SUCCESS) { |
| if (!create_metadata_array(*inner_value, &trailing_metadata)) { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "Bad trailing metadata value given", |
| 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| ops[op_num].data.send_status_from_server.trailing_metadata = |
| trailing_metadata.metadata; |
| ops[op_num].data.send_status_from_server.trailing_metadata_count = |
| trailing_metadata.count; |
| } |
| if (zend_hash_find(status_hash, "code", sizeof("code"), |
| (void**)&inner_value) == SUCCESS) { |
| if (Z_TYPE_PP(inner_value) != IS_LONG) { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "Status code must be an integer", |
| 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| ops[op_num].data.send_status_from_server.status = |
| Z_LVAL_PP(inner_value); |
| } else { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "Integer status code is required", |
| 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| if (zend_hash_find(status_hash, "details", sizeof("details"), |
| (void**)&inner_value) == SUCCESS) { |
| if (Z_TYPE_PP(inner_value) != IS_STRING) { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "Status details must be a string", |
| 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| ops[op_num].data.send_status_from_server.status_details = |
| Z_STRVAL_PP(inner_value); |
| } else { |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "String status details is required", |
| 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| break; |
| case GRPC_OP_RECV_INITIAL_METADATA: |
| ops[op_num].data.recv_initial_metadata = &recv_metadata; |
| break; |
| case GRPC_OP_RECV_MESSAGE: |
| ops[op_num].data.recv_message = &message; |
| break; |
| case GRPC_OP_RECV_STATUS_ON_CLIENT: |
| ops[op_num].data.recv_status_on_client.trailing_metadata = |
| &recv_trailing_metadata; |
| ops[op_num].data.recv_status_on_client.status = &status; |
| ops[op_num].data.recv_status_on_client.status_details = |
| &status_details; |
| ops[op_num].data.recv_status_on_client.status_details_capacity = |
| &status_details_capacity; |
| break; |
| case GRPC_OP_RECV_CLOSE_ON_SERVER: |
| ops[op_num].data.recv_close_on_server.cancelled = &cancelled; |
| break; |
| default: |
| zend_throw_exception(spl_ce_InvalidArgumentException, |
| "Unrecognized key in batch", 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| ops[op_num].op = (grpc_op_type)index; |
| op_num++; |
| } |
| error = grpc_call_start_batch(call->wrapped, ops, op_num, call->wrapped); |
| if (error != GRPC_CALL_OK) { |
| zend_throw_exception(spl_ce_LogicException, |
| "start_batch was called incorrectly", |
| (long)error TSRMLS_CC); |
| goto cleanup; |
| } |
| event = grpc_completion_queue_pluck(call->queue, call->wrapped, |
| gpr_inf_future); |
| if (event->data.op_complete != GRPC_OP_OK) { |
| zend_throw_exception(spl_ce_LogicException, |
| "The batch failed for some reason", |
| 1 TSRMLS_CC); |
| goto cleanup; |
| } |
| for (int i = 0; i < op_num; i++) { |
| switch(ops[i].op) { |
| case GRPC_OP_SEND_INITIAL_METADATA: |
| add_property_bool(result, "send_metadata", true); |
| break; |
| case GRPC_OP_SEND_MESSAGE: |
| add_property_bool(result, "send_message", true); |
| break; |
| case GRPC_OP_SEND_CLOSE_FROM_CLIENT: |
| add_property_bool(result, "send_close", true); |
| break; |
| case GRPC_OP_SEND_STATUS_FROM_SERVER: |
| add_property_bool(result, "send_status", true); |
| break; |
| case GRPC_OP_RECV_INITIAL_METADATA: |
| add_property_zval(result, "metadata", |
| grpc_parse_metadata_array(&recv_metadata)); |
| break; |
| case GRPC_OP_RECV_MESSAGE: |
| byte_buffer_to_string(message, &message_str, &message_len); |
| if (message_str == NULL) { |
| add_property_null(result, "message"); |
| } else { |
| add_property_stringl(result, "message", message_str, message_len, |
| false); |
| } |
| break; |
| case GRPC_OP_RECV_STATUS_ON_CLIENT: |
| MAKE_STD_ZVAL(recv_status); |
| object_init(recv_status); |
| add_property_zval(recv_status, "metadata", |
| grpc_parse_metadata_array(&recv_trailing_metadata)); |
| add_property_long(recv_status, "code", status); |
| add_property_string(recv_status, "details", status_details, true); |
| add_property_zval(result, "status", recv_status); |
| break; |
| case GRPC_OP_RECV_CLOSE_ON_SERVER: |
| add_property_bool(result, "cancelled", cancelled); |
| break; |
| default: |
| break; |
| } |
| } |
| cleanup: |
| grpc_metadata_array_destroy(&metadata); |
| grpc_metadata_array_destroy(&trailing_metadata); |
| grpc_metadata_array_destroy(&recv_metadata); |
| grpc_metadata_array_destroy(&recv_trailing_metadata); |
| if (status_details != NULL) { |
| gpr_free(status_details); |
| } |
| RETURN_DESTROY_ZVAL(result); |
| } |
| |
| /** |
| * Cancel the call. This will cause the call to end with STATUS_CANCELLED if it |
| * has not already ended with another status. |
| */ |
| PHP_METHOD(Call, cancel) { |
| wrapped_grpc_call *call = |
| (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC); |
| grpc_call_cancel(call->wrapped); |
| } |
| |
| static zend_function_entry call_methods[] = { |
| PHP_ME(Call, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) |
| PHP_ME(Call, start_batch, NULL, ZEND_ACC_PUBLIC) |
| PHP_ME(Call, cancel, NULL, ZEND_ACC_PUBLIC) PHP_FE_END}; |
| |
| void grpc_init_call(TSRMLS_D) { |
| zend_class_entry ce; |
| INIT_CLASS_ENTRY(ce, "Grpc\\Call", call_methods); |
| ce.create_object = create_wrapped_grpc_call; |
| grpc_ce_call = zend_register_internal_class(&ce TSRMLS_CC); |
| } |