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

/* copy a file from one to another. */void MVM_file_copy(MVMThreadContext *tc, MVMString *src, MVMString *dest) {    uv_fs_t req;    char *       const a = MVM_string_utf8_encode_C_string(tc, src);    const uv_file  in_fd = uv_fs_open(tc->loop, &req, (const char *)a, O_RDONLY, 0, NULL);    if (in_fd >= 0 && uv_fs_stat(tc->loop, &req, a, NULL) >= 0) {        char *       const b = MVM_string_utf8_encode_C_string(tc, dest);        const uv_file out_fd = uv_fs_open(tc->loop, &req, (const char *)b, O_WRONLY | O_CREAT | O_TRUNC, DEFAULT_MODE, NULL);        MVM_free(a);        if (out_fd >= 0                && uv_fs_sendfile(tc->loop, &req, out_fd, in_fd, 0, req.statbuf.st_size, NULL) >= 0) {            MVM_free(b);            if (uv_fs_close(tc->loop, &req, in_fd, NULL) < 0) {                uv_fs_close(tc->loop, &req, out_fd, NULL); /* should close out_fd before throw. */                MVM_exception_throw_adhoc(tc, "Failed to close file: %s", uv_strerror(req.result));            }            if (uv_fs_close(tc->loop, &req, out_fd, NULL) < 0) {                MVM_exception_throw_adhoc(tc, "Failed to close file: %s", uv_strerror(req.result));            }            return;        }        else            MVM_free(b);    }    else        MVM_free(a);    MVM_exception_throw_adhoc(tc, "Failed to copy file: %s", uv_strerror(req.result));}

// Sync readfile using libuv APIs as an API function.static duk_ret_t duv_loadfile(duk_context *ctx) {  const char* path = duk_require_string(ctx, 0);  uv_fs_t req;  int fd = 0;  uint64_t size;  char* chunk;  uv_buf_t buf;  if (uv_fs_open(&loop, &req, path, O_RDONLY, 0644, NULL) < 0) goto fail;  fd = req.result;  if (uv_fs_fstat(&loop, &req, fd, NULL) < 0) goto fail;  size = req.statbuf.st_size;  chunk = duk_alloc(ctx, size);  buf = uv_buf_init(chunk, size);  if (uv_fs_read(&loop, &req, fd, &buf, 1, 0, NULL) < 0) goto fail;  duk_push_lstring(ctx, chunk, size);  duk_free(ctx, chunk);  uv_fs_close(&loop, &req, fd, NULL);  uv_fs_req_cleanup(&req);  return 1;  fail:  if (fd) uv_fs_close(&loop, &req, fd, NULL);  uv_fs_req_cleanup(&req);  duk_error(ctx, DUK_ERR_ERROR, "%s: %s: %s", uv_err_name(req.result), uv_strerror(req.result), path);}

static void read_cb(uv_fs_t* req) {  int r;  TUV_ASSERT(req == &read_req);  TUV_ASSERT(req->fs_type == UV_FS_READ);  TUV_ASSERT(req->result >= 0);  /* FIXME(bnoordhuis) Check if requested size? */  read_cb_count++;  uv_fs_req_cleanup(req);  if (read_cb_count == 1) {    TUV_ASSERT(strcmp(buf, test_buf) == 0);#if !defined(__NUTTX__)    r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7,                        ftruncate_cb);#else    /* cannot truncate on nuttx so just close the file */    r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);#endif  } else {#if !defined(__NUTTX__)    TUV_ASSERT(strcmp(buf, "test-bu") == 0);#else    TUV_ASSERT(strcmp(buf, test_buf) == 0);#endif    r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);  }  TUV_ASSERT(r == 0);}

DLLEXPORT void jl_close_uv(uv_handle_t *handle){    if (handle->type==UV_TTY)        uv_tty_set_mode((uv_tty_t*)handle,0);    if ((handle->type == UV_NAMED_PIPE || handle->type == UV_TCP) &&        uv_is_writable((uv_stream_t*)handle)) {        uv_shutdown_t *req = (uv_shutdown_t*)malloc(sizeof(uv_shutdown_t));        req->data = 0;        /*         * We are explicity ignoring the error here for the following reason:         * There is only two scenarios in which this returns an error:         * a) In case the stream is already shut down, in which case we're likely         *    in the process of closing this stream (since there's no other call to         *    uv_shutdown).         * b) In case the stream is already closed, in which case uv_close would         *    cause an assertion failure.         */        uv_shutdown(req, (uv_stream_t*)handle, &jl_uv_shutdownCallback);    }    else if (handle->type == UV_FILE) {        uv_fs_t req;        jl_uv_file_t *fd = (jl_uv_file_t*)handle;        if (fd->file != -1) {            uv_fs_close(handle->loop, &req, fd->file, NULL);            fd->file = -1;        }    }    else if (!uv_is_closing((uv_handle_t*)handle)) {        uv_close(handle,&jl_uv_closeHandle);    }}

void read_cb(uv_fs_t *read_req) {    int err = 0;    if (read_req->result < 0) {        UV_CHECK(read_req->result, "uv_fs_read callback");    }    /* extracting our context from the read_req */    context_t *context = read_req->data;    /* 4. Report the contents of the buffer */    //log_report("%s", read_req->bufs->base);    lwlog_info("Read buf: %s", read_req->bufs->base);    free(read_req->bufs->base);    /* 5. Close the file descriptor (synchronously) */    uv_fs_t close_req;    err = uv_fs_close(uv_default_loop(), &close_req, context->open_req->result, NULL);    if (err < 0) {        UV_CHECK(abs(err), "uv_fs_close");    }    /* cleanup all requests and context */    uv_fs_req_cleanup(context->open_req);    uv_fs_req_cleanup(read_req);    uv_fs_req_cleanup(&close_req);    free(context);    return;}

void read_cb(uv_fs_t* read_req) {  int r = 0;  if (read_req->result < 0) CHECK(read_req->result, "uv_fs_read callback");  /* extracting our context from the read_req */  context_t* context = read_req->data;  /* 4. Report the contents of the buffer */  /*  log_report("%s", read_req->bufsml->base);  log_info("%s", read_req->bufsml->base);  free(read_req->bufsml->base);  log_report("%s", context->iov->base);  log_info("%s", context->iov->base);  if I don't call log_report/log_info on context->iov, then valgrind has 0 erro!  */  log_report("%s", context->iov.base);  log_info("%s", context->iov.base);  /* 5. Close the file descriptor (synchronously) */  uv_fs_t close_req;  r = uv_fs_close(read_req->loop, &close_req, context->open_req->result, NULL);  if (r < 0) CHECK(abs(r), "uv_fs_close");  /* cleanup all requests and context */  uv_fs_req_cleanup(context->open_req);  uv_fs_req_cleanup(read_req);  uv_fs_req_cleanup(&close_req);  free(context);}

void saveBlock(block_s * block){	// Get region path	char * regionPath;	int regionPathLength = setRegionPath(&regionPath, 0, 0);	// Make the path	makeDir(regionPath);	// Get chunk path	char * chunkPath;	setChunkPath(&chunkPath, regionPath, regionPathLength, block->cx, block->cy);	uv_fs_t open_req;	uv_fs_t write_req;	uv_fs_t close_req;	// store type in buffer	unsigned char typeBuffer[2];	shortToBuffer(4, 0, typeBuffer);	// Open	uv_fs_open(uv_default_loop(), &open_req, chunkPath,  O_WRONLY | O_CREAT, 0700, NULL);	uv_fs_req_cleanup(&open_req);	uv_fs_write(uv_default_loop(), &write_req, open_req.result, typeBuffer, 2,(block->z * 512 + ((block->x  * 2) + block->y * 16 * 2)), NULL);	uv_fs_req_cleanup(&write_req);	// Close	uv_fs_close(uv_default_loop(), &close_req, open_req.result, NULL);	uv_fs_req_cleanup(&close_req);	free(regionPath);	free(chunkPath);}

static void touch_file(const char* name, unsigned int size) {  uv_file file;  uv_fs_t req;  uv_buf_t buf;  int r;  unsigned int i;  r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT | O_TRUNC,                 S_IWUSR | S_IRUSR, NULL);  uv_fs_req_cleanup(&req);  ASSERT(r >= 0);  file = r;  buf = uv_buf_init("a", 1);  /* Inefficient but simple. */  for (i = 0; i < size; i++) {    r = uv_fs_write(NULL, &req, file, &buf, 1, i, NULL);    uv_fs_req_cleanup(&req);    ASSERT(r >= 0);  }  r = uv_fs_close(NULL, &req, file, NULL);  uv_fs_req_cleanup(&req);  ASSERT(r == 0);}

static bool adc_read_data(uint32_t pin, struct adc_msg_s* msg) {  int32_t adc_number = ADC_GET_NUMBER(pin);  char path[ADC_DEVICE_PATH_BUFFER_SIZE] = { 0 };  adc_get_path(path, adc_number);  const iotjs_environment_t* env = iotjs_environment_get();  uv_loop_t* loop = iotjs_environment_loop(env);  int result, close_result;  // Open file  uv_fs_t open_req;  result = uv_fs_open(loop, &open_req, path, O_RDONLY, 0666, NULL);  uv_fs_req_cleanup(&open_req);  if (result < 0) {    return false;  }  // Read value  uv_fs_t read_req;  uv_buf_t uvbuf = uv_buf_init((char*)msg, sizeof(*msg));  result = uv_fs_read(loop, &read_req, open_req.result, &uvbuf, 1, 0, NULL);  uv_fs_req_cleanup(&read_req);  // Close file  uv_fs_t close_req;  close_result = uv_fs_close(loop, &close_req, open_req.result, NULL);  uv_fs_req_cleanup(&close_req);  if (result < 0 || close_result < 0) {    return false;  }  DDDLOG("ADC Read - path: %s, value: %d", path, msg->am_data);  return true;}

/* * fs.close */static int fs_close(lua_State* L) {  FSR__SETUP  int fd = luaL_checkint(L, 1);  FSR__SET_OPT_CB(2, on_fs_callback)  uv_fs_close(loop, req, fd, cb);  FSR__TEARDOWN}

JL_DLLEXPORT int jl_fs_close(int handle){    uv_fs_t req;    int ret = uv_fs_close(jl_io_loop, &req, handle, NULL);    uv_fs_req_cleanup(&req);    return ret;}

bool xmrig::CommonConfig::save(){    if (m_fileName.isNull()) {        return false;    }    uv_fs_t req;    const int fd = uv_fs_open(uv_default_loop(), &req, m_fileName.data(), O_WRONLY | O_CREAT | O_TRUNC, 0644, nullptr);    if (fd < 0) {        return false;    }    uv_fs_req_cleanup(&req);    rapidjson::Document doc;    getJSON(doc);    FILE *fp = fdopen(fd, "w");    char buf[4096];    rapidjson::FileWriteStream os(fp, buf, sizeof(buf));    rapidjson::PrettyWriter<rapidjson::FileWriteStream> writer(os);    doc.Accept(writer);    fflush(fp);    uv_fs_close(uv_default_loop(), &req, fd, nullptr);    uv_fs_req_cleanup(&req);    LOG_NOTICE("configuration saved to: /"%s/"", m_fileName.data());    return true;}

void FileRequestBaton::file_stated(uv_fs_t *req) {    FileRequestBaton *ptr = (FileRequestBaton *)req->data;    assert(ptr->thread_id == std::this_thread::get_id());    if (req->result != 0 || ptr->canceled || !ptr->request) {        // Stating failed or was canceled. We already have an open file handle        // though, which we'll have to close.        notify_error(req);        uv_fs_req_cleanup(req);        uv_fs_close(req->loop, req, ptr->fd, file_closed);    } else {#if UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR <= 10        const uv_statbuf_t *stat = static_cast<const uv_statbuf_t *>(req->ptr);#else        const uv_stat_t *stat = static_cast<const uv_stat_t *>(req->ptr);#endif        if (stat->st_size > std::numeric_limits<int>::max()) {            // File is too large for us to open this way because uv_buf's only support unsigned            // ints as maximum size.            if (ptr->request) {                ptr->request->response = util::make_unique<Response>();                ptr->request->response->code = UV_EFBIG;#if UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR <= 10                ptr->request->response->message = uv_strerror(uv_err_t {UV_EFBIG, 0});#else                ptr->request->response->message = uv_strerror(UV_EFBIG);#endif                ptr->request->notify();            }            uv_fs_req_cleanup(req);            uv_fs_close(req->loop, req, ptr->fd, file_closed);        } else {            const unsigned int size = (unsigned int)(stat->st_size);            ptr->body.resize(size);            ptr->buffer = uv_buf_init(const_cast<char *>(ptr->body.data()), size);            uv_fs_req_cleanup(req);#if UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR <= 10            uv_fs_read(req->loop, req, ptr->fd, ptr->buffer.base, ptr->buffer.len, -1, file_read);#else            uv_fs_read(req->loop, req, ptr->fd, &ptr->buffer, 1, 0, file_read);#endif        }    }}

int uvc_fs_close(uvc_io *io){	io->handle->data=io;	uv_fs_close(uvc_loop_default(),(uv_fs_t *)io->handle,io->file,uvc_fs_cb);	io->cur =uvc_self();	uvc_yield();	uv_fs_req_cleanup((uv_fs_t *)io->handle);	free(io->handle);	return 0;}

static void fsync_cb(uv_fs_t* req) {  int r;  ASSERT(req == &fsync_req);  ASSERT(req->fs_type == UV_FS_FSYNC);  ASSERT(req->result != -1);  fsync_cb_count++;  uv_fs_req_cleanup(req);  r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);}

static void ftruncate_cb(uv_fs_t* req) {  int r;  ASSERT(req == &ftruncate_req);  ASSERT(req->fs_type == UV_FS_FTRUNCATE);  ASSERT(req->result != -1);  ftruncate_cb_count++;  uv_fs_req_cleanup(req);  r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);}

static voiddestroy_response(http_response* response, int close_handle) {  if (response->pbuf) free(response->pbuf);  if (response->request) destroy_request(response->request, close_handle);  if (response->fd != -1) {    uv_fs_t close_req;    uv_fs_close(loop, &close_req, response->fd, NULL);  }  free(response);}

  void FileObject::close(gc<Fiber> fiber)  {    ASSERT(isOpen_, "IO library should not call close on a closed file.");    // Mark the file closed immediately so other fibers can't try to use it.    isOpen_ = false;    FSTask* task = new FSTask(fiber);    uv_fs_close(task->loop(), task->request(), file_,                closeFileCallback);  }

void fileFinalize(void* data){  int fd = *(int*)data;    // Already closed.  if (fd == -1) return;    uv_fs_t request;  uv_fs_close(getLoop(), &request, fd, NULL);  uv_fs_req_cleanup(&request);}

void on_open(uv_fs_t* req) {    int result = req->result;    if (result == -1) {        fprintf(stderr, "Error on opening file: %s./n",                 uv_strerror(uv_last_error(loop)));    }    uv_fs_req_cleanup(req);    uv_fs_close(loop, &close_req, open_req.result, on_close);}

void on_read(uv_fs_t *req) {    if (req->result < 0) {        fprintf(stderr, "Read error: %s/n", uv_strerror(req->result));    } else if(req->result == 0) {        uv_fs_t close_req;        uv_fs_close(uv_default_loop(), &close_req, open_req.result, NULL);    } else if(req->result > 0) {        iov.len = req->result;        uv_fs_write(uv_default_loop(), &write_req, 1, &iov, 1, -1, on_write);    }}

JL_DLLEXPORT void jl_close_uv(uv_handle_t *handle){    if (handle->type == UV_FILE) {        uv_fs_t req;        jl_uv_file_t *fd = (jl_uv_file_t*)handle;        if (fd->file != -1) {            uv_fs_close(handle->loop, &req, fd->file, NULL);            fd->file = -1;        }        jl_uv_closeHandle(handle); // synchronous (ok since the callback is known to not interact with any global state)        return;    }    if (handle->type == UV_NAMED_PIPE || handle->type == UV_TCP) {#ifdef _OS_WINDOWS_        if (((uv_stream_t*)handle)->stream.conn.shutdown_req) {#else        if (((uv_stream_t*)handle)->shutdown_req) {#endif            // don't close the stream while attempting a graceful shutdown            return;        }        if (uv_is_writable((uv_stream_t*)handle)) {            // attempt graceful shutdown of writable streams to give them a chance to flush first            uv_shutdown_t *req = (uv_shutdown_t*)malloc(sizeof(uv_shutdown_t));            req->data = 0;            /*             * We are explicitly ignoring the error here for the following reason:             * There is only two scenarios in which this returns an error:             * a) In case the stream is already shut down, in which case we're likely             *    in the process of closing this stream (since there's no other call to             *    uv_shutdown).             * b) In case the stream is already closed, in which case uv_close would             *    cause an assertion failure.             */            uv_shutdown(req, (uv_stream_t*)handle, &jl_uv_shutdownCallback);            return;        }    }    if (!uv_is_closing((uv_handle_t*)handle)) {        // avoid double-closing the stream        if (handle->type == UV_TTY)            uv_tty_set_mode((uv_tty_t*)handle, UV_TTY_MODE_NORMAL);        uv_close(handle, &jl_uv_closeHandle);    }}JL_DLLEXPORT void jl_forceclose_uv(uv_handle_t *handle){    uv_close(handle,&jl_uv_closeHandle);}

static void create_file(const char* name) {  int r;  uv_file file;  uv_fs_t req;  r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL);  ASSERT(r >= 0);  file = r;  uv_fs_req_cleanup(&req);  r = uv_fs_close(NULL, &req, file, NULL);  ASSERT(r == 0);  uv_fs_req_cleanup(&req);}

/* Closes the file. */static MVMint64 closefh(MVMThreadContext *tc, MVMOSHandle *h) {    MVMIOFileData *data = (MVMIOFileData *)h->body.data;    uv_fs_t req;    if (data->ds) {        MVM_string_decodestream_destory(tc, data->ds);        data->ds = NULL;    }    if (uv_fs_close(tc->loop, &req, data->fd, NULL) < 0) {        data->fd = -1;        MVM_exception_throw_adhoc(tc, "Failed to close filehandle: %s", uv_strerror(req.result));    }    data->fd = -1;    return 0;}

void on_read(uv_fs_t *req) {    uv_fs_req_cleanup(req);    if (req->result < 0) {        fprintf(stderr, "Read error: %s/n", uv_strerror(uv_last_error(uv_default_loop())));    }    else if (req->result == 0) {        uv_fs_t close_req;        // synchronous        uv_fs_close(uv_default_loop(), &close_req, open_req.result, NULL);    }    else {        uv_fs_write(uv_default_loop(), &write_req, 1, buffer, req->result, -1, on_write);    }}

static void read_cb(uv_fs_t* req) {    int r;    ASSERT(req == &read_req);    ASSERT(req->fs_type == UV_FS_READ);    ASSERT(req->result != -1);    read_cb_count++;    uv_fs_req_cleanup(req);    if (read_cb_count == 1) {        ASSERT(strcmp(buf, test_buf) == 0);        r = uv_fs_ftruncate(&ftruncate_req, open_req1.result, 7, ftruncate_cb);    } else {        ASSERT(strcmp(buf, "test-bu") == 0);        r = uv_fs_close(&close_req, open_req1.result, close_cb);    }}

static bool_t getPage(EFSRepoRef const repo, HTTPConnectionRef const conn, HTTPMethod const method, strarg_t const URI) {	if(HTTP_GET != method) return false;	size_t pathlen = prefix("/", URI);	if(!pathlen) return false;	if(!pathterm(URI, (size_t)pathlen)) return false;	EFSSessionRef const session = auth(repo, conn, method, URI+pathlen);	if(!session) {		HTTPConnectionSendStatus(conn, 403);		return true;	}	// TODO: Parse querystring `q` parameter	EFSFilterRef const filter = EFSFilterCreate(EFSTypeFilter);	EFSFilterAddStringArg(filter, "text/html; charset=utf-8");	EFSFileInfo *const files = EFSSessionCreateFileInfoList(session, filter, RESULTS_MAX);	HTTPConnectionWriteResponse(conn, 200, "OK");	HTTPConnectionWriteHeader(conn, "Content-Type", "text/html; charset=utf-8");	HTTPConnectionWriteHeader(conn, "Transfer-Encoding", "chunked");	HTTPConnectionBeginBody(conn);	// TODO: Page header	uv_fs_t req = { .data = co_active(); }	for(index_t i = 0; i < files->count; ++i) {		uv_fs_open(loop, &req, path, O_RDONLY, 0400, async_fs_cb);		co_switch(yield);		uv_fs_req_cleanup(&req);		uv_file const file = req.result;		if(file < 0) continue;		HTTPConnectionWriteChunkLength(conn, files->items[i].size);		HTTPConnectionWriteFile(conn, file);		uv_fs_close(loop, &req, file, async_fs_cb);		co_switch(yield);		uv_fs_req_cleanup(&req);		HTTPConnectionWrite(conn, "/r/n", 2);	}	// TODO: Page trailer	HTTPConnectionWriteChunkLength(conn, 0);	HTTPConnectionWrite(conn, "/r/n", 2);	HTTPConnectionEnd(conn);	EFSFileInfoListFree(files);	return true;}

static int lluv_file_close(lua_State *L){  lluv_file_t *f = lluv_check_file(L, 1, 0);  lluv_loop_t *loop = f->loop;  if(IS_(f, OPEN)){    const char  *path = NULL;    int          argc = 1;    UNSET_(f, OPEN);    if(!IS_(f, NOCLOSE)){      LLUV_PRE_FILE();      err = uv_fs_close(loop->handle, &req->req, f->handle, cb);      LLUV_POST_FILE();    }  }  return 0;}