//static S32 LLAPRFile::size(const std::string& filename, LLVolatileAPRPool* pool) { apr_file_t* apr_file; apr_finfo_t info; apr_status_t s; pool = pool ? pool : LLAPRFile::sAPRFilePoolp ; s = apr_file_open(&apr_file, filename.c_str(), APR_READ, APR_OS_DEFAULT, pool->getVolatileAPRPool()); if (s != APR_SUCCESS || !apr_file) { pool->clearVolatileAPRPool() ; return 0; } else { apr_status_t s = apr_file_info_get(&info, APR_FINFO_SIZE, apr_file); apr_file_close(apr_file) ; pool->clearVolatileAPRPool() ; if (s == APR_SUCCESS) { return (S32)info.size; } else { return 0; } } }
static int output_body_sendfile(request_rec *r, const char *path) { apr_file_t *fd; apr_status_t status; apr_size_t len, nbytes; apr_finfo_t finfo; int rc; status = apr_file_open(&fd, path, APR_READ|APR_BINARY, APR_OS_DEFAULT, r->pool); if (status != APR_SUCCESS) { return HTTP_INTERNAL_SERVER_ERROR; } apr_file_info_get(&finfo, APR_FINFO_NORM, fd); len = finfo.size; status = ap_send_fd(fd, r, 0, len, &nbytes); apr_file_close(fd); if (status == APR_SUCCESS) { ap_set_content_length(r, nbytes); rc = OK; } else { rc = HTTP_INTERNAL_SERVER_ERROR; } return rc; }
/* Load content from file. */ static const char *speech_channel_load_content(speech_channel_t *schannel, const char *path) { char *content; apr_file_t *file; apr_finfo_t finfo; if (apr_file_open(&file, path, APR_FOPEN_READ, 0, schannel->pool) != APR_SUCCESS) { ast_log(LOG_WARNING, "Could not open file to read: %s\n", path); return NULL; } if (apr_file_info_get(&finfo, APR_FINFO_SIZE, file) == APR_SUCCESS) { content = apr_palloc(schannel->pool, finfo.size+1); apr_size_t length = (apr_size_t)finfo.size; if (apr_file_read(file, content, &length) == APR_SUCCESS) { content[length] = '\0'; } else { ast_log(LOG_WARNING, "Failed to read content from file: %s, size: %"APR_OFF_T_FMT"\n", path, finfo.size); content = NULL; } } else { ast_log(LOG_WARNING, "Failed to get file info: %s\n", path); content = NULL; } apr_file_close(file); return content; }
svn_error_t *svn_ra_neon__set_neon_body_provider(svn_ra_neon__request_t *req, apr_file_t *body_file) { apr_status_t status; apr_finfo_t finfo; body_provider_baton_t *b = apr_palloc(req->pool, sizeof(*b)); status = apr_file_info_get(&finfo, APR_FINFO_SIZE, body_file); if (status) return svn_error_wrap_apr(status, _("Can't calculate the request body size")); b->body_file = body_file; b->req = req; #if defined(SVN_NEON_0_27) ne_set_request_body_provider(req->ne_req, (ne_off_t)finfo.size, ra_neon_body_provider, b); #elif defined(NE_LFS) ne_set_request_body_provider64(req->ne_req, finfo.size, ra_neon_body_provider, b); #else /* Cut size to 32 bit */ ne_set_request_body_provider(req->ne_req, (size_t) finfo.size, ra_neon_body_provider, b); #endif return SVN_NO_ERROR; }
/* should be apr_status_t really */ static void restore_slotmem(void *ptr, const char *name, apr_size_t size, apr_pool_t *pool) { const char *storename; apr_file_t *fp; apr_size_t nbytes = size; apr_status_t rv; storename = slotmem_filename(pool, name, 1); ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf, APLOGNO(02335) "restoring %s", storename); if (storename) { rv = apr_file_open(&fp, storename, APR_READ | APR_WRITE, APR_OS_DEFAULT, pool); if (rv == APR_SUCCESS) { apr_finfo_t fi; if (apr_file_info_get(&fi, APR_FINFO_SIZE, fp) == APR_SUCCESS) { if (fi.size == nbytes) { apr_file_read(fp, ptr, &nbytes); } else { apr_file_close(fp); apr_file_remove(storename, pool); return; } } apr_file_close(fp); } } }
S32 ll_apr_file_size(const std::string& filename, apr_pool_t* pool) { apr_file_t* apr_file; apr_finfo_t info; apr_status_t s; if (pool == NULL) pool = gAPRPoolp; s = apr_file_open(&apr_file, filename.c_str(), APR_READ, APR_OS_DEFAULT, pool); if (s != APR_SUCCESS || !apr_file) { return 0; } else { apr_status_t s = apr_file_info_get(&info, APR_FINFO_SIZE, apr_file); apr_file_close(apr_file); if (s == APR_SUCCESS) { return (S32)info.size; } else { return 0; } } }
/** Create DEFINE-GRAMMAR request */ static mrcp_message_t* define_grammar_message_create(asr_session_t *asr_session, const char *grammar_file) { /* create MRCP message */ mrcp_message_t *mrcp_message = mrcp_application_message_create( asr_session->mrcp_session, asr_session->mrcp_channel, RECOGNIZER_DEFINE_GRAMMAR); if(mrcp_message) { mrcp_generic_header_t *generic_header; /* set message body */ const apt_dir_layout_t *dir_layout = mrcp_application_dir_layout_get(asr_session->engine->mrcp_app); apr_pool_t *pool = mrcp_application_session_pool_get(asr_session->mrcp_session); char *grammar_file_path = apt_datadir_filepath_get(dir_layout,grammar_file,pool); if(grammar_file_path) { apr_finfo_t finfo; apr_file_t *grammar_file; apt_str_t *content = &mrcp_message->body; if(apr_file_open(&grammar_file,grammar_file_path,APR_FOPEN_READ|APR_FOPEN_BINARY,0,pool) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open Grammar File %s",grammar_file_path); return NULL; } if(apr_file_info_get(&finfo,APR_FINFO_SIZE,grammar_file) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get Grammar File Info %s",grammar_file_path); apr_file_close(grammar_file); return NULL; } content->length = (apr_size_t)finfo.size; content->buf = (char*) apr_palloc(pool,content->length+1); apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Load Grammar File Content size [%"APR_SIZE_T_FMT" bytes] %s", content->length,grammar_file_path); if(apr_file_read(grammar_file,content->buf,&content->length) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Read Grammar File Content %s",grammar_file_path); apr_file_close(grammar_file); return NULL; } content->buf[content->length] = '\0'; apr_file_close(grammar_file); } /* get/allocate generic header */ generic_header = mrcp_generic_header_prepare(mrcp_message); if(generic_header) { /* set generic header fields */ if(mrcp_message->start_line.version == MRCP_VERSION_2) { apt_string_assign(&generic_header->content_type,"application/srgs+xml",mrcp_message->pool); } else { apt_string_assign(&generic_header->content_type,"application/grammar+xml",mrcp_message->pool); } mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE); apt_string_assign(&generic_header->content_id,"demo-grammar",mrcp_message->pool); mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_ID); } } return mrcp_message; }
//static S32 LLAPRFile::size(const std::string& filename) { apr_file_t* file_handle; apr_finfo_t info; apr_status_t s; LLScopedVolatileAPRFilePool pool; s = apr_file_open(&file_handle, filename.c_str(), APR_READ, APR_OS_DEFAULT, pool); if (s != APR_SUCCESS || !file_handle) { return 0; } else { apr_status_t s = apr_file_info_get(&info, APR_FINFO_SIZE, file_handle); apr_file_close(file_handle) ; if (s == APR_SUCCESS) { return (S32)info.size; } else { return 0; } } }
ipr_finfo_t * ipr_file_get_info ( char * filename // File to examine ) { apr_pool_t *pool; // Pool for all allocations apr_file_t *handle; apr_finfo_t apr_finfo; ipr_finfo_t * finfo = NULL; // Not documented // assert (filename); apr_pool_create (&pool, NULL); if (!apr_file_open (&handle, filename, APR_READ, APR_OS_DEFAULT, pool)) { memset (&apr_finfo, 0, sizeof (apr_finfo_t)); apr_file_info_get (&apr_finfo, APR_FINFO_NORM, handle); finfo = ipr_finfo_new (&apr_finfo); apr_file_close (handle); } apr_pool_destroy (pool); return (finfo); }
static void test_buffered_write_size(abts_case *tc, void *data) { const apr_size_t data_len = strlen(NEWFILEDATA); apr_file_t *thefile; apr_finfo_t finfo; apr_status_t rv; apr_size_t bytes; rv = apr_file_open(&thefile, NEWFILENAME, APR_READ | APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BUFFERED | APR_DELONCLOSE, APR_OS_DEFAULT, p); APR_ASSERT_SUCCESS(tc, "open file", rv); /* A funny thing happened to me the other day: I wrote something * into a buffered file, then asked for its size using * apr_file_info_get; and guess what? The size was 0! That's not a * nice way to behave. */ bytes = data_len; rv = apr_file_write(thefile, NEWFILEDATA, &bytes); APR_ASSERT_SUCCESS(tc, "write file contents", rv); ABTS_TRUE(tc, data_len == bytes); rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, thefile); APR_ASSERT_SUCCESS(tc, "get file size", rv); ABTS_TRUE(tc, bytes == (apr_size_t) finfo.size); apr_file_close(thefile); }
/* Construct a cache key for the BDB environment at PATH in *KEYP. if DBCONFIG_FILE is not NULL, return the opened file handle. Allocate from POOL. */ static svn_error_t * bdb_cache_key(bdb_env_key_t *keyp, apr_file_t **dbconfig_file, const char *path, apr_pool_t *pool) { const char *dbcfg_file_name = svn_dirent_join(path, BDB_CONFIG_FILE, pool); apr_file_t *dbcfg_file; apr_status_t apr_err; apr_finfo_t finfo; SVN_ERR(svn_io_file_open(&dbcfg_file, dbcfg_file_name, APR_READ, APR_OS_DEFAULT, pool)); apr_err = apr_file_info_get(&finfo, APR_FINFO_DEV | APR_FINFO_INODE, dbcfg_file); if (apr_err) return svn_error_wrap_apr (apr_err, "Can't create BDB environment cache key"); /* Make sure that any padding in the key is always cleared, so that the key's hash deterministic. */ memset(keyp, 0, sizeof *keyp); keyp->device = finfo.device; keyp->inode = finfo.inode; if (dbconfig_file) *dbconfig_file = dbcfg_file; else apr_file_close(dbcfg_file); return SVN_NO_ERROR; }
static apr_finfo_t MVM_file_info(MVMThreadContext *tc, MVMString *filename, apr_int32_t wanted) { apr_status_t rv; apr_pool_t *tmp_pool; apr_file_t *file_handle; apr_finfo_t finfo; char *fname = MVM_string_utf8_encode_C_string(tc, filename); /* need a temporary pool */ if ((rv = apr_pool_create(&tmp_pool, POOL(tc))) != APR_SUCCESS) { free(fname); MVM_exception_throw_apr_error(tc, rv, "Open file failed to create pool: "); } if ((rv = apr_file_open(&file_handle, (const char *)fname, APR_FOPEN_READ, APR_OS_DEFAULT, tmp_pool)) != APR_SUCCESS) { free(fname); apr_pool_destroy(tmp_pool); MVM_exception_throw_apr_error(tc, rv, "Failed to open file: "); } free(fname); if((rv = apr_file_info_get(&finfo, wanted, file_handle)) != APR_SUCCESS) { MVM_exception_throw_apr_error(tc, rv, "Failed to stat file: "); } if ((rv = apr_file_close(file_handle)) != APR_SUCCESS) { MVM_exception_throw_apr_error(tc, rv, "Failed to close filehandle: "); } return finfo; }
/* ** dav_fs_load_locknull_list: Returns a dav_buffer dump of the locknull file ** for the given directory. */ static dav_error * dav_fs_load_locknull_list(apr_pool_t *p, const char *dirpath, dav_buffer *pbuf) { apr_finfo_t finfo; apr_file_t *file = NULL; dav_error *err = NULL; apr_size_t amt; apr_status_t rv; dav_buffer_init(p, pbuf, dirpath); if (pbuf->buf[pbuf->cur_len - 1] == '/') pbuf->buf[--pbuf->cur_len] = '\0'; dav_buffer_place(p, pbuf, "/" DAV_FS_STATE_DIR "/" DAV_FS_LOCK_NULL_FILE); /* reset this in case we leave w/o reading into the buffer */ pbuf->cur_len = 0; if (apr_file_open(&file, pbuf->buf, APR_READ | APR_BINARY, APR_OS_DEFAULT, p) != APR_SUCCESS) { return NULL; } rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, file); if (rv != APR_SUCCESS) { err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv, apr_psprintf(p, "Opened but could not stat file %s", pbuf->buf)); goto loaderror; } if (finfo.size != (apr_size_t)finfo.size) { err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, 0, apr_psprintf(p, "Opened but rejected huge file %s", pbuf->buf)); goto loaderror; } amt = (apr_size_t)finfo.size; dav_set_bufsize(p, pbuf, amt); if ((rv = apr_file_read(file, pbuf->buf, &amt)) != APR_SUCCESS || amt != finfo.size) { err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv, apr_psprintf(p, "Failure reading locknull file " "for %s", dirpath)); /* just in case the caller disregards the returned error */ pbuf->cur_len = 0; goto loaderror; } loaderror: apr_file_close(file); return err; }
static void test_get_filesize(abts_case *tc, void *data) { apr_status_t rv; rv = apr_file_info_get(&thisfinfo, APR_FINFO_NORM, thefile); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_ASSERT(tc, "File size mismatch", thisfsize == thisfinfo.size); }
// read SQInteger file_get_contents(HSQUIRRELVM v) { // function parameters const SQChar* filename; char* contents; // internal structures apr_file_t* file; apr_finfo_t finfo; apr_size_t nbytes; apr_status_t status; request_rec* r = get_request_rec(v); // for error messages char error[120]; char errorMessage[120]; ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "file_get_contents()"); // grab filename param if( sq_gettype(v, 2) != OT_STRING ) { return SQ_ERROR; } else if( SQ_FAILED(sq_getstring(v, 2, &filename)) ) { return SQ_ERROR; } ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, " file_get_contents('%s')", filename); if( (status = apr_file_open(&file, filename, APR_READ, APR_OS_DEFAULT, r->pool)) != APR_SUCCESS ) { apr_strerror(status, error, sizeof error); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, " file_get_contents() failed: %s", error); sprintf(errorMessage, "file_get_contents() failed: %s", error); errorfunc(v, errorMessage); sq_pushbool(v, SQFalse); return 1; } // figure out file size and allocate enough room to read it all in status = apr_file_info_get(&finfo, APR_FINFO_NORM, file); nbytes = finfo.size; ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "file_get_contents() file is %d", (int)nbytes); contents = apr_palloc(r->pool, finfo.size); if( (status = apr_file_read(file, contents, &nbytes)) != APR_SUCCESS ) { apr_strerror(status, error, sizeof error); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, " file_get_contents() failed: %s", error); sprintf(errorMessage, "file_get_contents() read %d bytes, but failed: %s", (int)nbytes, error); errorfunc(v, errorMessage); sq_pushbool(v, SQFalse); } else { contents[nbytes] = '\0'; sq_pushstring(v, contents, -1); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, " file_get_contents() read %d bytes", (int)nbytes); } ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "file_get_contents() returning 1"); return 1; }
static int twms_handler(request_rec *r) { twms_dir_conf *dcfg; const char *data; const char *val; apr_table_t *tab; apr_file_t *fh; apr_size_t nsend; apr_finfo_t info; if ((r->method_number != M_GET )||(r->args==0)) return DECLINED; data=r->args; // scfg=ap_get_module_config(r->server->module_config,&twms_module); dcfg=ap_get_module_config(r->per_dir_config,&twms_module); if (!dcfg) return DECLINED; // Does this ever happen? if (!ap_strstr(data,"GetTileService")) return DECLINED; // Do we have a config for this directory // ap_log_error(APLOG_MARK,APLOG_ERR,0,r->server,"TWMS_handler: args %s, path %s scfg %x dcfg %x dir %s conf %s", // data,r->parsed_uri.path,scfg,dcfg,dcfg->path,dcfg->Config); if (!dcfg->Config) return DECLINED; // This is overkill here, but it works tab=apr_table_make(r->pool,0); while (*data && (val=ap_getword(r->pool, &data, '&'))) { char *key=apr_pstrdup(r->pool,ap_getword(r->pool, &val, '=')); char *ival=apr_pstrdup(r->pool,val); ap_unescape_url(key);ap_unescape_url(ival); apr_table_merge(tab,key,ival); } if (!(val=apr_table_get(tab,"request"))) return DECLINED; if (apr_strnatcmp(val,"GetTileService")) return DECLINED; if (APR_SUCCESS!=apr_file_open(&fh,apr_pstrcat(r->pool,dcfg->path,dcfg->Config,0), APR_READ,APR_OS_DEFAULT,r->pool)) { ap_log_error(APLOG_MARK,APLOG_ERR,0,r->server,"TWMS file can't be read"); return HTTP_CONFLICT; } ap_log_error(APLOG_MARK,APLOG_ERR,0,r->server,"TWMS Sending GTS file"); apr_file_info_get(&info,APR_FINFO_SIZE,fh); ap_set_content_type(r,"text/xml"); ap_send_fd(fh,r,0,info.size,&nsend); apr_file_close(fh); return OK; }
int load( const char* filename ) { free( resource ); apr_file_t* newfile; apr_file_open( &newfile, filename, APR_READ, APR_OS_DEFAULT, mempool ); apr_finfo_t finfo; apr_file_info_get( &finfo, APR_FINFO_SIZE, newfile ); apr_mmap_t* mmap; apr_mmap_create( &mmap, newfile, 0, finfo.size, APR_MMAP_READ, mempool ); resource = (char*)malloc( finfo.size ); memcpy( resource, mmap->mm, finfo.size ); apr_mmap_delete( mmap ); }
// Creates a temporary file and copies the contents of the upload to it. // Populates finfo with the file info for the temporary file. apr_status_t porter_stream_file_to_disk(apr_pool_t *pool, apreq_param_t *p, apr_finfo_t *finfo, const char *path) { apr_status_t rv; apr_file_t *temp_file; apr_off_t len; PORTER_HANDLE_ERROR(apreq_file_mktemp(&temp_file, pool, path)); PORTER_HANDLE_ERROR(apreq_brigade_fwrite(temp_file, &len, p->upload)); PORTER_HANDLE_ERROR(apr_file_info_get(finfo, APR_FINFO_NORM, temp_file)); return APR_SUCCESS; }
static int file_stat(lua_State *L) { lua_apr_stat_context context = { 0 }; lua_apr_file *file; apr_status_t status; file = file_check(L, 1, 1); context.firstarg = 2; context.lastarg = lua_gettop(L); check_stat_request(L, &context); status = apr_file_info_get(&context.info, context.wanted, file->handle); if (status != APR_SUCCESS && !APR_STATUS_IS_INCOMPLETE(status)) return push_file_error(L, file, status); return push_stat_results(L, &context, NULL); }
/* read all of a filehandle into a string. */ MVMString * MVM_file_readall_fh(MVMThreadContext *tc, MVMObject *oshandle) { MVMString *result; apr_status_t rv; MVMOSHandle *handle; apr_finfo_t finfo; apr_pool_t *tmp_pool; char *buf; MVMint64 bytes_read; /* XXX TODO length currently means bytes. alter it to mean graphemes. */ /* XXX TODO handle length == -1 to mean read to EOF */ verify_filehandle_type(tc, oshandle, &handle, "Readall from filehandle"); ENCODING_VALID(handle->body.encoding_type); /* need a temporary pool */ if ((rv = apr_pool_create(&tmp_pool, POOL(tc))) != APR_SUCCESS) { MVM_exception_throw_apr_error(tc, rv, "Readall failed to create pool: "); } if ((rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, handle->body.file_handle)) != APR_SUCCESS) { apr_pool_destroy(tmp_pool); MVM_exception_throw_apr_error(tc, rv, "Readall failed to get info about file: "); } apr_pool_destroy(tmp_pool); if (finfo.size > 0) { buf = malloc(finfo.size); bytes_read = finfo.size; if ((rv = apr_file_read(handle->body.file_handle, buf, (apr_size_t *)&bytes_read)) != APR_SUCCESS) { free(buf); MVM_exception_throw_apr_error(tc, rv, "Readall from filehandle failed: "); } /* XXX should this take a type object? */ result = MVM_decode_C_buffer_to_string(tc, tc->instance->VMString, buf, bytes_read, handle->body.encoding_type); free(buf); } else { result = (MVMString *)REPR(tc->instance->VMString)->allocate(tc, STABLE(tc->instance->VMString)); } return result; }
char * avro_util_file_read_full (apr_pool_t * pool, const char *fname, apr_size_t * len) { apr_status_t status; apr_finfo_t finfo; apr_file_t *file; char *rval; apr_size_t bytes_read; /* open the file */ status = apr_file_open (&file, fname, APR_READ, 0, pool); if (status != APR_SUCCESS) { return NULL; } /* get the file length */ status = apr_file_info_get (&finfo, APR_FINFO_SIZE, file); if (status != APR_SUCCESS) { return NULL; } /* alloc space for the data */ rval = apr_palloc (pool, finfo.size + 1); if (!rval) { return NULL; } /* read in the data */ status = apr_file_read_full (file, rval, finfo.size, &bytes_read); if (status != APR_SUCCESS) { return NULL; } rval[finfo.size] = '\0'; if (len) { *len = bytes_read; } return rval; }
/* NOTE: this function blocks until it acquires the lock */ APU_DECLARE(apr_status_t) apr_sdbm_lock(apr_sdbm_t *db, int type) { apr_status_t status; if (!(type == APR_FLOCK_SHARED || type == APR_FLOCK_EXCLUSIVE)) return APR_EINVAL; if (db->flags & SDBM_EXCLUSIVE_LOCK) { ++db->lckcnt; return APR_SUCCESS; } else if (db->flags & SDBM_SHARED_LOCK) { /* * Cannot promote a shared lock to an exlusive lock * in a cross-platform compatibile manner. */ if (type == APR_FLOCK_EXCLUSIVE) return APR_EINVAL; ++db->lckcnt; return APR_SUCCESS; } /* * zero size: either a fresh database, or one with a single, * unsplit data page: dirpage is all zeros. */ if ((status = apr_file_lock(db->dirf, type)) == APR_SUCCESS) { apr_finfo_t finfo; if ((status = apr_file_info_get(&finfo, APR_FINFO_SIZE, db->dirf)) != APR_SUCCESS) { (void) apr_file_unlock(db->dirf); return status; } SDBM_INVALIDATE_CACHE(db, finfo); ++db->lckcnt; if (type == APR_FLOCK_SHARED) db->flags |= SDBM_SHARED_LOCK; else if (type == APR_FLOCK_EXCLUSIVE) db->flags |= SDBM_EXCLUSIVE_LOCK; } return status; }
static void test_stat_eq_finfo(abts_case *tc, void *data) { apr_file_t *thefile; apr_finfo_t finfo; apr_finfo_t stat_finfo; apr_status_t rv; rv = apr_file_open(&thefile, FILENAME, APR_READ, APR_OS_DEFAULT, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_file_info_get(&finfo, APR_FINFO_NORM, thefile); /* Opening the file may have toggled the atime member (time last * accessed), so fetch our apr_stat() after getting the fileinfo * of the open file... */ rv = apr_stat(&stat_finfo, FILENAME, APR_FINFO_NORM, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); apr_file_close(thefile); finfo_equal(tc, &stat_finfo, &finfo); }
const char* UmcScenario::LoadFileContent(const char* pFileName, apr_size_t& size, apr_pool_t* pool) const { if(!m_pDirLayout || !pFileName) return NULL; char* pFilePath = apt_datadir_filepath_get(m_pDirLayout,pFileName,pool); if(!pFilePath) return NULL; apr_file_t *pFile; if(apr_file_open(&pFile,pFilePath,APR_FOPEN_READ|APR_FOPEN_BINARY,0,pool) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open File %s",pFilePath); return NULL; } apr_finfo_t finfo; if(apr_file_info_get(&finfo,APR_FINFO_SIZE,pFile) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get File Info %s",pFilePath); apr_file_close(pFile); return NULL; } size = (apr_size_t)finfo.size; char* pContent = (char*) apr_palloc(pool,size+1); apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Load File Content size [%"APR_SIZE_T_FMT" bytes] %s",size,pFilePath); if(apr_file_read(pFile,pContent,&size) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Read Content %s",pFilePath); apr_file_close(pFile); return NULL; } pContent[size] = '\0'; apr_file_close(pFile); return pContent; }
int lua_apr_xml(lua_State *L) { lua_apr_xml_object *object; apr_status_t status; const char *filename; filename = luaL_optstring(L, 1, NULL); object = new_object(L, &lua_apr_xml_type); if (object == NULL) return push_error_memory(L); status = apr_pool_create(&object->pool, NULL); if (status != APR_SUCCESS) return push_error_status(L, status); if (filename == NULL) { object->parser = apr_xml_parser_create(object->pool); if (object->parser == NULL) return push_error_memory(L); } else { apr_finfo_t info; apr_file_t *xmlfd; status = apr_file_open(&xmlfd, filename, APR_FOPEN_READ, 0, object->pool); if (status != APR_SUCCESS) return push_status(L, status); status = apr_file_info_get(&info, APR_FINFO_SIZE, xmlfd); if (status != APR_SUCCESS) { apr_file_close(xmlfd); return push_status(L, status); } status = apr_xml_parse_file(object->pool, &object->parser, &object->doc, xmlfd, (apr_size_t)info.size); apr_file_close(xmlfd); if (status != APR_SUCCESS) return push_xml_status(L, object, status); } return 1; }
/* * Check whether we need to rotate. * Possible reasons are: * - No log file open (ROTATE_NEW) * - User forces us to rotate (ROTATE_FORCE) * - Our log file size is already bigger than the * allowed maximum (ROTATE_SIZE) * - The next log time interval expired (ROTATE_TIME) * * When size and time constraints are both given, * it suffices that one of them is fulfilled. */ static void checkRotate(rotate_config_t *config, rotate_status_t *status) { if (status->current.fd == NULL) { status->rotateReason = ROTATE_NEW; } else if (config->sRotation) { apr_finfo_t finfo; apr_off_t current_size = -1; if (apr_file_info_get(&finfo, APR_FINFO_SIZE, status->current.fd) == APR_SUCCESS) { current_size = finfo.size; } if (current_size > config->sRotation) { status->rotateReason = ROTATE_SIZE; } else if (config->tRotation) { if (get_now(config) >= status->tLogEnd) { status->rotateReason = ROTATE_TIME; } } } else if (config->tRotation) { if (get_now(config) >= status->tLogEnd) { status->rotateReason = ROTATE_TIME; } } else { fprintf(stderr, "No rotation time or size specified\n"); exit(2); } if (status->rotateReason != ROTATE_NONE && config->verbose) { fprintf(stderr, "File rotation needed, reason: %s\n", ROTATE_REASONS[status->rotateReason]); } }
static void test_info_get(abts_case *tc, void *data) { apr_file_t *thefile; apr_finfo_t finfo; apr_status_t rv; rv = apr_file_open(&thefile, FILENAME, APR_READ, APR_OS_DEFAULT, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_file_info_get(&finfo, APR_FINFO_NORM, thefile); if (rv == APR_INCOMPLETE) { char *str; int i; str = apr_pstrdup(p, "APR_INCOMPLETE: Missing "); for (i = 0; vfi[i].bits; ++i) { if (vfi[i].bits & ~finfo.valid) { str = apr_pstrcat(p, str, vfi[i].description, " ", NULL); } } ABTS_FAIL(tc, str); } ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); apr_file_close(thefile); }
static int open_entity(cache_handle_t *h, request_rec *r, const char *key) { apr_uint32_t format; apr_size_t len; const char *nkey; apr_status_t rc; static int error_logged = 0; disk_cache_conf *conf = ap_get_module_config(r->server->module_config, &disk_cache_module); apr_finfo_t finfo; cache_object_t *obj; cache_info *info; disk_cache_object_t *dobj; int flags; h->cache_obj = NULL; /* Look up entity keyed to 'url' */ if (conf->cache_root == NULL) { if (!error_logged) { error_logged = 1; ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "disk_cache: Cannot cache files to disk without a CacheRoot specified."); } return DECLINED; } /* Create and init the cache object */ h->cache_obj = obj = apr_pcalloc(r->pool, sizeof(cache_object_t)); obj->vobj = dobj = apr_pcalloc(r->pool, sizeof(disk_cache_object_t)); info = &(obj->info); /* Open the headers file */ dobj->prefix = NULL; /* Save the cache root */ dobj->root = apr_pstrndup(r->pool, conf->cache_root, conf->cache_root_len); dobj->root_len = conf->cache_root_len; dobj->hdrsfile = header_file(r->pool, conf, dobj, key); flags = APR_READ|APR_BINARY|APR_BUFFERED; rc = apr_file_open(&dobj->hfd, dobj->hdrsfile, flags, 0, r->pool); if (rc != APR_SUCCESS) { return DECLINED; } /* read the format from the cache file */ len = sizeof(format); apr_file_read_full(dobj->hfd, &format, len, &len); if (format == VARY_FORMAT_VERSION) { apr_array_header_t* varray; apr_time_t expire; len = sizeof(expire); apr_file_read_full(dobj->hfd, &expire, len, &len); varray = apr_array_make(r->pool, 5, sizeof(char*)); rc = read_array(r, varray, dobj->hfd); if (rc != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_ERR, rc, r->server, "disk_cache: Cannot parse vary header file: %s", dobj->hdrsfile); return DECLINED; } apr_file_close(dobj->hfd); nkey = regen_key(r->pool, r->headers_in, varray, key); dobj->hashfile = NULL; dobj->prefix = dobj->hdrsfile; dobj->hdrsfile = header_file(r->pool, conf, dobj, nkey); flags = APR_READ|APR_BINARY|APR_BUFFERED; rc = apr_file_open(&dobj->hfd, dobj->hdrsfile, flags, 0, r->pool); if (rc != APR_SUCCESS) { return DECLINED; } } else if (format != DISK_FORMAT_VERSION) { ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "cache_disk: File '%s' has a version mismatch. File had version: %d.", dobj->hdrsfile, format); return DECLINED; } else { apr_off_t offset = 0; /* This wasn't a Vary Format file, so we must seek to the * start of the file again, so that later reads work. */ apr_file_seek(dobj->hfd, APR_SET, &offset); nkey = key; } obj->key = nkey; dobj->key = nkey; dobj->name = key; dobj->datafile = data_file(r->pool, conf, dobj, nkey); dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL); /* Open the data file */ flags = APR_READ|APR_BINARY; #ifdef APR_SENDFILE_ENABLED flags |= APR_SENDFILE_ENABLED; #endif rc = apr_file_open(&dobj->fd, dobj->datafile, flags, 0, r->pool); if (rc != APR_SUCCESS) { /* XXX: Log message */ return DECLINED; } rc = apr_file_info_get(&finfo, APR_FINFO_SIZE, dobj->fd); if (rc == APR_SUCCESS) { dobj->file_size = finfo.size; } /* Read the bytes to setup the cache_info fields */ rc = file_cache_recall_mydata(dobj->hfd, info, dobj, r); if (rc != APR_SUCCESS) { /* XXX log message */ return DECLINED; } /* Initialize the cache_handle callback functions */ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "disk_cache: Recalled cached URL info header %s", dobj->name); return OK; }
SWITCH_DECLARE(switch_size_t) switch_file_get_size(switch_file_t *thefile) { struct apr_finfo_t finfo; return apr_file_info_get(&finfo, APR_FINFO_SIZE, thefile) == SWITCH_STATUS_SUCCESS ? (switch_size_t) finfo.size : 0; }
static apr_status_t ap_xsendfile_output_filter(ap_filter_t *f, apr_bucket_brigade *in) { request_rec *r = f->r, *sr = NULL; xsendfile_conf_t *dconf = (xsendfile_conf_t *)ap_get_module_config(r->per_dir_config, &xsendfile_module), *sconf = (xsendfile_conf_t *)ap_get_module_config(r->server->module_config, &xsendfile_module), *conf = xsendfile_config_merge(r->pool, sconf, dconf); core_dir_config *coreconf = (core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module); apr_status_t rv; apr_bucket *e; apr_file_t *fd = NULL; apr_finfo_t finfo; const char *file = NULL; char *translated = NULL; int errcode; #ifdef _DEBUG ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: output_filter for %s", r->the_request); #endif /* should we proceed with this request? * sub-requests suck * furthermore default-handled requests suck, as they actually shouldn't be able to set headers */ if ( r->status != HTTP_OK || r->main || (r->handler && strcmp(r->handler, "default-handler") == 0) /* those table-keys are lower-case, right? */ ) { #ifdef _DEBUG ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: not met [%d]", r->status); #endif ap_remove_output_filter(f); return ap_pass_brigade(f->next, in); } /* alright, look for x-sendfile */ file = apr_table_get(r->headers_out, AP_XSENDFILE_HEADER); apr_table_unset(r->headers_out, AP_XSENDFILE_HEADER); /* cgi/fastcgi will put the stuff into err_headers_out */ if (!file || !*file) { file = apr_table_get(r->err_headers_out, AP_XSENDFILE_HEADER); apr_table_unset(r->err_headers_out, AP_XSENDFILE_HEADER); } /* nothing there :p */ if (!file || !*file) { #ifdef _DEBUG ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: nothing found"); #endif ap_remove_output_filter(f); return ap_pass_brigade(f->next, in); } /* drop *everything* might be pretty expensive to generate content first that goes straight to the bitbucket, but actually the scripts that might set this flag won't output too much anyway */ while (!APR_BRIGADE_EMPTY(in)) { e = APR_BRIGADE_FIRST(in); apr_bucket_delete(e); } r->eos_sent = 0; rv = ap_xsendfile_get_filepath(r, conf, file, &translated); if (rv != OK) { ap_log_rerror( APLOG_MARK, APLOG_ERR, rv, r, "xsendfile: unable to find file: %s", file ); ap_remove_output_filter(f); ap_die(HTTP_NOT_FOUND, r); return HTTP_NOT_FOUND; } #ifdef _DEBUG ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: found %s", translated); #endif /* ry open the file */ if ((rv = apr_file_open( &fd, translated, APR_READ | APR_BINARY #if APR_HAS_SENDFILE | (coreconf->enable_sendfile == ENABLE_SENDFILE_ON ? APR_SENDFILE_ENABLED : 0) #endif , 0, r->pool )) != APR_SUCCESS) { ap_log_rerror( APLOG_MARK, APLOG_ERR, rv, r, "xsendfile: cannot open file: %s", translated ); ap_remove_output_filter(f); ap_die(HTTP_NOT_FOUND, r); return HTTP_NOT_FOUND; } #if APR_HAS_SENDFILE && defined(_DEBUG) if (coreconf->enable_sendfile != ENABLE_SENDFILE_ON) { ap_log_error( APLOG_MARK, APLOG_WARNING, 0, r->server, "xsendfile: sendfile configured, but not active %d", coreconf->enable_sendfile ); } #endif /* stat (for etag/cache/content-length stuff) */ if ((rv = apr_file_info_get(&finfo, APR_FINFO_NORM, fd)) != APR_SUCCESS) { ap_log_rerror( APLOG_MARK, APLOG_ERR, rv, r, "xsendfile: unable to stat file: %s", translated ); apr_file_close(fd); ap_remove_output_filter(f); ap_die(HTTP_FORBIDDEN, r); return HTTP_FORBIDDEN; } /* no inclusion of directories! we're serving files! */ if (finfo.filetype != APR_REG) { ap_log_rerror( APLOG_MARK, APLOG_ERR, APR_EBADPATH, r, "xsendfile: not a file %s", translated ); apr_file_close(fd); ap_remove_output_filter(f); ap_die(HTTP_NOT_FOUND, r); return HTTP_NOT_FOUND; } /* need to cheat here a bit as etag generator will use those ;) and we want local_copy and cache */ r->finfo.inode = finfo.inode; r->finfo.size = finfo.size; /* caching? why not :p */ r->no_cache = r->no_local_copy = 0; /* some script (f?cgi) place stuff in err_headers_out */ if ( conf->ignoreLM == XSENDFILE_ENABLED || ( !apr_table_get(r->headers_out, "last-modified") && !apr_table_get(r->headers_out, "last-modified") ) ) { apr_table_unset(r->err_headers_out, "last-modified"); ap_update_mtime(r, finfo.mtime); ap_set_last_modified(r); } if ( conf->ignoreETag == XSENDFILE_ENABLED || ( !apr_table_get(r->headers_out, "etag") && !apr_table_get(r->err_headers_out, "etag") ) ) { apr_table_unset(r->err_headers_out, "etag"); ap_set_etag(r); } apr_table_unset(r->err_headers_out, "content-length"); ap_set_content_length(r, finfo.size); /* as we dropped all the content this field is not valid anymore! */ apr_table_unset(r->headers_out, "Content-Encoding"); apr_table_unset(r->err_headers_out, "Content-Encoding"); /* cache or something? */ if ((errcode = ap_meets_conditions(r)) != OK) { #ifdef _DEBUG ap_log_error( APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: met condition %d for %s", errcode, file ); #endif apr_file_close(fd); r->status = errcode; } else { /* For platforms where the size of the file may be larger than * that which can be stored in a single bucket (where the * length field is an apr_size_t), split it into several * buckets: */ if (sizeof(apr_off_t) > sizeof(apr_size_t) && finfo.size > AP_MAX_SENDFILE) { apr_off_t fsize = finfo.size; e = apr_bucket_file_create(fd, 0, AP_MAX_SENDFILE, r->pool, in->bucket_alloc); while (fsize > AP_MAX_SENDFILE) { apr_bucket *ce; apr_bucket_copy(e, &ce); APR_BRIGADE_INSERT_TAIL(in, ce); e->start += AP_MAX_SENDFILE; fsize -= AP_MAX_SENDFILE; } e->length = (apr_size_t)fsize; /* Resize just the last bucket */ } else { e = apr_bucket_file_create(fd, 0, (apr_size_t)finfo.size, r->pool, in->bucket_alloc); } #if APR_HAS_MMAP if (coreconf->enable_mmap == ENABLE_MMAP_ON) { apr_bucket_file_enable_mmap(e, 0); } #if defined(_DEBUG) else { ap_log_error( APLOG_MARK, APLOG_WARNING, 0, r->server, "xsendfile: mmap configured, but not active %d", coreconf->enable_mmap ); } #endif /* _DEBUG */ #endif /* APR_HAS_MMAP */ APR_BRIGADE_INSERT_TAIL(in, e); } e = apr_bucket_eos_create(in->bucket_alloc); APR_BRIGADE_INSERT_TAIL(in, e); /* remove ourselves from the filter chain */ ap_remove_output_filter(f); #ifdef _DEBUG ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: sending %d bytes", (int)finfo.size); #endif /* send the data up the stack */ return ap_pass_brigade(f->next, in); }