src/php/ext/grpc/call.c

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 /**
  20  * class Call
  21  * @see https://github.com/grpc/grpc/tree/master/src/php/ext/grpc/call.c
  22  */
  23
  24 #include "call.h"
  25
  26 #include <ext/spl/spl_exceptions.h>
  27 #include <zend_exceptions.h>
  28
  29 #include <grpc/support/alloc.h>
  30
  31 #include "call_credentials.h"
  32 #include "completion_queue.h"
  33 #include "timeval.h"
  34 #include "channel.h"
  35 #include "byte_buffer.h"
  36
  37 zend_class_entry *grpc_ce_call;
  38 PHP_GRPC_DECLARE_OBJECT_HANDLER(call_ce_handlers)
  39
  40 /* Frees and destroys an instance of wrapped_grpc_call */
  41 PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_call)
  42   if (p->owned && p->wrapped != NULL) {
  43     grpc_call_unref(p->wrapped);
  44   }
  45 PHP_GRPC_FREE_WRAPPED_FUNC_END()
  46
  47 /* Initializes an instance of wrapped_grpc_call to be associated with an
  48  * object of a class specified by class_type */
  49 php_grpc_zend_object create_wrapped_grpc_call(zend_class_entry *class_type
  50                                               TSRMLS_DC) {
  51   PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_call);
  52   zend_object_std_init(&intern->std, class_type TSRMLS_CC);
  53   object_properties_init(&intern->std, class_type);
  54   PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_call, call_ce_handlers);
  55 }
  56
  57 /* Creates and returns a PHP array object with the data in a
  58  * grpc_metadata_array. Returns NULL on failure */
  59 zval *grpc_parse_metadata_array(grpc_metadata_array
  60                                 *metadata_array TSRMLS_DC) {
  61   int count = metadata_array->count;
  62   grpc_metadata *elements = metadata_array->metadata;
  63   zval *array;
  64   PHP_GRPC_MAKE_STD_ZVAL(array);
  65   array_init(array);
  66   int i;
  67   HashTable *array_hash;
  68   zval *inner_array;
  69   char *str_key;
  70   char *str_val;
  71   size_t key_len;
  72   zval *data = NULL;
  73
  74   array_hash = Z_ARRVAL_P(array);
  75   grpc_metadata *elem;
  76   for (i = 0; i < count; i++) {
  77     elem = &elements[i];
  78     key_len = GRPC_SLICE_LENGTH(elem->key);
  79     str_key = ecalloc(key_len + 1, sizeof(char));
  80     memcpy(str_key, GRPC_SLICE_START_PTR(elem->key), key_len);
  81     str_val = ecalloc(GRPC_SLICE_LENGTH(elem->value) + 1, sizeof(char));
  82     memcpy(str_val, GRPC_SLICE_START_PTR(elem->value),
  83            GRPC_SLICE_LENGTH(elem->value));
  84     if (php_grpc_zend_hash_find(array_hash, str_key, key_len, (void **)&data)
  85         == SUCCESS) {
  86       if (Z_TYPE_P(data) != IS_ARRAY) {
  87         zend_throw_exception(zend_exception_get_default(TSRMLS_C),
  88                              "Metadata hash somehow contains wrong types.",
  89                              1 TSRMLS_CC);
  90         efree(str_key);
  91         efree(str_val);
  92         PHP_GRPC_FREE_STD_ZVAL(array);
  93         return NULL;
  94       }
  95       php_grpc_add_next_index_stringl(data, str_val,
  96                                       GRPC_SLICE_LENGTH(elem->value),
  97                                       false);
  98     } else {
  99       PHP_GRPC_MAKE_STD_ZVAL(inner_array);
 100       array_init(inner_array);
 101       php_grpc_add_next_index_stringl(inner_array, str_val,
 102                                       GRPC_SLICE_LENGTH(elem->value), false);
 103       add_assoc_zval(array, str_key, inner_array);
 104       PHP_GRPC_FREE_STD_ZVAL(inner_array);
 105     }
 106     efree(str_key);
 107 #if PHP_MAJOR_VERSION >= 7
 108     efree(str_val);
 109 #endif
 110   }
 111   return array;
 112 }
 113
 114 /* Populates a grpc_metadata_array with the data in a PHP array object.
 115    Returns true on success and false on failure */
 116 bool create_metadata_array(zval *array, grpc_metadata_array *metadata) {
 117   HashTable *array_hash;
 118   HashTable *inner_array_hash;
 119   zval *value;
 120   zval *inner_array;
 121   grpc_metadata_array_init(metadata);
 122   metadata->count = 0;
 123   metadata->metadata = NULL;
 124   if (Z_TYPE_P(array) != IS_ARRAY) {
 125     return false;
 126   }
 127   array_hash = Z_ARRVAL_P(array);
 128
 129   char *key;
 130   int key_type;
 131   PHP_GRPC_HASH_FOREACH_STR_KEY_VAL_START(array_hash, key, key_type,
 132                                           inner_array)
 133     if (key_type != HASH_KEY_IS_STRING || key == NULL) {
 134       return false;
 135     }
 136     if (Z_TYPE_P(inner_array) != IS_ARRAY) {
 137       return false;
 138     }
 139     inner_array_hash = Z_ARRVAL_P(inner_array);
 140     metadata->capacity += zend_hash_num_elements(inner_array_hash);
 141   PHP_GRPC_HASH_FOREACH_END()
 142
 143   metadata->metadata = gpr_malloc(metadata->capacity * sizeof(grpc_metadata));
 144
 145   char *key1 = NULL;
 146   int key_type1;
 147   PHP_GRPC_HASH_FOREACH_STR_KEY_VAL_START(array_hash, key1, key_type1,
 148                                           inner_array)
 149     if (key_type1 != HASH_KEY_IS_STRING) {
 150       return false;
 151     }
 152     if (!grpc_header_key_is_legal(grpc_slice_from_static_string(key1))) {
 153       return false;
 154     }
 155     inner_array_hash = Z_ARRVAL_P(inner_array);
 156     PHP_GRPC_HASH_FOREACH_VAL_START(inner_array_hash, value)
 157       if (Z_TYPE_P(value) != IS_STRING) {
 158         return false;
 159       }
 160       metadata->metadata[metadata->count].key =
 161         grpc_slice_from_copied_string(key1);
 162       metadata->metadata[metadata->count].value =
 163         grpc_slice_from_copied_buffer(Z_STRVAL_P(value), Z_STRLEN_P(value));
 164       metadata->count += 1;
 165     PHP_GRPC_HASH_FOREACH_END()
 166   PHP_GRPC_HASH_FOREACH_END()
 167   return true;
 168 }
 169
 170 void grpc_php_metadata_array_destroy_including_entries(
 171     grpc_metadata_array* array) {
 172   size_t i;
 173   if (array->metadata) {
 174     for (i = 0; i < array->count; i++) {
 175       grpc_slice_unref(array->metadata[i].key);
 176       grpc_slice_unref(array->metadata[i].value);
 177     }
 178   }
 179   grpc_metadata_array_destroy(array);
 180 }
 181
 182 /* Wraps a grpc_call struct in a PHP object. Owned indicates whether the
 183    struct should be destroyed at the end of the object's lifecycle */
 184 zval *grpc_php_wrap_call(grpc_call *wrapped, bool owned TSRMLS_DC) {
 185   zval *call_object;
 186   PHP_GRPC_MAKE_STD_ZVAL(call_object);
 187   object_init_ex(call_object, grpc_ce_call);
 188   wrapped_grpc_call *call = PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_call,
 189                                                         call_object);
 190   call->wrapped = wrapped;
 191   call->owned = owned;
 192   return call_object;
 193 }
 194
 195 /**
 196  * Constructs a new instance of the Call class.
 197  * @param Channel $channel_obj The channel to associate the call with.
 198  *                             Must not be closed.
 199  * @param string $method The method to call
 200  * @param Timeval $deadline_obj The deadline for completing the call
 201  * @param string $host_override = "" The host is set by user (optional)
 202  */
 203 PHP_METHOD(Call, __construct) {
 204   zval *channel_obj;
 205   char *method;
 206   php_grpc_int method_len;
 207   zval *deadline_obj;
 208   char *host_override = NULL;
 209   php_grpc_int host_override_len = 0;
 210   wrapped_grpc_call *call = PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_call,
 211                                                         getThis());
 212
 213   /* "OsO|s" == 1 Object, 1 string, 1 Object, 1 optional string */
 214   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO|s", &channel_obj,
 215                             grpc_ce_channel, &method, &method_len,
 216                             &deadline_obj, grpc_ce_timeval, &host_override,
 217                             &host_override_len) == FAILURE) {
 218     zend_throw_exception(spl_ce_InvalidArgumentException,
 219                          "Call expects a Channel, a String, a Timeval and "
 220                          "an optional String", 1 TSRMLS_CC);
 221     return;
 222   }
 223   wrapped_grpc_channel *channel =
 224     PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_channel, channel_obj);
 225   if (channel->wrapper == NULL) {
 226     zend_throw_exception(spl_ce_InvalidArgumentException,
 227                          "Call cannot be constructed from a closed Channel",
 228                          1 TSRMLS_CC);
 229     return;
 230   }
 231   gpr_mu_lock(&channel->wrapper->mu);
 232   if (channel->wrapper == NULL || channel->wrapper->wrapped == NULL) {
 233     zend_throw_exception(spl_ce_InvalidArgumentException,
 234                          "Call cannot be constructed from a closed Channel",
 235                          1 TSRMLS_CC);
 236     gpr_mu_unlock(&channel->wrapper->mu);
 237     return;
 238   }
 239   add_property_zval(getThis(), "channel", channel_obj);
 240   wrapped_grpc_timeval *deadline =
 241     PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_timeval, deadline_obj);
 242   grpc_slice method_slice = grpc_slice_from_copied_string(method);
 243   grpc_slice host_slice = host_override != NULL ?
 244       grpc_slice_from_copied_string(host_override) : grpc_empty_slice();
 245   call->wrapped =
 246     grpc_channel_create_call(channel->wrapper->wrapped, NULL,
 247                              GRPC_PROPAGATE_DEFAULTS,
 248                              completion_queue, method_slice,
 249                              host_override != NULL ? &host_slice : NULL,
 250                              deadline->wrapped, NULL);
 251   grpc_slice_unref(method_slice);
 252   grpc_slice_unref(host_slice);
 253   call->owned = true;
 254   call->channel = channel;
 255   gpr_mu_unlock(&channel->wrapper->mu);
 256 }
 257
 258 /**
 259  * Start a batch of RPC actions.
 260  * @param array $array Array of actions to take
 261  * @return object Object with results of all actions
 262  */
 263 PHP_METHOD(Call, startBatch) {
 264   zval *result;
 265   PHP_GRPC_MAKE_STD_ZVAL(result);
 266   object_init(result);
 267   php_grpc_ulong index;
 268   zval *recv_status;
 269   zval *value;
 270   zval *inner_value;
 271   zval *message_value;
 272   zval *message_flags;
 273   wrapped_grpc_call *call = PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_call,
 274                                                         getThis());
 275   if (call->channel) {
 276     // startBatch in gRPC PHP server doesn't have channel in it.
 277     if (call->channel->wrapper == NULL ||
 278         call->channel->wrapper->wrapped == NULL) {
 279       zend_throw_exception(spl_ce_RuntimeException,
 280                            "startBatch Error. Channel is closed",
 281                            1 TSRMLS_CC);
 282     }
 283   }
 284
 285   grpc_op ops[8];
 286   size_t op_num = 0;
 287   zval *array;
 288   HashTable *array_hash;
 289   HashTable *status_hash;
 290   HashTable *message_hash;
 291
 292   grpc_metadata_array metadata;
 293   grpc_metadata_array trailing_metadata;
 294   grpc_metadata_array recv_metadata;
 295   grpc_metadata_array recv_trailing_metadata;
 296   grpc_status_code status;
 297   grpc_slice recv_status_details = grpc_empty_slice();
 298   grpc_slice send_status_details = grpc_empty_slice();
 299   grpc_byte_buffer *message;
 300   int cancelled;
 301   grpc_call_error error;
 302
 303   #if PHP_MAJOR_VERSION < 7
 304   char *message_str;
 305   size_t message_len;
 306   #else
 307   zend_string* zmessage = NULL;
 308   #endif // PHP_MAJOR_VERSION < 7
 309
 310   grpc_metadata_array_init(&metadata);
 311   grpc_metadata_array_init(&trailing_metadata);
 312   grpc_metadata_array_init(&recv_metadata);
 313   grpc_metadata_array_init(&recv_trailing_metadata);
 314   memset(ops, 0, sizeof(ops));
 315
 316   /* "a" == 1 array */
 317   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) ==
 318       FAILURE) {
 319     zend_throw_exception(spl_ce_InvalidArgumentException,
 320                          "start_batch expects an array", 1 TSRMLS_CC);
 321     goto cleanup;
 322   }
 323
 324   array_hash = Z_ARRVAL_P(array);
 325
 326   char *key = NULL;
 327   int key_type;
 328   PHP_GRPC_HASH_FOREACH_LONG_KEY_VAL_START(array_hash, key, key_type, index,
 329                                            value)
 330     if (key_type != HASH_KEY_IS_LONG || key != NULL) {
 331       zend_throw_exception(spl_ce_InvalidArgumentException,
 332                            "batch keys must be integers", 1 TSRMLS_CC);
 333       goto cleanup;
 334     }
 335
 336     ops[op_num].op = (grpc_op_type)index;
 337     ops[op_num].flags = 0;
 338     ops[op_num].reserved = NULL;
 339
 340     switch(index) {
 341     case GRPC_OP_SEND_INITIAL_METADATA:
 342       if (!create_metadata_array(value, &metadata)) {
 343         zend_throw_exception(spl_ce_InvalidArgumentException,
 344                              "Bad metadata value given", 1 TSRMLS_CC);
 345         goto cleanup;
 346       }
 347       ops[op_num].data.send_initial_metadata.count = metadata.count;
 348       ops[op_num].data.send_initial_metadata.metadata = metadata.metadata;
 349       break;
 350     case GRPC_OP_SEND_MESSAGE:
 351       if (Z_TYPE_P(value) != IS_ARRAY) {
 352         zend_throw_exception(spl_ce_InvalidArgumentException,
 353                              "Expected an array for send message",
 354                              1 TSRMLS_CC);
 355         goto cleanup;
 356       }
 357       message_hash = Z_ARRVAL_P(value);
 358       if (php_grpc_zend_hash_find(message_hash, "flags", sizeof("flags"),
 359                          (void **)&message_flags) == SUCCESS) {
 360         if (Z_TYPE_P(message_flags) != IS_LONG) {
 361           zend_throw_exception(spl_ce_InvalidArgumentException,
 362                                "Expected an int for message flags",
 363                                1 TSRMLS_CC);
 364         }
 365         ops[op_num].flags = Z_LVAL_P(message_flags) & GRPC_WRITE_USED_MASK;
 366       }
 367       if (php_grpc_zend_hash_find(message_hash, "message", sizeof("message"),
 368                          (void **)&message_value) != SUCCESS ||
 369           Z_TYPE_P(message_value) != IS_STRING) {
 370         zend_throw_exception(spl_ce_InvalidArgumentException,
 371                              "Expected a string for send message",
 372                              1 TSRMLS_CC);
 373         goto cleanup;
 374       }
 375       ops[op_num].data.send_message.send_message =
 376           string_to_byte_buffer(Z_STRVAL_P(message_value),
 377                                 Z_STRLEN_P(message_value));
 378       break;
 379     case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
 380       break;
 381     case GRPC_OP_SEND_STATUS_FROM_SERVER:
 382       status_hash = Z_ARRVAL_P(value);
 383       if (php_grpc_zend_hash_find(status_hash, "metadata", sizeof("metadata"),
 384                          (void **)&inner_value) == SUCCESS) {
 385         if (!create_metadata_array(inner_value, &trailing_metadata)) {
 386           zend_throw_exception(spl_ce_InvalidArgumentException,
 387                                "Bad trailing metadata value given",
 388                                1 TSRMLS_CC);
 389           goto cleanup;
 390         }
 391         ops[op_num].data.send_status_from_server.trailing_metadata =
 392             trailing_metadata.metadata;
 393         ops[op_num].data.send_status_from_server.trailing_metadata_count =
 394             trailing_metadata.count;
 395       }
 396       if (php_grpc_zend_hash_find(status_hash, "code", sizeof("code"),
 397                          (void**)&inner_value) == SUCCESS) {
 398         if (Z_TYPE_P(inner_value) != IS_LONG) {
 399           zend_throw_exception(spl_ce_InvalidArgumentException,
 400                                "Status code must be an integer",
 401                                1 TSRMLS_CC);
 402           goto cleanup;
 403         }
 404         ops[op_num].data.send_status_from_server.status =
 405             Z_LVAL_P(inner_value);
 406       } else {
 407         zend_throw_exception(spl_ce_InvalidArgumentException,
 408                              "Integer status code is required",
 409                              1 TSRMLS_CC);
 410         goto cleanup;
 411       }
 412       if (php_grpc_zend_hash_find(status_hash, "details", sizeof("details"),
 413                          (void**)&inner_value) == SUCCESS) {
 414         if (Z_TYPE_P(inner_value) != IS_STRING) {
 415           zend_throw_exception(spl_ce_InvalidArgumentException,
 416                                "Status details must be a string",
 417                                1 TSRMLS_CC);
 418           goto cleanup;
 419         }
 420         send_status_details = grpc_slice_from_copied_string(
 421           Z_STRVAL_P(inner_value));
 422         ops[op_num].data.send_status_from_server.status_details =
 423           &send_status_details;
 424       } else {
 425         zend_throw_exception(spl_ce_InvalidArgumentException,
 426                              "String status details is required",
 427                              1 TSRMLS_CC);
 428         goto cleanup;
 429       }
 430       break;
 431     case GRPC_OP_RECV_INITIAL_METADATA:
 432       ops[op_num].data.recv_initial_metadata.recv_initial_metadata =
 433           &recv_metadata;
 434       break;
 435     case GRPC_OP_RECV_MESSAGE:
 436       ops[op_num].data.recv_message.recv_message = &message;
 437       break;
 438     case GRPC_OP_RECV_STATUS_ON_CLIENT:
 439       ops[op_num].data.recv_status_on_client.trailing_metadata =
 440           &recv_trailing_metadata;
 441       ops[op_num].data.recv_status_on_client.status = &status;
 442       ops[op_num].data.recv_status_on_client.status_details =
 443           &recv_status_details;
 444       break;
 445     case GRPC_OP_RECV_CLOSE_ON_SERVER:
 446       ops[op_num].data.recv_close_on_server.cancelled = &cancelled;
 447       break;
 448     default:
 449       zend_throw_exception(spl_ce_InvalidArgumentException,
 450                            "Unrecognized key in batch", 1 TSRMLS_CC);
 451       goto cleanup;
 452     }
 453     op_num++;
 454   PHP_GRPC_HASH_FOREACH_END()
 455
 456   error = grpc_call_start_batch(call->wrapped, ops, op_num, call->wrapped,
 457                                 NULL);
 458   if (error != GRPC_CALL_OK) {
 459     zend_throw_exception(spl_ce_LogicException,
 460                          "start_batch was called incorrectly",
 461                          (long)error TSRMLS_CC);
 462     goto cleanup;
 463   }
 464   grpc_completion_queue_pluck(completion_queue, call->wrapped,
 465                               gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
 466 #if PHP_MAJOR_VERSION >= 7
 467   zval *recv_md;
 468 #endif
 469   for (int i = 0; i < op_num; i++) {
 470     switch(ops[i].op) {
 471     case GRPC_OP_SEND_INITIAL_METADATA:
 472       add_property_bool(result, "send_metadata", true);
 473       break;
 474     case GRPC_OP_SEND_MESSAGE:
 475       add_property_bool(result, "send_message", true);
 476       break;
 477     case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
 478       add_property_bool(result, "send_close", true);
 479       break;
 480     case GRPC_OP_SEND_STATUS_FROM_SERVER:
 481       add_property_bool(result, "send_status", true);
 482       break;
 483     case GRPC_OP_RECV_INITIAL_METADATA:
 484 #if PHP_MAJOR_VERSION < 7
 485       array = grpc_parse_metadata_array(&recv_metadata TSRMLS_CC);
 486       add_property_zval(result, "metadata", array);
 487 #else
 488       recv_md = grpc_parse_metadata_array(&recv_metadata);
 489       add_property_zval(result, "metadata", recv_md);
 490       zval_ptr_dtor(recv_md);
 491       PHP_GRPC_FREE_STD_ZVAL(recv_md);
 492 #endif
 493       PHP_GRPC_DELREF(array);
 494       break;
 495     case GRPC_OP_RECV_MESSAGE:
 496 #if PHP_MAJOR_VERSION < 7
 497       byte_buffer_to_string(message, &message_str, &message_len);
 498 #else
 499       zmessage = byte_buffer_to_zend_string(message);
 500 #endif // PHP_MAJOR_VERSION < 7
 501
 502 #if PHP_MAJOR_VERSION < 7
 503       if (message_str == NULL) {
 504 #else
 505       if (zmessage == NULL) {
 506 #endif // PHP_MAJOR_VERSION < 7
 507         add_property_null(result, "message");
 508       } else {
 509 #if PHP_MAJOR_VERSION < 7
 510         php_grpc_add_property_stringl(result, "message", message_str,
 511                                       message_len, false);
 512 #else
 513         zval zmessage_val;
 514         ZVAL_NEW_STR(&zmessage_val, zmessage);
 515         add_property_zval(result, "message", &zmessage_val);
 516         zval_ptr_dtor(&zmessage_val);
 517 #endif // PHP_MAJOR_VERSION < 7
 518       }
 519       break;
 520     case GRPC_OP_RECV_STATUS_ON_CLIENT:
 521       PHP_GRPC_MAKE_STD_ZVAL(recv_status);
 522       object_init(recv_status);
 523 #if PHP_MAJOR_VERSION < 7
 524       array = grpc_parse_metadata_array(&recv_trailing_metadata TSRMLS_CC);
 525       add_property_zval(recv_status, "metadata", array);
 526 #else
 527       recv_md = grpc_parse_metadata_array(&recv_trailing_metadata);
 528       add_property_zval(recv_status, "metadata", recv_md);
 529       zval_ptr_dtor(recv_md);
 530       PHP_GRPC_FREE_STD_ZVAL(recv_md);
 531 #endif
 532       PHP_GRPC_DELREF(array);
 533       add_property_long(recv_status, "code", status);
 534       char *status_details_text = grpc_slice_to_c_string(recv_status_details);
 535       php_grpc_add_property_string(recv_status, "details", status_details_text,
 536                                    true);
 537       gpr_free(status_details_text);
 538       add_property_zval(result, "status", recv_status);
 539 #if PHP_MAJOR_VERSION >= 7
 540       zval_ptr_dtor(recv_status);
 541 #endif
 542       PHP_GRPC_DELREF(recv_status);
 543       PHP_GRPC_FREE_STD_ZVAL(recv_status);
 544       break;
 545     case GRPC_OP_RECV_CLOSE_ON_SERVER:
 546       add_property_bool(result, "cancelled", cancelled);
 547       break;
 548     default:
 549       break;
 550     }
 551   }
 552
 553 cleanup:
 554   grpc_php_metadata_array_destroy_including_entries(&metadata);
 555   grpc_php_metadata_array_destroy_including_entries(&trailing_metadata);
 556   grpc_metadata_array_destroy(&recv_metadata);
 557   grpc_metadata_array_destroy(&recv_trailing_metadata);
 558   grpc_slice_unref(recv_status_details);
 559   grpc_slice_unref(send_status_details);
 560   for (int i = 0; i < op_num; i++) {
 561     if (ops[i].op == GRPC_OP_SEND_MESSAGE) {
 562       grpc_byte_buffer_destroy(ops[i].data.send_message.send_message);
 563     }
 564     if (ops[i].op == GRPC_OP_RECV_MESSAGE) {
 565       grpc_byte_buffer_destroy(message);
 566       #if PHP_MAJOR_VERSION < 7
 567       PHP_GRPC_FREE_STD_ZVAL(message_str);
 568       #endif // PHP_MAJOR_VERSION < 7
 569     }
 570   }
 571   RETURN_DESTROY_ZVAL(result);
 572 }
 573
 574 /**
 575  * Get the endpoint this call/stream is connected to
 576  * @return string The URI of the endpoint
 577  */
 578 PHP_METHOD(Call, getPeer) {
 579   wrapped_grpc_call *call = PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_call,
 580                                                         getThis());
 581   char *peer = grpc_call_get_peer(call->wrapped);
 582   PHP_GRPC_RETVAL_STRING(peer, 1);
 583   gpr_free(peer);
 584 }
 585
 586 /**
 587  * Cancel the call. This will cause the call to end with STATUS_CANCELLED
 588  * if it has not already ended with another status.
 589  * @return void
 590  */
 591 PHP_METHOD(Call, cancel) {
 592   wrapped_grpc_call *call = PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_call,
 593                                                         getThis());
 594   grpc_call_cancel(call->wrapped, NULL);
 595 }
 596
 597 /**
 598  * Set the CallCredentials for this call.
 599  * @param CallCredentials $creds_obj The CallCredentials object
 600  * @return int The error code
 601  */
 602 PHP_METHOD(Call, setCredentials) {
 603   zval *creds_obj;
 604
 605   /* "O" == 1 Object */
 606   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &creds_obj,
 607                             grpc_ce_call_credentials) == FAILURE) {
 608     zend_throw_exception(spl_ce_InvalidArgumentException,
 609                          "setCredentials expects 1 CallCredentials",
 610                          1 TSRMLS_CC);
 611     return;
 612   }
 613
 614   wrapped_grpc_call_credentials *creds =
 615     PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_call_credentials, creds_obj);
 616   wrapped_grpc_call *call = PHP_GRPC_GET_WRAPPED_OBJECT(wrapped_grpc_call,
 617                                                         getThis());
 618
 619   grpc_call_error error = GRPC_CALL_ERROR;
 620   error = grpc_call_set_credentials(call->wrapped, creds->wrapped);
 621   RETURN_LONG(error);
 622 }
 623
 624 ZEND_BEGIN_ARG_INFO_EX(arginfo_construct, 0, 0, 3)
 625   ZEND_ARG_INFO(0, channel)
 626   ZEND_ARG_INFO(0, method)
 627   ZEND_ARG_INFO(0, deadline)
 628   ZEND_ARG_INFO(0, host_override)
 629 ZEND_END_ARG_INFO()
 630
 631 ZEND_BEGIN_ARG_INFO_EX(arginfo_startBatch, 0, 0, 1)
 632   ZEND_ARG_INFO(0, ops)
 633 ZEND_END_ARG_INFO()
 634
 635 ZEND_BEGIN_ARG_INFO_EX(arginfo_getPeer, 0, 0, 0)
 636 ZEND_END_ARG_INFO()
 637
 638 ZEND_BEGIN_ARG_INFO_EX(arginfo_cancel, 0, 0, 0)
 639 ZEND_END_ARG_INFO()
 640
 641 ZEND_BEGIN_ARG_INFO_EX(arginfo_setCredentials, 0, 0, 1)
 642   ZEND_ARG_INFO(0, credentials)
 643 ZEND_END_ARG_INFO()
 644
 645 static zend_function_entry call_methods[] = {
 646   PHP_ME(Call, __construct, arginfo_construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
 647   PHP_ME(Call, startBatch, arginfo_startBatch, ZEND_ACC_PUBLIC)
 648   PHP_ME(Call, getPeer, arginfo_getPeer, ZEND_ACC_PUBLIC)
 649   PHP_ME(Call, cancel, arginfo_cancel, ZEND_ACC_PUBLIC)
 650   PHP_ME(Call, setCredentials, arginfo_setCredentials, ZEND_ACC_PUBLIC)
 651   PHP_FE_END
 652 };
 653
 654 void grpc_init_call(TSRMLS_D) {
 655   zend_class_entry ce;
 656   INIT_CLASS_ENTRY(ce, "Grpc\\Call", call_methods);
 657   ce.create_object = create_wrapped_grpc_call;
 658   grpc_ce_call = zend_register_internal_class(&ce TSRMLS_CC);
 659   PHP_GRPC_INIT_HANDLER(wrapped_grpc_call, call_ce_handlers);
 660 }