//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);
}
