static void test_open_writecreate(CuTest *tc)
{
apr_status_t rv;
apr_file_t *filetest = NULL;
filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_WRITE | APR_CREATE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
apr_file_close(filetest);
}
static void test_open_writecreate(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *filetest = NULL;
filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_FOPEN_WRITE | APR_FOPEN_CREATE,
APR_FPROT_UREAD | APR_FPROT_UWRITE | APR_FPROT_GREAD, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
apr_file_close(filetest);
}
static void test_bigread(abts_case *tc, void *data)
{
apr_file_t *f = NULL;
apr_status_t rv;
char buf[APR_BUFFERSIZE * 2];
apr_size_t nbytes;
/* Create a test file with known content.
*/
rv = apr_file_open(&f, "data/created_file",
APR_FOPEN_CREATE | APR_FOPEN_WRITE | APR_FOPEN_TRUNCATE,
APR_FPROT_UREAD | APR_FPROT_UWRITE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
nbytes = APR_BUFFERSIZE;
memset(buf, 0xFE, nbytes);
rv = apr_file_write(f, buf, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, APR_BUFFERSIZE, nbytes);
rv = apr_file_close(f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
f = NULL;
rv = apr_file_open(&f, "data/created_file", APR_FOPEN_READ, 0, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
nbytes = sizeof buf;
rv = apr_file_read(f, buf, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, APR_BUFFERSIZE, nbytes);
rv = apr_file_close(f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_remove("data/created_file", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
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 );
}
static void test_bigread(CuTest *tc)
{
apr_file_t *f = NULL;
apr_status_t rv;
char buf[APR_BUFFERSIZE * 2];
apr_size_t nbytes;
/* Create a test file with known content.
*/
rv = apr_file_open(&f, "data/created_file",
APR_CREATE | APR_WRITE | APR_TRUNCATE,
APR_UREAD | APR_UWRITE, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
nbytes = APR_BUFFERSIZE;
memset(buf, 0xFE, nbytes);
rv = apr_file_write(f, buf, &nbytes);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, APR_BUFFERSIZE, nbytes);
rv = apr_file_close(f);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
f = NULL;
rv = apr_file_open(&f, "data/created_file", APR_READ, 0, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
nbytes = sizeof buf;
rv = apr_file_read(f, buf, &nbytes);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, APR_BUFFERSIZE, nbytes);
rv = apr_file_close(f);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_file_remove("data/created_file", p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
}
/* Test for a (fixed) bug in apr_dir_read(). This bug only happened
in threadless cases. */
static void test_uncleared_errno(abts_case *tc, void *data)
{
apr_file_t *thefile = NULL;
apr_finfo_t finfo;
apr_int32_t finfo_flags = APR_FINFO_TYPE | APR_FINFO_NAME;
apr_dir_t *this_dir;
apr_status_t rv;
rv = apr_dir_make("dir1", APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_make("dir2", APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_open(&thefile, "dir1/file1",
APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE, APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_close(thefile);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Try to remove dir1. This should fail because it's not empty.
However, on a platform with threads disabled (such as FreeBSD),
`errno' will be set as a result. */
rv = apr_dir_remove("dir1", p);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ENOTEMPTY(rv));
/* Read `.' and `..' out of dir2. */
rv = apr_dir_open(&this_dir, "dir2", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_read(&finfo, finfo_flags, this_dir);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_read(&finfo, finfo_flags, this_dir);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Now, when we attempt to do a third read of empty dir2, and the
underlying system readdir() returns NULL, the old value of
errno shouldn't cause a false alarm. We should get an ENOENT
back from apr_dir_read, and *not* the old errno. */
rv = apr_dir_read(&finfo, finfo_flags, this_dir);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ENOENT(rv));
rv = apr_dir_close(this_dir);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Cleanup */
rv = apr_file_remove("dir1/file1", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_remove("dir1", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_remove("dir2", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, access_t access_type, S32* sizep)
{
llassert_always(!mFile);
llassert_always(!mVolatileFilePoolp && !mRegularFilePoolp);
apr_status_t status;
{
apr_pool_t* apr_file_open_pool;
if (access_type == local)
{
// Use a "volatile" thread-local pool.
mVolatileFilePoolp = &AIThreadLocalData::tldata().mVolatileAPRPool;
// Access the pool and increment it's reference count.
// The reference count of AIVolatileAPRPool objects will be decremented
// again in LLAPRFile::close by calling mVolatileFilePoolp->clearVolatileAPRPool().
apr_file_open_pool = mVolatileFilePoolp->getVolatileAPRPool();
}
else
{
mRegularFilePoolp = new AIAPRPool(AIThreadLocalData::tldata().mRootPool);
apr_file_open_pool = (*mRegularFilePoolp)();
}
status = apr_file_open(&mFile, filename.c_str(), flags, APR_OS_DEFAULT, apr_file_open_pool);
}
if (status != APR_SUCCESS || !mFile)
{
mFile = NULL ;
close() ;
if (sizep)
{
*sizep = 0;
}
return status;
}
if (sizep)
{
S32 file_size = 0;
apr_off_t offset = 0;
if (apr_file_seek(mFile, APR_END, &offset) == APR_SUCCESS)
{
llassert_always(offset <= 0x7fffffff);
file_size = (S32)offset;
offset = 0;
apr_file_seek(mFile, APR_SET, &offset);
}
*sizep = file_size;
}
return status;
}
static apt_bool_t test_file_process(apt_test_suite_t *suite, mrcp_resource_factory_t *factory, mrcp_version_e version, const char *file_path)
{
apr_file_t *file;
char buffer[500];
apt_text_stream_t stream;
mrcp_parser_t *parser;
mrcp_generator_t *generator;
apr_size_t length;
apr_size_t offset;
apt_str_t resource_name;
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Open File [%s]",file_path);
if(apr_file_open(&file,file_path,APR_FOPEN_READ | APR_FOPEN_BINARY,APR_OS_DEFAULT,suite->pool) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open File");
return FALSE;
}
parser = mrcp_parser_create(factory,suite->pool);
generator = mrcp_generator_create(factory,suite->pool);
apt_string_reset(&resource_name);
if(version == MRCP_VERSION_1) {
resource_name_read(file,parser);
}
apt_text_stream_init(&stream,buffer,sizeof(buffer)-1);
do {
/* init length of the stream */
stream.text.length = sizeof(buffer)-1;
/* calculate offset remaining from the previous receive / if any */
offset = stream.pos - stream.text.buf;
/* calculate available length */
length = stream.text.length - offset;
if(apr_file_read(file,stream.pos,&length) != APR_SUCCESS) {
break;
}
/* calculate actual length of the stream */
stream.text.length = offset + length;
stream.pos[length] = '\0';
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Parse MRCP Stream [%lu bytes]\n%s",length,stream.pos);
/* reset pos */
stream.pos = stream.text.buf;
mrcp_stream_walk(parser,&stream,mrcp_message_handler,generator);
}
while(apr_file_eof(file) != APR_EOF);
apr_file_close(file);
return TRUE;
}
static void test_dup2_readwrite(abts_case *tc, void *data)
{
apr_file_t *errfile = NULL;
apr_file_t *testfile = NULL;
apr_file_t *saveerr = NULL;
apr_status_t rv;
apr_size_t txtlen = sizeof(TEST);
char buff[50];
apr_off_t fpos;
rv = apr_file_open(&testfile, FILEPATH "testdup2.readwrite.file",
APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE |
APR_FOPEN_DELONCLOSE, APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, testfile);
rv = apr_file_open_stderr(&errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Set aside the real errfile */
rv = apr_file_dup(&saveerr, errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, saveerr);
rv = apr_file_dup2(errfile, testfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
txtlen = sizeof(TEST2);
rv = apr_file_write(errfile, TEST2, &txtlen);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, sizeof(TEST2), txtlen);
fpos = 0;
rv = apr_file_seek(testfile, APR_SET, &fpos);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File position mismatch, expected 0", fpos == 0);
txtlen = 50;
rv = apr_file_read(testfile, buff, &txtlen);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, TEST2, buff);
apr_file_close(testfile);
rv = apr_file_dup2(errfile, saveerr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
apr_file_close(saveerr);
}
AP_DECLARE(void) ap_log_pid(apr_pool_t *p, const char *filename)
{
apr_file_t *pid_file = NULL;
apr_finfo_t finfo;
static pid_t saved_pid = -1;
pid_t mypid;
apr_status_t rv;
const char *fname;
if (!filename) {
return;
}
fname = ap_server_root_relative(p, filename);
if (!fname) {
ap_log_error(APLOG_MARK, APLOG_STARTUP|APLOG_CRIT, APR_EBADPATH,
NULL, "Invalid PID file path %s, ignoring.", filename);
return;
}
mypid = getpid();
if (mypid != saved_pid
&& apr_stat(&finfo, fname, APR_FINFO_MTIME, p) == APR_SUCCESS) {
/* AP_SIG_GRACEFUL and HUP call this on each restart.
* Only warn on first time through for this pid.
*
* XXX: Could just write first time through too, although
* that may screw up scripts written to do something
* based on the last modification time of the pid file.
*/
ap_log_perror(APLOG_MARK, APLOG_WARNING, 0, p,
"pid file %s overwritten -- Unclean "
"shutdown of previous Apache run?",
fname);
}
if ((rv = apr_file_open(&pid_file, fname,
APR_WRITE | APR_CREATE | APR_TRUNCATE,
APR_UREAD | APR_UWRITE | APR_GREAD | APR_WREAD, p))
!= APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
"could not create %s", fname);
ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL,
"%s: could not log pid to file %s",
ap_server_argv0, fname);
exit(1);
}
apr_file_printf(pid_file, "%ld" APR_EOL_STR, (long)mypid);
apr_file_close(pid_file);
saved_pid = mypid;
}
/*
** dav_fs_save_locknull_list: Saves contents of pbuf into the
** locknull file for dirpath.
*/
static dav_error * dav_fs_save_locknull_list(apr_pool_t *p, const char *dirpath,
dav_buffer *pbuf)
{
const char *pathname;
apr_file_t *file = NULL;
dav_error *err = NULL;
apr_size_t amt;
apr_status_t rv;
if (pbuf->buf == NULL)
return NULL;
dav_fs_ensure_state_dir(p, dirpath);
pathname = apr_pstrcat(p,
dirpath,
dirpath[strlen(dirpath) - 1] == '/' ? "" : "/",
DAV_FS_STATE_DIR "/" DAV_FS_LOCK_NULL_FILE,
NULL);
if (pbuf->cur_len == 0) {
/* delete the file if cur_len == 0 */
if ((rv = apr_file_remove(pathname, p)) != APR_SUCCESS) {
return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
apr_psprintf(p,
"Error removing %s", pathname));
}
return NULL;
}
if ((rv = apr_file_open(&file, pathname,
APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BINARY,
APR_OS_DEFAULT, p)) != APR_SUCCESS) {
return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
apr_psprintf(p,
"Error opening %s for writing",
pathname));
}
amt = pbuf->cur_len;
if ((rv = apr_file_write_full(file, pbuf->buf, amt, &amt)) != APR_SUCCESS
|| amt != pbuf->cur_len) {
err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0, rv,
apr_psprintf(p,
"Error writing %" APR_SIZE_T_FMT
" bytes to %s",
pbuf->cur_len, pathname));
}
apr_file_close(file);
return err;
}
/* Deltifies a node, i.e. generates a svndiff that can be dumped */
static svn_error_t *delta_deltify_node(de_node_baton_t *node)
{
svn_txdelta_stream_t *stream;
svn_txdelta_window_handler_t handler;
void *handler_baton;
svn_stream_t *source, *target, *dest;
apr_file_t *source_file = NULL, *target_file = NULL, *dest_file = NULL;
dump_options_t *opts = node->de_baton->opts;
apr_pool_t *pool = svn_pool_create(node->pool);
svn_error_t *err;
DEBUG_MSG("delta_deltify_node(%s): %s -> %s\n", node->path, node->old_filename, node->filename);
/* Open source and target */
apr_file_open(&target_file, node->filename, APR_READ, 0600, pool);
target = svn_stream_from_aprfile2(target_file, FALSE, pool);
if (node->old_filename) {
apr_file_open(&source_file, node->old_filename, APR_READ, 0600, pool);
source = svn_stream_from_aprfile2(source_file, FALSE, pool);
} else {
source = svn_stream_empty(pool);
}
/* Open temporary output file */
node->delta_filename = apr_psprintf(node->pool, "%s/XXXXXX", opts->temp_dir);
apr_file_mktemp(&dest_file, node->delta_filename, APR_CREATE | APR_READ | APR_WRITE | APR_EXCL, pool);
dest = svn_stream_from_aprfile2(dest_file, FALSE, pool);
DEBUG_MSG("delta_deltify_node(%s): writing to %s\n", node->path, node->delta_filename);
/* Produce delta in svndiff format */
svn_txdelta(&stream, source, target, pool);
svn_txdelta_to_svndiff2(&handler, &handler_baton, dest, 0, pool);
err = svn_txdelta_send_txstream(stream, handler, handler_baton, pool);
svn_pool_destroy(pool);
return err;
}
static void test_truncate(CuTest *tc)
{
apr_status_t rv;
apr_file_t *f;
const char *fname = "data/testtruncate.dat";
const char *s;
apr_size_t nbytes;
apr_finfo_t finfo;
apr_file_remove(fname, p);
rv = apr_file_open(&f, fname,
APR_CREATE | APR_WRITE, APR_UREAD | APR_UWRITE, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
s = "some data";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, strlen(s), nbytes);
rv = apr_file_close(f);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_file_open(&f, fname,
APR_TRUNCATE | APR_WRITE, APR_UREAD | APR_UWRITE, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_file_close(f);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_stat(&finfo, fname, APR_FINFO_SIZE, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssert(tc, "File size mismatch, expected 0 (empty)", finfo.size == 0);
rv = apr_file_remove(fname, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
}
static void test_truncate(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *f;
const char *fname = "data/testtruncate.dat";
const char *s;
apr_size_t nbytes;
apr_finfo_t finfo;
apr_file_remove(fname, p);
rv = apr_file_open(&f, fname,
APR_CREATE | APR_WRITE, APR_UREAD | APR_UWRITE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
s = "some data";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, strlen(s), nbytes);
rv = apr_file_close(f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_open(&f, fname,
APR_TRUNCATE | APR_WRITE, APR_UREAD | APR_UWRITE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_close(f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_stat(&finfo, fname, APR_FINFO_SIZE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File size mismatch, expected 0 (empty)", finfo.size == 0);
rv = apr_file_remove(fname, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
static void store_slotmem(ap_slotmem_instance_t *slotmem)
{
apr_file_t *fp;
apr_status_t rv;
apr_size_t nbytes;
unsigned char digest[APR_MD5_DIGESTSIZE];
const char *storename = slotmem->pname;
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf, APLOGNO(02334)
"storing %s", storename);
if (storename) {
rv = apr_file_open(&fp, storename, APR_CREATE | APR_READ | APR_WRITE,
APR_OS_DEFAULT, slotmem->gpool);
if (APR_STATUS_IS_EEXIST(rv)) {
apr_file_remove(storename, slotmem->gpool);
rv = apr_file_open(&fp, storename, APR_CREATE | APR_READ | APR_WRITE,
APR_OS_DEFAULT, slotmem->gpool);
}
if (rv != APR_SUCCESS) {
return;
}
if (AP_SLOTMEM_IS_CLEARINUSE(slotmem)) {
slotmem_clearinuse(slotmem);
}
nbytes = (slotmem->desc.size * slotmem->desc.num) +
(slotmem->desc.num * sizeof(char)) + AP_UNSIGNEDINT_OFFSET;
apr_md5(digest, slotmem->persist, nbytes);
rv = apr_file_write_full(fp, slotmem->persist, nbytes, NULL);
if (rv == APR_SUCCESS) {
rv = apr_file_write_full(fp, digest, APR_MD5_DIGESTSIZE, NULL);
}
apr_file_close(fp);
if (rv != APR_SUCCESS) {
apr_file_remove(storename, slotmem->gpool);
}
}
}
static void test_getc(abts_case *tc, void *data)
{
apr_file_t *f = NULL;
apr_status_t rv;
char ch;
rv = apr_file_open(&f, FILENAME, APR_READ, 0, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
apr_file_getc(&ch, f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, (int)TESTSTR[0], (int)ch);
apr_file_close(f);
}
static void test_getc(CuTest *tc)
{
apr_file_t *f = NULL;
apr_status_t rv;
char ch;
rv = apr_file_open(&f, FILENAME, APR_READ, 0, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
apr_file_getc(&ch, f);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, (int)TESTSTR[0], (int)ch);
apr_file_close(f);
}
/**
* Initialise the modsecurity engine. This function must be invoked
* after configuration processing is complete as Apache needs to know the
* username it is running as.
*/
int modsecurity_init(msc_engine *msce, apr_pool_t *mp)
{
apr_status_t rc;
/* auditlog互斥锁 */
rc = apr_global_mutex_create(&msce->auditlog_lock, NULL, APR_LOCK_DEFAULT, mp);
if (rc != APR_SUCCESS) {
return -1;
}
#ifdef __SET_MUTEX_PERMS
#if AP_SERVER_MAJORVERSION_NUMBER > 1 && AP_SERVER_MINORVERSION_NUMBER > 2
rc = ap_unixd_set_global_mutex_perms(msce->auditlog_lock);
#else
rc = unixd_set_global_mutex_perms(msce->auditlog_lock);
#endif
if (rc != APR_SUCCESS) {
return -1;
}
#endif /* SET_MUTEX_PERMS */
/* geo互斥锁 */
rc = apr_global_mutex_create(&msce->geo_lock, NULL, APR_LOCK_DEFAULT, mp);
if (rc != APR_SUCCESS) {
return -1;
}
#ifdef __SET_MUTEX_PERMS
#if AP_SERVER_MAJORVERSION_NUMBER > 1 && AP_SERVER_MINORVERSION_NUMBER > 2
rc = ap_unixd_set_global_mutex_perms(msce->geo_lock);
#else
rc = unixd_set_global_mutex_perms(msce->geo_lock);
#endif
if (rc != APR_SUCCESS) {
return -1;
}
#endif /* SET_MUTEX_PERMS */
#ifdef DEBUG_FILELOG
const char *file_name = ap_server_root_relative(mp, "logs/audit_log");
rc = apr_file_open(&auditlog_fd, file_name,
APR_WRITE | APR_APPEND | APR_CREATE | APR_BINARY, CREATEMODE, mp);
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, "Create or open audit failed.");
return -1;
}
#endif
return 1;
}
static void test_open_readwrite(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *filetest = NULL;
filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_READ | APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, filetest);
apr_file_close(filetest);
}
//static
S32 LLAPRFile::writeEx(const std::string& filename, void *buf, S32 offset, S32 nbytes)
{
apr_int32_t flags = APR_CREATE|APR_WRITE|APR_BINARY;
if (offset < 0)
{
flags |= APR_APPEND;
offset = 0;
}
apr_file_t* file_handle;
LLScopedVolatileAPRFilePool pool;
apr_status_t s = apr_file_open(&file_handle, filename.c_str(), flags, APR_OS_DEFAULT, pool);
if (s != APR_SUCCESS || !file_handle)
{
ll_apr_warn_status(s);
LL_WARNS("APR") << " while attempting to open file \"" << filename << '"' << LL_ENDL;
return 0;
}
if (offset > 0)
{
offset = LLAPRFile::seek(file_handle, APR_SET, offset);
}
apr_size_t bytes_written;
if (offset < 0)
{
bytes_written = 0;
}
else
{
bytes_written = nbytes ;
apr_status_t s = apr_file_write(file_handle, buf, &bytes_written);
if (s != APR_SUCCESS)
{
LL_WARNS("APR") << " Attempting to write filename: " << filename << LL_ENDL;
ll_apr_warn_status(s);
bytes_written = 0;
}
else
{
llassert_always(bytes_written <= 0x7fffffff);
}
}
apr_file_close(file_handle);
return (S32)bytes_written;
}
/** Returns the name of the currently executing program.
*
* Allocates the result on pool.
*/
char *get_self_name(apr_pool_t *pool) {
apr_file_t *f;
apr_pool_t *subpool;
apr_status_t err;
char *self_name;
char line_buf[8096];
apr_pool_create(&subpool, pool);
err = apr_file_open(&f, "/proc/self/status", APR_READ, APR_OS_DEFAULT, subpool);
if (err != APR_SUCCESS) {
apr_pool_destroy(subpool);
return NULL;
}
while (1) {
char *s;
size_t line_s;
/* Read a line of the file. */
err = apr_file_gets(line_buf, sizeof(line_buf), f);
if (err != APR_SUCCESS)
break;
line_s = strlen(line_buf);
line_buf[--line_s] = '\0';
/* Search for the process name in the current line. */
s = strstr(line_buf, "Name:\t");
if (s != NULL) {
/* Go past the space. */
s += 6;
line_s -= 6;
if (line_s > 0) {
/* We have something, yay! As the memory was
allocated by read_line, we expect the returned
string to be sanely null-terminated. */
apr_pool_destroy(subpool);
self_name = apr_pstrdup(pool, s);
return self_name;
}
}
}
apr_pool_destroy(subpool);
return NULL;
}
mm_logger* logging_getLogger(pool* p,char* path,long maxLogFileSizeMB) {
apr_status_t rc;
if(path==NULL) return NULL;
mm_logger* ret=(mm_logger*)apr_pcalloc(p,sizeof(mm_logger));
ret->filepath=apr_pstrdup(p,path);
ret->maxLogFileSizeMB=maxLogFileSizeMB;
if((rc=apr_file_open(&(ret->file),path,APR_READ|APR_WRITE|APR_CREATE|APR_APPEND,APR_OS_DEFAULT,p))!=APR_SUCCESS) {
return NULL;
}
ret->p=p;
return ret;
}
/* Make a test file named FNAME, and write CONTENTS to it. */
static apr_file_t *make_test_file(abts_case *tc, const char *fname,
const char *contents)
{
apr_file_t *f;
ABTS_ASSERT(tc, "create test file",
apr_file_open(&f, fname,
APR_READ|APR_WRITE|APR_TRUNCATE|APR_CREATE,
APR_OS_DEFAULT, p) == APR_SUCCESS);
ABTS_ASSERT(tc, "write test file contents",
apr_file_puts(contents, f) == APR_SUCCESS);
return f;
}
static void test_userdata_set(CuTest *tc)
{
apr_status_t rv;
apr_file_t *filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_file_data_set(filetest, "This is a test",
"test", apr_pool_cleanup_null);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
apr_file_close(filetest);
}
static void test_userdata_set(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_data_set(filetest, "This is a test",
"test", apr_pool_cleanup_null);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
apr_file_close(filetest);
}
/* open a filehandle; takes a type object */
MVMObject * MVM_file_open_fh(MVMThreadContext *tc, MVMString *filename, MVMString *mode) {
MVMOSHandle *result;
apr_status_t rv;
apr_pool_t *tmp_pool;
apr_file_t *file_handle;
apr_int32_t flag;
MVMObject *type_object = tc->instance->boot_types->BOOTIO;
char *fname = MVM_string_utf8_encode_C_string(tc, filename);
char *fmode;
/* 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: ");
}
fmode = MVM_string_utf8_encode_C_string(tc, mode);
/* generate apr compatible open mode flags */
if (0 == strcmp("r", fmode))
flag = APR_FOPEN_READ;
else if (0 == strcmp("w", fmode))
flag = APR_FOPEN_WRITE|APR_FOPEN_CREATE|APR_FOPEN_TRUNCATE;
else if (0 == strcmp("wa", fmode))
flag = APR_FOPEN_WRITE|APR_FOPEN_CREATE|APR_FOPEN_APPEND;
else
MVM_exception_throw_adhoc(tc, "invalid open mode: %d", fmode);
/* try to open the file */
if ((rv = apr_file_open(&file_handle, (const char *)fname, flag, APR_OS_DEFAULT, tmp_pool)) != APR_SUCCESS) {
free(fname);
free(fmode);
apr_pool_destroy(tmp_pool);
MVM_exception_throw_apr_error(tc, rv, "Failed to open file: ");
}
/* initialize the object */
result = (MVMOSHandle *)REPR(type_object)->allocate(tc, STABLE(type_object));
result->body.file_handle = file_handle;
result->body.handle_type = MVM_OSHANDLE_FILE;
result->body.mem_pool = tmp_pool;
result->body.encoding_type = MVM_encoding_type_utf8;
free(fname);
free(fmode);
return (MVMObject *)result;
}
apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, access_t access_type, S32* sizep)
{
llassert_always(!mFile);
llassert_always(!mCurrentFilePoolp);
// Access the pool and increment it's reference count.
// The reference count of LLVolatileAPRPool objects will be decremented
// again in LLAPRFile::close by calling mCurrentFilePoolp->clearVolatileAPRPool().
apr_pool_t* pool;
if (access_type == local)
{
// Use a "volatile" thread-local pool.
mCurrentFilePoolp = LLVolatileAPRPool::getLocalAPRFilePool();
pool = mCurrentFilePoolp->getVolatileAPRPool();
}
else
{
llassert(is_main_thread());
pool = gAPRPoolp;
}
apr_status_t s = apr_file_open(&mFile, filename.c_str(), flags, APR_OS_DEFAULT, pool);
if (s != APR_SUCCESS || !mFile)
{
mFile = NULL ;
close() ;
if (sizep)
{
*sizep = 0;
}
return s;
}
if (sizep)
{
S32 file_size = 0;
apr_off_t offset = 0;
if (apr_file_seek(mFile, APR_END, &offset) == APR_SUCCESS)
{
llassert_always(offset <= 0x7fffffff);
file_size = (S32)offset;
offset = 0;
apr_file_seek(mFile, APR_SET, &offset);
}
*sizep = file_size;
}
return s;
}
static void test_readzero(abts_case *tc, void *data)
{
apr_status_t rv;
apr_size_t nbytes = 0;
char *str = NULL;
apr_file_t *filetest;
rv = apr_file_open(&filetest, FILENAME, APR_READ, APR_OS_DEFAULT, p);
APR_ASSERT_SUCCESS(tc, "Opening test file " FILENAME, rv);
rv = apr_file_read(filetest, str, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, 0, nbytes);
apr_file_close(filetest);
}
static void test_userdata_getnokey(abts_case *tc, void *data)
{
apr_status_t rv;
void *teststr;
apr_file_t *filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_data_get(&teststr, "nokey", filetest);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_EQUAL(tc, NULL, teststr);
apr_file_close(filetest);
}
static void test_write(abts_case *tc, void *data)
{
apr_status_t rv;
apr_size_t bytes = strlen(TESTSTR);
apr_file_t *filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_WRITE | APR_CREATE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_write(filetest, TESTSTR, &bytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
apr_file_close(filetest);
}