/* 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);
}
static celix_status_t deploymentAdmin_deleteTree(char * directory, apr_pool_t *mp) {
celix_status_t status = CELIX_SUCCESS;
apr_dir_t *dir;
if (directory && mp) {
if (apr_dir_open(&dir, directory, mp) == APR_SUCCESS) {
apr_finfo_t dp;
while ((apr_dir_read(&dp, APR_FINFO_DIRENT|APR_FINFO_TYPE, dir)) == APR_SUCCESS) {
if ((strcmp((dp.name), ".") != 0) && (strcmp((dp.name), "..") != 0)) {
char subdir[strlen(directory) + strlen(dp.name) + 2];
strcpy(subdir, directory);
strcat(subdir, "/");
strcat(subdir, dp.name);
if (dp.filetype == APR_DIR) {
deploymentAdmin_deleteTree(subdir, mp);
} else {
remove(subdir);
}
}
}
remove(directory);
} else {
status = CELIX_FILE_IO_EXCEPTION;
}
} else {
status = CELIX_ILLEGAL_ARGUMENT;
}
return status;
}
static apt_bool_t test_dir_process(apt_test_suite_t *suite, mrcp_resource_factory_t *factory, mrcp_version_e version)
{
apr_status_t rv;
apr_dir_t *dir;
const char *dir_name = "v2";
if(version == MRCP_VERSION_1) {
dir_name = "v1";
}
if(apr_dir_open(&dir,dir_name,suite->pool) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot Open Directory [%s]",dir_name);
return FALSE;
}
do {
apr_finfo_t finfo;
rv = apr_dir_read(&finfo,APR_FINFO_DIRENT,dir);
if(rv == APR_SUCCESS) {
if(finfo.filetype == APR_REG && finfo.name) {
char *file_path;
apr_filepath_merge(&file_path,dir_name,finfo.name,0,suite->pool);
test_file_process(suite,factory,version,file_path);
printf("\nPress ENTER to continue\n");
getchar();
}
}
}
while(rv == APR_SUCCESS);
apr_dir_close(dir);
return TRUE;
}
SWITCH_DECLARE(const char *) switch_dir_next_file(switch_dir_t *thedir, char *buf, switch_size_t len)
{
const char *fname = NULL;
apr_int32_t finfo_flags = APR_FINFO_DIRENT | APR_FINFO_TYPE | APR_FINFO_NAME;
const char *name;
while (apr_dir_read(&(thedir->finfo), finfo_flags, thedir->dir_handle) == SWITCH_STATUS_SUCCESS) {
if (thedir->finfo.filetype != APR_REG) {
continue;
}
if (!(name = thedir->finfo.fname)) {
name = thedir->finfo.name;
}
if (!name) {
continue;
}
if (name) {
switch_copy_string(buf, name, len);
fname = buf;
break;
} else {
continue;
}
}
return fname;
}
void mapcache_locker_disk_clear_all_locks(mapcache_context *ctx, mapcache_locker *self) {
mapcache_locker_disk *ldisk = (mapcache_locker_disk*)self;
apr_dir_t *lockdir;
char errmsg[120];
apr_finfo_t finfo;
apr_status_t rv = apr_dir_open(&lockdir,ldisk->dir,ctx->pool);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx,500, "failed to open lock directory %s: %s" ,ldisk->dir,apr_strerror(rv,errmsg,120));
return;
}
while ((apr_dir_read(&finfo, APR_FINFO_DIRENT|APR_FINFO_TYPE|APR_FINFO_NAME, lockdir)) == APR_SUCCESS) {
if(finfo.filetype == APR_REG) {
if(!strncmp(finfo.name, MAPCACHE_LOCKFILE_PREFIX, strlen(MAPCACHE_LOCKFILE_PREFIX))) {
ctx->log(ctx,MAPCACHE_WARN,"found old lockfile %s/%s, deleting it",ldisk->dir,
finfo.name);
rv = apr_file_remove(apr_psprintf(ctx->pool,"%s/%s",ldisk->dir, finfo.name),ctx->pool);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx,500, "failed to remove lockfile %s: %s",finfo.name,apr_strerror(rv,errmsg,120));
return;
}
}
}
}
apr_dir_close(lockdir);
}
// Find all files start with 'gpdb-alert' under GPMON_LOG directory, sort it and
// remove the latest one 'gpdb-alert-*.csv' as it is still used by GPDB.
static void get_alert_log_tail_files(apr_array_header_t *tail_files, apr_pool_t *pool)
{
apr_dir_t *dir;
apr_status_t status = apr_dir_open(&dir, GPMON_LOG, pool);
if (status != APR_SUCCESS)
{
gpmon_warningx(FLINE, status, "failed opening directory:%s", GPMON_LOG);
return;
}
apr_finfo_t dirent;
static const char gpdb_prefix[] = "gpdb-alert";
while (apr_dir_read(&dirent, APR_FINFO_DIRENT, dir) == APR_SUCCESS)
{
if (strncmp(dirent.name, gpdb_prefix, sizeof(gpdb_prefix) - 1) == 0)
{
void *file_slot = apr_array_push(tail_files);
if (! file_slot)
{
gpmon_warningx(FLINE, 0, "failed getting alert tail log:%s due to out of memory", dirent.name);
continue;
}
(*(const char**)file_slot) = apr_pstrcat(pool, GPMON_LOG, "/", dirent.name, NULL);
}
}
// We only want to use qsort in stdlib.h, not the macro qsort in port.h.
(qsort)(tail_files->elts, tail_files->nelts, tail_files->elt_size, cmp_string);
(void)apr_array_pop(tail_files);
apr_dir_close(dir);
}
static apt_bool_t test_dir_process(apt_test_suite_t *suite)
{
apr_status_t rv;
apr_dir_t *dir;
const char *dir_name = "msg";
if(apr_dir_open(&dir,dir_name,suite->pool) != APR_SUCCESS) {
apt_log(APT_PRIO_WARNING,"Cannot Open Directory [%s]",dir_name);
return FALSE;
}
do {
apr_finfo_t finfo;
rv = apr_dir_read(&finfo,APR_FINFO_DIRENT,dir);
if(rv == APR_SUCCESS) {
if(finfo.filetype == APR_REG && finfo.name) {
char *file_path;
apr_filepath_merge(&file_path,dir_name,finfo.name,0,suite->pool);
test_file_process(suite,file_path);
}
}
}
while(rv == APR_SUCCESS);
apr_dir_close(dir);
return TRUE;
}
static void test_rewind(abts_case *tc, void *data)
{
apr_dir_t *dir;
apr_finfo_t first, second;
APR_ASSERT_SUCCESS(tc, "apr_dir_open failed", apr_dir_open(&dir, "data", p));
APR_ASSERT_SUCCESS(tc, "apr_dir_read failed",
apr_dir_read(&first, APR_FINFO_DIRENT, dir));
APR_ASSERT_SUCCESS(tc, "apr_dir_rewind failed", apr_dir_rewind(dir));
APR_ASSERT_SUCCESS(tc, "second apr_dir_read failed",
apr_dir_read(&second, APR_FINFO_DIRENT, dir));
APR_ASSERT_SUCCESS(tc, "apr_dir_close failed", apr_dir_close(dir));
ABTS_STR_EQUAL(tc, first.name, second.name);
}
apr_status_t kahanaIOReadDir( apr_pool_t *p, kDir_t **newDirObj, const char *path, apr_int32_t wanted, ... )
{
apr_dir_t *dir = NULL;
kDir_t *dirObj = NULL;
apr_pool_t *sp = NULL;
apr_status_t rc;
if( ( rc = apr_dir_open( &dir, dirObj->path, p ) ) ){
kahanaLogPut( NULL, NULL, "failed to apr_dir_open(): %s", STRERROR_APR( rc ) );
}
else if( ( rc = kahanaMalloc( p, sizeof( kDir_t ), (void**)&dirObj, &sp ) ) ){
kahanaLogPut( NULL, NULL, "failed to kahanaMalloc(): %s", STRERROR_APR( rc ) );
}
else
{
apr_filetype_e type;
va_list types;
dirObj->p = sp;
dirObj->files = apr_array_make( sp, 0, sizeof( apr_finfo_t ) );
dirObj->path = (const char*)apr_pstrdup( sp, path );
*newDirObj = dirObj;
do
{
apr_finfo_t finfo = { 0 };
if( ( rc = apr_dir_read( &finfo, wanted, dir ) ) ){
kahanaLogPut( NULL, NULL, "failed to apr_dir_read(): %s", STRERROR_APR( rc ) );
break;
}
else
{
va_start( types, wanted );
while( ( type = va_arg( types, apr_filetype_e ) ) )
{
if( finfo.filetype == type ){
APR_ARRAY_PUSH( dirObj->files, apr_finfo_t ) = finfo;
break;
}
}
va_end( types );
}
} while( rc == APR_SUCCESS );
rc = ( rc == APR_ENOENT ) ? APR_SUCCESS : rc;
if( ( rc = apr_dir_close( dir ) ) ){
kahanaLogPut( NULL, NULL, "failed to apr_dir_close(): %s", STRERROR_APR( rc ) );
}
}
return rc;
}
bool read(FileInfo& entryInfo){
// Calling check_apr frequently prints out "No such file or directory"
// messages, so disabling for now...
if(APR_SUCCESS ==
/*check_apr*/(apr_dir_read(&finfo, APR_FINFO_TYPE | APR_FINFO_NAME, dir)))
{
entryInfo.type(fromAPRFileType(finfo.filetype));
entryInfo.name(finfo.name);
return true;
}
return false;
}
void mapcache_configuration_parse(mapcache_context *ctx, const char *filename, mapcache_cfg *config, int cgi) {
apr_dir_t *lockdir;
apr_status_t rv;
char errmsg[120];
char *url;
mapcache_configuration_parse_xml(ctx,filename,config);
GC_CHECK_ERROR(ctx);
if(!config->lockdir || !strlen(config->lockdir)) {
config->lockdir = apr_pstrdup(ctx->pool, "/tmp");
}
rv = apr_dir_open(&lockdir,config->lockdir,ctx->pool);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx,500, "failed to open lock directory %s: %s"
,config->lockdir,apr_strerror(rv,errmsg,120));
return;
}
/* only remove lockfiles if we're not in cgi mode */
if(!cgi) {
apr_finfo_t finfo;
while ((apr_dir_read(&finfo, APR_FINFO_DIRENT|APR_FINFO_TYPE|APR_FINFO_NAME, lockdir)) == APR_SUCCESS) {
if(finfo.filetype == APR_REG) {
if(!strncmp(finfo.name, MAPCACHE_LOCKFILE_PREFIX, strlen(MAPCACHE_LOCKFILE_PREFIX))) {
ctx->log(ctx,MAPCACHE_WARN,"found old lockfile %s/%s, deleting it",config->lockdir,
finfo.name);
rv = apr_file_remove(apr_psprintf(ctx->pool,"%s/%s",config->lockdir, finfo.name),ctx->pool);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx,500, "failed to remove lockfile %s: %s",finfo.name,apr_strerror(rv,errmsg,120));
return;
}
}
}
}
}
apr_dir_close(lockdir);
/* if we were suppplied with an onlineresource, make sure it ends with a / */
if(NULL != (url = (char*)apr_table_get(config->metadata,"url"))) {
char *urlend = url + strlen(url)-1;
if(*urlend != '/') {
url = apr_pstrcat(ctx->pool,url,"/",NULL);
apr_table_setn(config->metadata,"url",url);
}
}
}
// Multicast index handler
static int multicast_index_handler(request_rec *rec)
{
multicast_conf* conf = ap_get_module_config(rec->per_dir_config, &multicast_index_module);
apr_status_t status = APR_SUCCESS;
apr_finfo_t finfo;
apr_dir_t* dir;
if(strcasecmp(rec->handler, MULTICAST_INDEX)) return DECLINED;
if(!conf || !conf->enabled) return DECLINED;
if(rec->method_number!=M_GET) return DECLINED;
// setup content-type of response.
rec->content_type = "text/json";
// do request
status = apr_dir_open(&dir, rec->filename, rec->pool);
if(status!=APR_SUCCESS) {
// 404 Not Found.
rec->status = HTTP_NOT_FOUND;
return multicast_404_not_found(rec, conf);
}
// 200 OK.
if(!rec->header_only) {
int the_first = TRUE;
ap_rputs("[", rec);
while((status=apr_dir_read(&finfo, APR_FINFO_NAME|APR_FINFO_TYPE, dir))==APR_SUCCESS) {
if((strcmp(finfo.name, ".")==0) || (strcmp(finfo.name, "..")==0)) continue;
if(the_first) { the_first = FALSE; } else { ap_rputs(",", rec); }
switch(finfo.filetype) {
case APR_DIR:
ap_rprintf(rec, "\"%s/\"", finfo.name);
break;
case APR_REG:
ap_rprintf(rec, "\"%s\"", finfo.name);
break;
case APR_LNK:
ap_rprintf(rec, "\"%s@\"", finfo.name);
break;
default:
break;
}
}
ap_rputs("]\n", rec);
rec->status = HTTP_OK;
}
apr_dir_close(dir);
return multicast_200_ok(rec, conf);
}
/*
* get a list of configured OIDC providers based on the entries in the provider metadata directory
*/
apr_byte_t oidc_metadata_list(request_rec *r, oidc_cfg *cfg,
apr_array_header_t **list) {
apr_status_t rc;
apr_dir_t *dir;
apr_finfo_t fi;
char s_err[128];
oidc_debug(r, "enter");
/* open the metadata directory */
if ((rc = apr_dir_open(&dir, cfg->metadata_dir, r->pool)) != APR_SUCCESS) {
oidc_error(r, "error opening metadata directory '%s' (%s)",
cfg->metadata_dir, apr_strerror(rc, s_err, sizeof(s_err)));
return FALSE;
}
/* allocate some space in the array that will hold the list of providers */
*list = apr_array_make(r->pool, 5, sizeof(sizeof(const char*)));
/* BTW: we could estimate the number in the array based on # directory entries... */
/* loop over the entries in the provider metadata directory */
while (apr_dir_read(&fi, APR_FINFO_NAME, dir) == APR_SUCCESS) {
/* skip "." and ".." entries */
if (fi.name[0] == '.')
continue;
/* skip other non-provider entries */
char *ext = strrchr(fi.name, '.');
if ((ext == NULL)
|| (strcmp(++ext, OIDC_METADATA_SUFFIX_PROVIDER) != 0))
continue;
/* get the issuer from the filename */
const char *issuer = oidc_metadata_filename_to_issuer(r, fi.name);
/* get the provider and client metadata, do all checks and registration if possible */
oidc_provider_t *provider = NULL;
if (oidc_metadata_get(r, cfg, issuer, &provider) == TRUE) {
/* push the decoded issuer filename in to the array */
*(const char**) apr_array_push(*list) = provider->issuer;
}
}
/* we're done, cleanup now */
apr_dir_close(dir);
return TRUE;
}
term_t bif_list_dir1(term_t Dir, process_t *ctx)
{
apr_status_t rs;
apr_pool_t *p;
const char *path;
apr_dir_t *dir;
term_t r = nil;
term_t cons = nil;
if (!is_string(Dir))
return A_BADARG;
apr_pool_create(&p, 0);
path = ltoz(Dir, p);
rs = apr_dir_open(&dir, path, p);
if (rs == 0)
{
apr_finfo_t fi;
for (;;)
{
rs = apr_dir_read(&fi, APR_FINFO_NAME | APR_FINFO_SIZE, dir);
if (rs == 0 || APR_STATUS_IS_INCOMPLETE(rs))
{
term_t name = ztol(fi.name, proc_gc_pool(ctx));
lst_add(r, cons, name, proc_gc_pool(ctx));
}
if (APR_STATUS_IS_ENOENT(rs))
{
rs = APR_SUCCESS;
break;
}
}
apr_dir_close(dir);
}
if (rs != 0 && !APR_STATUS_IS_ENOENT(rs))
result(make_tuple2(A_ERROR, decipher_status(rs), proc_gc_pool(ctx)));
else
result(make_tuple2(A_OK, r, proc_gc_pool(ctx)));
apr_pool_destroy(p);
return AI_OK;
}
term_t bif_list_dir3_0_1(term_t Dir, process_t *ctx)
{
apr_status_t rs;
apr_pool_t *p;
const char *path;
apr_dir_t *dir;
term_t r = nil;
term_t cons = nil;
apr_uint32_t wanted = APR_FINFO_MTIME | APR_FINFO_CTIME | APR_FINFO_ATIME |
APR_FINFO_NAME | APR_FINFO_SIZE | APR_FINFO_TYPE |
APR_FINFO_USER | APR_FINFO_GROUP | APR_FINFO_PROT;
if (!is_string(Dir))
return A_BADARG;
apr_pool_create(&p, 0);
path = ltoz(Dir, p);
rs = apr_dir_open(&dir, path, p);
if (rs == 0)
{
apr_finfo_t fi;
for (;;)
{
rs = apr_dir_read(&fi, wanted, dir);
if (rs == 0 || APR_STATUS_IS_INCOMPLETE(rs))
{
term_t file_info = make_file_info(&fi, proc_gc_pool(ctx));
lst_add(r, cons, file_info, proc_gc_pool(ctx));
}
else if (APR_STATUS_IS_ENOENT(rs))
{
rs = 0;
break;
}
}
apr_dir_close(dir);
}
if (rs != 0)
result(make_tuple2(A_ERROR, decipher_status(rs), proc_gc_pool(ctx)));
else
result(make_tuple2(A_OK, r, proc_gc_pool(ctx)));
apr_pool_destroy(p);
return AI_OK;
}
/* Find all files matching the specified pattern */
APR_DECLARE(apr_status_t) apr_match_glob(const char *pattern,
apr_array_header_t **result,
apr_pool_t *p)
{
apr_dir_t *dir;
apr_finfo_t finfo;
apr_status_t rv;
char *path;
/* XXX So, this is kind of bogus. Basically, I need to strip any leading
* directories off the pattern, but there is no portable way to do that.
* So, for now we just find the last occurance of '/' and if that doesn't
* return anything, then we look for '\'. This means that we could
* screw up on unix if the pattern is something like "foo\.*" That '\'
* isn't a directory delimiter, it is a part of the filename. To fix this,
* we really need apr_filepath_basename, which will be coming as soon as
* I get to it. rbb
*/
char *idx = strrchr(pattern, '/');
if (idx == NULL) {
idx = strrchr(pattern, '\\');
}
if (idx == NULL) {
path = ".";
}
else {
path = apr_pstrndup(p, pattern, idx - pattern);
pattern = idx + 1;
}
*result = apr_array_make(p, 0, sizeof(char *));
rv = apr_dir_open(&dir, path, p);
if (rv != APR_SUCCESS) {
return rv;
}
while (apr_dir_read(&finfo, APR_FINFO_NAME, dir) == APR_SUCCESS) {
if (apr_fnmatch(pattern, finfo.name, 0) == APR_SUCCESS) {
*(const char **)apr_array_push(*result) = apr_pstrdup(p, finfo.name);
}
}
apr_dir_close(dir);
return APR_SUCCESS;
}
term_t bif_list_dir2_1(term_t Dir, process_t *ctx)
{
apr_status_t rs;
apr_pool_t *p;
const char *path;
apr_dir_t *dir;
term_t r = nil;
if (!is_string(Dir))
return A_BADARG;
apr_pool_create(&p, 0);
path = ltoz(Dir, p);
rs = apr_dir_open(&dir, path, p);
if (rs == 0)
{
term_t cons = nil;
apr_finfo_t fi;
for (;;)
{
term_t v;
term_t name;
rs = apr_dir_read(&fi, APR_FINFO_NAME | APR_FINFO_SIZE, dir);
if (rs != 0)
break;
name = ztol(fi.name, proc_gc_pool(ctx));
if (fi.filetype == APR_DIR)
v = make_tuple2(A_DIR, name, proc_gc_pool(ctx));
else if (fi.filetype == APR_REG)
v = make_tuple3(A_FILE, name, intnum(fi.size), proc_gc_pool(ctx)); //TODO: large size
else
v = make_tuple2(A_UNKNOWN, name, proc_gc_pool(ctx));
lst_add(r, cons, v, proc_gc_pool(ctx));
}
apr_dir_close(dir);
}
if (rs != 0 && !APR_STATUS_IS_ENOENT(rs))
result(make_tuple2(A_ERROR, decipher_status(rs), proc_gc_pool(ctx)));
else
result(make_tuple2(A_OK, r, proc_gc_pool(ctx)));
apr_pool_destroy(p);
return AI_OK;
}
List* read_dir(apr_pool_t* pool, List* file_list, const char* dir_path, int* count, error_messages_t* error_messages){
apr_status_t rv;
char errorbuf [255];
apr_dir_t *dir;
apr_finfo_t filef;
char* file_path;
rv = apr_dir_open(&dir, dir_path, pool);
if (rv != 0){
apr_strerror(rv, (char *)&errorbuf, 255);
error_messages_add(error_messages, ERROR,apr_psprintf(pool, "Error opening directory (%s) (%d)", dir_path, rv), errorbuf);
return NULL;
}
//Read file is directory
while (apr_dir_read(&filef, APR_FINFO_TYPE | APR_FINFO_NAME | APR_FINFO_MTIME, dir) == 0){
file_path = apr_pstrcat(pool, dir_path, "/", filef.name, NULL);
if (file_path == NULL){
return NULL;
///BIG ERROR
}
//Is a Directory
if (filef.filetype == APR_DIR){
if(filef.name[0] != '.'){
file_list = read_dir(pool, file_list, file_path, count, error_messages);
}
}
//Is a File
if (filef.filetype == APR_REG){
List* file_list_new;
(*count)++;
file_list_new = apr_pcalloc(pool, sizeof(List));
file_list->file.path = file_path;
file_list->file.mtime = filef.mtime;
file_list->file.type = get_file_ext(pool,file_path);
file_list->next = file_list_new;
file_list = file_list_new;
}
}
rv = apr_dir_close(dir);
return file_list;
}
int glob(const std::string& regex, FileList& result, bool recursive=true) {
std::regex e(regex);
if (dir && APR_SUCCESS == check_apr(apr_dir_open(&dir, dirname.c_str(), mPool))) {
// iterate over directory:
while (APR_SUCCESS == (apr_dir_read(&dirent, APR_FINFO_TYPE|APR_FINFO_NAME, dir))) {
//printf("test %s %s\n", dirname.c_str(), dirent.name);
if (dirent.filetype == APR_REG && dirent.name && std::regex_match(dirname+dirent.name,e) ) {
FilePath res;
res.file(dirent.name);
res.path(dirname);
result.add(res);
} else if (recursive && dirent.filetype == APR_DIR && dirent.name && dirent.name[0] != '.') {
Path path(dirname + dirent.name + AL_FILE_DELIMITER);
path.glob(regex, result, true);
}
}
} else {
AL_WARN("couldn't open directory %s", dirname.c_str());
}
return result.count();
}
bool find(const std::string& name, FilePath& result, bool recursive=true) {
bool found = false;
if (dir && APR_SUCCESS == check_apr(apr_dir_open(&dir, dirname.c_str(), mPool))) {
// iterate over directory:
while ((!found) && APR_SUCCESS == (apr_dir_read(&dirent, APR_FINFO_TYPE|APR_FINFO_NAME, dir))) {
//printf("test %s %s\n", dirname.c_str(), dirent.name);
if (dirent.filetype == APR_REG && dirent.name && std::string(dirent.name) == name) {
result.file(dirent.name);
result.path(dirname);
found = true;
break;
} else if (recursive && dirent.filetype == APR_DIR && dirent.name && dirent.name[0] != '.') {
Path path(dirname + dirent.name + AL_FILE_DELIMITER);
found = path.find(name, result, true);
}
}
} else {
printf("couldn't open directory %s\n", dirname.c_str());
}
return found;
}
static int add_ldap_certs(abts_case *tc)
{
apr_status_t status;
apr_dir_t *thedir;
apr_finfo_t dirent;
apr_ldap_err_t *result = NULL;
if ((status = apr_dir_open(&thedir, DIRNAME, p)) == APR_SUCCESS) {
apr_ldap_opt_tls_cert_t *cert = (apr_ldap_opt_tls_cert_t *)apr_pcalloc(p, sizeof(apr_ldap_opt_tls_cert_t));
do {
status = apr_dir_read(&dirent, APR_FINFO_MIN | APR_FINFO_NAME, thedir);
if (APR_STATUS_IS_INCOMPLETE(status)) {
continue; /* ignore un-stat()able files */
}
else if (status != APR_SUCCESS) {
break;
}
if (strstr(dirent.name, ".der")) {
cert->type = APR_LDAP_CA_TYPE_DER;
cert->path = apr_pstrcat (p, DIRNAME, "/", dirent.name, NULL);
apr_ldap_set_option(p, NULL, APR_LDAP_OPT_TLS_CERT, (void *)cert, &result);
ABTS_TRUE(tc, result->rc == LDAP_SUCCESS);
}
if (strstr(dirent.name, ".b64")) {
cert->type = APR_LDAP_CA_TYPE_BASE64;
cert->path = apr_pstrcat (p, DIRNAME, "/", dirent.name, NULL);
apr_ldap_set_option(p, NULL, APR_LDAP_OPT_TLS_CERT, (void *)cert, &result);
ABTS_TRUE(tc, result->rc == LDAP_SUCCESS);
}
} while (1);
apr_dir_close(thedir);
}
return 0;
}
static int dir_read(lua_State *L)
{
apr_status_t status;
lua_apr_dir *directory;
lua_apr_stat_context *context, backup_ctx;
int raise_errors;
directory = checkdir(L, 1, 1);
if (lua_isuserdata(L, lua_upvalueindex(1))) {
/* Iterator for directory:entries() */
context = lua_touserdata(L, lua_upvalueindex(1));
raise_errors = 1;
} else {
/* Standalone call to directory:read() */
backup_ctx.firstarg = 2;
backup_ctx.lastarg = lua_gettop(L);
check_stat_request(L, &backup_ctx);
context = &backup_ctx;
raise_errors = 0;
}
for (;;) {
status = apr_dir_read(&context->info, context->wanted, directory->handle);
if (APR_SUCCESS == status || APR_STATUS_IS_INCOMPLETE(status)) {
if (!(context->info.valid & APR_FINFO_NAME \
&& filename_symbolic(context->info.name)))
return push_stat_results(L, context, directory->filepath);
} else if (APR_STATUS_IS_ENOENT(status)) {
return 0;
} else if (raise_errors) {
return raise_error_status(L, status);
} else {
return push_error_status(L, status);
}
}
}
bool UmcFramework::LoadScenarios()
{
apr_dir_t* pDir;
apr_finfo_t finfo;
apr_status_t rv;
const char* pDirPath;
pDirPath = apt_dir_layout_path_compose(m_pDirLayout,APT_LAYOUT_CONF_DIR,"umc-scenarios",m_pPool);
if(!pDirPath)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Compose Config File Path");
return false;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Enter Directory [%s]",pDirPath);
rv = apr_dir_open(&pDir,pDirPath,m_pPool);
if(rv != APR_SUCCESS)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Such Directory %s",pDirPath);
return false;
}
while(apr_dir_read(&finfo,APR_FINFO_NAME,pDir) == APR_SUCCESS)
{
if(apr_fnmatch("*.xml",finfo.name,0) == APR_SUCCESS) {
char* pFilePath;
if(apr_filepath_merge(&pFilePath,pDirPath,finfo.name,APR_FILEPATH_NATIVE,m_pPool) == APR_SUCCESS)
{
LoadScenario(pFilePath);
}
}
}
apr_dir_close(pDir);
return true;
}
/** Load UniMRCP client */
static apt_bool_t unimrcp_client_load(unimrcp_client_loader_t *loader, const char *dir_path, const char *file_name, apr_pool_t *pool)
{
apr_xml_doc *doc;
const apr_xml_elem *elem;
const apr_xml_elem *root;
const apr_xml_attr *attr;
const char *file_path;
const char *version = NULL;
const char *subfolder = NULL;
if(!dir_path || !file_name) {
return FALSE;
}
if(*dir_path == '\0') {
file_path = file_name;
}
else {
file_path = apr_psprintf(pool,"%s/%s",dir_path,file_name);
}
/* Parse XML document */
doc = unimrcp_client_doc_parse(file_path,pool);
if(!doc) {
return FALSE;
}
root = doc->root;
/* Match document name */
if(!root || strcasecmp(root->name,"unimrcpclient") != 0) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown Document <%s>",root->name);
return FALSE;
}
/* Read attributes */
for(attr = root->attr; attr; attr = attr->next) {
if(strcasecmp(attr->name,"version") == 0) {
version = attr->value;
}
else if(strcasecmp(attr->name,"subfolder") == 0) {
subfolder = attr->value;
}
}
/* Check version number first */
if(!version) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown Version");
return FALSE;
}
loader->doc = doc;
/* Navigate through document */
for(elem = root->first_child; elem; elem = elem->next) {
if(strcasecmp(elem->name,"properties") == 0) {
unimrcp_client_properties_load(loader,elem);
}
else if(strcasecmp(elem->name,"components") == 0) {
unimrcp_client_components_load(loader,elem);
}
else if(strcasecmp(elem->name,"settings") == 0) {
unimrcp_client_settings_load(loader,elem);
}
else if(strcasecmp(elem->name,"profiles") == 0) {
unimrcp_client_profiles_load(loader,elem);
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown Element <%s>",elem->name);
}
}
if(subfolder && subfolder != '\0') {
apr_dir_t *dir;
apr_finfo_t finfo;
apr_status_t rv;
dir_path = apr_psprintf(pool,"%s/%s",dir_path,subfolder);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Enter Directory [%s]",dir_path);
rv = apr_dir_open(&dir,dir_path,pool);
if(rv == APR_SUCCESS) {
while(apr_dir_read(&finfo, APR_FINFO_NAME, dir) == APR_SUCCESS) {
if(apr_fnmatch("*.xml", finfo.name, 0) == APR_SUCCESS) {
unimrcp_client_load(loader,dir_path,finfo.name,pool);
}
}
apr_dir_close(dir);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Leave Directory [%s]",dir_path);
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Such Directory %s",dir_path);
}
}
return TRUE;
}
/*
* walk the cache directory tree
*/
static int process_dir(char *path, apr_pool_t *pool)
{
apr_dir_t *dir;
apr_pool_t *p;
apr_hash_t *h;
apr_hash_index_t *i;
apr_file_t *fd;
apr_status_t status;
apr_finfo_t info;
apr_size_t len;
apr_time_t current, deviation;
char *nextpath, *base, *ext, *orig_basename;
APR_RING_ENTRY(_direntry) anchor;
DIRENTRY *d, *t, *n;
ENTRY *e;
int skip, retries;
disk_cache_info_t disk_info;
APR_RING_INIT(&anchor, _direntry, link);
apr_pool_create(&p, pool);
h = apr_hash_make(p);
fd = NULL;
skip = 0;
deviation = MAXDEVIATION * APR_USEC_PER_SEC;
if (apr_dir_open(&dir, path, p) != APR_SUCCESS) {
return 1;
}
while (apr_dir_read(&info, 0, dir) == APR_SUCCESS && !interrupted) {
if (!strcmp(info.name, ".") || !strcmp(info.name, "..")) {
continue;
}
d = apr_pcalloc(p, sizeof(DIRENTRY));
d->basename = apr_pstrcat(p, path, "/", info.name, NULL);
APR_RING_INSERT_TAIL(&anchor, d, _direntry, link);
}
apr_dir_close(dir);
if (interrupted) {
return 1;
}
skip = baselen + 1;
for (d = APR_RING_FIRST(&anchor);
!interrupted && d != APR_RING_SENTINEL(&anchor, _direntry, link);
d=n) {
n = APR_RING_NEXT(d, link);
base = strrchr(d->basename, '/');
if (!base++) {
base = d->basename;
}
ext = strchr(base, '.');
/* there may be temporary files which may be gone before
* processing, always skip these if not in realclean mode
*/
if (!ext && !realclean) {
if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
&& strlen(base) == AP_TEMPFILE_NAMELEN) {
continue;
}
}
/* this may look strange but apr_stat() may return errno which
* is system dependent and there may be transient failures,
* so just blindly retry for a short while
*/
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, d->basename, DIRINFO, p);
} while (status != APR_SUCCESS && !interrupted && --retries);
/* what may happen here is that apache did create a file which
* we did detect but then does delete the file before we can
* get file information, so if we don't get any file information
* we will ignore the file in this case
*/
if (status != APR_SUCCESS) {
if (!realclean && !interrupted) {
continue;
}
return 1;
}
if (info.filetype == APR_DIR) {
/* Make a copy of the basename, as process_dir modifies it */
orig_basename = apr_pstrdup(pool, d->basename);
if (process_dir(d->basename, pool)) {
return 1;
}
/* If asked to delete dirs, do so now. We don't care if it fails.
* If it fails, it likely means there was something else there.
*/
if (deldirs && !dryrun) {
apr_dir_remove(orig_basename, pool);
}
continue;
}
if (info.filetype != APR_REG) {
continue;
}
if (!ext) {
if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
&& strlen(base) == AP_TEMPFILE_NAMELEN) {
d->basename += skip;
d->type = TEMP;
d->dsize = info.size;
apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
}
continue;
}
if (!strcasecmp(ext, CACHE_HEADER_SUFFIX)) {
*ext = '\0';
d->basename += skip;
/* if a user manually creates a '.header' file */
if (d->basename[0] == '\0') {
continue;
}
t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);
if (t) {
d = t;
}
d->type |= HEADER;
d->htime = info.mtime;
d->hsize = info.size;
apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
continue;
}
if (!strcasecmp(ext, CACHE_DATA_SUFFIX)) {
*ext = '\0';
d->basename += skip;
/* if a user manually creates a '.data' file */
if (d->basename[0] == '\0') {
continue;
}
t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);
if (t) {
d = t;
}
d->type |= DATA;
d->dtime = info.mtime;
d->dsize = info.size;
apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
}
}
if (interrupted) {
return 1;
}
path[baselen] = '\0';
for (i = apr_hash_first(p, h); i && !interrupted; i = apr_hash_next(i)) {
void *hvalue;
apr_uint32_t format;
apr_hash_this(i, NULL, NULL, &hvalue);
d = hvalue;
switch(d->type) {
case HEADERDATA:
nextpath = apr_pstrcat(p, path, "/", d->basename,
CACHE_HEADER_SUFFIX, NULL);
if (apr_file_open(&fd, nextpath, APR_FOPEN_READ | APR_FOPEN_BINARY,
APR_OS_DEFAULT, p) == APR_SUCCESS) {
len = sizeof(format);
if (apr_file_read_full(fd, &format, len,
&len) == APR_SUCCESS) {
if (format == DISK_FORMAT_VERSION) {
apr_off_t offset = 0;
apr_file_seek(fd, APR_SET, &offset);
len = sizeof(disk_cache_info_t);
if (apr_file_read_full(fd, &disk_info, len,
&len) == APR_SUCCESS) {
apr_file_close(fd);
e = apr_palloc(pool, sizeof(ENTRY));
APR_RING_INSERT_TAIL(&root, e, _entry, link);
e->expire = disk_info.expire;
e->response_time = disk_info.response_time;
e->htime = d->htime;
e->dtime = d->dtime;
e->hsize = d->hsize;
e->dsize = d->dsize;
e->basename = apr_pstrdup(pool, d->basename);
break;
}
else {
apr_file_close(fd);
}
}
else if (format == VARY_FORMAT_VERSION) {
/* This must be a URL that added Vary headers later,
* so kill the orphaned .data file
*/
apr_file_close(fd);
apr_file_remove(apr_pstrcat(p, path, "/", d->basename,
CACHE_DATA_SUFFIX, NULL),
p);
}
}
else {
apr_file_close(fd);
}
}
/* we have a somehow unreadable headers file which is associated
* with a data file. this may be caused by apache currently
* rewriting the headers file. thus we may delete the file set
* either in realclean mode or if the headers file modification
* timestamp is not within a specified positive or negative offset
* to the current time.
*/
current = apr_time_now();
if (realclean || d->htime < current - deviation
|| d->htime > current + deviation) {
delete_entry(path, d->basename, p);
unsolicited += d->hsize;
unsolicited += d->dsize;
}
break;
/* single data and header files may be deleted either in realclean
* mode or if their modification timestamp is not within a
* specified positive or negative offset to the current time.
* this handling is necessary due to possible race conditions
* between apache and this process
*/
case HEADER:
current = apr_time_now();
nextpath = apr_pstrcat(p, path, "/", d->basename,
CACHE_HEADER_SUFFIX, NULL);
if (apr_file_open(&fd, nextpath, APR_FOPEN_READ | APR_FOPEN_BINARY,
APR_OS_DEFAULT, p) == APR_SUCCESS) {
len = sizeof(format);
if (apr_file_read_full(fd, &format, len,
&len) == APR_SUCCESS) {
if (format == VARY_FORMAT_VERSION) {
apr_time_t expires;
len = sizeof(expires);
apr_file_read_full(fd, &expires, len, &len);
apr_file_close(fd);
if (expires < current) {
delete_entry(path, d->basename, p);
}
break;
}
}
apr_file_close(fd);
}
if (realclean || d->htime < current - deviation
|| d->htime > current + deviation) {
delete_entry(path, d->basename, p);
unsolicited += d->hsize;
}
break;
case DATA:
current = apr_time_now();
if (realclean || d->dtime < current - deviation
|| d->dtime > current + deviation) {
delete_entry(path, d->basename, p);
unsolicited += d->dsize;
}
break;
/* temp files may only be deleted in realclean mode which
* is asserted above if a tempfile is in the hash array
*/
case TEMP:
delete_file(path, d->basename, p);
unsolicited += d->dsize;
break;
}
}
if (interrupted) {
return 1;
}
apr_pool_destroy(p);
if (benice) {
apr_sleep(NICE_DELAY);
}
if (interrupted) {
return 1;
}
return 0;
}
static int check_speling(request_rec *r)
{
spconfig *cfg;
char *good, *bad, *postgood, *url;
apr_finfo_t dirent;
int filoc, dotloc, urlen, pglen;
apr_array_header_t *candidates = NULL;
apr_dir_t *dir;
cfg = ap_get_module_config(r->per_dir_config, &speling_module);
if (!cfg->enabled) {
return DECLINED;
}
/* We only want to worry about GETs */
if (r->method_number != M_GET) {
return DECLINED;
}
/* We've already got a file of some kind or another */
if (r->finfo.filetype != APR_NOFILE) {
return DECLINED;
}
/* Not a file request */
if (r->proxyreq || !r->filename) {
return DECLINED;
}
/* This is a sub request - don't mess with it */
if (r->main) {
return DECLINED;
}
/*
* The request should end up looking like this:
* r->uri: /correct-url/mispelling/more
* r->filename: /correct-file/mispelling r->path_info: /more
*
* So we do this in steps. First break r->filename into two pieces
*/
filoc = ap_rind(r->filename, '/');
/*
* Don't do anything if the request doesn't contain a slash, or
* requests "/"
*/
if (filoc == -1 || strcmp(r->uri, "/") == 0) {
return DECLINED;
}
/* good = /correct-file */
good = apr_pstrndup(r->pool, r->filename, filoc);
/* bad = mispelling */
bad = apr_pstrdup(r->pool, r->filename + filoc + 1);
/* postgood = mispelling/more */
postgood = apr_pstrcat(r->pool, bad, r->path_info, NULL);
urlen = strlen(r->uri);
pglen = strlen(postgood);
/* Check to see if the URL pieces add up */
if (strcmp(postgood, r->uri + (urlen - pglen))) {
return DECLINED;
}
/* url = /correct-url */
url = apr_pstrndup(r->pool, r->uri, (urlen - pglen));
/* Now open the directory and do ourselves a check... */
if (apr_dir_open(&dir, good, r->pool) != APR_SUCCESS) {
/* Oops, not a directory... */
return DECLINED;
}
candidates = apr_array_make(r->pool, 2, sizeof(misspelled_file));
dotloc = ap_ind(bad, '.');
if (dotloc == -1) {
dotloc = strlen(bad);
}
while (apr_dir_read(&dirent, APR_FINFO_DIRENT, dir) == APR_SUCCESS) {
sp_reason q;
/*
* If we end up with a "fixed" URL which is identical to the
* requested one, we must have found a broken symlink or some such.
* Do _not_ try to redirect this, it causes a loop!
*/
if (strcmp(bad, dirent.name) == 0) {
apr_dir_close(dir);
return OK;
}
/*
* miscapitalization errors are checked first (like, e.g., lower case
* file, upper case request)
*/
else if (strcasecmp(bad, dirent.name) == 0) {
misspelled_file *sp_new;
sp_new = (misspelled_file *) apr_array_push(candidates);
sp_new->name = apr_pstrdup(r->pool, dirent.name);
sp_new->quality = SP_MISCAPITALIZED;
}
/*
* simple typing errors are checked next (like, e.g.,
* missing/extra/transposed char)
*/
else if ((cfg->check_case_only == 0)
&& ((q = spdist(bad, dirent.name)) != SP_VERYDIFFERENT)) {
misspelled_file *sp_new;
sp_new = (misspelled_file *) apr_array_push(candidates);
sp_new->name = apr_pstrdup(r->pool, dirent.name);
sp_new->quality = q;
}
/*
* The spdist() should have found the majority of the misspelled
* requests. It is of questionable use to continue looking for
* files with the same base name, but potentially of totally wrong
* type (index.html <-> index.db).
*
* If you're using MultiViews, and have a file named foobar.html,
* which you refer to as "foobar", and someone tried to access
* "Foobar", without CheckBasenameMatch, mod_speling won't find it,
* because it won't find anything matching that spelling.
* With the extension-munging, it would locate "foobar.html".
*/
else if ((cfg->check_case_only == 0) &&
(cfg->check_basename_match == 1)) {
/*
* Okay... we didn't find anything. Now we take out the hard-core
* power tools. There are several cases here. Someone might have
* entered a wrong extension (.htm instead of .html or vice
* versa) or the document could be negotiated. At any rate, now
* we just compare stuff before the first dot. If it matches, we
* figure we got us a match. This can result in wrong things if
* there are files of different content types but the same prefix
* (e.g. foo.gif and foo.html) This code will pick the first one
* it finds. Better than a Not Found, though.
*/
int entloc = ap_ind(dirent.name, '.');
if (entloc == -1) {
entloc = strlen(dirent.name);
}
if ((dotloc == entloc)
&& !strncasecmp(bad, dirent.name, dotloc)) {
misspelled_file *sp_new;
sp_new = (misspelled_file *) apr_array_push(candidates);
sp_new->name = apr_pstrdup(r->pool, dirent.name);
sp_new->quality = SP_VERYDIFFERENT;
}
}
}
apr_dir_close(dir);
if (candidates->nelts != 0) {
/* Wow... we found us a mispelling. Construct a fixed url */
char *nuri;
const char *ref;
misspelled_file *variant = (misspelled_file *) candidates->elts;
int i;
ref = apr_table_get(r->headers_in, "Referer");
qsort((void *) candidates->elts, candidates->nelts,
sizeof(misspelled_file), sort_by_quality);
/*
* Conditions for immediate redirection:
* a) the first candidate was not found by stripping the suffix
* AND b) there exists only one candidate OR the best match is not
* ambiguous
* then return a redirection right away.
*/
if (variant[0].quality != SP_VERYDIFFERENT
&& (candidates->nelts == 1
|| variant[0].quality != variant[1].quality)) {
nuri = ap_escape_uri(r->pool, apr_pstrcat(r->pool, url,
variant[0].name,
r->path_info, NULL));
if (r->parsed_uri.query)
nuri = apr_pstrcat(r->pool, nuri, "?", r->parsed_uri.query, NULL);
apr_table_setn(r->headers_out, "Location",
ap_construct_url(r->pool, nuri, r));
ap_log_rerror(APLOG_MARK, APLOG_INFO, APR_SUCCESS,
r,
ref ? "Fixed spelling: %s to %s from %s"
: "Fixed spelling: %s to %s%s",
r->uri, nuri,
(ref ? ref : ""));
return HTTP_MOVED_PERMANENTLY;
}
/*
* Otherwise, a "[300] Multiple Choices" list with the variants is
* returned.
*/
else {
apr_pool_t *p;
apr_table_t *notes;
apr_pool_t *sub_pool;
apr_array_header_t *t;
apr_array_header_t *v;
if (r->main == NULL) {
p = r->pool;
notes = r->notes;
}
else {
p = r->main->pool;
notes = r->main->notes;
}
if (apr_pool_create(&sub_pool, p) != APR_SUCCESS)
return DECLINED;
t = apr_array_make(sub_pool, candidates->nelts * 8 + 8,
sizeof(char *));
v = apr_array_make(sub_pool, candidates->nelts * 5,
sizeof(char *));
/* Generate the response text. */
*(const char **)apr_array_push(t) =
"The document name you requested (<code>";
*(const char **)apr_array_push(t) = ap_escape_html(sub_pool, r->uri);
*(const char **)apr_array_push(t) =
"</code>) could not be found on this server.\n"
"However, we found documents with names similar "
"to the one you requested.<p>"
"Available documents:\n<ul>\n";
for (i = 0; i < candidates->nelts; ++i) {
char *vuri;
const char *reason;
reason = sp_reason_str[(int) (variant[i].quality)];
/* The format isn't very neat... */
vuri = apr_pstrcat(sub_pool, url, variant[i].name, r->path_info,
(r->parsed_uri.query != NULL) ? "?" : "",
(r->parsed_uri.query != NULL)
? r->parsed_uri.query : "",
NULL);
*(const char **)apr_array_push(v) = "\"";
*(const char **)apr_array_push(v) = ap_escape_uri(sub_pool, vuri);
*(const char **)apr_array_push(v) = "\";\"";
*(const char **)apr_array_push(v) = reason;
*(const char **)apr_array_push(v) = "\"";
*(const char **)apr_array_push(t) = "<li><a href=\"";
*(const char **)apr_array_push(t) = ap_escape_uri(sub_pool, vuri);
*(const char **)apr_array_push(t) = "\">";
*(const char **)apr_array_push(t) = ap_escape_html(sub_pool, vuri);
*(const char **)apr_array_push(t) = "</a> (";
*(const char **)apr_array_push(t) = reason;
*(const char **)apr_array_push(t) = ")\n";
/*
* when we have printed the "close matches" and there are
* more "distant matches" (matched by stripping the suffix),
* then we insert an additional separator text to suggest
* that the user LOOK CLOSELY whether these are really the
* files she wanted.
*/
if (i > 0 && i < candidates->nelts - 1
&& variant[i].quality != SP_VERYDIFFERENT
&& variant[i + 1].quality == SP_VERYDIFFERENT) {
*(const char **)apr_array_push(t) =
"</ul>\nFurthermore, the following related "
"documents were found:\n<ul>\n";
}
}
*(const char **)apr_array_push(t) = "</ul>\n";
/* If we know there was a referring page, add a note: */
if (ref != NULL) {
*(const char **)apr_array_push(t) =
"Please consider informing the owner of the "
"<a href=\"";
*(const char **)apr_array_push(t) = ap_escape_uri(sub_pool, ref);
*(const char **)apr_array_push(t) = "\">referring page</a> "
"about the broken link.\n";
}
/* Pass our apr_table_t to http_protocol.c (see mod_negotiation): */
apr_table_setn(notes, "variant-list", apr_array_pstrcat(p, t, 0));
apr_table_mergen(r->subprocess_env, "VARIANTS",
apr_array_pstrcat(p, v, ','));
apr_pool_destroy(sub_pool);
ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
ref ? "Spelling fix: %s: %d candidates from %s"
: "Spelling fix: %s: %d candidates%s",
r->uri, candidates->nelts,
(ref ? ref : ""));
return HTTP_MULTIPLE_CHOICES;
}
}
return OK;
}
/** Process parsed XML document */
static apt_bool_t unimrcp_client_doc_process(unimrcp_client_loader_t *loader, const char *dir_path, apr_xml_doc *doc, apr_pool_t *pool)
{
const apr_xml_elem *elem;
const apr_xml_elem *root;
const apr_xml_attr *attr;
const char *version = NULL;
const char *subfolder = NULL;
if(!doc) {
return FALSE;
}
root = doc->root;
/* Match document name */
if(!root || strcasecmp(root->name,"unimrcpclient") != 0) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown Document <%s>",root ? root->name : "null");
return FALSE;
}
/* Read attributes */
for(attr = root->attr; attr; attr = attr->next) {
if(strcasecmp(attr->name,"version") == 0) {
version = attr->value;
}
else if(strcasecmp(attr->name,"subfolder") == 0) {
subfolder = attr->value;
}
}
/* Check version number first */
if(!version) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown Version");
return FALSE;
}
loader->doc = doc;
/* Navigate through document */
for(elem = root->first_child; elem; elem = elem->next) {
if(strcasecmp(elem->name,"properties") == 0) {
unimrcp_client_properties_load(loader,elem);
}
else if(strcasecmp(elem->name,"components") == 0) {
unimrcp_client_components_load(loader,elem);
}
else if(strcasecmp(elem->name,"settings") == 0) {
unimrcp_client_settings_load(loader,elem);
}
else if(strcasecmp(elem->name,"profiles") == 0) {
unimrcp_client_profiles_load(loader,elem);
}
else if(strcasecmp(elem->name,"misc") == 0) {
unimrcp_client_misc_load(loader,elem);
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown Element <%s>",elem->name);
}
}
if(subfolder && *subfolder != '\0') {
apr_dir_t *dir;
apr_finfo_t finfo;
apr_status_t rv;
char *subdir_path;
if (!dir_path) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Attempt to Process Subdirectory when "
"Creating from Config String");
return TRUE;
}
if(apr_filepath_merge(&subdir_path,dir_path,subfolder,APR_FILEPATH_NATIVE,pool) == APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Enter Directory [%s]",subdir_path);
rv = apr_dir_open(&dir,subdir_path,pool);
if(rv == APR_SUCCESS) {
while(apr_dir_read(&finfo, APR_FINFO_NAME, dir) == APR_SUCCESS) {
if(apr_fnmatch("*.xml", finfo.name, 0) == APR_SUCCESS) {
unimrcp_client_load(loader,subdir_path,finfo.name);
}
}
apr_dir_close(dir);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Leave Directory [%s]",dir_path);
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Such Directory %s",dir_path);
}
}
}
return TRUE;
}
void nx_expr_proc__xm_fileop_file_remove(nx_expr_eval_ctx_t *eval_ctx,
nx_module_t *module,
nx_expr_arg_list_t *args)
{
nx_expr_arg_t *arg;
nx_value_t file;
apr_status_t rv;
apr_pool_t *pool = NULL;
apr_dir_t *dir;
nx_exception_t e;
nx_string_t *dirname = NULL;
nx_string_t *fname = NULL;
char *filename;
char *idx;
int flags = 0;
apr_finfo_t finfo;
nx_expr_arg_t *older;
nx_value_t olderval;
apr_time_t older_time = 0LL;
ASSERT(module != NULL);
ASSERT(args != NULL);
arg = NX_DLIST_FIRST(args);
ASSERT(arg != NULL);
ASSERT(arg->expr != NULL);
nx_expr_evaluate(eval_ctx, &file, arg->expr);
if ( file.defined != TRUE )
{
throw_msg("'file' is undef");
}
try
{
if ( file.type != NX_VALUE_TYPE_STRING )
{
throw_msg("string type required for 'file'");
}
older = NX_DLIST_NEXT(arg, link);
if ( older != NULL )
{
ASSERT(older->expr != NULL);
nx_expr_evaluate(eval_ctx, &olderval, older->expr);
if ( olderval.type != NX_VALUE_TYPE_DATETIME )
{
nx_value_kill(&olderval);
throw_msg("datetime type required for 'older'");
}
if ( olderval.defined == TRUE )
{
older_time = olderval.datetime;
}
}
if ( apr_fnmatch_test(file.string->buf) != 0 )
{ // we have wildcards, expand it
pool = nx_pool_create_core();
filename = file.string->buf;
idx = strrchr(filename, '/');
#ifndef WIN32
flags = APR_FNM_CASE_BLIND;
if ( idx == NULL )
{
idx = strrchr(filename, '\\');
}
#endif
if ( idx == NULL )
{
dirname = nx_string_create("."NX_DIR_SEPARATOR, -1);
}
else
{
dirname = nx_string_create(filename, (int) (idx + 1 - filename));
filename = idx + 1;
}
CHECKERR_MSG(apr_dir_open(&dir, dirname->buf, pool),
"failed to open directory: %s", dirname->buf);
fname = nx_string_new();
while ( apr_dir_read(&finfo, APR_FINFO_NAME | APR_FINFO_TYPE | APR_FINFO_CTIME,
dir) == APR_SUCCESS )
{
if ( finfo.filetype == APR_REG )
{
log_debug("checking '%s' against wildcard '%s':", finfo.name, filename);
if ( apr_fnmatch(filename, finfo.name, flags) == APR_SUCCESS )
{
nx_string_sprintf(fname, "%s%s", dirname->buf, finfo.name);
if ( (older_time == 0) ||
((older_time != 0) && (finfo.ctime < older_time)) )
{
log_debug("'%s' matches wildcard '%s' and is 'older', removing",
fname->buf, file.string->buf);
log_info("removing file %s", fname->buf);
rv = apr_file_remove(fname->buf, NULL);
if ( APR_STATUS_IS_ENOENT(rv) )
{
}
else if ( rv == APR_SUCCESS )
{
}
else
{
log_aprerror(rv, "failed to remove file '%s'", fname->buf);
}
_reopen_logfile(fname->buf);
}
}
}
}
nx_string_free(fname);
apr_pool_destroy(pool);
}
else
{
CHECKERR_MSG(apr_file_remove(file.string->buf, NULL),
"failed to remove file '%s'", file.string->buf);
}
}
catch(e)
{
nx_value_kill(&file);
if ( pool != NULL )
{
apr_pool_destroy(pool);
}
if ( dirname != NULL )
{
nx_string_free(dirname);
}
log_exception(e);
}
}
static int mediarss_index_directory(request_rec* r)
{
apr_status_t status;
apr_dir_t* dir;
apr_finfo_t dirent;
if ((status = apr_dir_open(&dir, r->filename, r->pool)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, "Can't open directory for index: %s", r->filename);
return HTTP_FORBIDDEN;
}
/* Content header */
char* url;
url = ap_construct_url(r->pool, r->uri, r);
ap_set_content_type(r, "text/xml; charset=utf-8");
ap_rputs("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n\n", r);
if (strcmp(r->args, "format=mediarss") == 0) {
ap_rputs("<rss version=\"2.0\" xmlns:media=\"http://search.yahoo.com/mrss/\">\n", r);
} else {
ap_rputs("<rss version=\"2.0\">\n", r);
}
ap_rputs(" <channel>\n", r);
ap_rvputs(r, " <title>Index of ", url, "</title>\n", NULL);
ap_rvputs(r, " <link>", url, "</link>\n", NULL);
/* Collect information about the files in the directory */
while (1)
{
status = apr_dir_read(&dirent, APR_FINFO_MIN | APR_FINFO_NAME, dir);
if (APR_STATUS_IS_INCOMPLETE(status)) {
continue; /* ignore un-stat()able files */
} else if (status != APR_SUCCESS) {
break;
}
/* We are only interested in regular files. TODO Deal with symlinks. */
if (dirent.filetype == APR_REG)
{
request_rec* rr;
rr = ap_sub_req_lookup_dirent(&dirent, r, AP_SUBREQ_NO_ARGS, NULL);
if (rr != NULL)
{
if (rr->finfo.filetype == APR_REG && rr->status == HTTP_OK)
{
/* In case of media rss, only include the item if it is a media type */
if (strcmp(r->args, "format=mediarss") == 0 && mediarss_is_media_content(rr->content_type) == 0) {
continue;
}
char size[16];
snprintf(size, sizeof(size), "%d", dirent.size);
char date[APR_RFC822_DATE_LEN];
apr_rfc822_date(date, dirent.mtime);
char* guid = ap_md5(r->pool, (unsigned char*) apr_pstrcat(r->pool, url, dirent.name, NULL));
ap_rputs(" <item>\n", r);
ap_rvputs(r, " <guid>", guid, "</guid>\n", NULL);
ap_rvputs(r, " <title>", dirent.name, "</title>\n", NULL);
ap_rvputs(r, " <pubDate>", date, "</pubDate>\n", NULL);
ap_rvputs(r, " <enclosure url=\"", url, dirent.name, "\" length=\"", size, "\"\n", NULL);
ap_rvputs(r, " type=\"", rr->content_type, "\"/>\n", NULL);
if (strcmp(r->args, "format=mediarss") == 0) {
ap_rvputs(r, " <media:content url=\"", url, dirent.name, "\" fileSize=\"", size, "\"\n", NULL);
ap_rvputs(r, " type=\"", rr->content_type, "\"/>\n", NULL);
}
ap_rputs(" </item>\n", r);
}
ap_destroy_sub_req(rr);
}
}
}
/* Content footer */
ap_rputs(" </channel>\n", r);
ap_rputs("</rss>\n", r);
apr_dir_close(dir);
return OK;
}
/* Like svn_io_copy_dir_recursively() but doesn't copy regular files that
* exist in the destination and do not differ from the source in terms of
* kind, size, and mtime. Set *SKIPPED_P to FALSE only if at least one
* file was copied, do not change the value in *SKIPPED_P otherwise.
* SKIPPED_P may be NULL if not required. */
static svn_error_t *
hotcopy_io_copy_dir_recursively(svn_boolean_t *skipped_p,
const char *src,
const char *dst_parent,
const char *dst_basename,
svn_boolean_t copy_perms,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
svn_node_kind_t kind;
apr_status_t status;
const char *dst_path;
apr_dir_t *this_dir;
apr_finfo_t this_entry;
apr_int32_t flags = APR_FINFO_TYPE | APR_FINFO_NAME;
/* Make a subpool for recursion */
apr_pool_t *subpool = svn_pool_create(pool);
/* The 'dst_path' is simply dst_parent/dst_basename */
dst_path = svn_dirent_join(dst_parent, dst_basename, pool);
/* Sanity checks: SRC and DST_PARENT are directories, and
DST_BASENAME doesn't already exist in DST_PARENT. */
SVN_ERR(svn_io_check_path(src, &kind, subpool));
if (kind != svn_node_dir)
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("Source '%s' is not a directory"),
svn_dirent_local_style(src, pool));
SVN_ERR(svn_io_check_path(dst_parent, &kind, subpool));
if (kind != svn_node_dir)
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("Destination '%s' is not a directory"),
svn_dirent_local_style(dst_parent, pool));
SVN_ERR(svn_io_check_path(dst_path, &kind, subpool));
/* Create the new directory. */
/* ### TODO: copy permissions (needs apr_file_attrs_get()) */
SVN_ERR(svn_io_make_dir_recursively(dst_path, pool));
/* Loop over the dirents in SRC. ('.' and '..' are auto-excluded) */
SVN_ERR(svn_io_dir_open(&this_dir, src, subpool));
for (status = apr_dir_read(&this_entry, flags, this_dir);
status == APR_SUCCESS;
status = apr_dir_read(&this_entry, flags, this_dir))
{
if ((this_entry.name[0] == '.')
&& ((this_entry.name[1] == '\0')
|| ((this_entry.name[1] == '.')
&& (this_entry.name[2] == '\0'))))
{
continue;
}
else
{
const char *entryname_utf8;
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
SVN_ERR(entry_name_to_utf8(&entryname_utf8, this_entry.name,
src, subpool));
if (this_entry.filetype == APR_REG) /* regular file */
{
SVN_ERR(hotcopy_io_dir_file_copy(skipped_p, src, dst_path,
entryname_utf8, subpool));
}
else if (this_entry.filetype == APR_LNK) /* symlink */
{
const char *src_target = svn_dirent_join(src, entryname_utf8,
subpool);
const char *dst_target = svn_dirent_join(dst_path,
entryname_utf8,
subpool);
SVN_ERR(svn_io_copy_link(src_target, dst_target,
subpool));
}
else if (this_entry.filetype == APR_DIR) /* recurse */
{
const char *src_target;
/* Prevent infinite recursion by filtering off our
newly created destination path. */
if (strcmp(src, dst_parent) == 0
&& strcmp(entryname_utf8, dst_basename) == 0)
continue;
src_target = svn_dirent_join(src, entryname_utf8, subpool);
SVN_ERR(hotcopy_io_copy_dir_recursively(skipped_p,
src_target,
dst_path,
entryname_utf8,
copy_perms,
cancel_func,
cancel_baton,
subpool));
}
/* ### support other APR node types someday?? */
}
}
if (! (APR_STATUS_IS_ENOENT(status)))
return svn_error_wrap_apr(status, _("Can't read directory '%s'"),
svn_dirent_local_style(src, pool));
status = apr_dir_close(this_dir);
if (status)
return svn_error_wrap_apr(status, _("Error closing directory '%s'"),
svn_dirent_local_style(src, pool));
/* Free any memory used by recursion */
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
