/* Writes the specified string to the file handle, maybe with a newline. */ static MVMint64 write_str(MVMThreadContext *tc, MVMOSHandle *h, MVMString *str, MVMint64 newline) { MVMIOFileData *data = (MVMIOFileData *)h->body.data; MVMuint64 output_size; MVMint64 bytes_written; char *output = MVM_string_encode(tc, str, 0, -1, &output_size, data->encoding, NULL, MVM_TRANSLATE_NEWLINE_OUTPUT); uv_buf_t write_buf = uv_buf_init(output, output_size); uv_fs_t req; bytes_written = uv_fs_write(tc->loop, &req, data->fd, &write_buf, 1, -1, NULL); if (bytes_written < 0) { MVM_free(output); MVM_exception_throw_adhoc(tc, "Failed to write bytes to filehandle: %s", uv_strerror(req.result)); } MVM_free(output); if (newline) { uv_buf_t nl = uv_buf_init("\n", 1); if (uv_fs_write(tc->loop, &req, data->fd, &nl, 1, -1, NULL) < 0) MVM_exception_throw_adhoc(tc, "Failed to write newline to filehandle: %s", uv_strerror(req.result)); bytes_written++; } return bytes_written; }
void AccessLog::write(const char *fmt, ...) { va_list args; va_start(args, fmt); time_t now = time(nullptr); tm stime; # ifdef _WIN32 localtime_s(&stime, &now); # else localtime_r(&now, &stime); # endif char *buf = new char[1024]; int size = snprintf(buf, 23, "[%d-%02d-%02d %02d:%02d:%02d] ", stime.tm_year + 1900, stime.tm_mon + 1, stime.tm_mday, stime.tm_hour, stime.tm_min, stime.tm_sec); size = vsnprintf(buf + size, 1024 - size - 1, fmt, args) + size; buf[size] = '\n'; uv_buf_t ubuf = uv_buf_init(buf, (unsigned int) size + 1); uv_fs_t *req = new uv_fs_t; req->data = ubuf.base; uv_fs_write(uv_default_loop(), req, m_file, &ubuf, 1, 0, AccessLog::onWrite); va_end(args); }
DLLEXPORT int jl_fs_write(int handle, char *buf, size_t len, size_t offset) { uv_fs_t req; int ret = uv_fs_write(jl_io_loop, &req, handle, buf, len, offset, NULL); uv_fs_req_cleanup(&req); return ret; }
void saveBlock(block_s * block) { // Get region path char * regionPath; int regionPathLength = setRegionPath(®ionPath, 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); }
/* local ret = fs.write(fd, data, pos) * ret < 0 => errno * ret >= 0 => write bytes */ static int LuaIO_fs_write(lua_State* L) { int fd = luaL_checkinteger(L, 1); /*common.h*/ LuaIO_check_data(L, 2, fs_native:write(fd, data, pos)); int pos = luaL_checkinteger(L, 3); CREATE_REQ1(); req->bytes = bytes; int err = uv_fs_write(uv_default_loop(), &req->req, fd, bufs, count, pos, LuaIO_fs_callback); if (err) { if(tmp != NULL) { LuaIO_pmemory_free(tmp); } LuaIO_pfree(&LuaIO_fs_req_pool, req); lua_pushinteger(L, err); return 1; } lua_pushvalue(L, 2); req->write_data_ref = luaL_ref(L, LUA_REGISTRYINDEX); if(tmp != NULL) { LuaIO_pmemory_free(tmp); } return lua_yield(L, 0); }
DLLEXPORT int jl_putc(char c, uv_stream_t *stream) { int err; if (stream!=0) { if (stream->type<UV_HANDLE_TYPE_MAX) { //is uv handle if (stream->type == UV_FILE) { JL_SIGATOMIC_BEGIN(); jl_uv_file_t *file = (jl_uv_file_t *)stream; // Do a blocking write for now uv_fs_t req; uv_buf_t buf[1]; buf[0].base = &c; buf[0].len = 1; err = uv_fs_write(file->loop, &req, file->file, buf, 1, -1, NULL); JL_SIGATOMIC_END(); return err ? 0 : 1; } else { uv_write_t *uvw = (uv_write_t*)malloc(sizeof(uv_write_t)+1); err = jl_write_copy(stream,(char*)&c,1,uvw, (void*)&jl_uv_writecb); if (err < 0) { free(uvw); return 0; } return 1; } } else { ios_t *handle = (ios_t*)stream; return ios_putc(c,handle); } } return 0; }
DLLEXPORT size_t jl_write(uv_stream_t *stream, const char *str, size_t n) { int err; //TODO: BAD!! Needed because Julia can't yet detect null stdio if (stream == 0) return 0; if (stream->type<UV_HANDLE_TYPE_MAX) { //is uv handle if (stream->type == UV_FILE) { JL_SIGATOMIC_BEGIN(); jl_uv_file_t *file = (jl_uv_file_t *)stream; // Do a blocking write for now uv_fs_t req; uv_buf_t buf[1]; buf[0].base = (char*)str; buf[0].len = n; err = uv_fs_write(file->loop, &req, file->file, buf, 1, -1, NULL); JL_SIGATOMIC_END(); return err ? 0 : n; } else { uv_write_t *uvw = (uv_write_t*)malloc(sizeof(uv_write_t)+n); err = jl_write_copy(stream,str,n,uvw, (void*)&jl_uv_writecb); if (err < 0) { free(uvw); return 0; } return n; } } else { ios_t *handle = (ios_t*)stream; return ios_write(handle,str,n); } }
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); }
DLLEXPORT int jl_putc(unsigned char c, uv_stream_t *stream) { if (stream!=0) { if (stream->type<UV_HANDLE_TYPE_MAX) { //is uv handle if (stream->type == UV_FILE) { JL_SIGATOMIC_BEGIN(); jl_uv_file_t *file = (jl_uv_file_t *)stream; // Do a blocking write for now uv_fs_t req; int err = uv_fs_write(file->loop, &req, file->file, &c, 1, -1, NULL); JL_SIGATOMIC_END(); return err ? 0 : 1; } else { JL_SIGATOMIC_BEGIN(); uv_write_t *uvw = malloc(sizeof(uv_write_t) + 1); char *data = (char*)(uvw+1); *data = c; uv_buf_t buf[] = {{.base = data,.len=1}}; uvw->data = data; int err = uv_write(uvw,stream,buf,1,&jl_free_buffer); JL_SIGATOMIC_END(); return err ? 0 : 1; } } else {
DLLEXPORT int jl_fs_write_byte(int handle, char c) { uv_fs_t req; int ret = uv_fs_write(jl_io_loop, &req, handle, &c, 1, -1, NULL); uv_fs_req_cleanup(&req); return ret; }
/* Writes the specified bytes to the file handle. */ static MVMint64 write_bytes(MVMThreadContext *tc, MVMOSHandle *h, char *buf, MVMint64 bytes) { MVMIOFileData *data = (MVMIOFileData *)h->body.data; uv_buf_t write_buf = uv_buf_init(buf, bytes); uv_fs_t req; MVMint64 bytes_written; bytes_written = uv_fs_write(tc->loop, &req, data->fd, &write_buf, 1, -1, NULL); if (bytes_written < 0) MVM_exception_throw_adhoc(tc, "Failed to write bytes to filehandle: %s", uv_strerror(req.result)); return bytes_written; }
int uvc_fs_write(uvc_io *io,void *data,ssize_t size){ uv_buf_t buf; io->handle->data=io; buf.len=size; buf.base=data; uv_fs_write(uvc_loop_default() ,(uv_fs_t *)io->handle,io->file,&buf,1,-1,uvc_fs_cb); io->cur =uvc_self(); uvc_yield( ); return ((uv_fs_t *)(io->handle))->result;; }
static void create_cb(uv_fs_t* req) { int r; ASSERT(req == &open_req1); ASSERT(req->fs_type == UV_FS_OPEN); ASSERT(req->result != -1); create_cb_count++; uv_fs_req_cleanup(req); r = uv_fs_write(loop, &write_req, req->result, test_buf, sizeof(test_buf), -1, write_cb); }
DLLEXPORT int jl_fs_write_byte(int handle, char c) { uv_fs_t req; uv_buf_t buf[1]; buf[0].base = &c; buf[0].len = 1; int ret = uv_fs_write(jl_io_loop, &req, handle, buf, 1, -1, NULL); uv_fs_req_cleanup(&req); return ret; }
DLLEXPORT int jl_fs_write(int handle, char *data, size_t len, size_t offset) { uv_fs_t req; uv_buf_t buf[1]; buf[0].base = data; buf[0].len = len; int ret = uv_fs_write(jl_io_loop, &req, handle, buf, 1, offset, NULL); uv_fs_req_cleanup(&req); return ret; }
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); } }
static void create_cb(uv_fs_t* req) { int r; TUV_ASSERT(req == &open_req1); TUV_ASSERT(req->fs_type == UV_FS_OPEN); TUV_ASSERT(req->result >= 0); create_cb_count++; uv_fs_req_cleanup(req); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(loop, &write_req, req->result, &iov, 1, -1, write_cb); TUV_ASSERT(r == 0); }
static int lluv_file_write(lua_State* L) { // if you provide string then function does not copy this string // write(buffer | string, [position, [ [offset,] [length,] ] ] [callback]) const char *path = NULL; lluv_file_t *f = lluv_check_file(L, 1, LLUV_FLAG_OPEN); lluv_loop_t *loop = f->loop; lluv_fixed_buffer_t *buffer = NULL; const char *str = NULL; size_t capacity; int64_t position = 0; /* position in file default: 0*/ int64_t offset = 0; /* offset in buffer default: 0*/ size_t length = 0; /* number or bytes default: buffer->capacity - offset*/ int argc = 2; if(NULL == (str = lua_tolstring(L, 2, &capacity))){ buffer = lluv_check_fbuf(L, 2); capacity = buffer->capacity; str = buffer->data; } if(lluv_arg_exists(L, 3)){ /* position */ position = lutil_checkint64(L, ++argc); } if(lluv_arg_exists(L, 5)){ /* offset + length */ offset = lutil_checkint64(L, ++argc); length = (size_t)lutil_checkint64(L, ++argc); } else if(lluv_arg_exists(L, 4)){ /* offset */ offset = lutil_checkint64(L, ++argc); length = capacity - offset; } else{ length = capacity; } luaL_argcheck (L, capacity > (size_t)offset, 4, LLUV_PREFIX" offset out of index"); luaL_argcheck (L, capacity >= ((size_t)offset + length), 5, LLUV_PREFIX" length out of index"); LLUV_PRE_FILE(); { uv_buf_t ubuf = lluv_buf_init((char*)&str[offset], length); lua_pushvalue(L, 2); /*string or buffer*/ lua_rawsetp(L, LLUV_LUA_REGISTRY, &req->req); lua_pushvalue(L, 1); req->file_ref = luaL_ref(L, LLUV_LUA_REGISTRY); err = uv_fs_write(loop->handle, &req->req, f->handle, &ubuf, 1, position, cb); } LLUV_POST_FILE(); }
JL_DLLEXPORT int jl_fs_write(int handle, const char *data, size_t len, int64_t offset) { if (jl_safe_restore) return write(handle, data, len); uv_fs_t req; uv_buf_t buf[1]; buf[0].base = (char*)data; buf[0].len = len; int ret = uv_fs_write(jl_io_loop, &req, handle, buf, 1, offset, NULL); uv_fs_req_cleanup(&req); return ret; }
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); } }
/* * fs.write */ static int fs_write(lua_State* L) { FSR__SETUP int fd = luaL_checkint(L, 1); MemSlice *ms = lev_checkbuffer(L, 2); int64_t file_pos = luaL_optlong(L, 3, 0); file_pos--; /* Luaisms */ size_t file_until = luaL_optlong(L, 4, 0); if (file_until > ms->until) { file_until = ms->until; } /* TODO: Check fs_callback index is really the same as file_until. */ FSR__SET_OPT_CB(4, on_fs_callback) uv_fs_write(loop, req, fd, ms->slice, (file_until ? file_until : ms->until), file_pos, cb); FSR__TEARDOWN }
int main(int argc, char* argv[]) { char* format_string = NULL; uv_fs_t write_req; format_string = jstr_format("Reading file [%s]...\n", argv[1]); write_req.data = argv[1]; uv_fs_write(uv_default_loop(), &write_req, 1, format_string, strlen(format_string), -1, on_message_written); uv_run(uv_default_loop(), UV_RUN_DEFAULT); uv_fs_req_cleanup(&write_req); return 0; }
static void touch_file(uv_loop_t* loop, const char* name) { int r; uv_file file; uv_fs_t req; r = uv_fs_open(loop, &req, name, O_RDWR, 0, NULL); ASSERT(r != -1); file = r; uv_fs_req_cleanup(&req); r = uv_fs_write(loop, &req, file, "foo", 4, -1, NULL); ASSERT(r != -1); uv_fs_req_cleanup(&req); r = uv_fs_close(loop, &req, file, NULL); ASSERT(r != -1); uv_fs_req_cleanup(&req); }
static duk_int_t myload_code(duk_context *ctx, const char *code) { static int reqid = 0; char buf[1024]; uv_fs_t open_req1; sprintf(buf, "file%d.js", reqid++); unlink(buf); duk_push_thread_stash(ctx, ctx); duk_bool_t rc = duk_get_prop_string(ctx, -1, "__duk_loop"); assert(rc); uv_loop_t *dukLoop = (uv_loop_t *)duk_get_pointer(ctx, -1); duk_pop(ctx); duk_pop(ctx); int r; r = uv_fs_open(dukLoop, &open_req1, buf, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); assert(r >= 0); assert(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); uv_buf_t iov = uv_buf_init((char *)code, strlen(code)); uv_fs_t write_req; r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); assert(r >= 0); assert(write_req.result >= 0); uv_fs_req_cleanup(&write_req); uv_fs_t close_req; uv_fs_close(dukLoop, &close_req, open_req1.result, NULL); duk_push_c_function(ctx, duv_main, 1); duk_push_string(ctx, buf); if (duk_pcall(ctx, 1)) { duv_dump_error(ctx, -1); //uv_loop_close(dukLoop); duk_destroy_heap(ctx); return 1; } return 0; }
static void touch_file(uv_loop_t* loop, const char* name) { int r; uv_file file; uv_fs_t req; uv_buf_t buf; r = uv_fs_open(loop, &req, name, O_RDWR, 0, NULL); ASSERT(r >= 0); file = r; uv_fs_req_cleanup(&req); buf = uv_buf_init("foo", 4); r = uv_fs_write(loop, &req, file, &buf, 1, -1, NULL); ASSERT(r >= 0); uv_fs_req_cleanup(&req); r = uv_fs_close(loop, &req, file, NULL); ASSERT(r == 0); uv_fs_req_cleanup(&req); }
void on_read(uv_fs_t* req) { ssize_t size_read = req->result; read_write_op_t* read_write_op = req->data; uv_fs_req_cleanup(req); if (size_read < 0) { fprintf(stderr, "Error when reading: %s\n", uv_strerror(uv_last_error(uv_default_loop()))); } else if (size_read == 0) { uv_fs_t close_req; if (read_write_op && read_write_op->buff) { free(read_write_op->buff); read_write_op->buff = NULL; } uv_fs_close(uv_default_loop(), &close_req, read_write_op->read_fd, NULL); } else { uv_fs_t write_req; write_req.data = read_write_op; uv_fs_write(uv_default_loop(), &write_req, 1, read_write_op->buff, size_read, -1, on_write); } }
void css_logger_dump_to_file(int is_lock, int should_close) { char *tbuffer; int64_t len = offset; uv_fs_t *req; css_logger_write_req_t *wreq; int ret; int should_roll_log = 0; if (!css_logger.writer) { printf("writer is null.\n"); offset = 0; return; } if (!is_lock) LOGGER_UV_MUTEX_LOCK(&css_logger_mutex); if (offset == 0) { if (should_close) { req = (uv_fs_t*) malloc(sizeof(uv_fs_t)); req->data = css_logger.writer; ret = uv_fs_close(css_logger.loop, req, css_logger.writer->fd, after_roll_logger_cb); if (ret < 0) { printf("close file:%s error by reason:%s\n", css_logger.writer->path, uv_strerror(ret)); FREE(req); FREE(css_logger.writer); } } if (!is_lock) LOGGER_UV_MUTEX_UNLOCK(&css_logger_mutex); return; } tbuffer = buffer; if (bindex > (MAX_LOGGER_BUFFER_LEN - 1)) bindex = 0; buffer = buffers[bindex]; bindex++; offset = 0; *buffer = '\0'; css_logger.writer_offset += len; wreq = (css_logger_write_req_t*) malloc(sizeof(css_logger_write_req_t)); wreq->buf.base = tbuffer; wreq->buf.len = len; wreq->writer = css_logger.writer; req = (uv_fs_t*) malloc(sizeof(uv_fs_t)); req->data = wreq; // printf("dump %lld.%lldb to file:%s.\n", css_logger.writer_offset / 1024, // css_logger.writer_offset % 1024, css_logger.writer->path); should_roll_log = css_logger.writer_offset > CSS_LOGGER_MAX_FILE_SIZE ? 1 : 0; if (should_roll_log) should_close = 1; if (should_close) { // close log. ret = uv_fs_write(css_logger.loop, req, css_logger.writer->fd, &wreq->buf, 1, -1, after_write_logger_and_close_cb); if (ret < 0) { req->data = wreq->writer; ret = uv_fs_close(css_logger.loop, req, wreq->writer->fd, after_roll_logger_cb); FREE(wreq); } css_logger.writer = NULL; css_logger.writer_offset = 0; if (should_roll_log) { css_logger_new_file(); } } else { ret = uv_fs_write(css_logger.loop, req, css_logger.writer->fd, &wreq->buf, 1, -1, after_write_logger_cb); } if (!is_lock) LOGGER_UV_MUTEX_UNLOCK(&css_logger_mutex); }
extern "C" int rust_uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file fd, void* buf, size_t len, int64_t offset, uv_fs_cb cb) { return uv_fs_write(loop, req, fd, buf, len, offset, cb); }