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

static void destroy_curl_context(curl_context_t *context){  uv_close((uv_handle_t *) &context->poll_handle, curl_close_cb);}

static void after_shutdown(uv_req_t* req, int status) {  uv_close(req->handle, on_close);  free(req);}

void write_done( uv_write_t *wreq, int status ){    ctx_t *ctx = ( ctx_t *)wreq->data;    uv_close( ( uv_handle_t *)wreq->handle, close_done ); //close client    free( wreq );}

static void check_cb(uv_check_t* handle) {  ASSERT(check_cb_called == 0);  uv_close((uv_handle_t*) &async_handle, NULL);  uv_close((uv_handle_t*) &check_handle, NULL);  check_cb_called++;}

static void timeout_cb(uv_timer_t* timer, int status) {  uv_close((uv_handle_t*)&server, close_cb);  uv_close((uv_handle_t*)&client, close_cb);  uv_close((uv_handle_t*)&timeout, close_cb);}

static void timer_cb(uv_timer_t* timer) {  timer_cb_called++;  uv_close((uv_handle_t*) timer, NULL);}

DLLEXPORT void jl_uv_shutdownCallback(uv_shutdown_t* req, int status){    uv_close((uv_handle_t*) req->handle, &jl_uv_closeHandle);    free(req);}

void utb_on_shutdown(uv_shutdown_t* req,int status){	uv_close((uv_handle_t*)req->handle,utb_on_close);	UTB_PRINTF("free %p",req);	free(req);}

extern "C" voidrust_uv_hilvl_close(uv_handle_t* handle, crust_close_cb cb) {    handle_data* data = (handle_data*)handle->data;    data->close_cb = cb;    uv_close(handle, native_close_cb);}

static void tiny_timer_cb(uv_timer_t* handle) {  ASSERT(handle == &tiny_timer);  uv_close((uv_handle_t*) &tiny_timer, NULL);  uv_close((uv_handle_t*) &huge_timer1, NULL);  uv_close((uv_handle_t*) &huge_timer2, NULL);}

extern "C" voidrust_uv_close(uv_handle_t* handle, uv_close_cb cb) {    uv_close(handle, cb);}

extern "C" voidrust_uv_stop_op_cb(uv_handle_t* op_handle) {    uv_close(op_handle, native_close_op_cb);}

static void connect_cb(uv_connect_t* connect_req, int status) {  ASSERT(status == UV_ENOENT);  connect_cb_called++;  uv_close((uv_handle_t*)&prepare_handle, close_cb);  uv_close((uv_handle_t*)&pipe_handle, close_cb);}

static void lws_uv_walk_cb(uv_handle_t *handle, void *arg){	if (!uv_is_closing(handle))		uv_close(handle, lws_uv_close_cb);}

static voidlwsgs_email_read(struct uv_stream_s *s, ssize_t nread, const uv_buf_t *buf){	struct lws_email *email = (struct lws_email *)s->data;	static const short retcodes[] = {		0,	/* idle */		0,	/* connecting */		220,	/* connected */		250,	/* helo */		250,	/* from */		250,	/* to */		354,	/* data */		250,	/* body */		221,	/* quit */	};	uv_write_t write_req;	uv_buf_t wbuf;	int n;	if (nread >= 0)		email->email_buf[nread] = '/0';	lwsl_notice("%s: %s/n", __func__, buf->base);	if (nread == -1) {		lwsl_err("%s: failed/n", __func__);		return;	}	n = atoi(buf->base);	if (n != retcodes[email->estate]) {		lwsl_err("%s: bad response from server/n", __func__);		goto close_conn;	}	switch (email->estate) {	case LGSSMTP_CONNECTED:		n = sprintf(email->content, "HELO %s/n", email->email_helo);		email->estate = LGSSMTP_SENT_HELO;		break;	case LGSSMTP_SENT_HELO:		n = sprintf(email->content, "MAIL FROM: <%s>/n", email->email_from);		email->estate = LGSSMTP_SENT_FROM;		break;	case LGSSMTP_SENT_FROM:		n = sprintf(email->content, "RCPT TO: <%s>/n", email->email_to);		email->estate = LGSSMTP_SENT_TO;		break;	case LGSSMTP_SENT_TO:		n = sprintf(email->content, "DATA/n");		email->estate = LGSSMTP_SENT_DATA;		break;	case LGSSMTP_SENT_DATA:		if (email->on_get_body(email, email->content, email->max_content_size))			return;		n = strlen(email->content);		email->estate = LGSSMTP_SENT_BODY;		break;	case LGSSMTP_SENT_BODY:		n = sprintf(email->content, "quit/n");		email->estate = LGSSMTP_SENT_QUIT;		break;	case LGSSMTP_SENT_QUIT:		lwsl_notice("%s: done/n", __func__);		email->on_sent(email);		email->estate = LGSSMTP_IDLE;		goto close_conn;	default:		return;	}	puts(email->content);	wbuf = uv_buf_init(email->content, n);	uv_write(&write_req, s, &wbuf, 1, on_write_end);	return;close_conn:	uv_close((uv_handle_t *)s, ccb);}

void async_cb(uv_async_t* async, int status) {  printf("async_cb/n");  uv_close((uv_handle_t*) async, NULL);}

void ipc_write_cb(uv_write_t* req, int status){    struct ipc_peer_ctx* ctx;    ctx = container_of(req, struct ipc_peer_ctx, write_req);    uv_close((uv_handle_t*) &ctx->peer_handle, ipc_close_cb);}

void fork_signal_to_child_cb(uv_signal_t* handle, int signum){  fork_signal_cb_called = signum;  uv_close((uv_handle_t*)handle, NULL);}

void destroy_http_context(client_context * context){    uv_close((uv_handle_t*) &context->poll_handle, &close_cb);}

static void timer_cb_touch(uv_timer_t* timer) {  uv_close((uv_handle_t*)timer, NULL);  touch_file("watch_file");  timer_cb_touch_called++;}

//.........这里部分代码省略.........    }    if (daemonize) {        if (logfile) {            if (daemon (0, 1) < 0) {                perror ("daemon()");                exit (0);            }            close (0);            close (1);            close (2);            ret =                open (logfile, O_WRONLY | O_CREAT | O_APPEND,                      S_IRUSR | S_IWUSR);            if (ret != -1) {                dup2 (ret, 1);                dup2 (ret, 2);            }        } else {            if (daemon (0, 0) < 0) {                perror ("daemon()");                exit (0);            }        }    }    /* add all listen (-s -m) ports to event_base, if someone connect: accept_connect is executed with struct listener argument */    for (listener = first_listener; listener; listener = listener->next) {        for (i = 0, ok = 0; i < 10; i++) {            listener->stream = create_listen_socket (listener->s);            listener->stream->data = listener;            int r =                uv_listen ((uv_stream_t *) listener->stream, -1,                           on_incoming_connection);            if (r) {                logmsg ("listen to %s failed, retrying", listener->s);                uv_close ((uv_handle_t *) listener->stream, on_close_listener);                usleep (200 * 1000);            } else {                logmsg ("listening on %s", listener->s);                ok = 1;                break;            }        }        if (ok == 0) {            logmsg ("listen to %s failed, exiting", listener->s);            _exit (-1);        }    }    if (!first_destination && !mysql_cdb_file && !postgresql_cdb_file) {        usage ();    }    if (daemonize) {        if (pidfile) {            FILE *fp = fopen(pidfile, "w");            if (fp) {                fprintf (fp, "%d", getpid());                fclose (fp);            } else {                logmsg("cannot open pidfile %s (%s)", pidfile, strerror (errno));            }        }    }    /* main libuv loop */    uv_run (uv_default_loop (), UV_RUN_DEFAULT);    /* SIGINT || SIGTERM received, clean up */    bufpool_done (pool);    free (pool);    if (mysql_cdb_file) {        free (mysql_cdb_file);    }    if (postgresql_cdb_file) {        free (postgresql_cdb_file);    }    struct destination *dst;    dst = first_destination;    while (dst) {        destination = dst->next;        free (dst->s);        free (dst);        dst = destination;    }    free (sigint);    free (sigterm);    exit (0);}

void shut_done( uv_shutdown_t *req, int status ){    ctx_t *ctx = ( ctx_t *)req->data;    uv_close( ( uv_handle_t *)&ctx->tcp, free_done );    free( req );}

static void on_close(uv_handle_t* peer) {  free(peer);  uv_close((uv_handle_t*)&tcpServer, NULL);}

JL_DLLEXPORT void jl_forceclose_uv(uv_handle_t *handle){    uv_close(handle,&jl_uv_closeHandle);}

  void close_handles() {#if !defined(_WIN32)    uv_signal_stop(&sigpipe_);    uv_close(copy_cast<uv_signal_t*, uv_handle_t*>(&sigpipe_), NULL);#endif  }

bud_error_t bud_worker(bud_config_t* config) {    int r;    bud_error_t err;    bud_log(config, kBudLogDebug, "worker starting");    config->loop = uv_default_loop();    config->ipc = malloc(sizeof(*config->ipc));    config->signal.sighup = malloc(sizeof(*config->signal.sighup));    if (config->ipc == NULL || config->signal.sighup == NULL) {        err = bud_error_str(kBudErrNoMem, "config->ipc");        goto fatal;    }    config->ipc->data = config;    config->signal.sighup->data = config;    r = uv_pipe_init(config->loop, config->ipc, 1);    if (r != 0) {        err = bud_error_num(kBudErrIPCPipeInit, r);        goto fatal;    }    r = uv_pipe_open(config->ipc, 0);    if (r != 0) {        err = bud_error_num(kBudErrIPCPipeOpen, r);        goto failed_pipe_open;    }    r = uv_read_start((uv_stream_t*) config->ipc,                      bud_worker_alloc_cb,                      bud_worker_read_cb);    if (r != 0) {        err = bud_error_num(kBudErrIPCReadStart, r);        goto failed_pipe_open;    }#ifndef _WIN32    /* Drop privileges */    err = bud_config_drop_privileges(config);    if (!bud_is_ok(err))        goto failed_pipe_open;    r = uv_signal_init(config->loop, config->signal.sighup);    if (r != 0) {        err = bud_error_num(kBudErrSignalInit, r);        goto failed_pipe_open;    }    r = uv_signal_start(config->signal.sighup, bud_worker_signal_cb, SIGHUP);    if (r != 0) {        err = bud_error_num(kBudErrSignalInit, r);        goto failed_signal_start;    }#endif  /* !_WIN32 */    err = bud_ok();    return err;#ifndef _WIN32failed_signal_start:    uv_close((uv_handle_t*) config->signal.sighup, bud_worker_close_cb);#endif  /* !_WIN32 */failed_pipe_open:    uv_close((uv_handle_t*) config->ipc, bud_worker_close_cb);    goto cleanup;fatal:    free(config->ipc);cleanup:    config->ipc = NULL;    return err;}

 void stop() {     uv_close((uv_handle_t *)&async, [](uv_handle_t *handle) {         delete reinterpret_cast<AsyncQueue *>(handle->data);     }); }

static void spawn_on_exit(uv_process_t *req, MVMint64 exit_status, int term_signal) {    if (req->data)        *(MVMint64 *)req->data = (exit_status << 8) | term_signal;    uv_unref((uv_handle_t *)req);    uv_close((uv_handle_t *)req, NULL);}

static void timer_cb(uv_timer_t* handle, int status) {	uv_timer_stop(handle);    uv_close((uv_handle_t*)handle, 0);}