自学教程：C++ GRPC_ERROR_UNREF函数代码示例

// Callback to read the HTTP CONNECT request.// TODO(roth): Technically, for any of the failure modes handled by this// function, we should handle the error by returning an HTTP response to// the client indicating that the request failed.  However, for the purposes// of this test code, it's fine to pretend this is a client-side error,// which will cause the client connection to be dropped.static void on_read_request_done(grpc_exec_ctx* exec_ctx, void* arg,                                 grpc_error* error) {  proxy_connection* conn = arg;  if (error != GRPC_ERROR_NONE) {    proxy_connection_failed(exec_ctx, conn, true /* is_client */,                            "HTTP proxy read request", error);    return;  }  // Read request and feed it to the parser.  for (size_t i = 0; i < conn->client_read_buffer.count; ++i) {    if (GRPC_SLICE_LENGTH(conn->client_read_buffer.slices[i]) > 0) {      error = grpc_http_parser_parse(&conn->http_parser,                                     conn->client_read_buffer.slices[i], NULL);      if (error != GRPC_ERROR_NONE) {        proxy_connection_failed(exec_ctx, conn, true /* is_client */,                                "HTTP proxy request parse", error);        GRPC_ERROR_UNREF(error);        return;      }    }  }  grpc_slice_buffer_reset_and_unref(&conn->client_read_buffer);  // If we're not done reading the request, read more data.  if (conn->http_parser.state != GRPC_HTTP_BODY) {    grpc_endpoint_read(exec_ctx, conn->client_endpoint,                       &conn->client_read_buffer, &conn->on_read_request_done);    return;  }  // Make sure we got a CONNECT request.  if (strcmp(conn->http_request.method, "CONNECT") != 0) {    char* msg;    gpr_asprintf(&msg, "HTTP proxy got request method %s",                 conn->http_request.method);    error = GRPC_ERROR_CREATE(msg);    gpr_free(msg);    proxy_connection_failed(exec_ctx, conn, true /* is_client */,                            "HTTP proxy read request", error);    GRPC_ERROR_UNREF(error);    return;  }  // Resolve address.  grpc_resolved_addresses* resolved_addresses = NULL;  error = grpc_blocking_resolve_address(conn->http_request.path, "80",                                        &resolved_addresses);  if (error != GRPC_ERROR_NONE) {    proxy_connection_failed(exec_ctx, conn, true /* is_client */,                            "HTTP proxy DNS lookup", error);    GRPC_ERROR_UNREF(error);    return;  }  GPR_ASSERT(resolved_addresses->naddrs >= 1);  // Connect to requested address.  // The connection callback inherits our reference to conn.  const gpr_timespec deadline = gpr_time_add(      gpr_now(GPR_CLOCK_MONOTONIC), gpr_time_from_seconds(10, GPR_TIMESPAN));  grpc_tcp_client_connect(exec_ctx, &conn->on_server_connect_done,                          &conn->server_endpoint, conn->pollset_set, NULL,                          &resolved_addresses->addrs[0], deadline);  grpc_resolved_addresses_destroy(resolved_addresses);}

static void perform_transport_op(grpc_exec_ctx *exec_ctx, grpc_transport *gt,                                 grpc_transport_op *op) {  inproc_transport *t = (inproc_transport *)gt;  INPROC_LOG(GPR_DEBUG, "perform_transport_op %p %p", t, op);  gpr_mu_lock(&t->mu->mu);  if (op->on_connectivity_state_change) {    grpc_connectivity_state_notify_on_state_change(        exec_ctx, &t->connectivity, op->connectivity_state,        op->on_connectivity_state_change);  }  if (op->set_accept_stream) {    t->accept_stream_cb = op->set_accept_stream_fn;    t->accept_stream_data = op->set_accept_stream_user_data;  }  if (op->on_consumed) {    GRPC_CLOSURE_SCHED(exec_ctx, op->on_consumed, GRPC_ERROR_NONE);  }  bool do_close = false;  if (op->goaway_error != GRPC_ERROR_NONE) {    do_close = true;    GRPC_ERROR_UNREF(op->goaway_error);  }  if (op->disconnect_with_error != GRPC_ERROR_NONE) {    do_close = true;    GRPC_ERROR_UNREF(op->disconnect_with_error);  }  if (do_close) {    close_transport_locked(exec_ctx, t);  }  gpr_mu_unlock(&t->mu->mu);}

void grpc_chttp2_data_parser_destroy(grpc_exec_ctx *exec_ctx,                                     grpc_chttp2_data_parser *parser) {  if (parser->parsing_frame != NULL) {    GRPC_ERROR_UNREF(grpc_chttp2_incoming_byte_stream_finished(        exec_ctx, parser->parsing_frame,        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Parser destroyed"), false));  }  GRPC_ERROR_UNREF(parser->error);}

static void partly_done(grpc_exec_ctx *exec_ctx, state_watcher *w,                        bool due_to_completion, grpc_error *error) {  if (due_to_completion) {    grpc_timer_cancel(exec_ctx, &w->alarm);  } else {    grpc_channel_element *client_channel_elem = grpc_channel_stack_last_element(        grpc_channel_get_channel_stack(w->channel));    grpc_client_channel_watch_connectivity_state(        exec_ctx, client_channel_elem,        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)), NULL,        &w->on_complete, NULL);  }  gpr_mu_lock(&w->mu);  if (due_to_completion) {    if (GRPC_TRACER_ON(grpc_trace_operation_failures)) {      GRPC_LOG_IF_ERROR("watch_completion_error", GRPC_ERROR_REF(error));    }    GRPC_ERROR_UNREF(error);    error = GRPC_ERROR_NONE;  } else {    if (error == GRPC_ERROR_NONE) {      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(          "Timed out waiting for connection state change");    } else if (error == GRPC_ERROR_CANCELLED) {      error = GRPC_ERROR_NONE;    }  }  switch (w->phase) {    case WAITING:      GRPC_ERROR_REF(error);      w->error = error;      w->phase = READY_TO_CALL_BACK;      break;    case READY_TO_CALL_BACK:      if (error != GRPC_ERROR_NONE) {        GPR_ASSERT(!due_to_completion);        GRPC_ERROR_UNREF(w->error);        GRPC_ERROR_REF(error);        w->error = error;      }      w->phase = CALLING_BACK_AND_FINISHED;      grpc_cq_end_op(exec_ctx, w->cq, w->tag, w->error, finished_completion, w,                     &w->completion_storage);      break;    case CALLING_BACK_AND_FINISHED:      GPR_UNREACHABLE_CODE(return );      break;  }  gpr_mu_unlock(&w->mu);  GRPC_ERROR_UNREF(error);}

int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {  grpc_http_parser parser;  grpc_http_request request;  memset(&request, 0, sizeof(request));  grpc_http_parser_init(&parser, GRPC_HTTP_REQUEST, &request);  gpr_slice slice = gpr_slice_from_copied_buffer((const char *)data, size);  GRPC_ERROR_UNREF(grpc_http_parser_parse(&parser, slice));  GRPC_ERROR_UNREF(grpc_http_parser_eof(&parser));  gpr_slice_unref(slice);  grpc_http_parser_destroy(&parser);  grpc_http_request_destroy(&request);  return 0;}

static void really_destroy_stream(grpc_exec_ctx *exec_ctx, inproc_stream *s) {  INPROC_LOG(GPR_DEBUG, "really_destroy_stream %p", s);  slice_buffer_list_destroy(exec_ctx, &s->to_read_message);  slice_buffer_list_destroy(exec_ctx, &s->write_buffer_message);  GRPC_ERROR_UNREF(s->write_buffer_cancel_error);  GRPC_ERROR_UNREF(s->cancel_self_error);  GRPC_ERROR_UNREF(s->cancel_other_error);  unref_transport(exec_ctx, s->t);  if (s->closure_at_destroy) {    GRPC_CLOSURE_SCHED(exec_ctx, s->closure_at_destroy, GRPC_ERROR_NONE);  }}

static void on_initial_md_ready(grpc_exec_ctx *exec_ctx, void *user_data,                                grpc_error *err) {  grpc_call_element *elem = (grpc_call_element *)user_data;  call_data *calld = (call_data *)elem->call_data;  if (err == GRPC_ERROR_NONE) {    if (calld->recv_initial_metadata->idx.named.path != NULL) {      calld->service_method = grpc_slice_ref_internal(          GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.path->md));      calld->have_service_method = true;    } else {      err = grpc_error_add_child(          err, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing :path header"));    }    if (calld->recv_initial_metadata->idx.named.lb_token != NULL) {      calld->initial_md_string = grpc_slice_ref_internal(          GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.lb_token->md));      calld->have_initial_md_string = true;      grpc_metadata_batch_remove(          exec_ctx, calld->recv_initial_metadata,          calld->recv_initial_metadata->idx.named.lb_token);    }  } else {    GRPC_ERROR_REF(err);  }  calld->ops_recv_initial_metadata_ready->cb(      exec_ctx, calld->ops_recv_initial_metadata_ready->cb_arg, err);  GRPC_ERROR_UNREF(err);}

// Callback invoked when we receive a message.  Here we check the max// receive message size.static void recv_message_ready(grpc_exec_ctx* exec_ctx, void* user_data,                               grpc_error* error) {  grpc_call_element* elem = (grpc_call_element*)user_data;  call_data* calld = (call_data*)elem->call_data;  if (*calld->recv_message != NULL && calld->limits.max_recv_size >= 0 &&      (*calld->recv_message)->length > (size_t)calld->limits.max_recv_size) {    char* message_string;    gpr_asprintf(&message_string,                 "Received message larger than max (%u vs. %d)",                 (*calld->recv_message)->length, calld->limits.max_recv_size);    grpc_error* new_error = grpc_error_set_int(        GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string),        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);    if (error == GRPC_ERROR_NONE) {      error = new_error;    } else {      error = grpc_error_add_child(error, new_error);      GRPC_ERROR_UNREF(new_error);    }    gpr_free(message_string);  } else {    GRPC_ERROR_REF(error);  }  // Invoke the next callback.  GRPC_CLOSURE_RUN(exec_ctx, calld->next_recv_message_ready, error);}

static void cc_start_transport_op(grpc_exec_ctx *exec_ctx,                                  grpc_channel_element *elem,                                  grpc_transport_op *op) {  channel_data *chand = elem->channel_data;  grpc_exec_ctx_sched(exec_ctx, op->on_consumed, GRPC_ERROR_NONE, NULL);  GPR_ASSERT(op->set_accept_stream == false);  if (op->bind_pollset != NULL) {    grpc_pollset_set_add_pollset(exec_ctx, chand->interested_parties,                                 op->bind_pollset);  }  gpr_mu_lock(&chand->mu);  if (op->on_connectivity_state_change != NULL) {    grpc_connectivity_state_notify_on_state_change(        exec_ctx, &chand->state_tracker, op->connectivity_state,        op->on_connectivity_state_change);    op->on_connectivity_state_change = NULL;    op->connectivity_state = NULL;  }  if (op->send_ping != NULL) {    if (chand->lb_policy == NULL) {      grpc_exec_ctx_sched(exec_ctx, op->send_ping,                          GRPC_ERROR_CREATE("Ping with no load balancing"),                          NULL);    } else {      grpc_lb_policy_ping_one(exec_ctx, chand->lb_policy, op->send_ping);      op->bind_pollset = NULL;    }    op->send_ping = NULL;  }  if (op->disconnect_with_error != GRPC_ERROR_NONE) {    if (chand->resolver != NULL) {      set_channel_connectivity_state_locked(          exec_ctx, chand, GRPC_CHANNEL_SHUTDOWN,          GRPC_ERROR_REF(op->disconnect_with_error), "disconnect");      grpc_resolver_shutdown(exec_ctx, chand->resolver);      GRPC_RESOLVER_UNREF(exec_ctx, chand->resolver, "channel");      chand->resolver = NULL;      if (!chand->started_resolving) {        grpc_closure_list_fail_all(&chand->waiting_for_config_closures,                                   GRPC_ERROR_REF(op->disconnect_with_error));        grpc_exec_ctx_enqueue_list(exec_ctx,                                   &chand->waiting_for_config_closures, NULL);      }      if (chand->lb_policy != NULL) {        grpc_pollset_set_del_pollset_set(exec_ctx,                                         chand->lb_policy->interested_parties,                                         chand->interested_parties);        GRPC_LB_POLICY_UNREF(exec_ctx, chand->lb_policy, "channel");        chand->lb_policy = NULL;      }    }    GRPC_ERROR_UNREF(op->disconnect_with_error);  }  gpr_mu_unlock(&chand->mu);}

static void security_handshake_done(grpc_exec_ctx *exec_ctx,                                    grpc_security_handshake *h,                                    grpc_error *error) {    grpc_timer_cancel(exec_ctx, &h->timer);    if (!h->is_client_side) {        security_connector_remove_handshake(h);    }    if (error == GRPC_ERROR_NONE) {        h->cb(exec_ctx, h->user_data, GRPC_SECURITY_OK, h->secure_endpoint,              h->auth_context);    } else {        const char *msg = grpc_error_string(error);        gpr_log(GPR_ERROR, "Security handshake failed: %s", msg);        grpc_error_free_string(msg);        if (h->secure_endpoint != NULL) {            grpc_endpoint_shutdown(exec_ctx, h->secure_endpoint);            grpc_endpoint_destroy(exec_ctx, h->secure_endpoint);        } else {            grpc_endpoint_destroy(exec_ctx, h->wrapped_endpoint);        }        h->cb(exec_ctx, h->user_data, GRPC_SECURITY_ERROR, NULL, NULL);    }    unref_handshake(h);    GRPC_ERROR_UNREF(error);}

static void on_handshake_done(grpc_exec_ctx *exec_ctx, grpc_endpoint *endpoint,                              grpc_channel_args *args,                              gpr_slice_buffer *read_buffer, void *user_data,                              grpc_error *error) {  server_secure_connect *state = user_data;  if (error != GRPC_ERROR_NONE) {    const char *error_str = grpc_error_string(error);    gpr_log(GPR_ERROR, "Handshaking failed: %s", error_str);    grpc_error_free_string(error_str);    GRPC_ERROR_UNREF(error);    grpc_channel_args_destroy(args);    gpr_free(read_buffer);    grpc_handshake_manager_shutdown(exec_ctx, state->handshake_mgr);    grpc_handshake_manager_destroy(exec_ctx, state->handshake_mgr);    state_unref(state->state);    gpr_free(state);    return;  }  grpc_handshake_manager_destroy(exec_ctx, state->handshake_mgr);  state->handshake_mgr = NULL;  // TODO(roth, jboeuf): Convert security connector handshaking to use new  // handshake API, and then move the code from on_secure_handshake_done()  // into this function.  state->args = args;  grpc_server_security_connector_do_handshake(      exec_ctx, state->state->sc, state->acceptor, endpoint, read_buffer,      state->deadline, on_secure_handshake_done, state);}

static void pf_cancel_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,                           grpc_connected_subchannel **target,                           grpc_error *error) {  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;  pending_pick *pp;  gpr_mu_lock(&p->mu);  pp = p->pending_picks;  p->pending_picks = NULL;  while (pp != NULL) {    pending_pick *next = pp->next;    if (pp->target == target) {      *target = NULL;      grpc_exec_ctx_sched(          exec_ctx, pp->on_complete,          GRPC_ERROR_CREATE_REFERENCING("Pick Cancelled", &error, 1), NULL);      gpr_free(pp);    } else {      pp->next = p->pending_picks;      p->pending_picks = pp;    }    pp = next;  }  gpr_mu_unlock(&p->mu);  GRPC_ERROR_UNREF(error);}

static void inproc_slice_byte_stream_shutdown(grpc_exec_ctx *exec_ctx,                                              grpc_byte_stream *bs,                                              grpc_error *error) {  inproc_slice_byte_stream *stream = (inproc_slice_byte_stream *)bs;  GRPC_ERROR_UNREF(stream->shutdown_error);  stream->shutdown_error = error;}

static void pf_cancel_picks(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,                            uint32_t initial_metadata_flags_mask,                            uint32_t initial_metadata_flags_eq,                            grpc_error *error) {  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;  pending_pick *pp;  gpr_mu_lock(&p->mu);  pp = p->pending_picks;  p->pending_picks = NULL;  while (pp != NULL) {    pending_pick *next = pp->next;    if ((pp->initial_metadata_flags & initial_metadata_flags_mask) ==        initial_metadata_flags_eq) {      grpc_exec_ctx_sched(          exec_ctx, pp->on_complete,          GRPC_ERROR_CREATE_REFERENCING("Pick Cancelled", &error, 1), NULL);      gpr_free(pp);    } else {      pp->next = p->pending_picks;      p->pending_picks = pp;    }    pp = next;  }  gpr_mu_unlock(&p->mu);  GRPC_ERROR_UNREF(error);}

static grpc_error *parse_frame_slice(grpc_exec_ctx *exec_ctx,                                     grpc_chttp2_transport *t, grpc_slice slice,                                     int is_last) {  grpc_chttp2_stream *s = t->incoming_stream;  grpc_error *err = t->parser(exec_ctx, t->parser_data, t, s, slice, is_last);  if (err == GRPC_ERROR_NONE) {    return err;  } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, NULL)) {    if (GRPC_TRACER_ON(grpc_http_trace)) {      const char *msg = grpc_error_string(err);      gpr_log(GPR_ERROR, "%s", msg);    }    grpc_chttp2_parsing_become_skip_parser(exec_ctx, t);    if (s) {      s->forced_close_error = err;      grpc_slice_buffer_add(          &t->qbuf, grpc_chttp2_rst_stream_create(t->incoming_stream_id,                                                  GRPC_HTTP2_PROTOCOL_ERROR,                                                  &s->stats.outgoing));    } else {      GRPC_ERROR_UNREF(err);    }  }  return err;}

static grpc_error *parse_frame_slice(    grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing,    gpr_slice slice, int is_last) {  grpc_chttp2_stream_parsing *stream_parsing =      transport_parsing->incoming_stream;  grpc_error *err = transport_parsing->parser(      exec_ctx, transport_parsing->parser_data, transport_parsing,      stream_parsing, slice, is_last);  if (err == GRPC_ERROR_NONE) {    if (stream_parsing) {      grpc_chttp2_list_add_parsing_seen_stream(transport_parsing,                                               stream_parsing);    }    return GRPC_ERROR_NONE;  } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, NULL)) {    if (grpc_http_trace) {      const char *msg = grpc_error_string(err);      gpr_log(GPR_ERROR, "%s", msg);      grpc_error_free_string(msg);    }    grpc_chttp2_parsing_become_skip_parser(exec_ctx, transport_parsing);    if (stream_parsing) {      stream_parsing->forced_close_error = err;      gpr_slice_buffer_add(          &transport_parsing->qbuf,          grpc_chttp2_rst_stream_create(transport_parsing->incoming_stream_id,                                        GRPC_CHTTP2_PROTOCOL_ERROR,                                        &stream_parsing->stats.outgoing));    } else {      GRPC_ERROR_UNREF(err);    }  }  return err;}

/* Might be called multiple times */static void fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_error *why) {  if (grpc_lfev_set_shutdown(exec_ctx, &fd->read_closure,                             GRPC_ERROR_REF(why))) {    shutdown(fd->fd, SHUT_RDWR);    grpc_lfev_set_shutdown(exec_ctx, &fd->write_closure, GRPC_ERROR_REF(why));  }  GRPC_ERROR_UNREF(why);}

static void tcp_free(grpc_exec_ctx *exec_ctx, grpc_tcp *tcp) {  grpc_winsocket_destroy(tcp->socket);  gpr_mu_destroy(&tcp->mu);  gpr_free(tcp->peer_string);  grpc_resource_user_unref(exec_ctx, tcp->resource_user);  if (tcp->shutting_down) GRPC_ERROR_UNREF(tcp->shutdown_error);  gpr_free(tcp);}

/* Prepare a recently-created socket for listening. */static grpc_error *prepare_socket(int fd, const struct sockaddr *addr,                                  size_t addr_len, bool so_reuseport,                                  int *port) {  struct sockaddr_storage sockname_temp;  socklen_t sockname_len;  grpc_error *err = GRPC_ERROR_NONE;  GPR_ASSERT(fd >= 0);  if (so_reuseport) {    err = grpc_set_socket_reuse_port(fd, 1);    if (err != GRPC_ERROR_NONE) goto error;  }  err = grpc_set_socket_nonblocking(fd, 1);  if (err != GRPC_ERROR_NONE) goto error;  err = grpc_set_socket_cloexec(fd, 1);  if (err != GRPC_ERROR_NONE) goto error;  if (!grpc_is_unix_socket(addr)) {    err = grpc_set_socket_low_latency(fd, 1);    if (err != GRPC_ERROR_NONE) goto error;    err = grpc_set_socket_reuse_addr(fd, 1);    if (err != GRPC_ERROR_NONE) goto error;  }  err = grpc_set_socket_no_sigpipe_if_possible(fd);  if (err != GRPC_ERROR_NONE) goto error;  GPR_ASSERT(addr_len < ~(socklen_t)0);  if (bind(fd, addr, (socklen_t)addr_len) < 0) {    err = GRPC_OS_ERROR(errno, "bind");    goto error;  }  if (listen(fd, get_max_accept_queue_size()) < 0) {    err = GRPC_OS_ERROR(errno, "listen");    goto error;  }  sockname_len = sizeof(sockname_temp);  if (getsockname(fd, (struct sockaddr *)&sockname_temp, &sockname_len) < 0) {    err = GRPC_OS_ERROR(errno, "getsockname");    goto error;  }  *port = grpc_sockaddr_get_port((struct sockaddr *)&sockname_temp);  return GRPC_ERROR_NONE;error:  GPR_ASSERT(err != GRPC_ERROR_NONE);  if (fd >= 0) {    close(fd);  }  grpc_error *ret = grpc_error_set_int(      GRPC_ERROR_CREATE_REFERENCING("Unable to configure socket", &err, 1),      GRPC_ERROR_INT_FD, fd);  GRPC_ERROR_UNREF(err);  return ret;}

void grpc_closure_list_fail_all(grpc_closure_list *list,                                grpc_error *forced_failure) {  for (grpc_closure *c = list->head; c != NULL; c = c->next_data.next) {    if (c->error_data.error == GRPC_ERROR_NONE) {      c->error_data.error = GRPC_ERROR_REF(forced_failure);    }  }  GRPC_ERROR_UNREF(forced_failure);}

static void send_security_metadata(grpc_exec_ctx *exec_ctx,                                   grpc_call_element *elem,                                   grpc_transport_stream_op_batch *batch) {  call_data *calld = elem->call_data;  channel_data *chand = elem->channel_data;  grpc_client_security_context *ctx =      (grpc_client_security_context *)batch->payload          ->context[GRPC_CONTEXT_SECURITY]          .value;  grpc_call_credentials *channel_call_creds =      chand->security_connector->request_metadata_creds;  int call_creds_has_md = (ctx != NULL) && (ctx->creds != NULL);  if (channel_call_creds == NULL && !call_creds_has_md) {    /* Skip sending metadata altogether. */    grpc_call_next_op(exec_ctx, elem, batch);    return;  }  if (channel_call_creds != NULL && call_creds_has_md) {    calld->creds = grpc_composite_call_credentials_create(channel_call_creds,                                                          ctx->creds, NULL);    if (calld->creds == NULL) {      grpc_transport_stream_op_batch_finish_with_failure(          exec_ctx, batch,          grpc_error_set_int(              GRPC_ERROR_CREATE_FROM_STATIC_STRING(                  "Incompatible credentials set on channel and call."),              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAUTHENTICATED));      return;    }  } else {    calld->creds = grpc_call_credentials_ref(        call_creds_has_md ? ctx->creds : channel_call_creds);  }  build_auth_metadata_context(&chand->security_connector->base,                              chand->auth_context, calld);  grpc_error *cancel_error = set_cancel_func(elem, cancel_get_request_metadata);  if (cancel_error != GRPC_ERROR_NONE) {    grpc_transport_stream_op_batch_finish_with_failure(exec_ctx, batch,                                                       cancel_error);    return;  }  GPR_ASSERT(calld->pollent != NULL);  GRPC_CLOSURE_INIT(&calld->closure, on_credentials_metadata, batch,                    grpc_schedule_on_exec_ctx);  grpc_error *error = GRPC_ERROR_NONE;  if (grpc_call_credentials_get_request_metadata(          exec_ctx, calld->creds, calld->pollent, calld->auth_md_context,          &calld->md_array, &calld->closure, &error)) {    // Synchronous return; invoke on_credentials_metadata() directly.    on_credentials_metadata(exec_ctx, batch, error);    GRPC_ERROR_UNREF(error);  }}

static void fail_locked(grpc_exec_ctx *exec_ctx, call_data *calld,                        grpc_error *error) {  size_t i;  for (i = 0; i < calld->waiting_ops_count; i++) {    grpc_transport_stream_op_finish_with_failure(        exec_ctx, calld->waiting_ops[i], GRPC_ERROR_REF(error));  }  calld->waiting_ops_count = 0;  GRPC_ERROR_UNREF(error);}

int external_dns_works(const char *host) {  grpc_resolved_addresses *res = NULL;  grpc_error *error = grpc_blocking_resolve_address(host, "80", &res);  GRPC_ERROR_UNREF(error);  if (res != NULL) {    grpc_resolved_addresses_destroy(res);    return 1;  }  return 0;}

static void uv_endpoint_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,                                 grpc_error *why) {  grpc_tcp *tcp = (grpc_tcp *)ep;  if (!tcp->shutting_down) {    tcp->shutting_down = true;    uv_shutdown_t *req = &tcp->shutdown_req;    uv_shutdown(req, (uv_stream_t *)tcp->handle, shutdown_callback);  }  GRPC_ERROR_UNREF(why);}

static void fail_locked(grpc_exec_ctx *exec_ctx,                        grpc_subchannel_call_holder *holder,                        grpc_error *error) {  size_t i;  for (i = 0; i < holder->waiting_ops_count; i++) {    grpc_transport_stream_op_finish_with_failure(        exec_ctx, &holder->waiting_ops[i], GRPC_ERROR_REF(error));  }  holder->waiting_ops_count = 0;  GRPC_ERROR_UNREF(error);}

static void security_handshaker_shutdown(grpc_exec_ctx *exec_ctx,                                         grpc_handshaker *handshaker,                                         grpc_error *why) {  security_handshaker *h = (security_handshaker *)handshaker;  gpr_mu_lock(&h->mu);  if (!h->shutdown) {    h->shutdown = true;    grpc_endpoint_shutdown(exec_ctx, h->args->endpoint, GRPC_ERROR_REF(why));    cleanup_args_for_failure_locked(exec_ctx, h);  }  gpr_mu_unlock(&h->mu);  GRPC_ERROR_UNREF(why);}

static void hs_on_recv(grpc_exec_ctx *exec_ctx, void *user_data,                       grpc_error *err) {  grpc_call_element *elem = user_data;  call_data *calld = elem->call_data;  if (err == GRPC_ERROR_NONE) {    server_filter_args a;    a.elem = elem;    a.exec_ctx = exec_ctx;    grpc_metadata_batch_filter(calld->recv_initial_metadata, server_filter, &a);    /* Have we seen the required http2 transport headers?       (:method, :scheme, content-type, with :path and :authority covered       at the channel level right now) */    if (calld->seen_method && calld->seen_scheme && calld->seen_te_trailers &&        calld->seen_path && calld->seen_authority) {      /* do nothing */    } else {      err = GRPC_ERROR_CREATE("Bad incoming HTTP headers");      if (!calld->seen_path) {        err = grpc_error_add_child(err,                                   GRPC_ERROR_CREATE("Missing :path header"));      }      if (!calld->seen_authority) {        err = grpc_error_add_child(            err, GRPC_ERROR_CREATE("Missing :authority header"));      }      if (!calld->seen_method) {        err = grpc_error_add_child(err,                                   GRPC_ERROR_CREATE("Missing :method header"));      }      if (!calld->seen_scheme) {        err = grpc_error_add_child(err,                                   GRPC_ERROR_CREATE("Missing :scheme header"));      }      if (!calld->seen_te_trailers) {        err = grpc_error_add_child(            err, GRPC_ERROR_CREATE("Missing te: trailers header"));      }      /* Error this call out */      if (grpc_http_trace) {        const char *error_str = grpc_error_string(err);        gpr_log(GPR_ERROR, "Invalid http2 headers: %s", error_str);        grpc_error_free_string(error_str);      }      grpc_call_element_send_cancel(exec_ctx, elem);    }  } else {    GRPC_ERROR_REF(err);  }  calld->on_done_recv->cb(exec_ctx, calld->on_done_recv->cb_arg, err);  GRPC_ERROR_UNREF(err);}

static void http_connect_handshaker_shutdown(grpc_exec_ctx* exec_ctx,                                             grpc_handshaker* handshaker_in,                                             grpc_error* why) {  http_connect_handshaker* handshaker = (http_connect_handshaker*)handshaker_in;  gpr_mu_lock(&handshaker->mu);  if (!handshaker->shutdown) {    handshaker->shutdown = true;    grpc_endpoint_shutdown(exec_ctx, handshaker->args->endpoint,                           GRPC_ERROR_REF(why));    cleanup_args_for_failure_locked(exec_ctx, handshaker);  }  gpr_mu_unlock(&handshaker->mu);  GRPC_ERROR_UNREF(why);}

int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr,                                      grpc_server_credentials *creds) {  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  grpc_error *err = GRPC_ERROR_NONE;  grpc_server_security_connector *sc = NULL;  int port_num = 0;  GRPC_API_TRACE(      "grpc_server_add_secure_http2_port("      "server=%p, addr=%s, creds=%p)",      3, (server, addr, creds));  // Create security context.  if (creds == NULL) {    err = GRPC_ERROR_CREATE(        "No credentials specified for secure server port (creds==NULL)");    goto done;  }  grpc_security_status status =      grpc_server_credentials_create_security_connector(&exec_ctx, creds, &sc);  if (status != GRPC_SECURITY_OK) {    char *msg;    gpr_asprintf(&msg,                 "Unable to create secure server with credentials of type %s.",                 creds->type);    err = grpc_error_set_int(GRPC_ERROR_CREATE(msg),                             GRPC_ERROR_INT_SECURITY_STATUS, status);    gpr_free(msg);    goto done;  }  // Create channel args.  grpc_arg args_to_add[2];  args_to_add[0] = grpc_server_credentials_to_arg(creds);  args_to_add[1] = grpc_security_connector_to_arg(&sc->base);  grpc_channel_args *args =      grpc_channel_args_copy_and_add(grpc_server_get_channel_args(server),                                     args_to_add, GPR_ARRAY_SIZE(args_to_add));  // Add server port.  err = grpc_chttp2_server_add_port(&exec_ctx, server, addr, args, &port_num);done:  if (sc != NULL) {    GRPC_SECURITY_CONNECTOR_UNREF(&exec_ctx, &sc->base, "server");  }  grpc_exec_ctx_finish(&exec_ctx);  if (err != GRPC_ERROR_NONE) {    const char *msg = grpc_error_string(err);    gpr_log(GPR_ERROR, "%s", msg);    grpc_error_free_string(msg);    GRPC_ERROR_UNREF(err);  }  return port_num;}

static void channel_broadcaster_shutdown(grpc_exec_ctx *exec_ctx,                                         channel_broadcaster *cb,                                         int send_goaway,                                         grpc_error *force_disconnect) {  size_t i;  for (i = 0; i < cb->num_channels; i++) {    send_shutdown(exec_ctx, cb->channels[i], send_goaway,                  GRPC_ERROR_REF(force_disconnect));    GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, cb->channels[i], "broadcast");  }  gpr_free(cb->channels);  GRPC_ERROR_UNREF(force_disconnect);}