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

static int new_timer(lua_State* L) {  uv_timer_t* handle = luv_create_timer(L);  if (uv_timer_init(uv_default_loop(), handle)) {    uv_err_t err = uv_last_error(uv_default_loop());    return luaL_error(L, "new_timer: %s", uv_strerror(err));  }  return 1;}

void connect_cb(uv_connect_t* req, int status) {  int r;  if (!status) {    state_t* state = (state_t*) req->handle->data;    state->is_connected = 1;    r = uv_read_start(req->handle, alloc_cb, read_cb);    if (r) {      uv_err_t err = uv_last_error(req->handle->loop);      printf("error occurred. %s/n", uv_strerror(err));    }  } else {    uv_err_t err = uv_last_error(req->handle->loop);    printf("error occurred. %s/n", uv_strerror(err));  }  free(req);}

void HttpRequest::handleRequest() {  int r = uv_read_start(handle(), &on_alloc, &HttpRequest_on_request_read);  if (r) {    uv_err_t err = uv_last_error(_pLoop);    fatal_error("read_start", uv_strerror(err));    return;  }}

static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {  /* The server will not send anything, it should close gracefully. */  if (buf.base) {    free(buf.base);  }  if (nread != -1) {    ASSERT(nread == 0);    ASSERT(uv_last_error().code == UV_EAGAIN);  } else {    ASSERT(tcp != NULL);    ASSERT(nread == -1);    ASSERT(uv_last_error().code == UV_EOF);    uv_close((uv_handle_t*)tcp, close_cb);  }}

void on_read(uv_stream_t *client, ssize_t nread, uv_buf_t buf) {    if (nread == -1) {        if (uv_last_error(loop).code != UV_EOF)            fprintf(stderr, "Read error %s/n", uv_err_name(uv_last_error(loop)));        uv_close((uv_handle_t*) client, NULL);        free(client);        return;    }    char *data = (char*) malloc(sizeof(char) * (nread+1));    data[nread] = '/0';    strncpy(data, buf.base, nread);    fprintf(stderr, "%s", data);    free(data);    free(buf.base);}

void echo_write(uv_write_t *req, int status) {    if (status == -1) {        fprintf(stderr, "Write error %s/n", uv_err_name(uv_last_error(loop)));    }    char *base = (char*) req->data;    free(base);    free(req);}

static void after_write(uv_write_t* req, int status) {  if (status != 0) {    fprintf(stderr, "write error %s/n", uv_err_name(uv_last_error(loop)));    uv_close((uv_handle_t*)req->handle, close_cb);    conns_failed++;    return;  }}

static void create_dir(uv_loop_t* loop, const char* name) {  int r;  uv_fs_t req;  r = uv_fs_rmdir(loop, &req, name, NULL);  r = uv_fs_mkdir(loop, &req, name, 0755, NULL);  ASSERT(r == 0 || uv_last_error(loop).code == UV_EEXIST);  uv_fs_req_cleanup(&req);}

void spawn() {  int i;  char** env = NULL;  env = env_copy(environ, env);  child = malloc(sizeof(uv_process_t));  uv_stdio_container_t stdio[4];  uv_process_options_t options;  uv_pipe_init(loop, &child_stdout, 0);  uv_pipe_init(loop, &child_stderr, 0);  uv_pipe_init(loop, &child_ipc, 0);  //  // Setup child's stdio. stdout and stderr are pipes so that we can read  // child process' output.  // FD 3 is a pipe used for IPC.  //  options.stdio_count = 4;  stdio[0].flags = UV_INHERIT_FD;  stdio[0].data.fd = 0;  stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;  stdio[1].data.stream = (uv_stream_t*) &child_stdout;  stdio[2].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;  stdio[2].data.stream = (uv_stream_t*) &child_stderr;  stdio[3].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;  stdio[3].data.stream = (uv_stream_t*) &child_ipc;  options.env = env;  options.cwd = NULL;  options.file = arguments[0];  options.args = arguments;  options.flags = 0;  options.stdio = stdio;  options.exit_cb = on_process_exit;  for (i = 0; i < PLUGIN_COUNT; i++) {    if (plugins[i].process_options_cb) {      plugins[i].process_options_cb(&options);    }  }  if (uv_spawn(loop, child, options)) {    fprintf(stderr, "uv_spawn: %s/n", uv_err_name(uv_last_error(loop)));    return;  }  for (i = 0; i < PLUGIN_COUNT; i++) {    if (plugins[i].process_spawned_cb) {      plugins[i].process_spawned_cb(child, &options);    }  }  uv_read_start(options.stdio[1].data.stream, forza__on_alloc, forza__on_stdout_read);  uv_read_start(options.stdio[2].data.stream, forza__on_alloc, forza__on_stderr_read);  uv_read_start(options.stdio[3].data.stream, forza__on_alloc, forza__on_ipc_read);}

/* * Class:     com_iwebpp_libuvpp_handles_LoopHandle * Method:    _get_last_error * Signature: (J)Lcom/iwebpp/libuvpp/NativeException; */extern "C" JNIEXPORT  jthrowable JNICALL Java_com_iwebpp_libuvpp_handles_LoopHandle__1get_1last_1error  (JNIEnv *env, jobject that, jlong ptr) {  assert(ptr);  uv_loop_t* loop = reinterpret_cast<uv_loop_t*>(ptr);  int code = uv_last_error(loop).code;  return NewException(env, code);}

void on_write(uv_fs_t *req) {    uv_fs_req_cleanup(req);    if (req->result < 0) {        fprintf(stderr, "Write error: %s/n", uv_strerror(uv_last_error(uv_default_loop())));    }    else {        uv_fs_read(uv_default_loop(), &read_req, open_req.result, buffer, sizeof(buffer), -1, on_read);    }}

static void on_connect_with_close(uv_connect_t *req, int status) {  ASSERT((uv_stream_t*) &tcp == req->handle);  ASSERT(status == -1);  ASSERT(uv_last_error(uv_default_loop()).code == UV_ECONNREFUSED);  connect_cb_calls++;  ASSERT(close_cb_calls == 0);  uv_close((uv_handle_t*)req->handle, on_close);}

int luv_udp_recv_stop(lua_State* L) {  uv_udp_t* handle = (uv_udp_t*)luv_checkudata(L, 1, "udp");  if (uv_udp_recv_stop(handle)) {    uv_err_t err = uv_last_error(luv_get_loop(L));    return luaL_error(L, "udp_recv_stop: %s", uv_strerror(err));  }  luv_handle_unref(L, handle->data);  return 0;}

static void on_connect_without_close(uv_connect_t *req, int status) {  ASSERT(status == -1);  ASSERT(uv_last_error(uv_default_loop()).code == UV_ECONNREFUSED);  connect_cb_calls++;  uv_timer_start(&timer, timer_cb, 100, 0);  ASSERT(close_cb_calls == 0);}

static void file_readdir_cb(uv_fs_t* req) {  ASSERT(req == &readdir_req);  ASSERT(req->fs_type == UV_FS_READDIR);  ASSERT(req->result == -1);  ASSERT(req->ptr == NULL);  ASSERT(uv_last_error(req->loop).code == UV_ENOTDIR);  uv_fs_req_cleanup(req);  readdir_cb_count++;}

/* _http_start(): start http server.*/static void_http_start(u2_http* htp_u){  struct sockaddr_in add_u;  uv_tcp_init(u2L, &htp_u->wax_u);  memset(&add_u, 0, sizeof(add_u));  add_u.sin_family = AF_INET;  add_u.sin_addr.s_addr = INADDR_ANY;  /*  Try ascending ports.  */  while ( 1 ) {    add_u.sin_port = htons(htp_u->por_w);    if ( 0 != uv_tcp_bind(&htp_u->wax_u, add_u)  ) {      uv_err_t las_u = uv_last_error(u2L);      if ( UV_EADDRINUSE == las_u.code ) {        htp_u->por_w++;        continue;      }      else {        uL(fprintf(uH, "http: bind: %s/n", uv_strerror(las_u)));      }    }    if ( 0 != uv_listen((uv_stream_t*)&htp_u->wax_u, 16, _http_listen_cb) ) {      uv_err_t las_u = uv_last_error(u2L);      if ( UV_EADDRINUSE == las_u.code ) {        htp_u->por_w++;        continue;      }      else {        uL(fprintf(uH, "http: listen: %s/n", uv_strerror(las_u)));      }    }    uL(fprintf(uH, "http: live (%s) on %d/n",                   (u2_yes == htp_u->sec) ? "/"secure/"" : "insecure",                   htp_u->por_w));    break;  }}

static void connect_to_remote_cb(uv_connect_t* req, int status){	server_ctx *ctx = (server_ctx *)req->data;	if (status) {		if (uv_last_error(req->handle->loop).code != UV_ECANCELED) {			SHOW_UV_ERROR(ctx->client.loop);			uv_close((uv_handle_t*)(void *)&ctx->remote, remote_established_close_cb);			free(ctx->handshake_buffer);			free(req);		}		return;	}	free(req);	LOGCONN(&ctx->remote, "Connected to %s");	uv_buf_t buf;	buf.base = (char *)ctx->handshake_buffer;	buf.len = HANDSHAKE_BUFFER_SIZE;	if (!ctx->buffer_len) {		free(ctx->handshake_buffer);	} else {		uv_write_t *wreq = (uv_write_t *)malloc(sizeof(uv_write_t));		if (!wreq) {			uv_close((uv_handle_t*)(void *)&ctx->client, client_established_close_cb);			FATAL("malloc() failed!");		}		wreq->data = buf.base;		buf.len = ctx->buffer_len;		int n = uv_write(wreq, (uv_stream_t *)(void *)&ctx->remote, &buf, 1, after_write_cb);		if (n) {			LOGE("Write to remote failed!");			free(wreq);			uv_close((uv_handle_t*)(void *)&ctx->remote, remote_established_close_cb);			return;		}	}	ctx->handshake_buffer = NULL;	ctx->buffer_len = 0;		int n = uv_read_start((uv_stream_t *)(void *)&ctx->client, established_alloc_cb, client_established_read_cb);	if (n) {		SHOW_UV_ERROR(ctx->client.loop);		uv_close((uv_handle_t*)(void *)&ctx->client, client_established_close_cb);		return;	}	n = uv_read_start((uv_stream_t *)(void *)&ctx->remote, established_alloc_cb, remote_established_read_cb);	if (n) {		SHOW_UV_ERROR(ctx->client.loop);		uv_close((uv_handle_t*)(void *)&ctx->remote, remote_established_close_cb);		return;	}}

int main(int argc, char *argv[]) {  char** hosts;  char* hostname;  char* user;  char* name;  int i, c = 0;  uv_interface_address_t* addresses;  uv_err_t err;  srand(time(NULL));  atexit(forza__kill);  signal(SIGTERM, forza__on_sigterm);  loop = uv_default_loop();#ifdef FORZA_VERSION_HASH  printf("forza "FORZA_VERSION_HASH"/n");#else  printf("forza/n");#endif  opt = saneopt_init(argc - 1, argv + 1);  saneopt_alias(opt, "host", "h");  hosts = saneopt_get_all(opt, "host");  hostname = saneopt_get(opt, "hostname");  user = saneopt_get(opt, "app-user");  name = saneopt_get(opt, "app-name");  arguments = saneopt_arguments(opt);  if (hostname == NULL) {    hostname = malloc(256 * sizeof(*hostname));    err = uv_interface_addresses(&addresses, &c);    if (err.code != UV_OK) {      fprintf(stderr, "uv_interface_addresses: %s/n", uv_err_name(uv_last_error(loop)));      return 1;    }    for (i = 0; i < c; i++) {      /* For now, only grab the first non-internal, non 0.0.0.0 interface.       * TODO: Make this smarter.       */      if (addresses[i].is_internal) continue;      uv_ip4_name(&addresses[i].address.address4, hostname, 255 * sizeof(*hostname));      if (strcmp(hostname, "0.0.0.0") != 0) break;    }    uv_free_interface_addresses(addresses, c);  }  forza_connect(hosts, hostname, user, name, on_connect);  uv_run(loop, UV_RUN_DEFAULT);  free(hosts);  return 0;}

static void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {  uv_err_t err = uv_last_error(uv_default_loop());  if (nread > 0) {    output_used += nread;  } else if (nread < 0) {    ASSERT(err.code == UV_EOF);    uv_close((uv_handle_t*)tcp, close_cb);  }}

int luv_execpath(lua_State* L) {  size_t size = 2*PATH_MAX;  char exec_path[size];  if (uv_exepath(exec_path, &size)) {    uv_err_t err = uv_last_error(uv_default_loop());    return luaL_error(L, "tcp_bind6: %s", uv_strerror(err));  }  lua_pushlstring(L, exec_path, size);  return 1;}

void on_connect(uv_connect_t *req, int status) {    if (status == -1) {        fprintf(stderr, "connect failed error %s/n", uv_err_name(uv_last_error(loop)));        free(req);        return;    }    uv_read_start((uv_stream_t*) req->data, alloc_buffer, on_read);    free(req);}

voidnet_resolve_cb(uv_getaddrinfo_t *rv, int stat, net_ai * ai) {  net_t * net = (net_t*) rv->data;  err_t err;  socketPair_t dest;  char addr[INET6_ADDRSTRLEN];  int ret;  if (stat != 0) {    err = uv_last_error(net->loop);    if (net->error_cb) {      net->error_cb(net, err, (char *) uv_strerror(err));    } else {      printf("error(%s:%d) %s", net->hostname, net->port, (char *) uv_strerror(err));      net_free(net);    }    return;  }  uv_ip4_name((socketPair_t *) ai->ai_addr, addr, INET6_ADDRSTRLEN);  dest = uv_ip4_addr(addr, net->port);  /*   * create tcp instance.   */  uv_tcp_init(net->loop, net->handle);  ret = uv_tcp_connect(net->conn, net->handle, dest, net_connect_cb);  if (ret != NET_OK) {    err = uv_last_error(net->loop);    if (net->error_cb) {      net->error_cb(net, err, (char *) uv_strerror(err));    } else {      printf("error(%s:%d) %s", net->hostname, net->port, (char *) uv_strerror(err));      net_free(net);    }    return;  }  /*   * free   */  uv_freeaddrinfo(ai);}

static void connect_cb(uv_req_t* req, int status) {  if (status) LOG(uv_strerror(uv_last_error()));  ASSERT(status == 0);  write_sockets++;  req_free(req);  maybe_connect_some();  maybe_start_writing();}

int luv_execpath(lua_State* L) {  size_t size = 2*PATH_MAX;  char exec_path[2*PATH_MAX];  if (uv_exepath(exec_path, &size)) {    uv_err_t err = uv_last_error(luv_get_loop(L));    return luaL_error(L, "uv_exepath: %s", uv_strerror(err));  }  lua_pushlstring(L, exec_path, size);  return 1;}

int luv_tcp_nodelay (lua_State* L) {  uv_tcp_t* handle = (uv_tcp_t*)luv_checkudata(L, 1, "tcp");  int enable = lua_toboolean(L, 2);  if (uv_tcp_nodelay(handle, enable)) {    uv_err_t err = uv_last_error(luv_get_loop(L));    return luaL_error(L, "tcp_nodelay: %s", uv_strerror(err));  }  return 0;}

static void _send_cb(uv_udp_send_t* req, int status) {  assert(req->handle);  assert(req->data);  assert(req->handle->data);  UDPCallbacks* cb = reinterpret_cast<UDPCallbacks*>(req->handle->data);  ContextHolder* req_data = reinterpret_cast<ContextHolder*>(req->data);  cb->on_send(status, status < 0 ? uv_last_error(req->handle->loop).code : 0, req_data->data(), req_data->context());  delete req_data;  delete req;}

VALUE ae_get_last_uv_error(void){  AE_TRACE();  VALUE ae_uv_error;  if (NIL_P(ae_uv_error = rb_hash_aref(AE_UV_ERRORS, INT2FIX(uv_last_error(AE_uv_loop).code))))    ae_uv_error = rb_hash_aref(AE_UV_ERRORS, INT2FIX(-1));  return ae_uv_error;}

void Connection::on_read_ssl(uv_stream_t* client, ssize_t nread, uv_buf_t buf) {#elsevoid Connection::on_read_ssl(uv_stream_t* client, ssize_t nread, const uv_buf_t* buf) {#endif  Connection* connection = static_cast<Connection*>(client->data);  SslSession* ssl_session = connection->ssl_session_.get();  assert(ssl_session != NULL);  if (nread < 0) {#if UV_VERSION_MAJOR == 0    if (uv_last_error(connection->loop_).code != UV_EOF) {#else    if (nread != UV_EOF) {#endif      connection->notify_error("Read error '" +                               std::string(UV_ERRSTR(nread, connection->loop_)) +                               "'");    } else {      connection->defunct();    }    return;  }  ssl_session->incoming().commit(nread);  if (ssl_session->is_handshake_done()) {    char buf[SSL_READ_SIZE];    int rc =  0;    while ((rc = ssl_session->decrypt(buf, sizeof(buf))) > 0) {      connection->consume(buf, rc);    }    if (rc <= 0 && ssl_session->has_error()) {      connection->notify_error("Unable to decrypt data: " + ssl_session->error_message(),                               CONNECTION_ERROR_SSL);    }  } else {    connection->ssl_handshake();  }}void Connection::on_timeout(Timer* timer) {  Handler* handler = static_cast<Handler*>(timer->data());  Connection* connection = handler->connection();  LOG_INFO("Request timed out to host %s on connection(%p)",           connection->host_->address_string().c_str(),           static_cast<void*>(connection));  // TODO (mpenick): We need to handle the case where we have too many  // timeout requests and we run out of stream ids. The java-driver  // uses a threshold to defunct the connection.  handler->set_state(Handler::REQUEST_STATE_TIMEOUT);  handler->on_timeout();  connection->metrics_->request_timeouts.inc();}

/* _term_write_cb(): general write callback.*/static void_term_write_cb(uv_write_t* wri_u, c3_i sas_i){  _u2_write_t* ruq_u = (void *)wri_u;  if ( 0 != sas_i ) {    uL(fprintf(uH, "term: write: %s/n", uv_strerror(uv_last_error(u2L))));  }  free(ruq_u->buf_y);  free(ruq_u);}

void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {  uv_err_t err = uv_last_error();  if (nread > 0) {    output_used += nread;  } else if (nread < 0) {    if (err.code == UV_EOF) {      uv_close((uv_handle_t*)tcp, close_cb);    }  }}