Craig Tiller | 1a61b17 | 2015-02-16 11:53:47 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Craig Tiller | 6169d5f | 2016-03-31 07:46:18 -0700 | [diff] [blame^] | 3 | * Copyright 2015, Google Inc. |
Craig Tiller | 1a61b17 | 2015-02-16 11:53:47 -0800 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 34 | #include "call.h" |
| 35 | |
| 36 | #ifdef HAVE_CONFIG_H |
| 37 | #include "config.h" |
| 38 | #endif |
| 39 | |
murgatroid99 | 8242ba7 | 2015-04-01 15:29:44 -0700 | [diff] [blame] | 40 | #include <php.h> |
| 41 | #include <php_ini.h> |
| 42 | #include <ext/standard/info.h> |
| 43 | #include <ext/spl/spl_exceptions.h> |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 44 | #include "php_grpc.h" |
Stanley Cheung | 3580580 | 2015-12-10 11:42:55 -0800 | [diff] [blame] | 45 | #include "call_credentials.h" |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 46 | |
murgatroid99 | 8242ba7 | 2015-04-01 15:29:44 -0700 | [diff] [blame] | 47 | #include <zend_exceptions.h> |
| 48 | #include <zend_hash.h> |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 49 | |
| 50 | #include <stdbool.h> |
| 51 | |
murgatroid99 | 8242ba7 | 2015-04-01 15:29:44 -0700 | [diff] [blame] | 52 | #include <grpc/support/alloc.h> |
| 53 | #include <grpc/grpc.h> |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 54 | |
murgatroid99 | 268acd5 | 2015-05-14 15:05:00 -0700 | [diff] [blame] | 55 | #include "completion_queue.h" |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 56 | #include "timeval.h" |
| 57 | #include "channel.h" |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 58 | #include "byte_buffer.h" |
| 59 | |
Xiaoguang Sun | 8a929a9 | 2015-03-13 14:22:31 +0800 | [diff] [blame] | 60 | zend_class_entry *grpc_ce_call; |
| 61 | |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 62 | /* Frees and destroys an instance of wrapped_grpc_call */ |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 63 | void free_wrapped_grpc_call(void *object TSRMLS_DC) { |
| 64 | wrapped_grpc_call *call = (wrapped_grpc_call *)object; |
| 65 | if (call->owned && call->wrapped != NULL) { |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 66 | grpc_call_destroy(call->wrapped); |
| 67 | } |
| 68 | efree(call); |
| 69 | } |
| 70 | |
| 71 | /* Initializes an instance of wrapped_grpc_call to be associated with an object |
| 72 | * of a class specified by class_type */ |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 73 | zend_object_value create_wrapped_grpc_call(zend_class_entry *class_type |
| 74 | TSRMLS_DC) { |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 75 | zend_object_value retval; |
| 76 | wrapped_grpc_call *intern; |
| 77 | |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 78 | intern = (wrapped_grpc_call *)emalloc(sizeof(wrapped_grpc_call)); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 79 | memset(intern, 0, sizeof(wrapped_grpc_call)); |
| 80 | |
| 81 | zend_object_std_init(&intern->std, class_type TSRMLS_CC); |
| 82 | object_properties_init(&intern->std, class_type); |
| 83 | retval.handle = zend_objects_store_put( |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 84 | intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, |
| 85 | free_wrapped_grpc_call, NULL TSRMLS_CC); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 86 | retval.handlers = zend_get_std_object_handlers(); |
| 87 | return retval; |
| 88 | } |
| 89 | |
mlumish | 34cd1f0 | 2015-01-02 13:32:41 -0800 | [diff] [blame] | 90 | /* Wraps a grpc_call struct in a PHP object. Owned indicates whether the struct |
| 91 | should be destroyed at the end of the object's lifecycle */ |
murgatroid99 | 268acd5 | 2015-05-14 15:05:00 -0700 | [diff] [blame] | 92 | zval *grpc_php_wrap_call(grpc_call *wrapped, bool owned) { |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 93 | zval *call_object; |
| 94 | MAKE_STD_ZVAL(call_object); |
| 95 | object_init_ex(call_object, grpc_ce_call); |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 96 | wrapped_grpc_call *call = |
| 97 | (wrapped_grpc_call *)zend_object_store_get_object(call_object TSRMLS_CC); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 98 | call->wrapped = wrapped; |
| 99 | return call_object; |
| 100 | } |
| 101 | |
murgatroid99 | 9c4425a | 2015-03-24 09:43:41 -0700 | [diff] [blame] | 102 | /* Creates and returns a PHP array object with the data in a |
| 103 | * grpc_metadata_array. Returns NULL on failure */ |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 104 | zval *grpc_parse_metadata_array(grpc_metadata_array *metadata_array) { |
| 105 | int count = metadata_array->count; |
| 106 | grpc_metadata *elements = metadata_array->metadata; |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 107 | int i; |
| 108 | zval *array; |
| 109 | zval **data = NULL; |
| 110 | HashTable *array_hash; |
| 111 | zval *inner_array; |
| 112 | char *str_key; |
| 113 | char *str_val; |
| 114 | size_t key_len; |
| 115 | MAKE_STD_ZVAL(array); |
| 116 | array_init(array); |
| 117 | array_hash = Z_ARRVAL_P(array); |
| 118 | grpc_metadata *elem; |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 119 | for (i = 0; i < count; i++) { |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 120 | elem = &elements[i]; |
| 121 | key_len = strlen(elem->key); |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 122 | str_key = ecalloc(key_len + 1, sizeof(char)); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 123 | memcpy(str_key, elem->key, key_len); |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 124 | str_val = ecalloc(elem->value_length + 1, sizeof(char)); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 125 | memcpy(str_val, elem->value, elem->value_length); |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 126 | if (zend_hash_find(array_hash, str_key, key_len, (void **)data) == |
| 127 | SUCCESS) { |
Stanley Cheung | b91f0f2 | 2016-02-16 09:36:36 -0800 | [diff] [blame] | 128 | if (Z_TYPE_P(*data) != IS_ARRAY) { |
| 129 | zend_throw_exception(zend_exception_get_default(), |
| 130 | "Metadata hash somehow contains wrong types.", |
| 131 | 1 TSRMLS_CC); |
| 132 | efree(str_key); |
| 133 | efree(str_val); |
| 134 | return NULL; |
| 135 | } |
| 136 | add_next_index_stringl(*data, str_val, elem->value_length, false); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 137 | } else { |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 138 | MAKE_STD_ZVAL(inner_array); |
| 139 | array_init(inner_array); |
| 140 | add_next_index_stringl(inner_array, str_val, elem->value_length, false); |
| 141 | add_assoc_zval(array, str_key, inner_array); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 142 | } |
| 143 | } |
| 144 | return array; |
| 145 | } |
| 146 | |
murgatroid99 | 9c4425a | 2015-03-24 09:43:41 -0700 | [diff] [blame] | 147 | /* Populates a grpc_metadata_array with the data in a PHP array object. |
| 148 | Returns true on success and false on failure */ |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 149 | bool create_metadata_array(zval *array, grpc_metadata_array *metadata) { |
| 150 | zval **inner_array; |
| 151 | zval **value; |
| 152 | HashTable *array_hash; |
| 153 | HashPosition array_pointer; |
| 154 | HashTable *inner_array_hash; |
| 155 | HashPosition inner_array_pointer; |
| 156 | char *key; |
| 157 | uint key_len; |
| 158 | ulong index; |
| 159 | if (Z_TYPE_P(array) != IS_ARRAY) { |
| 160 | return false; |
| 161 | } |
| 162 | grpc_metadata_array_init(metadata); |
| 163 | array_hash = Z_ARRVAL_P(array); |
| 164 | for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); |
| 165 | zend_hash_get_current_data_ex(array_hash, (void**)&inner_array, |
| 166 | &array_pointer) == SUCCESS; |
| 167 | zend_hash_move_forward_ex(array_hash, &array_pointer)) { |
| 168 | if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, |
| 169 | &array_pointer) != HASH_KEY_IS_STRING) { |
| 170 | return false; |
| 171 | } |
| 172 | if (Z_TYPE_P(*inner_array) != IS_ARRAY) { |
| 173 | return false; |
| 174 | } |
| 175 | inner_array_hash = Z_ARRVAL_P(*inner_array); |
| 176 | metadata->capacity += zend_hash_num_elements(inner_array_hash); |
| 177 | } |
| 178 | metadata->metadata = gpr_malloc(metadata->capacity * sizeof(grpc_metadata)); |
| 179 | for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); |
| 180 | zend_hash_get_current_data_ex(array_hash, (void**)&inner_array, |
| 181 | &array_pointer) == SUCCESS; |
| 182 | zend_hash_move_forward_ex(array_hash, &array_pointer)) { |
| 183 | if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, |
| 184 | &array_pointer) != HASH_KEY_IS_STRING) { |
| 185 | return false; |
| 186 | } |
| 187 | inner_array_hash = Z_ARRVAL_P(*inner_array); |
| 188 | for (zend_hash_internal_pointer_reset_ex(inner_array_hash, |
| 189 | &inner_array_pointer); |
| 190 | zend_hash_get_current_data_ex(inner_array_hash, (void**)&value, |
| 191 | &inner_array_pointer) == SUCCESS; |
| 192 | zend_hash_move_forward_ex(inner_array_hash, &inner_array_pointer)) { |
| 193 | if (Z_TYPE_P(*value) != IS_STRING) { |
| 194 | return false; |
| 195 | } |
| 196 | metadata->metadata[metadata->count].key = key; |
| 197 | metadata->metadata[metadata->count].value = Z_STRVAL_P(*value); |
| 198 | metadata->metadata[metadata->count].value_length = Z_STRLEN_P(*value); |
| 199 | metadata->count += 1; |
| 200 | } |
| 201 | } |
| 202 | return true; |
| 203 | } |
| 204 | |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 205 | /** |
| 206 | * Constructs a new instance of the Call class. |
| 207 | * @param Channel $channel The channel to associate the call with. Must not be |
| 208 | * closed. |
| 209 | * @param string $method The method to call |
| 210 | * @param Timeval $absolute_deadline The deadline for completing the call |
| 211 | */ |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 212 | PHP_METHOD(Call, __construct) { |
| 213 | wrapped_grpc_call *call = |
| 214 | (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 215 | zval *channel_obj; |
| 216 | char *method; |
| 217 | int method_len; |
| 218 | zval *deadline_obj; |
Stanley Cheung | 478fb00 | 2015-08-19 14:25:00 -0700 | [diff] [blame] | 219 | char *host_override = NULL; |
| 220 | int host_override_len = 0; |
| 221 | /* "OsO|s" == 1 Object, 1 string, 1 Object, 1 optional string */ |
| 222 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO|s", |
| 223 | &channel_obj, grpc_ce_channel, |
| 224 | &method, &method_len, |
| 225 | &deadline_obj, grpc_ce_timeval, |
| 226 | &host_override, &host_override_len) |
| 227 | == FAILURE) { |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 228 | zend_throw_exception( |
| 229 | spl_ce_InvalidArgumentException, |
Stanley Cheung | 478fb00 | 2015-08-19 14:25:00 -0700 | [diff] [blame] | 230 | "Call expects a Channel, a String, a Timeval and an optional String", |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 231 | 1 TSRMLS_CC); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 232 | return; |
| 233 | } |
| 234 | wrapped_grpc_channel *channel = |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 235 | (wrapped_grpc_channel *)zend_object_store_get_object( |
| 236 | channel_obj TSRMLS_CC); |
| 237 | if (channel->wrapped == NULL) { |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 238 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 239 | "Call cannot be constructed from a closed Channel", |
| 240 | 1 TSRMLS_CC); |
| 241 | return; |
| 242 | } |
| 243 | add_property_zval(getThis(), "channel", channel_obj); |
| 244 | wrapped_grpc_timeval *deadline = |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 245 | (wrapped_grpc_timeval *)zend_object_store_get_object( |
| 246 | deadline_obj TSRMLS_CC); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 247 | call->wrapped = grpc_channel_create_call( |
Craig Tiller | e1b0e6e | 2015-07-31 17:07:31 -0700 | [diff] [blame] | 248 | channel->wrapped, NULL, GRPC_PROPAGATE_DEFAULTS, completion_queue, method, |
Stanley Cheung | ddb16a8 | 2015-08-19 15:11:51 -0700 | [diff] [blame] | 249 | host_override, deadline->wrapped, NULL); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | /** |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 253 | * Start a batch of RPC actions. |
| 254 | * @param array batch Array of actions to take |
| 255 | * @return object Object with results of all actions |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 256 | */ |
murgatroid99 | c1d7e24 | 2015-04-02 10:02:43 -0700 | [diff] [blame] | 257 | PHP_METHOD(Call, startBatch) { |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 258 | wrapped_grpc_call *call = |
| 259 | (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 260 | grpc_op ops[8]; |
| 261 | size_t op_num = 0; |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 262 | zval *array; |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 263 | zval **value; |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 264 | zval **inner_value; |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 265 | HashTable *array_hash; |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 266 | HashPosition array_pointer; |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 267 | HashTable *status_hash; |
Stanley Cheung | 3ab8e79 | 2015-08-24 16:58:42 -0700 | [diff] [blame] | 268 | HashTable *message_hash; |
| 269 | zval **message_value; |
| 270 | zval **message_flags; |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 271 | char *key; |
| 272 | uint key_len; |
| 273 | ulong index; |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 274 | grpc_metadata_array metadata; |
| 275 | grpc_metadata_array trailing_metadata; |
| 276 | grpc_metadata_array recv_metadata; |
| 277 | grpc_metadata_array recv_trailing_metadata; |
| 278 | grpc_status_code status; |
| 279 | char *status_details = NULL; |
murgatroid99 | 9fe516a | 2015-03-11 14:47:10 -0700 | [diff] [blame] | 280 | size_t status_details_capacity = 0; |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 281 | grpc_byte_buffer *message; |
| 282 | int cancelled; |
| 283 | grpc_call_error error; |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 284 | zval *result; |
| 285 | char *message_str; |
| 286 | size_t message_len; |
| 287 | zval *recv_status; |
| 288 | grpc_metadata_array_init(&metadata); |
| 289 | grpc_metadata_array_init(&trailing_metadata); |
murgatroid99 | d8bb957 | 2015-03-11 09:18:06 -0700 | [diff] [blame] | 290 | grpc_metadata_array_init(&recv_metadata); |
| 291 | grpc_metadata_array_init(&recv_trailing_metadata); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 292 | MAKE_STD_ZVAL(result); |
| 293 | object_init(result); |
| 294 | /* "a" == 1 array */ |
| 295 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 296 | FAILURE) { |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 297 | zend_throw_exception(spl_ce_InvalidArgumentException, |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 298 | "start_batch expects an array", 1 TSRMLS_CC); |
| 299 | goto cleanup; |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 300 | } |
| 301 | array_hash = Z_ARRVAL_P(array); |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 302 | for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 303 | zend_hash_get_current_data_ex(array_hash, (void**)&value, |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 304 | &array_pointer) == SUCCESS; |
| 305 | zend_hash_move_forward_ex(array_hash, &array_pointer)) { |
| 306 | if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 307 | &array_pointer) != HASH_KEY_IS_LONG) { |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 308 | zend_throw_exception(spl_ce_InvalidArgumentException, |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 309 | "batch keys must be integers", 1 TSRMLS_CC); |
| 310 | goto cleanup; |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 311 | } |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 312 | switch(index) { |
| 313 | case GRPC_OP_SEND_INITIAL_METADATA: |
| 314 | if (!create_metadata_array(*value, &metadata)) { |
| 315 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 316 | "Bad metadata value given", 1 TSRMLS_CC); |
| 317 | goto cleanup; |
| 318 | } |
| 319 | ops[op_num].data.send_initial_metadata.count = |
| 320 | metadata.count; |
| 321 | ops[op_num].data.send_initial_metadata.metadata = |
| 322 | metadata.metadata; |
| 323 | break; |
| 324 | case GRPC_OP_SEND_MESSAGE: |
Stanley Cheung | 3ab8e79 | 2015-08-24 16:58:42 -0700 | [diff] [blame] | 325 | if (Z_TYPE_PP(value) != IS_ARRAY) { |
| 326 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 327 | "Expected an array for send message", |
| 328 | 1 TSRMLS_CC); |
| 329 | goto cleanup; |
| 330 | } |
| 331 | message_hash = Z_ARRVAL_PP(value); |
| 332 | if (zend_hash_find(message_hash, "flags", sizeof("flags"), |
| 333 | (void **)&message_flags) == SUCCESS) { |
| 334 | if (Z_TYPE_PP(message_flags) != IS_LONG) { |
| 335 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 336 | "Expected an int for message flags", |
| 337 | 1 TSRMLS_CC); |
| 338 | } |
| 339 | ops[op_num].flags = Z_LVAL_PP(message_flags) & GRPC_WRITE_USED_MASK; |
| 340 | } |
| 341 | if (zend_hash_find(message_hash, "message", sizeof("message"), |
| 342 | (void **)&message_value) != SUCCESS || |
| 343 | Z_TYPE_PP(message_value) != IS_STRING) { |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 344 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 345 | "Expected a string for send message", |
| 346 | 1 TSRMLS_CC); |
Stanley Cheung | 3ab8e79 | 2015-08-24 16:58:42 -0700 | [diff] [blame] | 347 | goto cleanup; |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 348 | } |
| 349 | ops[op_num].data.send_message = |
Stanley Cheung | 3ab8e79 | 2015-08-24 16:58:42 -0700 | [diff] [blame] | 350 | string_to_byte_buffer(Z_STRVAL_PP(message_value), |
| 351 | Z_STRLEN_PP(message_value)); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 352 | break; |
| 353 | case GRPC_OP_SEND_CLOSE_FROM_CLIENT: |
| 354 | break; |
| 355 | case GRPC_OP_SEND_STATUS_FROM_SERVER: |
| 356 | status_hash = Z_ARRVAL_PP(value); |
| 357 | if (zend_hash_find(status_hash, "metadata", sizeof("metadata"), |
| 358 | (void **)&inner_value) == SUCCESS) { |
| 359 | if (!create_metadata_array(*inner_value, &trailing_metadata)) { |
| 360 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 361 | "Bad trailing metadata value given", |
| 362 | 1 TSRMLS_CC); |
| 363 | goto cleanup; |
| 364 | } |
| 365 | ops[op_num].data.send_status_from_server.trailing_metadata = |
| 366 | trailing_metadata.metadata; |
| 367 | ops[op_num].data.send_status_from_server.trailing_metadata_count = |
| 368 | trailing_metadata.count; |
| 369 | } |
| 370 | if (zend_hash_find(status_hash, "code", sizeof("code"), |
| 371 | (void**)&inner_value) == SUCCESS) { |
| 372 | if (Z_TYPE_PP(inner_value) != IS_LONG) { |
| 373 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 374 | "Status code must be an integer", |
| 375 | 1 TSRMLS_CC); |
| 376 | goto cleanup; |
| 377 | } |
| 378 | ops[op_num].data.send_status_from_server.status = |
| 379 | Z_LVAL_PP(inner_value); |
| 380 | } else { |
| 381 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 382 | "Integer status code is required", |
| 383 | 1 TSRMLS_CC); |
| 384 | goto cleanup; |
| 385 | } |
| 386 | if (zend_hash_find(status_hash, "details", sizeof("details"), |
| 387 | (void**)&inner_value) == SUCCESS) { |
| 388 | if (Z_TYPE_PP(inner_value) != IS_STRING) { |
| 389 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 390 | "Status details must be a string", |
| 391 | 1 TSRMLS_CC); |
| 392 | goto cleanup; |
| 393 | } |
| 394 | ops[op_num].data.send_status_from_server.status_details = |
| 395 | Z_STRVAL_PP(inner_value); |
| 396 | } else { |
| 397 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 398 | "String status details is required", |
| 399 | 1 TSRMLS_CC); |
| 400 | goto cleanup; |
| 401 | } |
| 402 | break; |
| 403 | case GRPC_OP_RECV_INITIAL_METADATA: |
| 404 | ops[op_num].data.recv_initial_metadata = &recv_metadata; |
| 405 | break; |
| 406 | case GRPC_OP_RECV_MESSAGE: |
| 407 | ops[op_num].data.recv_message = &message; |
| 408 | break; |
| 409 | case GRPC_OP_RECV_STATUS_ON_CLIENT: |
| 410 | ops[op_num].data.recv_status_on_client.trailing_metadata = |
| 411 | &recv_trailing_metadata; |
| 412 | ops[op_num].data.recv_status_on_client.status = &status; |
| 413 | ops[op_num].data.recv_status_on_client.status_details = |
| 414 | &status_details; |
| 415 | ops[op_num].data.recv_status_on_client.status_details_capacity = |
| 416 | &status_details_capacity; |
| 417 | break; |
| 418 | case GRPC_OP_RECV_CLOSE_ON_SERVER: |
| 419 | ops[op_num].data.recv_close_on_server.cancelled = &cancelled; |
| 420 | break; |
| 421 | default: |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 422 | zend_throw_exception(spl_ce_InvalidArgumentException, |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 423 | "Unrecognized key in batch", 1 TSRMLS_CC); |
| 424 | goto cleanup; |
| 425 | } |
| 426 | ops[op_num].op = (grpc_op_type)index; |
David Garcia Quintas | ba710e5 | 2015-06-15 13:31:15 -0700 | [diff] [blame] | 427 | ops[op_num].flags = 0; |
Craig Tiller | 4275899 | 2015-08-18 10:34:32 -0700 | [diff] [blame] | 428 | ops[op_num].reserved = NULL; |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 429 | op_num++; |
| 430 | } |
Nicolas "Pixel" Noble | 150b7c4 | 2015-08-01 01:15:10 +0200 | [diff] [blame] | 431 | error = grpc_call_start_batch(call->wrapped, ops, op_num, call->wrapped, |
| 432 | NULL); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 433 | if (error != GRPC_CALL_OK) { |
| 434 | zend_throw_exception(spl_ce_LogicException, |
| 435 | "start_batch was called incorrectly", |
| 436 | (long)error TSRMLS_CC); |
| 437 | goto cleanup; |
| 438 | } |
Stanley Cheung | c0c9ba9 | 2015-08-18 16:19:38 -0700 | [diff] [blame] | 439 | grpc_completion_queue_pluck(completion_queue, call->wrapped, |
| 440 | gpr_inf_future(GPR_CLOCK_REALTIME), NULL); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 441 | for (int i = 0; i < op_num; i++) { |
| 442 | switch(ops[i].op) { |
| 443 | case GRPC_OP_SEND_INITIAL_METADATA: |
| 444 | add_property_bool(result, "send_metadata", true); |
| 445 | break; |
| 446 | case GRPC_OP_SEND_MESSAGE: |
| 447 | add_property_bool(result, "send_message", true); |
| 448 | break; |
| 449 | case GRPC_OP_SEND_CLOSE_FROM_CLIENT: |
| 450 | add_property_bool(result, "send_close", true); |
| 451 | break; |
| 452 | case GRPC_OP_SEND_STATUS_FROM_SERVER: |
| 453 | add_property_bool(result, "send_status", true); |
| 454 | break; |
| 455 | case GRPC_OP_RECV_INITIAL_METADATA: |
murgatroid99 | aa11066 | 2015-04-08 16:53:47 -0700 | [diff] [blame] | 456 | array = grpc_parse_metadata_array(&recv_metadata); |
| 457 | add_property_zval(result, "metadata", array); |
| 458 | Z_DELREF_P(array); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 459 | break; |
| 460 | case GRPC_OP_RECV_MESSAGE: |
| 461 | byte_buffer_to_string(message, &message_str, &message_len); |
murgatroid99 | c1da8f2 | 2015-03-25 11:33:05 -0700 | [diff] [blame] | 462 | if (message_str == NULL) { |
| 463 | add_property_null(result, "message"); |
| 464 | } else { |
| 465 | add_property_stringl(result, "message", message_str, message_len, |
| 466 | false); |
| 467 | } |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 468 | break; |
| 469 | case GRPC_OP_RECV_STATUS_ON_CLIENT: |
| 470 | MAKE_STD_ZVAL(recv_status); |
| 471 | object_init(recv_status); |
murgatroid99 | aa11066 | 2015-04-08 16:53:47 -0700 | [diff] [blame] | 472 | array = grpc_parse_metadata_array(&recv_trailing_metadata); |
| 473 | add_property_zval(recv_status, "metadata", array); |
| 474 | Z_DELREF_P(array); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 475 | add_property_long(recv_status, "code", status); |
murgatroid99 | 9fe516a | 2015-03-11 14:47:10 -0700 | [diff] [blame] | 476 | add_property_string(recv_status, "details", status_details, true); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 477 | add_property_zval(result, "status", recv_status); |
murgatroid99 | aa11066 | 2015-04-08 16:53:47 -0700 | [diff] [blame] | 478 | Z_DELREF_P(recv_status); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 479 | break; |
| 480 | case GRPC_OP_RECV_CLOSE_ON_SERVER: |
| 481 | add_property_bool(result, "cancelled", cancelled); |
| 482 | break; |
| 483 | default: |
| 484 | break; |
murgatroid99 | 5ca9f92 | 2015-02-03 11:21:11 -0800 | [diff] [blame] | 485 | } |
| 486 | } |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 487 | cleanup: |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 488 | grpc_metadata_array_destroy(&metadata); |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 489 | grpc_metadata_array_destroy(&trailing_metadata); |
| 490 | grpc_metadata_array_destroy(&recv_metadata); |
| 491 | grpc_metadata_array_destroy(&recv_trailing_metadata); |
| 492 | if (status_details != NULL) { |
| 493 | gpr_free(status_details); |
mlumish | dba8789 | 2015-01-02 13:27:28 -0800 | [diff] [blame] | 494 | } |
murgatroid99 | afd541c | 2015-03-03 18:16:09 -0800 | [diff] [blame] | 495 | RETURN_DESTROY_ZVAL(result); |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 496 | } |
| 497 | |
murgatroid99 | c1da8f2 | 2015-03-25 11:33:05 -0700 | [diff] [blame] | 498 | /** |
Stanley Cheung | db98e08 | 2015-07-27 10:19:45 -0700 | [diff] [blame] | 499 | * Get the endpoint this call/stream is connected to |
| 500 | * @return string The URI of the endpoint |
| 501 | */ |
| 502 | PHP_METHOD(Call, getPeer) { |
| 503 | wrapped_grpc_call *call = |
| 504 | (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC); |
| 505 | RETURN_STRING(grpc_call_get_peer(call->wrapped), 1); |
| 506 | } |
| 507 | |
| 508 | /** |
murgatroid99 | c1da8f2 | 2015-03-25 11:33:05 -0700 | [diff] [blame] | 509 | * Cancel the call. This will cause the call to end with STATUS_CANCELLED if it |
| 510 | * has not already ended with another status. |
| 511 | */ |
| 512 | PHP_METHOD(Call, cancel) { |
| 513 | wrapped_grpc_call *call = |
| 514 | (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC); |
Nicolas "Pixel" Noble | 150b7c4 | 2015-08-01 01:15:10 +0200 | [diff] [blame] | 515 | grpc_call_cancel(call->wrapped, NULL); |
murgatroid99 | c1da8f2 | 2015-03-25 11:33:05 -0700 | [diff] [blame] | 516 | } |
| 517 | |
Stanley Cheung | 3580580 | 2015-12-10 11:42:55 -0800 | [diff] [blame] | 518 | /** |
| 519 | * Set the CallCredentials for this call. |
| 520 | * @param CallCredentials creds_obj The CallCredentials object |
| 521 | * @param int The error code |
| 522 | */ |
| 523 | PHP_METHOD(Call, setCredentials) { |
| 524 | zval *creds_obj; |
| 525 | |
| 526 | /* "O" == 1 Object */ |
| 527 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &creds_obj, |
| 528 | grpc_ce_call_credentials) == FAILURE) { |
| 529 | zend_throw_exception(spl_ce_InvalidArgumentException, |
| 530 | "setCredentials expects 1 CallCredentials", |
| 531 | 1 TSRMLS_CC); |
| 532 | return; |
| 533 | } |
| 534 | |
| 535 | wrapped_grpc_call_credentials *creds = |
| 536 | (wrapped_grpc_call_credentials *)zend_object_store_get_object( |
| 537 | creds_obj TSRMLS_CC); |
| 538 | |
| 539 | wrapped_grpc_call *call = |
| 540 | (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC); |
| 541 | |
| 542 | grpc_call_error error = GRPC_CALL_ERROR; |
| 543 | error = grpc_call_set_credentials(call->wrapped, creds->wrapped); |
| 544 | RETURN_LONG(error); |
| 545 | } |
| 546 | |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 547 | static zend_function_entry call_methods[] = { |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 548 | PHP_ME(Call, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) |
murgatroid99 | c1d7e24 | 2015-04-02 10:02:43 -0700 | [diff] [blame] | 549 | PHP_ME(Call, startBatch, NULL, ZEND_ACC_PUBLIC) |
Stanley Cheung | db98e08 | 2015-07-27 10:19:45 -0700 | [diff] [blame] | 550 | PHP_ME(Call, getPeer, NULL, ZEND_ACC_PUBLIC) |
| 551 | PHP_ME(Call, cancel, NULL, ZEND_ACC_PUBLIC) |
Stanley Cheung | 3580580 | 2015-12-10 11:42:55 -0800 | [diff] [blame] | 552 | PHP_ME(Call, setCredentials, NULL, ZEND_ACC_PUBLIC) |
Stanley Cheung | db98e08 | 2015-07-27 10:19:45 -0700 | [diff] [blame] | 553 | PHP_FE_END}; |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 554 | |
Craig Tiller | b5dcec5 | 2015-01-13 11:13:42 -0800 | [diff] [blame] | 555 | void grpc_init_call(TSRMLS_D) { |
mlumish | b892a27 | 2014-12-09 16:28:23 -0800 | [diff] [blame] | 556 | zend_class_entry ce; |
| 557 | INIT_CLASS_ENTRY(ce, "Grpc\\Call", call_methods); |
| 558 | ce.create_object = create_wrapped_grpc_call; |
| 559 | grpc_ce_call = zend_register_internal_class(&ce TSRMLS_CC); |
| 560 | } |