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 }
PHP_GRPC_FREE_WRAPPED_FUNC_END()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 */
grpc_parse_metadata_array(grpc_metadata_array * metadata_array TSRMLS_DC)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 */
create_metadata_array(zval * array,grpc_metadata_array * metadata)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
grpc_php_metadata_array_destroy_including_entries(grpc_metadata_array * array)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 */
grpc_php_wrap_call(grpc_call * wrapped,bool owned TSRMLS_DC)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 */
PHP_METHOD(Call,__construct)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 */
PHP_METHOD(Call,startBatch)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 }
661