static void store_slotmem(ap_slotmem_instance_t *slotmem)
{
apr_file_t *fp;
apr_status_t rv;
apr_size_t nbytes;
const char *storename;
storename = slotmem_filename(slotmem->gpool, slotmem->name, 1);
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;
/* XXX: Error handling */
apr_file_write_full(fp, slotmem->persist, nbytes, NULL);
apr_file_close(fp);
}
}
mapcache_lock_result mapcache_locker_disk_aquire_lock(mapcache_context *ctx, mapcache_locker *self, char *resource, void **lock) {
char *lockname, errmsg[120];
mapcache_locker_disk *ldisk;
apr_file_t *lockfile;
apr_status_t rv;
assert(self->type == MAPCACHE_LOCKER_DISK);
ldisk = (mapcache_locker_disk*)self;
*lock = NULL; /*unused*/
lockname = lock_filename_for_resource(ctx,ldisk,resource);
/* create the lockfile */
rv = apr_file_open(&lockfile,lockname,APR_WRITE|APR_CREATE|APR_EXCL|APR_XTHREAD,APR_OS_DEFAULT,ctx->pool);
/* if the file already exists, wait for it to disappear */
/* TODO: check the lock isn't stale (i.e. too old) */
if( rv != APR_SUCCESS ) {
if( !APR_STATUS_IS_EEXIST(rv) ) {
ctx->set_error(ctx, 500, "failed to create lockfile %s: %s", lockname, apr_strerror(rv,errmsg,120));
return MAPCACHE_LOCK_NOENT;
}
return MAPCACHE_LOCK_LOCKED;
} else {
/* we acquired the lock */
char *pid_s;
pid_t pid;
apr_size_t pid_s_len;
pid = getpid();
pid_s = apr_psprintf(ctx->pool,"%"APR_PID_T_FMT,pid);
pid_s_len = strlen(pid_s);
apr_file_write(lockfile,pid_s,&pid_s_len);
apr_file_close(lockfile);
return MAPCACHE_LOCK_AQUIRED;
}
}
/*
* change directory for gprof to plop the gmon.out file
* configure in httpd.conf:
* GprofDir $RuntimeDir/ -> $ServerRoot/$RuntimeDir/gmon.out
* GprofDir $RuntimeDir/% -> $ServerRoot/$RuntimeDir/gprof.$pid/gmon.out
*/
static void chdir_for_gprof(void)
{
core_server_config *sconf =
ap_get_module_config(ap_server_conf->module_config, &core_module);
char *dir = sconf->gprof_dir;
const char *use_dir;
if(dir) {
apr_status_t res;
char *buf = NULL ;
int len = strlen(sconf->gprof_dir) - 1;
if(*(dir + len) == '%') {
dir[len] = '\0';
buf = ap_append_pid(pconf, dir, "gprof.");
}
use_dir = ap_server_root_relative(pconf, buf ? buf : dir);
res = apr_dir_make(use_dir,
APR_UREAD | APR_UWRITE | APR_UEXECUTE |
APR_GREAD | APR_GEXECUTE |
APR_WREAD | APR_WEXECUTE, pconf);
if(res != APR_SUCCESS && !APR_STATUS_IS_EEXIST(res)) {
ap_log_error(APLOG_MARK, APLOG_ERR, res, ap_server_conf,
"gprof: error creating directory %s", dir);
}
}
else {
use_dir = ap_server_root_relative(pconf, DEFAULT_REL_RUNTIMEDIR);
}
chdir(use_dir);
}
/*
* change directory for gprof to plop the gmon.out file
* configure in httpd.conf:
* GprofDir $RuntimeDir/ -> $ServerRoot/$RuntimeDir/gmon.out
* GprofDir $RuntimeDir/% -> $ServerRoot/$RuntimeDir/gprof.$pid/gmon.out
*/
static void chdir_for_gprof(void)
{
core_server_config *sconf =
ap_get_module_config(ap_server_conf->module_config, &core_module);
char *dir = sconf->gprof_dir;
const char *use_dir;
if(dir) {
apr_status_t res;
char buf[512];
int len = strlen(sconf->gprof_dir) - 1;
if(*(dir + len) == '%') {
dir[len] = '\0';
apr_snprintf(buf, sizeof(buf), "%sgprof.%d", dir, (int)getpid());
}
use_dir = ap_server_root_relative(pconf, buf[0] ? buf : dir);
res = apr_dir_make(use_dir, 0755, pconf);
if(res != APR_SUCCESS && !APR_STATUS_IS_EEXIST(res)) {
ap_log_error(APLOG_MARK, APLOG_ERR, errno, ap_server_conf,
"gprof: error creating directory %s", dir);
}
}
else {
use_dir = ap_server_root_relative(pconf, DEFAULT_REL_RUNTIMEDIR);
}
chdir(use_dir);
}
/* Open a file somewhere in the adm area for directory PATH.
* First, add the adm subdir as the next component of PATH, then add
* each of the varargs (they are char *'s), then add EXTENSION if it
* is non-null, then open the resulting file as *STREAM.
*
* If FLAGS indicates writing, open the file in the adm tmp area.
* This means the file will probably need to be renamed from there,
* either by passing the sync flag to close_adm_file() later, or with
* an explicit call to sync_adm_file().
*/
static svn_error_t *
open_adm_file(svn_stream_t **stream,
const char **selected_path,
const char *path,
const char *extension,
svn_boolean_t for_writing,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool,
...)
{
svn_error_t *err;
va_list ap;
/* If we're writing, always do it to a tmp file. */
if (for_writing)
{
/* Extend with tmp name. */
va_start(ap, scratch_pool);
path = v_extend_with_adm_name(path, extension, TRUE, result_pool, ap);
va_end(ap);
err = svn_stream_open_writable(stream, path, result_pool, scratch_pool);
}
else
{
/* Extend with regular adm name. */
va_start(ap, scratch_pool);
path = v_extend_with_adm_name(path, extension, FALSE, result_pool, ap);
va_end(ap);
err = svn_stream_open_readonly(stream, path, result_pool, scratch_pool);
}
if (selected_path)
*selected_path = path; /* note: built in result_pool */
if (for_writing && err && APR_STATUS_IS_EEXIST(err->apr_err))
{
/* Exclusive open failed, delete and retry */
svn_error_clear(err);
SVN_ERR(svn_io_remove_file(path, scratch_pool));
err = svn_stream_open_writable(stream, path, result_pool, scratch_pool);
}
/* Examine the error from the first and/or second attempt at opening. */
if (for_writing && err && APR_STATUS_IS_ENOENT(err->apr_err))
{
/* If we receive a failure to open a file in our temporary directory,
* it may be because our temporary directories aren't created.
* Older SVN clients did not create these directories.
* 'svn cleanup' will fix this problem.
*/
err = svn_error_quick_wrap(err,
_("Your .svn/tmp directory may be missing or "
"corrupt; run 'svn cleanup' and try again"));
}
return err;
}
/* Body of svn_fs_fs__open_rep_cache().
Implements svn_atomic__init_once().init_func.
*/
static svn_error_t *
open_rep_cache(void *baton,
apr_pool_t *pool)
{
svn_fs_t *fs = baton;
fs_fs_data_t *ffd = fs->fsap_data;
svn_sqlite__db_t *sdb;
const char *db_path;
int version;
/* Open (or create) the sqlite database. It will be automatically
closed when fs->pool is destroyed. */
db_path = path_rep_cache_db(fs->path, pool);
#ifndef WIN32
{
/* We want to extend the permissions that apply to the repository
as a whole when creating a new rep cache and not simply default
to umask. */
svn_boolean_t exists;
SVN_ERR(svn_fs_fs__exists_rep_cache(&exists, fs, pool));
if (!exists)
{
const char *current = svn_fs_fs__path_current(fs, pool);
svn_error_t *err = svn_io_file_create_empty(db_path, pool);
if (err && !APR_STATUS_IS_EEXIST(err->apr_err))
/* A real error. */
return svn_error_trace(err);
else if (err)
/* Some other thread/process created the file. */
svn_error_clear(err);
else
/* We created the file. */
SVN_ERR(svn_io_copy_perms(current, db_path, pool));
}
}
#endif
SVN_ERR(svn_sqlite__open(&sdb, db_path,
svn_sqlite__mode_rwcreate, statements,
0, NULL, 0,
fs->pool, pool));
SVN_ERR_CLOSE(svn_sqlite__read_schema_version(&version, sdb, pool), sdb);
if (version < REP_CACHE_SCHEMA_FORMAT)
{
/* Must be 0 -- an uninitialized (no schema) database. Create
the schema. Results in schema version of 1. */
SVN_ERR_CLOSE(svn_sqlite__exec_statements(sdb, STMT_CREATE_SCHEMA), sdb);
}
/* This is used as a flag that the database is available so don't
set it earlier. */
ffd->rep_cache_db = sdb;
return SVN_NO_ERROR;
}
static void test_open_excl(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *thefile = NULL;
rv = apr_file_open(&thefile, FILENAME,
APR_CREATE | APR_EXCL | APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
ABTS_TRUE(tc, rv != APR_SUCCESS);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EEXIST(rv));
ABTS_PTR_EQUAL(tc, NULL, thefile);
}
static void test_open_excl(CuTest *tc)
{
apr_status_t rv;
apr_file_t *thefile = NULL;
rv = apr_file_open(&thefile, FILENAME,
APR_CREATE | APR_EXCL | APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
CuAssertTrue(tc, rv != APR_SUCCESS);
CuAssertIntEquals(tc, 1, APR_STATUS_IS_EEXIST(rv));
CuAssertPtrEquals(tc, NULL, thefile);
}
static void test_mkdir_twice(abts_case *tc, void *data)
{
apr_status_t rv;
rv = apr_dir_make("data/testdir", APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_make("data/testdir", APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EEXIST(rv));
rv = apr_dir_remove("data/testdir", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
static void mkdir_structure(disk_cache_conf *conf, const char *file, apr_pool_t *pool)
{
apr_status_t rv;
char *p;
for (p = (char*)file + conf->cache_root_len + 1;;) {
p = strchr(p, '/');
if (!p)
break;
*p = '\0';
rv = apr_dir_make(file,
APR_UREAD|APR_UWRITE|APR_UEXECUTE, pool);
if (rv != APR_SUCCESS && !APR_STATUS_IS_EEXIST(rv)) {
/* XXX */
}
*p = '/';
++p;
}
}
int cache_check_freshness(cache_handle_t *h, cache_request_rec *cache,
request_rec *r)
{
apr_status_t status;
apr_int64_t age, maxage_req, maxage_cresp, maxage, smaxage, maxstale;
apr_int64_t minfresh;
const char *cc_req;
const char *pragma;
const char *agestr = NULL;
apr_time_t age_c = 0;
cache_info *info = &(h->cache_obj->info);
const char *warn_head;
cache_server_conf *conf =
(cache_server_conf *)ap_get_module_config(r->server->module_config,
&cache_module);
/*
* We now want to check if our cached data is still fresh. This depends
* on a few things, in this order:
*
* - RFC2616 14.9.4 End to end reload, Cache-Control: no-cache. no-cache
* in either the request or the cached response means that we must
* perform the request unconditionally, and ignore cached content. We
* should never reach here, but if we do, mark the content as stale,
* as this is the best we can do.
*
* - RFC2616 14.32 Pragma: no-cache This is treated the same as
* Cache-Control: no-cache.
*
* - RFC2616 14.9.3 Cache-Control: max-stale, must-revalidate,
* proxy-revalidate if the max-stale request header exists, modify the
* stale calculations below so that an object can be at most <max-stale>
* seconds stale before we request a revalidation, _UNLESS_ a
* must-revalidate or proxy-revalidate cached response header exists to
* stop us doing this.
*
* - RFC2616 14.9.3 Cache-Control: s-maxage the origin server specifies the
* maximum age an object can be before it is considered stale. This
* directive has the effect of proxy|must revalidate, which in turn means
* simple ignore any max-stale setting.
*
* - RFC2616 14.9.4 Cache-Control: max-age this header can appear in both
* requests and responses. If both are specified, the smaller of the two
* takes priority.
*
* - RFC2616 14.21 Expires: if this request header exists in the cached
* entity, and it's value is in the past, it has expired.
*
*/
/* This value comes from the client's initial request. */
cc_req = apr_table_get(r->headers_in, "Cache-Control");
pragma = apr_table_get(r->headers_in, "Pragma");
ap_cache_control(r, &cache->control_in, cc_req, pragma, r->headers_in);
if (cache->control_in.no_cache) {
if (!conf->ignorecachecontrol) {
/* Treat as stale, causing revalidation */
return 0;
}
ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00781)
"Incoming request is asking for a uncached version of "
"%s, but we have been configured to ignore it and "
"serve a cached response anyway",
r->unparsed_uri);
}
/* These come from the cached entity. */
if (h->cache_obj->info.control.no_cache
|| h->cache_obj->info.control.invalidated) {
/*
* The cached entity contained Cache-Control: no-cache, or a
* no-cache with a header present, or a private with a header
* present, or the cached entity has been invalidated in the
* past, so treat as stale causing revalidation.
*/
return 0;
}
if ((agestr = apr_table_get(h->resp_hdrs, "Age"))) {
char *endp;
apr_off_t offt;
if (!apr_strtoff(&offt, agestr, &endp, 10)
&& endp > agestr && !*endp) {
age_c = offt;
}
}
/* calculate age of object */
age = ap_cache_current_age(info, age_c, r->request_time);
/* extract s-maxage */
smaxage = h->cache_obj->info.control.s_maxage_value;
/* extract max-age from request */
maxage_req = -1;
if (!conf->ignorecachecontrol) {
maxage_req = cache->control_in.max_age_value;
}
/*
* extract max-age from response, if both s-maxage and max-age, s-maxage
* takes priority
*/
if (smaxage != -1) {
maxage_cresp = smaxage;
}
else {
maxage_cresp = h->cache_obj->info.control.max_age_value;
}
/*
* if both maxage request and response, the smaller one takes priority
*/
if (maxage_req == -1) {
maxage = maxage_cresp;
}
else if (maxage_cresp == -1) {
maxage = maxage_req;
}
else {
maxage = MIN(maxage_req, maxage_cresp);
}
/* extract max-stale */
if (cache->control_in.max_stale) {
if(cache->control_in.max_stale_value != -1) {
maxstale = cache->control_in.max_stale_value;
}
else {
/*
* If no value is assigned to max-stale, then the client is willing
* to accept a stale response of any age (RFC2616 14.9.3). We will
* set it to one year in this case as this situation is somewhat
* similar to a "never expires" Expires header (RFC2616 14.21)
* which is set to a date one year from the time the response is
* sent in this case.
*/
maxstale = APR_INT64_C(86400*365);
}
}
else {
maxstale = 0;
}
/* extract min-fresh */
if (!conf->ignorecachecontrol && cache->control_in.min_fresh) {
minfresh = cache->control_in.min_fresh_value;
}
else {
minfresh = 0;
}
/* override maxstale if must-revalidate, proxy-revalidate or s-maxage */
if (maxstale && (h->cache_obj->info.control.must_revalidate
|| h->cache_obj->info.control.proxy_revalidate || smaxage != -1)) {
maxstale = 0;
}
/* handle expiration */
if (((maxage != -1) && (age < (maxage + maxstale - minfresh))) ||
((smaxage == -1) && (maxage == -1) &&
(info->expire != APR_DATE_BAD) &&
(age < (apr_time_sec(info->expire - info->date) + maxstale - minfresh)))) {
warn_head = apr_table_get(h->resp_hdrs, "Warning");
/* it's fresh darlings... */
/* set age header on response */
apr_table_set(h->resp_hdrs, "Age",
apr_psprintf(r->pool, "%lu", (unsigned long)age));
/* add warning if maxstale overrode freshness calculation */
if (!(((maxage != -1) && age < maxage) ||
(info->expire != APR_DATE_BAD &&
(apr_time_sec(info->expire - info->date)) > age))) {
/* make sure we don't stomp on a previous warning */
if ((warn_head == NULL) ||
((warn_head != NULL) && (ap_strstr_c(warn_head, "110") == NULL))) {
apr_table_mergen(h->resp_hdrs, "Warning",
"110 Response is stale");
}
}
/*
* If none of Expires, Cache-Control: max-age, or Cache-Control:
* s-maxage appears in the response, and the response header age
* calculated is more than 24 hours add the warning 113
*/
if ((maxage_cresp == -1) && (smaxage == -1) && (apr_table_get(
h->resp_hdrs, "Expires") == NULL) && (age > 86400)) {
/* Make sure we don't stomp on a previous warning, and don't dup
* a 113 marning that is already present. Also, make sure to add
* the new warning to the correct *headers_out location.
*/
if ((warn_head == NULL) ||
((warn_head != NULL) && (ap_strstr_c(warn_head, "113") == NULL))) {
apr_table_mergen(h->resp_hdrs, "Warning",
"113 Heuristic expiration");
}
}
return 1; /* Cache object is fresh (enough) */
}
/*
* At this point we are stale, but: if we are under load, we may let
* a significant number of stale requests through before the first
* stale request successfully revalidates itself, causing a sudden
* unexpected thundering herd which in turn brings angst and drama.
*
* So.
*
* We want the first stale request to go through as normal. But the
* second and subsequent request, we must pretend to be fresh until
* the first request comes back with either new content or confirmation
* that the stale content is still fresh.
*
* To achieve this, we create a very simple file based lock based on
* the key of the cached object. We attempt to open the lock file with
* exclusive write access. If we succeed, woohoo! we're first, and we
* follow the stale path to the backend server. If we fail, oh well,
* we follow the fresh path, and avoid being a thundering herd.
*
* The lock lives only as long as the stale request that went on ahead.
* If the request succeeds, the lock is deleted. If the request fails,
* the lock is deleted, and another request gets to make a new lock
* and try again.
*
* At any time, a request marked "no-cache" will force a refresh,
* ignoring the lock, ensuring an extended lockout is impossible.
*
* A lock that exceeds a maximum age will be deleted, and another
* request gets to make a new lock and try again.
*/
status = cache_try_lock(conf, cache, r);
if (APR_SUCCESS == status) {
/* we obtained a lock, follow the stale path */
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(00782)
"Cache lock obtained for stale cached URL, "
"revalidating entry: %s",
r->unparsed_uri);
return 0;
}
else if (APR_STATUS_IS_EEXIST(status)) {
/* lock already exists, return stale data anyway, with a warning */
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, status, r, APLOGNO(00783)
"Cache already locked for stale cached URL, "
"pretend it is fresh: %s",
r->unparsed_uri);
/* make sure we don't stomp on a previous warning */
warn_head = apr_table_get(h->resp_hdrs, "Warning");
if ((warn_head == NULL) ||
((warn_head != NULL) && (ap_strstr_c(warn_head, "110") == NULL))) {
apr_table_mergen(h->resp_hdrs, "Warning",
"110 Response is stale");
}
return 1;
}
else {
/* some other error occurred, just treat the object as stale */
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, status, r, APLOGNO(00784)
"Attempt to obtain a cache lock for stale "
"cached URL failed, revalidating entry anyway: %s",
r->unparsed_uri);
return 0;
}
}
/* Make an unversioned copy of the versioned file or directory tree at the
* source path FROM_ABSPATH. Copy it to the destination path TO_ABSPATH.
*
* If REVISION is svn_opt_revision_working, copy the working version,
* otherwise copy the base version.
*
* See copy_one_versioned_file() for details of file copying behaviour,
* including IGNORE_KEYWORDS and NATIVE_EOL.
*
* Include externals unless IGNORE_EXTERNALS is true.
*
* Recurse according to DEPTH.
*
*/
static svn_error_t *
copy_versioned_files(const char *from_abspath,
const char *to_abspath,
const svn_opt_revision_t *revision,
svn_boolean_t force,
svn_boolean_t ignore_externals,
svn_boolean_t ignore_keywords,
svn_depth_t depth,
const char *native_eol,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_error_t *err;
apr_pool_t *iterpool;
const apr_array_header_t *children;
svn_node_kind_t from_kind;
svn_depth_t node_depth;
SVN_ERR_ASSERT(svn_dirent_is_absolute(from_abspath));
SVN_ERR_ASSERT(svn_dirent_is_absolute(to_abspath));
/* Only export 'added' and 'replaced' files when the revision is WORKING;
when the revision is BASE (i.e. != WORKING), only export 'added' and
'replaced' files when they are part of a copy-/move-here. Otherwise, skip
them, since they don't have an associated text-base. This condition for
added/replaced simply is an optimization. Added and replaced files would
be handled similarly by svn_wc_get_pristine_contents2(), which would
return NULL if they have no base associated.
TODO: We may prefer not to duplicate this condition and rather use
svn_wc_get_pristine_contents2() or a dedicated new function instead.
Don't export 'deleted' files and directories unless it's a
revision other than WORKING. These files and directories
don't really exist in WORKING. */
if (revision->kind != svn_opt_revision_working)
{
svn_boolean_t is_added;
const char *repos_relpath;
SVN_ERR(svn_wc__node_get_origin(&is_added, NULL, &repos_relpath,
NULL, NULL, NULL,
ctx->wc_ctx, from_abspath, FALSE,
pool, pool));
if (is_added && !repos_relpath)
return SVN_NO_ERROR; /* Local addition */
}
else
{
svn_boolean_t is_deleted;
SVN_ERR(svn_wc__node_is_status_deleted(&is_deleted, ctx->wc_ctx,
from_abspath, pool));
if (is_deleted)
return SVN_NO_ERROR;
}
SVN_ERR(svn_wc_read_kind(&from_kind, ctx->wc_ctx, from_abspath, FALSE,
pool));
if (from_kind == svn_node_dir)
{
apr_fileperms_t perm = APR_OS_DEFAULT;
int j;
/* Try to make the new directory. If this fails because the
directory already exists, check our FORCE flag to see if we
care. */
/* Keep the source directory's permissions if applicable.
Skip retrieving the umask on windows. Apr does not implement setting
filesystem privileges on Windows.
Retrieving the file permissions with APR_FINFO_PROT | APR_FINFO_OWNER
is documented to be 'incredibly expensive' */
#ifndef WIN32
if (revision->kind == svn_opt_revision_working)
{
apr_finfo_t finfo;
SVN_ERR(svn_io_stat(&finfo, from_abspath, APR_FINFO_PROT, pool));
perm = finfo.protection;
}
#endif
err = svn_io_dir_make(to_abspath, perm, pool);
if (err)
{
if (! APR_STATUS_IS_EEXIST(err->apr_err))
return svn_error_trace(err);
if (! force)
SVN_ERR_W(err, _("Destination directory exists, and will not be "
"overwritten unless forced"));
else
svn_error_clear(err);
}
SVN_ERR(svn_wc__node_get_children(&children, ctx->wc_ctx, from_abspath,
FALSE, pool, pool));
iterpool = svn_pool_create(pool);
for (j = 0; j < children->nelts; j++)
{
const char *child_abspath = APR_ARRAY_IDX(children, j, const char *);
const char *child_name = svn_dirent_basename(child_abspath, NULL);
const char *target_abspath;
svn_node_kind_t child_kind;
svn_pool_clear(iterpool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
target_abspath = svn_dirent_join(to_abspath, child_name, iterpool);
SVN_ERR(svn_wc_read_kind(&child_kind, ctx->wc_ctx, child_abspath,
FALSE, iterpool));
if (child_kind == svn_node_dir)
{
if (depth == svn_depth_infinity
|| depth == svn_depth_immediates)
{
if (ctx->notify_func2)
{
svn_wc_notify_t *notify =
svn_wc_create_notify(target_abspath,
svn_wc_notify_update_add, pool);
notify->kind = svn_node_dir;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
if (depth == svn_depth_infinity)
SVN_ERR(copy_versioned_files(child_abspath, target_abspath,
revision, force,
ignore_externals,
ignore_keywords, depth,
native_eol, ctx, iterpool));
else
SVN_ERR(svn_io_make_dir_recursively(target_abspath,
iterpool));
}
}
else if (child_kind == svn_node_file
&& depth >= svn_depth_files)
{
svn_node_kind_t external_kind;
SVN_ERR(svn_wc__read_external_info(&external_kind,
NULL, NULL, NULL,
NULL, ctx->wc_ctx,
child_abspath,
child_abspath, TRUE,
pool, pool));
if (external_kind != svn_node_file)
SVN_ERR(copy_one_versioned_file(child_abspath, target_abspath,
ctx, revision,
native_eol, ignore_keywords,
iterpool));
}
}
SVN_ERR(svn_wc__node_get_depth(&node_depth, ctx->wc_ctx,
from_abspath, pool));
/* Handle externals. */
if (! ignore_externals && depth == svn_depth_infinity
&& node_depth == svn_depth_infinity)
{
apr_array_header_t *ext_items;
const svn_string_t *prop_val;
SVN_ERR(svn_wc_prop_get2(&prop_val, ctx->wc_ctx, from_abspath,
SVN_PROP_EXTERNALS, pool, pool));
if (prop_val != NULL)
{
int i;
SVN_ERR(svn_wc_parse_externals_description3(&ext_items,
from_abspath,
prop_val->data,
FALSE, pool));
for (i = 0; i < ext_items->nelts; ++i)
{
svn_wc_external_item2_t *ext_item;
const char *new_from, *new_to;
svn_pool_clear(iterpool);
ext_item = APR_ARRAY_IDX(ext_items, i,
svn_wc_external_item2_t *);
new_from = svn_dirent_join(from_abspath,
ext_item->target_dir,
iterpool);
new_to = svn_dirent_join(to_abspath, ext_item->target_dir,
iterpool);
/* The target dir might have parents that don't exist.
Guarantee the path upto the last component. */
if (!svn_dirent_is_root(ext_item->target_dir,
strlen(ext_item->target_dir)))
{
const char *parent = svn_dirent_dirname(new_to, iterpool);
SVN_ERR(svn_io_make_dir_recursively(parent, iterpool));
}
SVN_ERR(copy_versioned_files(new_from, new_to,
revision, force, FALSE,
ignore_keywords,
svn_depth_infinity, native_eol,
ctx, iterpool));
}
}
static svn_error_t *
internal_open(svn_sqlite__db_t *db, const char *path, svn_sqlite__mode_t mode,
apr_int32_t timeout, apr_pool_t *scratch_pool)
{
{
int flags;
if (mode == svn_sqlite__mode_readonly)
flags = SQLITE_OPEN_READONLY;
else if (mode == svn_sqlite__mode_readwrite)
flags = SQLITE_OPEN_READWRITE;
else if (mode == svn_sqlite__mode_rwcreate)
flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
else
SVN_ERR_MALFUNCTION();
/* Turn off SQLite's mutexes. All svn objects are single-threaded,
so we can already guarantee that our use of the SQLite handle
will be serialized properly.
Note: in 3.6.x, we've already config'd SQLite into MULTITHREAD mode,
so this is probably redundant, but if we are running in a process where
somebody initialized SQLite before us it is needed anyway. */
flags |= SQLITE_OPEN_NOMUTEX;
#if !defined(WIN32) && !defined(SVN_SQLITE_INLINE)
if (mode == svn_sqlite__mode_rwcreate)
{
svn_node_kind_t kind;
/* Create the file before SQLite to avoid any permissions
problems with an SQLite build that uses the default
SQLITE_DEFAULT_FILE_PERMISSIONS of 644 modified by umask.
We simply want umask permissions. */
SVN_ERR(svn_io_check_path(path, &kind, scratch_pool));
if (kind == svn_node_none)
{
/* Another thread may have created the file, that's OK. */
svn_error_t *err = svn_io_file_create_empty(path, scratch_pool);
if (err && !APR_STATUS_IS_EEXIST(err->apr_err))
return svn_error_trace(err);
svn_error_clear(err);
}
}
#endif
/* Open the database. Note that a handle is returned, even when an error
occurs (except for out-of-memory); thus, we can safely use it to
extract an error message and construct an svn_error_t. SQLite always
requires sqlite3_close() after sqlite3_open_v2() while Subversion
typically does not require close() after an open() that returns an
error. So we must ensure we close the handle if this function, or
the caller svn_sqlite__open, returns an error to the application. */
{
const char *vFs = NULL;
#if defined(WIN32) && SQLITE_VERSION_AT_LEAST(3, 8, 1)
if (strlen(path) > 248)
{
WCHAR *win_path;
vFs = "win32-longpath"; /* Enable long paths in sqlite */
/* Long paths must be absolute */
if (!svn_dirent_is_absolute(path))
SVN_ERR(svn_dirent_get_absolute(&path, path, scratch_pool));
/* Convert the path to a properly canonicalized \\?\C:\long\path */
SVN_ERR(svn_io__utf8_to_unicode_longpath(&win_path, path,
scratch_pool));
/* And convert it back to UTF-8 because there is no
sqlite3_open16_v2() yet */
SVN_ERR(svn_utf__win32_utf16_to_utf8(&path, win_path, NULL,
scratch_pool));
}
#endif
/* ### SQLITE_CANTOPEN */
SQLITE_ERR_CLOSE(sqlite3_open_v2(path, &db->db3, flags, vFs),
db, scratch_pool);
}
}
if (timeout <= 0)
timeout = BUSY_TIMEOUT;
/* Retry until timeout when database is busy. */
SQLITE_ERR_CLOSE(sqlite3_busy_timeout(db->db3, timeout),
db, scratch_pool);
return SVN_NO_ERROR;
}
APR_DECLARE(apr_status_t) apr_shm_create(apr_shm_t **m,
apr_size_t reqsize,
const char *file,
apr_pool_t *pool)
{
static apr_size_t memblock = 0;
HANDLE hMap, hFile;
apr_status_t rv;
apr_size_t size;
apr_file_t *f;
void *base;
void *mapkey;
DWORD err, sizelo, sizehi;
reqsize += sizeof(memblock_t);
if (!memblock)
{
SYSTEM_INFO si;
GetSystemInfo(&si);
memblock = si.dwAllocationGranularity;
}
/* Compute the granualar multiple of the pagesize */
size = memblock * (1 + (reqsize - 1) / memblock);
sizelo = (DWORD)size;
#ifdef _WIN64
sizehi = (DWORD)(size >> 32);
#else
sizehi = 0;
#endif
if (!file) {
/* Do Anonymous, which must be passed as a duplicated handle */
#ifndef _WIN32_WCE
hFile = INVALID_HANDLE_VALUE;
#endif
mapkey = NULL;
}
else {
/* Do file backed, which is not an inherited handle
* While we could open APR_EXCL, it doesn't seem that Unix
* ever did. Ignore that error here, but fail later when
* we discover we aren't the creator of the file map object.
*/
rv = apr_file_open(&f, file,
APR_READ | APR_WRITE | APR_BINARY | APR_CREATE,
APR_UREAD | APR_UWRITE, pool);
if ((rv != APR_SUCCESS)
|| ((rv = apr_os_file_get(&hFile, f)) != APR_SUCCESS)) {
return rv;
}
rv = apr_file_trunc(f, size);
/* res_name_from_filename turns file into a pseudo-name
* without slashes or backslashes, and prepends the \global
* prefix on Win2K and later
*/
mapkey = res_name_from_filename(file, 1, pool);
}
#if APR_HAS_UNICODE_FS
IF_WIN_OS_IS_UNICODE
{
hMap = CreateFileMappingW(hFile, NULL, PAGE_READWRITE,
sizehi, sizelo, mapkey);
}
#endif
#if APR_HAS_ANSI_FS
ELSE_WIN_OS_IS_ANSI
{
hMap = CreateFileMappingA(hFile, NULL, PAGE_READWRITE,
sizehi, sizelo, mapkey);
}
#endif
err = apr_get_os_error();
if (file) {
apr_file_close(f);
}
if (hMap && APR_STATUS_IS_EEXIST(err)) {
CloseHandle(hMap);
return APR_EEXIST;
}
if (!hMap) {
return err;
}
base = MapViewOfFile(hMap, FILE_MAP_READ | FILE_MAP_WRITE,
0, 0, size);
if (!base) {
CloseHandle(hMap);
return apr_get_os_error();
}
*m = (apr_shm_t *) apr_palloc(pool, sizeof(apr_shm_t));
(*m)->pool = pool;
(*m)->hMap = hMap;
(*m)->memblk = base;
(*m)->size = size;
(*m)->usrmem = (char*)base + sizeof(memblock_t);
(*m)->length = reqsize - sizeof(memblock_t);;
(*m)->memblk->length = (*m)->length;
(*m)->memblk->size = (*m)->size;
(*m)->filename = file ? apr_pstrdup(pool, file) : NULL;
apr_pool_cleanup_register((*m)->pool, *m,
shm_cleanup, apr_pool_cleanup_null);
return APR_SUCCESS;
}
/**
* \brief write tile data to disk
*
* writes the content of mapcache_tile::data to disk.
* \returns MAPCACHE_FAILURE if there is no data to write, or if the tile isn't locked
* \returns MAPCACHE_SUCCESS if the tile has been successfully written to disk
* \private \memberof mapcache_cache_disk
* \sa mapcache_cache::tile_set()
*/
static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile)
{
apr_size_t bytes;
apr_file_t *f;
apr_status_t ret;
char errmsg[120];
char *filename, *hackptr1, *hackptr2=NULL;
mapcache_cache_disk *cache = (mapcache_cache_disk*)pcache;
const int creation_retry = cache->creation_retry;
int retry_count_create_file = 0;
#ifdef DEBUG
/* all this should be checked at a higher level */
if(!tile->encoded_data && !tile->raw_image) {
ctx->set_error(ctx,500,"attempting to write empty tile to disk");
return;
}
if(!tile->encoded_data && !tile->tileset->format) {
ctx->set_error(ctx,500,"received a raw tile image for a tileset with no format");
return;
}
#endif
cache->tile_key(ctx, cache, tile, &filename);
GC_CHECK_ERROR(ctx);
/* find the location of the last '/' in the string */
hackptr1 = filename;
while(*hackptr1) {
if(*hackptr1 == '/')
hackptr2 = hackptr1;
hackptr1++;
}
*hackptr2 = '\0';
if(APR_SUCCESS != (ret = apr_dir_make_recursive(filename,APR_OS_DEFAULT,ctx->pool))) {
/*
* apr_dir_make_recursive sometimes sends back this error, although it should not.
* ignore this one
*/
if(!APR_STATUS_IS_EEXIST(ret)) {
ctx->set_error(ctx, 500, "failed to create directory %s: %s",filename, apr_strerror(ret,errmsg,120));
return;
}
}
*hackptr2 = '/';
ret = apr_file_remove(filename,ctx->pool);
if(ret != APR_SUCCESS && !APR_STATUS_IS_ENOENT(ret)) {
ctx->set_error(ctx, 500, "failed to remove file %s: %s",filename, apr_strerror(ret,errmsg,120));
}
#ifdef HAVE_SYMLINK
if(cache->symlink_blank) {
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
char *blankname;
int retry_count_create_symlink = 0;
char *blankname_rel = NULL;
_mapcache_cache_disk_blank_tile_key(ctx,cache,tile,tile->raw_image->data,&blankname);
if(apr_file_open(&f, blankname, APR_FOPEN_READ, APR_OS_DEFAULT, ctx->pool) != APR_SUCCESS) {
int isLocked;
void *lock;
char *blankdirname;
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
/* create the blank file */
blankdirname = apr_psprintf(ctx->pool, "%s/%s/%s/blanks",
cache->base_directory,
tile->tileset->name,
tile->grid_link->grid->name);
if(APR_SUCCESS != (ret = apr_dir_make_recursive(
blankdirname, APR_OS_DEFAULT,ctx->pool))) {
if(!APR_STATUS_IS_EEXIST(ret)) {
ctx->set_error(ctx, 500, "failed to create directory %s for blank tiles",blankdirname, apr_strerror(ret,errmsg,120));
return;
}
}
/* aquire a lock on the blank file */
isLocked = mapcache_lock_or_wait_for_resource(ctx,ctx->config->locker,blankname, &lock);
if(isLocked == MAPCACHE_TRUE) {
if((ret = apr_file_open(&f, blankname,
APR_FOPEN_CREATE|APR_FOPEN_WRITE|APR_FOPEN_BUFFERED|APR_FOPEN_BINARY,
APR_OS_DEFAULT, ctx->pool)) != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to create file %s: %s",blankname, apr_strerror(ret,errmsg,120));
mapcache_unlock_resource(ctx,ctx->config->locker,blankname, lock);
return; /* we could not create the file */
}
bytes = (apr_size_t)tile->encoded_data->size;
ret = apr_file_write(f,(void*)tile->encoded_data->buf,&bytes);
if(ret != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to write data to file %s (wrote %d of %d bytes): %s",blankname, (int)bytes, (int)tile->encoded_data->size, apr_strerror(ret,errmsg,120));
mapcache_unlock_resource(ctx,ctx->config->locker,blankname, lock);
return; /* we could not create the file */
}
if(bytes != tile->encoded_data->size) {
ctx->set_error(ctx, 500, "failed to write image data to %s, wrote %d of %d bytes", blankname, (int)bytes, (int)tile->encoded_data->size);
mapcache_unlock_resource(ctx,ctx->config->locker,blankname, lock);
return;
}
apr_file_close(f);
mapcache_unlock_resource(ctx,ctx->config->locker,blankname, lock);
#ifdef DEBUG
ctx->log(ctx,MAPCACHE_DEBUG,"created blank tile %s",blankname);
#endif
}
} else {
apr_file_close(f);
}
/*
* compute the relative path between tile and blank tile
*/
blankname_rel = relative_path(ctx,filename, blankname);
GC_CHECK_ERROR(ctx);
/*
* depending on configuration symlink creation will retry if it fails.
* this can happen on nfs mounted network storage.
* the solution is to create the containing directory again and retry the symlink creation.
*/
while(symlink(blankname_rel, filename) != 0) {
retry_count_create_symlink++;
if(retry_count_create_symlink > creation_retry) {
char *error = strerror(errno);
ctx->set_error(ctx, 500, "failed to link tile %s to %s: %s",filename, blankname_rel, error);
return; /* we could not create the file */
}
*hackptr2 = '\0';
if(APR_SUCCESS != (ret = apr_dir_make_recursive(filename,APR_OS_DEFAULT,ctx->pool))) {
if(!APR_STATUS_IS_EEXIST(ret)) {
ctx->set_error(ctx, 500, "failed to create symlink, can not create directory %s: %s",filename, apr_strerror(ret,errmsg,120));
return; /* we could not create the file */
}
}
*hackptr2 = '/';
}
#ifdef DEBUG
ctx->log(ctx, MAPCACHE_DEBUG, "linked blank tile %s to %s",filename,blankname);
#endif
return;
}
}
#endif /*HAVE_SYMLINK*/
/* go the normal way: either we haven't configured blank tile detection, or the tile was not blank */
if(!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
/*
* depending on configuration file creation will retry if it fails.
* this can happen on nfs mounted network storage.
* the solution is to create the containing directory again and retry the file creation.
*/
while((ret = apr_file_open(&f, filename,
APR_FOPEN_CREATE|APR_FOPEN_WRITE|APR_FOPEN_BUFFERED|APR_FOPEN_BINARY,
APR_OS_DEFAULT, ctx->pool)) != APR_SUCCESS) {
retry_count_create_file++;
if(retry_count_create_file > creation_retry) {
ctx->set_error(ctx, 500, "failed to create file %s: %s",filename, apr_strerror(ret,errmsg,120));
return; /* we could not create the file */
}
*hackptr2 = '\0';
if(APR_SUCCESS != (ret = apr_dir_make_recursive(filename,APR_OS_DEFAULT,ctx->pool))) {
if(!APR_STATUS_IS_EEXIST(ret)) {
ctx->set_error(ctx, 500, "failed to create file, can not create directory %s: %s",filename, apr_strerror(ret,errmsg,120));
return; /* we could not create the file */
}
}
*hackptr2 = '/';
}
bytes = (apr_size_t)tile->encoded_data->size;
ret = apr_file_write(f,(void*)tile->encoded_data->buf,&bytes);
if(ret != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to write data to file %s (wrote %d of %d bytes): %s",filename, (int)bytes, (int)tile->encoded_data->size, apr_strerror(ret,errmsg,120));
return; /* we could not create the file */
}
if(bytes != tile->encoded_data->size) {
ctx->set_error(ctx, 500, "failed to write image data to %s, wrote %d of %d bytes", filename, (int)bytes, (int)tile->encoded_data->size);
}
ret = apr_file_close(f);
if(ret != APR_SUCCESS) {
ctx->set_error(ctx, 500, "failed to close file %s:%s",filename, apr_strerror(ret,errmsg,120));
return; /* we could not create the file */
}
}
void status_to_name(lua_State *L, apr_status_t status)
{
/* Use a switch statement for fast number to string mapping: */
switch (status) {
# ifdef APR_ANONYMOUS
case APR_ANONYMOUS:
lua_pushliteral(L, "ANONYMOUS");
return;
# endif
# ifdef APR_BADARG
case APR_BADARG:
lua_pushliteral(L, "BADARG");
return;
# endif
# ifdef APR_BADCH
case APR_BADCH:
lua_pushliteral(L, "BADCH");
return;
# endif
# ifdef APR_DETACH
case APR_DETACH:
lua_pushliteral(L, "DETACH");
return;
# endif
# ifdef APR_EABOVEROOT
case APR_EABOVEROOT:
lua_pushliteral(L, "EABOVEROOT");
return;
# endif
# ifdef APR_EABSOLUTE
case APR_EABSOLUTE:
lua_pushliteral(L, "EABSOLUTE");
return;
# endif
# ifdef APR_EACCES
case APR_EACCES:
lua_pushliteral(L, "EACCES");
return;
# endif
# ifdef APR_EAFNOSUPPORT
case APR_EAFNOSUPPORT:
lua_pushliteral(L, "EAFNOSUPPORT");
return;
# endif
# ifdef APR_EAGAIN
case APR_EAGAIN:
lua_pushliteral(L, "EAGAIN");
return;
# endif
# ifdef APR_EBADDATE
case APR_EBADDATE:
lua_pushliteral(L, "EBADDATE");
return;
# endif
# ifdef APR_EBADF
case APR_EBADF:
lua_pushliteral(L, "EBADF");
return;
# endif
# ifdef APR_EBADIP
case APR_EBADIP:
lua_pushliteral(L, "EBADIP");
return;
# endif
# ifdef APR_EBADMASK
case APR_EBADMASK:
lua_pushliteral(L, "EBADMASK");
return;
# endif
# ifdef APR_EBADPATH
case APR_EBADPATH:
lua_pushliteral(L, "EBADPATH");
return;
# endif
# ifdef APR_EBUSY
case APR_EBUSY:
lua_pushliteral(L, "EBUSY");
return;
# endif
# ifdef APR_ECONNABORTED
case APR_ECONNABORTED:
lua_pushliteral(L, "ECONNABORTED");
return;
# endif
# ifdef APR_ECONNREFUSED
case APR_ECONNREFUSED:
lua_pushliteral(L, "ECONNREFUSED");
return;
# endif
# ifdef APR_ECONNRESET
case APR_ECONNRESET:
lua_pushliteral(L, "ECONNRESET");
return;
# endif
# ifdef APR_EDSOOPEN
case APR_EDSOOPEN:
lua_pushliteral(L, "EDSOOPEN");
return;
# endif
# ifdef APR_EEXIST
case APR_EEXIST:
lua_pushliteral(L, "EEXIST");
return;
# endif
# ifdef APR_EFTYPE
case APR_EFTYPE:
lua_pushliteral(L, "EFTYPE");
return;
# endif
# ifdef APR_EGENERAL
case APR_EGENERAL:
lua_pushliteral(L, "EGENERAL");
return;
# endif
# ifdef APR_EHOSTUNREACH
case APR_EHOSTUNREACH:
lua_pushliteral(L, "EHOSTUNREACH");
return;
# endif
# ifdef APR_EINCOMPLETE
case APR_EINCOMPLETE:
lua_pushliteral(L, "EINCOMPLETE");
return;
# endif
# ifdef APR_EINIT
case APR_EINIT:
lua_pushliteral(L, "EINIT");
return;
# endif
# ifdef APR_EINPROGRESS
case APR_EINPROGRESS:
lua_pushliteral(L, "EINPROGRESS");
return;
# endif
# ifdef APR_EINTR
case APR_EINTR:
lua_pushliteral(L, "EINTR");
return;
# endif
# ifdef APR_EINVAL
case APR_EINVAL:
lua_pushliteral(L, "EINVAL");
return;
# endif
# ifdef APR_EINVALSOCK
case APR_EINVALSOCK:
lua_pushliteral(L, "EINVALSOCK");
return;
# endif
# ifdef APR_EMFILE
case APR_EMFILE:
lua_pushliteral(L, "EMFILE");
return;
# endif
# ifdef APR_EMISMATCH
case APR_EMISMATCH:
lua_pushliteral(L, "EMISMATCH");
return;
# endif
# ifdef APR_ENAMETOOLONG
case APR_ENAMETOOLONG:
lua_pushliteral(L, "ENAMETOOLONG");
return;
# endif
# ifdef APR_ENETUNREACH
case APR_ENETUNREACH:
lua_pushliteral(L, "ENETUNREACH");
return;
# endif
# ifdef APR_ENFILE
case APR_ENFILE:
lua_pushliteral(L, "ENFILE");
return;
# endif
# ifdef APR_ENODIR
case APR_ENODIR:
lua_pushliteral(L, "ENODIR");
return;
# endif
# ifdef APR_ENOENT
case APR_ENOENT:
lua_pushliteral(L, "ENOENT");
return;
# endif
# ifdef APR_ENOLOCK
case APR_ENOLOCK:
lua_pushliteral(L, "ENOLOCK");
return;
# endif
# ifdef APR_ENOMEM
case APR_ENOMEM:
lua_pushliteral(L, "ENOMEM");
return;
# endif
# ifdef APR_ENOPOLL
case APR_ENOPOLL:
lua_pushliteral(L, "ENOPOLL");
return;
# endif
# ifdef APR_ENOPOOL
case APR_ENOPOOL:
lua_pushliteral(L, "ENOPOOL");
return;
# endif
# ifdef APR_ENOPROC
case APR_ENOPROC:
lua_pushliteral(L, "ENOPROC");
return;
# endif
# ifdef APR_ENOSHMAVAIL
case APR_ENOSHMAVAIL:
lua_pushliteral(L, "ENOSHMAVAIL");
return;
# endif
# ifdef APR_ENOSOCKET
case APR_ENOSOCKET:
lua_pushliteral(L, "ENOSOCKET");
return;
# endif
# ifdef APR_ENOSPC
case APR_ENOSPC:
lua_pushliteral(L, "ENOSPC");
return;
# endif
# ifdef APR_ENOSTAT
case APR_ENOSTAT:
lua_pushliteral(L, "ENOSTAT");
return;
# endif
# ifdef APR_ENOTDIR
case APR_ENOTDIR:
lua_pushliteral(L, "ENOTDIR");
return;
# endif
# ifdef APR_ENOTEMPTY
case APR_ENOTEMPTY:
lua_pushliteral(L, "ENOTEMPTY");
return;
# endif
# ifdef APR_ENOTENOUGHENTROPY
case APR_ENOTENOUGHENTROPY:
lua_pushliteral(L, "ENOTENOUGHENTROPY");
return;
# endif
# ifdef APR_ENOTHDKEY
case APR_ENOTHDKEY:
lua_pushliteral(L, "ENOTHDKEY");
return;
# endif
# ifdef APR_ENOTHREAD
case APR_ENOTHREAD:
lua_pushliteral(L, "ENOTHREAD");
return;
# endif
# ifdef APR_ENOTIME
case APR_ENOTIME:
lua_pushliteral(L, "ENOTIME");
return;
# endif
# ifdef APR_ENOTIMPL
case APR_ENOTIMPL:
lua_pushliteral(L, "ENOTIMPL");
return;
# endif
# ifdef APR_ENOTSOCK
case APR_ENOTSOCK:
lua_pushliteral(L, "ENOTSOCK");
return;
# endif
# ifdef APR_EOF
case APR_EOF:
lua_pushliteral(L, "EOF");
return;
# endif
# ifdef APR_EPATHWILD
case APR_EPATHWILD:
lua_pushliteral(L, "EPATHWILD");
return;
# endif
# ifdef APR_EPIPE
case APR_EPIPE:
lua_pushliteral(L, "EPIPE");
return;
# endif
# ifdef APR_EPROC_UNKNOWN
case APR_EPROC_UNKNOWN:
lua_pushliteral(L, "EPROC_UNKNOWN");
return;
# endif
# ifdef APR_ERELATIVE
case APR_ERELATIVE:
lua_pushliteral(L, "ERELATIVE");
return;
# endif
# ifdef APR_ESPIPE
case APR_ESPIPE:
lua_pushliteral(L, "ESPIPE");
return;
# endif
# ifdef APR_ESYMNOTFOUND
case APR_ESYMNOTFOUND:
lua_pushliteral(L, "ESYMNOTFOUND");
return;
# endif
# ifdef APR_ETIMEDOUT
case APR_ETIMEDOUT:
lua_pushliteral(L, "ETIMEDOUT");
return;
# endif
# ifdef APR_EXDEV
case APR_EXDEV:
lua_pushliteral(L, "EXDEV");
return;
# endif
# ifdef APR_FILEBASED
case APR_FILEBASED:
lua_pushliteral(L, "FILEBASED");
return;
# endif
# ifdef APR_INCHILD
case APR_INCHILD:
lua_pushliteral(L, "INCHILD");
return;
# endif
# ifdef APR_INCOMPLETE
case APR_INCOMPLETE:
lua_pushliteral(L, "INCOMPLETE");
return;
# endif
# ifdef APR_INPARENT
case APR_INPARENT:
lua_pushliteral(L, "INPARENT");
return;
# endif
# ifdef APR_KEYBASED
case APR_KEYBASED:
lua_pushliteral(L, "KEYBASED");
return;
# endif
# ifdef APR_NOTDETACH
case APR_NOTDETACH:
lua_pushliteral(L, "NOTDETACH");
return;
# endif
# ifdef APR_NOTFOUND
case APR_NOTFOUND:
lua_pushliteral(L, "NOTFOUND");
return;
# endif
# ifdef APR_SUCCESS
case APR_SUCCESS:
lua_pushliteral(L, "SUCCESS");
return;
# endif
# ifdef APR_TIMEUP
case APR_TIMEUP:
lua_pushliteral(L, "TIMEUP");
return;
# endif
}
/* If the switch statement fails we fall back to the following monstrosity :-) */
if (0) ;
# ifdef APR_STATUS_IS_ANONYMOUS
else if (APR_STATUS_IS_ANONYMOUS(status)) {
lua_pushliteral(L, "ANONYMOUS");
return;
}
# endif
# ifdef APR_STATUS_IS_BADARG
else if (APR_STATUS_IS_BADARG(status)) {
lua_pushliteral(L, "BADARG");
return;
}
# endif
# ifdef APR_STATUS_IS_BADCH
else if (APR_STATUS_IS_BADCH(status)) {
lua_pushliteral(L, "BADCH");
return;
}
# endif
# ifdef APR_STATUS_IS_DETACH
else if (APR_STATUS_IS_DETACH(status)) {
lua_pushliteral(L, "DETACH");
return;
}
# endif
# ifdef APR_STATUS_IS_EABOVEROOT
else if (APR_STATUS_IS_EABOVEROOT(status)) {
lua_pushliteral(L, "EABOVEROOT");
return;
}
# endif
# ifdef APR_STATUS_IS_EABSOLUTE
else if (APR_STATUS_IS_EABSOLUTE(status)) {
lua_pushliteral(L, "EABSOLUTE");
return;
}
# endif
# ifdef APR_STATUS_IS_EACCES
else if (APR_STATUS_IS_EACCES(status)) {
lua_pushliteral(L, "EACCES");
return;
}
# endif
# ifdef APR_STATUS_IS_EAFNOSUPPORT
else if (APR_STATUS_IS_EAFNOSUPPORT(status)) {
lua_pushliteral(L, "EAFNOSUPPORT");
return;
}
# endif
# ifdef APR_STATUS_IS_EAGAIN
else if (APR_STATUS_IS_EAGAIN(status)) {
lua_pushliteral(L, "EAGAIN");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADDATE
else if (APR_STATUS_IS_EBADDATE(status)) {
lua_pushliteral(L, "EBADDATE");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADF
else if (APR_STATUS_IS_EBADF(status)) {
lua_pushliteral(L, "EBADF");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADIP
else if (APR_STATUS_IS_EBADIP(status)) {
lua_pushliteral(L, "EBADIP");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADMASK
else if (APR_STATUS_IS_EBADMASK(status)) {
lua_pushliteral(L, "EBADMASK");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADPATH
else if (APR_STATUS_IS_EBADPATH(status)) {
lua_pushliteral(L, "EBADPATH");
return;
}
# endif
# ifdef APR_STATUS_IS_EBUSY
else if (APR_STATUS_IS_EBUSY(status)) {
lua_pushliteral(L, "EBUSY");
return;
}
# endif
# ifdef APR_STATUS_IS_ECONNABORTED
else if (APR_STATUS_IS_ECONNABORTED(status)) {
lua_pushliteral(L, "ECONNABORTED");
return;
}
# endif
# ifdef APR_STATUS_IS_ECONNREFUSED
else if (APR_STATUS_IS_ECONNREFUSED(status)) {
lua_pushliteral(L, "ECONNREFUSED");
return;
}
# endif
# ifdef APR_STATUS_IS_ECONNRESET
else if (APR_STATUS_IS_ECONNRESET(status)) {
lua_pushliteral(L, "ECONNRESET");
return;
}
# endif
# ifdef APR_STATUS_IS_EDSOOPEN
else if (APR_STATUS_IS_EDSOOPEN(status)) {
lua_pushliteral(L, "EDSOOPEN");
return;
}
# endif
# ifdef APR_STATUS_IS_EEXIST
else if (APR_STATUS_IS_EEXIST(status)) {
lua_pushliteral(L, "EEXIST");
return;
}
# endif
# ifdef APR_STATUS_IS_EFTYPE
else if (APR_STATUS_IS_EFTYPE(status)) {
lua_pushliteral(L, "EFTYPE");
return;
}
# endif
# ifdef APR_STATUS_IS_EGENERAL
else if (APR_STATUS_IS_EGENERAL(status)) {
lua_pushliteral(L, "EGENERAL");
return;
}
# endif
# ifdef APR_STATUS_IS_EHOSTUNREACH
else if (APR_STATUS_IS_EHOSTUNREACH(status)) {
lua_pushliteral(L, "EHOSTUNREACH");
return;
}
# endif
# ifdef APR_STATUS_IS_EINCOMPLETE
else if (APR_STATUS_IS_EINCOMPLETE(status)) {
lua_pushliteral(L, "EINCOMPLETE");
return;
}
# endif
# ifdef APR_STATUS_IS_EINIT
else if (APR_STATUS_IS_EINIT(status)) {
lua_pushliteral(L, "EINIT");
return;
}
# endif
# ifdef APR_STATUS_IS_EINPROGRESS
else if (APR_STATUS_IS_EINPROGRESS(status)) {
lua_pushliteral(L, "EINPROGRESS");
return;
}
# endif
# ifdef APR_STATUS_IS_EINTR
else if (APR_STATUS_IS_EINTR(status)) {
lua_pushliteral(L, "EINTR");
return;
}
# endif
# ifdef APR_STATUS_IS_EINVAL
else if (APR_STATUS_IS_EINVAL(status)) {
lua_pushliteral(L, "EINVAL");
return;
}
# endif
# ifdef APR_STATUS_IS_EINVALSOCK
else if (APR_STATUS_IS_EINVALSOCK(status)) {
lua_pushliteral(L, "EINVALSOCK");
return;
}
# endif
# ifdef APR_STATUS_IS_EMFILE
else if (APR_STATUS_IS_EMFILE(status)) {
lua_pushliteral(L, "EMFILE");
return;
}
# endif
# ifdef APR_STATUS_IS_EMISMATCH
else if (APR_STATUS_IS_EMISMATCH(status)) {
lua_pushliteral(L, "EMISMATCH");
return;
}
# endif
# ifdef APR_STATUS_IS_ENAMETOOLONG
else if (APR_STATUS_IS_ENAMETOOLONG(status)) {
lua_pushliteral(L, "ENAMETOOLONG");
return;
}
# endif
# ifdef APR_STATUS_IS_ENETUNREACH
else if (APR_STATUS_IS_ENETUNREACH(status)) {
lua_pushliteral(L, "ENETUNREACH");
return;
}
# endif
# ifdef APR_STATUS_IS_ENFILE
else if (APR_STATUS_IS_ENFILE(status)) {
lua_pushliteral(L, "ENFILE");
return;
}
# endif
# ifdef APR_STATUS_IS_ENODIR
else if (APR_STATUS_IS_ENODIR(status)) {
lua_pushliteral(L, "ENODIR");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOENT
else if (APR_STATUS_IS_ENOENT(status)) {
lua_pushliteral(L, "ENOENT");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOLOCK
else if (APR_STATUS_IS_ENOLOCK(status)) {
lua_pushliteral(L, "ENOLOCK");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOMEM
else if (APR_STATUS_IS_ENOMEM(status)) {
lua_pushliteral(L, "ENOMEM");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOPOLL
else if (APR_STATUS_IS_ENOPOLL(status)) {
lua_pushliteral(L, "ENOPOLL");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOPOOL
else if (APR_STATUS_IS_ENOPOOL(status)) {
lua_pushliteral(L, "ENOPOOL");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOPROC
else if (APR_STATUS_IS_ENOPROC(status)) {
lua_pushliteral(L, "ENOPROC");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOSHMAVAIL
else if (APR_STATUS_IS_ENOSHMAVAIL(status)) {
lua_pushliteral(L, "ENOSHMAVAIL");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOSOCKET
else if (APR_STATUS_IS_ENOSOCKET(status)) {
lua_pushliteral(L, "ENOSOCKET");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOSPC
else if (APR_STATUS_IS_ENOSPC(status)) {
lua_pushliteral(L, "ENOSPC");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOSTAT
else if (APR_STATUS_IS_ENOSTAT(status)) {
lua_pushliteral(L, "ENOSTAT");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTDIR
else if (APR_STATUS_IS_ENOTDIR(status)) {
lua_pushliteral(L, "ENOTDIR");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTEMPTY
else if (APR_STATUS_IS_ENOTEMPTY(status)) {
lua_pushliteral(L, "ENOTEMPTY");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTENOUGHENTROPY
else if (APR_STATUS_IS_ENOTENOUGHENTROPY(status)) {
lua_pushliteral(L, "ENOTENOUGHENTROPY");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTHDKEY
else if (APR_STATUS_IS_ENOTHDKEY(status)) {
lua_pushliteral(L, "ENOTHDKEY");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTHREAD
else if (APR_STATUS_IS_ENOTHREAD(status)) {
lua_pushliteral(L, "ENOTHREAD");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTIME
else if (APR_STATUS_IS_ENOTIME(status)) {
lua_pushliteral(L, "ENOTIME");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTIMPL
else if (APR_STATUS_IS_ENOTIMPL(status)) {
lua_pushliteral(L, "ENOTIMPL");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTSOCK
else if (APR_STATUS_IS_ENOTSOCK(status)) {
lua_pushliteral(L, "ENOTSOCK");
return;
}
# endif
# ifdef APR_STATUS_IS_EOF
else if (APR_STATUS_IS_EOF(status)) {
lua_pushliteral(L, "EOF");
return;
}
# endif
# ifdef APR_STATUS_IS_EPATHWILD
else if (APR_STATUS_IS_EPATHWILD(status)) {
lua_pushliteral(L, "EPATHWILD");
return;
}
# endif
# ifdef APR_STATUS_IS_EPIPE
else if (APR_STATUS_IS_EPIPE(status)) {
lua_pushliteral(L, "EPIPE");
return;
}
# endif
# ifdef APR_STATUS_IS_EPROC_UNKNOWN
else if (APR_STATUS_IS_EPROC_UNKNOWN(status)) {
lua_pushliteral(L, "EPROC_UNKNOWN");
return;
}
# endif
# ifdef APR_STATUS_IS_ERELATIVE
else if (APR_STATUS_IS_ERELATIVE(status)) {
lua_pushliteral(L, "ERELATIVE");
return;
}
# endif
# ifdef APR_STATUS_IS_ESPIPE
else if (APR_STATUS_IS_ESPIPE(status)) {
lua_pushliteral(L, "ESPIPE");
return;
}
# endif
# ifdef APR_STATUS_IS_ESYMNOTFOUND
else if (APR_STATUS_IS_ESYMNOTFOUND(status)) {
lua_pushliteral(L, "ESYMNOTFOUND");
return;
}
# endif
# ifdef APR_STATUS_IS_ETIMEDOUT
else if (APR_STATUS_IS_ETIMEDOUT(status)) {
lua_pushliteral(L, "ETIMEDOUT");
return;
}
# endif
# ifdef APR_STATUS_IS_EXDEV
else if (APR_STATUS_IS_EXDEV(status)) {
lua_pushliteral(L, "EXDEV");
return;
}
# endif
# ifdef APR_STATUS_IS_FILEBASED
else if (APR_STATUS_IS_FILEBASED(status)) {
lua_pushliteral(L, "FILEBASED");
return;
}
# endif
# ifdef APR_STATUS_IS_INCHILD
else if (APR_STATUS_IS_INCHILD(status)) {
lua_pushliteral(L, "INCHILD");
return;
}
# endif
# ifdef APR_STATUS_IS_INCOMPLETE
else if (APR_STATUS_IS_INCOMPLETE(status)) {
lua_pushliteral(L, "INCOMPLETE");
return;
}
# endif
# ifdef APR_STATUS_IS_INPARENT
else if (APR_STATUS_IS_INPARENT(status)) {
lua_pushliteral(L, "INPARENT");
return;
}
# endif
# ifdef APR_STATUS_IS_KEYBASED
else if (APR_STATUS_IS_KEYBASED(status)) {
lua_pushliteral(L, "KEYBASED");
return;
}
# endif
# ifdef APR_STATUS_IS_NOTDETACH
else if (APR_STATUS_IS_NOTDETACH(status)) {
lua_pushliteral(L, "NOTDETACH");
return;
}
# endif
# ifdef APR_STATUS_IS_NOTFOUND
else if (APR_STATUS_IS_NOTFOUND(status)) {
lua_pushliteral(L, "NOTFOUND");
return;
}
# endif
# ifdef APR_STATUS_IS_TIMEUP
else if (APR_STATUS_IS_TIMEUP(status)) {
lua_pushliteral(L, "TIMEUP");
return;
}
# endif
lua_pushinteger(L, status);
}
static int gettemp(char *path, apr_file_t **doopen, apr_int32_t flags, apr_pool_t *p)
{
register char *start, *trv, *suffp;
char *pad;
apr_finfo_t sbuf;
apr_status_t rv;
apr_uint32_t randnum;
if (randseed==0) {
randseed = (int)apr_time_now();
seedrandom(randseed);
}
for (trv = path; *trv; ++trv)
;
suffp = trv;
--trv;
if (trv < path) {
return APR_EINVAL;
}
/* Fill space with random characters */
while (*trv == 'X') {
randnum = arc4random() % (sizeof(padchar) - 1);
*trv-- = padchar[randnum];
}
start = trv + 1;
/*
* check the target directory.
*/
for (;; --trv) {
if (trv <= path)
break;
if (*trv == '/') {
*trv = '\0';
rv = apr_stat(&sbuf, path, APR_FINFO_TYPE, p);
*trv = '/';
if (rv != APR_SUCCESS)
return rv;
if (sbuf.filetype != APR_DIR) {
return APR_ENOTDIR;
}
break;
}
}
for (;;) {
if ((rv = apr_file_open(doopen, path, flags,
APR_UREAD | APR_UWRITE, p)) == APR_SUCCESS)
return APR_SUCCESS;
if (!APR_STATUS_IS_EEXIST(rv))
return rv;
/* If we have a collision, cycle through the space of filenames */
for (trv = start;;) {
if (*trv == '\0' || trv == suffp)
return APR_EINVAL; /* XXX: is this the correct return code? */
pad = strchr((char *)padchar, *trv);
if (pad == NULL || !*++pad) {
*trv++ = padchar[0];
}
else {
*trv++ = *pad;
break;
}
}
}
/*NOTREACHED*/
}
