static void im_exec_stop(nx_module_t *module)
{
nx_im_exec_conf_t *imconf;
int i;
boolean sigterm_sent = FALSE;
apr_exit_why_e exitwhy;
int exitval;
int sig_num;
apr_status_t rv;
apr_status_t stopped = APR_SUCCESS;
ASSERT(module != NULL);
imconf = (nx_im_exec_conf_t *) module->config;
ASSERT(imconf != NULL);
log_debug("im_exec stopped");
if ( module->input.desc.f != NULL )
{
apr_file_close(module->input.desc.f);
apr_pool_clear(module->input.pool);
module->input.desc.f = NULL;
}
if ( imconf->running == TRUE )
{
for ( i = 0; i < 50; i++ )
{
if ( (rv = apr_proc_wait(&(imconf->proc), &exitval, &exitwhy, APR_NOWAIT)) != APR_SUCCESS )
{
if ( APR_STATUS_IS_CHILD_DONE(rv) )
{
rv = APR_SUCCESS;
break;
}
else if ( i >= 30 )
{ // still running, kill it after 3 sec
if ( sigterm_sent == FALSE )
{
sigterm_sent = TRUE;
#ifdef WIN32
sig_num = 1;
#else
sig_num = SIGTERM;
#endif
}
else
{
if ( i <= 31 )
{
log_warn("process %s did not exit, killing it.", imconf->cmd);
}
#ifdef WIN32
sig_num = 1;
#else
sig_num = SIGKILL;
#endif
}
if ( (rv = apr_proc_kill(&(imconf->proc), sig_num)) != APR_SUCCESS )
{
stopped = rv;
}
}
}
apr_sleep(APR_USEC_PER_SEC / 10);
}
if ( !((stopped == APR_SUCCESS) || APR_STATUS_IS_ENOPROC(stopped)) )
{
log_aprerror(stopped, "im_exec couldn't stop process");
}
}
imconf->event = NULL;
}
apr_status_t wsgi_apr_unix_file_cleanup(void *thefile)
{
apr_file_t *file = thefile;
return apr_file_close(file);
}
/*
* 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;
}
// get_user_info uses CURL calls to get the data for a user name and groups associated
// with a given opensso cookie
static int get_user_info(request_rec *r, const char *cookies, char ** user, char **groups) {
CURL *curl_handle;
CURLcode ec;
curl_global_init(CURL_GLOBAL_ALL);
curl_handle = curl_easy_init();
long no_cert_flag = 0L;
moon_svr_cfg* cfg = ap_get_module_config(r->server->module_config, &moon_module);
if(curl_handle==NULL) {
return HTTP_INTERNAL_SERVER_ERROR;
}
apr_file_t *groups_data;
apr_file_t *user_data;
apr_status_t rv;
// opens the file/stream for writing data about user
if(rv = open_file(r, &user_data, USER_TEMP_FILE_LOC) != OK) {
curl_easy_cleanup(curl_handle);
return rv;
}
// opens the file/stream for writing data about user groups
if(rv = open_file(r, &groups_data, GROUPS_TEMP_FILE_LOC) != OK) {
curl_easy_cleanup(curl_handle);
apr_file_close(user_data);
return rv;
}
// set all options for curl call requesting user data
rv = set_curl_options(curl_handle, (char*)cfg->user_data_url, &no_cert_flag, user_data,
write_data, cookies);
if(rv != OK) {
curl_easy_cleanup(curl_handle);
apr_file_close(user_data);
apr_file_close(groups_data);
return rv;
}
// execute request
ec = curl_easy_perform(curl_handle);
if(ec != CURLE_WRITE_ERROR && ec != CURLE_OK ) {
curl_easy_cleanup(curl_handle);
apr_file_close(user_data);
apr_file_close(groups_data);
return HTTP_INTERNAL_SERVER_ERROR;
}
double x = 0.0;
curl_easy_getinfo(curl_handle,CURLINFO_TOTAL_TIME,&x);
ap_rprintf(r,"\n\n<!--\nTime for user data request: %f\n-->\n\n",x);
// set all options for curl call requesting groups data
rv = set_curl_options(curl_handle, (char*)cfg->group_data_url, &no_cert_flag, groups_data, write_data, cookies);
if(rv != OK) {
curl_easy_cleanup(curl_handle);
apr_file_close(user_data);
apr_file_close(groups_data);
return rv;
}
// execute request
ec = curl_easy_perform(curl_handle);
if(ec != CURLE_WRITE_ERROR && ec != CURLE_OK ) {
curl_easy_cleanup(curl_handle);
apr_file_close(user_data);
apr_file_close(groups_data);
return HTTP_INTERNAL_SERVER_ERROR;
}
curl_easy_getinfo(curl_handle,CURLINFO_TOTAL_TIME,&x);
ap_rprintf(r,"\n\n<!--\nTime for group data request: %f\n-->\n\n",x);
// parse information from responses
get_user(r, user_data, user);
get_groups(r, groups_data, groups);
// cleanup and return
curl_easy_cleanup(curl_handle);
apr_file_close(user_data);
apr_file_close(groups_data);
return OK;
}
static int asis_handler(request_rec *r)
{
conn_rec *c = r->connection;
apr_file_t *f = NULL;
apr_status_t rv;
const char *location;
if(strcmp(r->handler,ASIS_MAGIC_TYPE) && strcmp(r->handler,"send-as-is"))
return DECLINED;
r->allowed |= (AP_METHOD_BIT << M_GET);
if (r->method_number != M_GET)
return DECLINED;
if (r->finfo.filetype == 0) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"File does not exist: %s", r->filename);
return HTTP_NOT_FOUND;
}
if ((rv = apr_file_open(&f, r->filename, APR_READ,
APR_OS_DEFAULT, r->pool)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"file permissions deny server access: %s", r->filename);
return HTTP_FORBIDDEN;
}
ap_scan_script_header_err(r, f, NULL);
location = apr_table_get(r->headers_out, "Location");
if (location && location[0] == '/' &&
((r->status == HTTP_OK) || ap_is_HTTP_REDIRECT(r->status))) {
apr_file_close(f);
/* Internal redirect -- fake-up a pseudo-request */
r->status = HTTP_OK;
/* This redirect needs to be a GET no matter what the original
* method was.
*/
r->method = apr_pstrdup(r->pool, "GET");
r->method_number = M_GET;
ap_internal_redirect_handler(location, r);
return OK;
}
if (!r->header_only) {
apr_bucket_brigade *bb;
apr_bucket *b;
apr_off_t pos = 0;
rv = apr_file_seek(f, APR_CUR, &pos);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"mod_asis: failed to find end-of-headers position "
"for %s", r->filename);
apr_file_close(f);
return HTTP_INTERNAL_SERVER_ERROR;
}
bb = apr_brigade_create(r->pool, c->bucket_alloc);
#if APR_HAS_LARGE_FILES
if (r->finfo.size - pos > AP_MAX_SENDFILE) {
/* APR_HAS_LARGE_FILES issue; must split into mutiple buckets,
* no greater than MAX(apr_size_t), and more granular than that
* in case the brigade code/filters attempt to read it directly.
*/
apr_off_t fsize = r->finfo.size - pos;
b = apr_bucket_file_create(f, pos, AP_MAX_SENDFILE,
r->pool, c->bucket_alloc);
while (fsize > AP_MAX_SENDFILE) {
APR_BRIGADE_INSERT_TAIL(bb, b);
apr_bucket_copy(b, &b);
b->start += AP_MAX_SENDFILE;
fsize -= AP_MAX_SENDFILE;
}
b->length = (apr_size_t)fsize; /* Resize just the last bucket */
}
else
#endif
b = apr_bucket_file_create(f, pos, (apr_size_t) (r->finfo.size - pos),
r->pool, c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
b = apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
rv = ap_pass_brigade(r->output_filters, bb);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"mod_asis: ap_pass_brigade failed for file %s", r->filename);
return HTTP_INTERNAL_SERVER_ERROR;
}
}
else {
apr_file_close(f);
}
return OK;
}
void nx_expr_proc__xm_fileop_file_truncate(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;
nx_expr_arg_t *offset;
nx_value_t offsetval;
nx_exception_t e;
apr_off_t offs = 0;
apr_status_t rv;
apr_pool_t *pool;
apr_file_t *fd;
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");
}
if ( file.type != NX_VALUE_TYPE_STRING )
{
nx_value_kill(&file);
throw_msg("string type required for 'file'");
}
if ( (offset = NX_DLIST_NEXT(arg, link)) != NULL )
{
ASSERT(offset->expr != NULL);
try
{
nx_expr_evaluate(eval_ctx, &offsetval, offset->expr);
}
catch(e)
{
nx_value_kill(&file);
rethrow(e);
}
if ( offsetval.defined != TRUE )
{
nx_value_kill(&file);
throw_msg("'offset' is undef");
}
if ( offsetval.type != NX_VALUE_TYPE_INTEGER )
{
nx_value_kill(&offsetval);
nx_value_kill(&file);
throw_msg("integer type required for 'offset'");
}
offs = (apr_off_t) offsetval.integer;
}
pool = nx_pool_create_core();
if ( (rv = apr_file_open(&fd, file.string->buf, APR_WRITE | APR_CREATE, APR_OS_DEFAULT,
pool)) != APR_SUCCESS )
{
log_aprerror(rv, "failed to open file '%s' when trying to truncate",
file.string->buf);
}
if ( rv == APR_SUCCESS )
{
if ( (rv = apr_file_trunc(fd, offs)) != APR_SUCCESS )
{
log_aprerror(rv, "failed to truncate file '%s' to length %lu",
file.string->buf, (long unsigned int) offs);
}
apr_file_close(fd);
}
apr_pool_destroy(pool);
nx_value_kill(&file);
}
void upload_new_resource(const std::string& src_filename, std::string name,
std::string desc, S32 compression_info,
LLAssetType::EType destination_folder_type,
LLInventoryType::EType inv_type,
U32 next_owner_perm,
const std::string& display_name,
LLAssetStorage::LLStoreAssetCallback callback,
void *userdata)
{
// Generate the temporary UUID.
std::string filename = gDirUtilp->getTempFilename();
LLTransactionID tid;
LLAssetID uuid;
LLStringUtil::format_map_t args;
std::string exten = gDirUtilp->getExtension(src_filename);
LLAssetType::EType asset_type = LLAssetType::AT_NONE;
std::string error_message;
BOOL error = FALSE;
if (exten.empty())
{
std::string short_name = gDirUtilp->getBaseFileName(filename);
// No extension
error_message = llformat(
"No file extension for the file: '%s'\nPlease make sure the file has a correct file extension",
short_name.c_str());
args["[FILE]"] = short_name;
upload_error(error_message, "NofileExtension", filename, args);
return;
}
else if( exten == "bmp")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_BMP ))
{
error_message = llformat( "Problem with file %s:\n\n%s\n",
src_filename.c_str(), LLImageBase::getLastError().c_str());
args["[FILE]"] = src_filename;
args["[ERROR]"] = LLImageBase::getLastError();
upload_error(error_message, "ProblemWithFile", filename, args);
return;
}
}
else if( exten == "tga")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_TGA ))
{
error_message = llformat("Problem with file %s:\n\n%s\n",
src_filename.c_str(), LLImageBase::getLastError().c_str());
args["[FILE]"] = src_filename;
args["[ERROR]"] = LLImageBase::getLastError();
upload_error(error_message, "ProblemWithFile", filename, args);
return;
}
}
else if( exten == "jpg" || exten == "jpeg")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_JPEG ))
{
error_message = llformat("Problem with file %s:\n\n%s\n",
src_filename.c_str(), LLImageBase::getLastError().c_str());
args["[FILE]"] = src_filename;
args["[ERROR]"] = LLImageBase::getLastError();
upload_error(error_message, "ProblemWithFile", filename, args);
return;
}
}
else if( exten == "png")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_PNG ))
{
error_message = llformat("Problem with file %s:\n\n%s\n",
src_filename.c_str(), LLImageBase::getLastError().c_str());
args["[FILE]"] = src_filename;
args["[ERROR]"] = LLImageBase::getLastError();
upload_error(error_message, "ProblemWithFile", filename, args);
return;
}
}
else if(exten == "wav")
{
asset_type = LLAssetType::AT_SOUND; // tag it as audio
S32 encode_result = 0;
llinfos << "Attempting to encode wav as an ogg file" << llendl;
encode_result = encode_vorbis_file(src_filename, filename);
if (LLVORBISENC_NOERR != encode_result)
{
switch(encode_result)
{
case LLVORBISENC_DEST_OPEN_ERR:
error_message = llformat( "Couldn't open temporary compressed sound file for writing: %s\n", filename.c_str());
args["[FILE]"] = filename;
upload_error(error_message, "CannotOpenTemporarySoundFile", filename, args);
break;
default:
error_message = llformat("Unknown vorbis encode failure on: %s\n", src_filename.c_str());
args["[FILE]"] = src_filename;
upload_error(error_message, "UnknownVorbisEncodeFailure", filename, args);
break;
}
return;
}
}
else if(exten == "tmp")
{
// This is a generic .lin resource file
asset_type = LLAssetType::AT_OBJECT;
LLFILE* in = LLFile::fopen(src_filename, "rb"); /* Flawfinder: ignore */
if (in)
{
// read in the file header
char buf[16384]; /* Flawfinder: ignore */
S32 read; /* Flawfinder: ignore */
S32 version;
if (fscanf(in, "LindenResource\nversion %d\n", &version))
{
if (2 == version)
{
// *NOTE: This buffer size is hard coded into scanf() below.
char label[MAX_STRING]; /* Flawfinder: ignore */
char value[MAX_STRING]; /* Flawfinder: ignore */
S32 tokens_read;
while (fgets(buf, 1024, in))
{
label[0] = '\0';
value[0] = '\0';
tokens_read = sscanf( /* Flawfinder: ignore */
buf,
"%254s %254s\n",
label, value);
llinfos << "got: " << label << " = " << value
<< llendl;
if (EOF == tokens_read)
{
fclose(in);
error_message = llformat("corrupt resource file: %s", src_filename.c_str());
args["[FILE]"] = src_filename;
upload_error(error_message, "CorruptResourceFile", filename, args);
return;
}
if (2 == tokens_read)
{
if (! strcmp("type", label))
{
asset_type = (LLAssetType::EType)(atoi(value));
}
}
else
{
if (! strcmp("_DATA_", label))
{
// below is the data section
break;
}
}
// other values are currently discarded
}
}
else
{
fclose(in);
error_message = llformat("unknown linden resource file version in file: %s", src_filename.c_str());
args["[FILE]"] = src_filename;
upload_error(error_message, "UnknownResourceFileVersion", filename, args);
return;
}
}
else
{
// this is an original binary formatted .lin file
// start over at the beginning of the file
fseek(in, 0, SEEK_SET);
const S32 MAX_ASSET_DESCRIPTION_LENGTH = 256;
const S32 MAX_ASSET_NAME_LENGTH = 64;
S32 header_size = 34 + MAX_ASSET_DESCRIPTION_LENGTH + MAX_ASSET_NAME_LENGTH;
S16 type_num;
// read in and throw out most of the header except for the type
if (fread(buf, header_size, 1, in) != 1)
{
llwarns << "Short read" << llendl;
}
memcpy(&type_num, buf + 16, sizeof(S16)); /* Flawfinder: ignore */
asset_type = (LLAssetType::EType)type_num;
}
// copy the file's data segment into another file for uploading
LLFILE* out = LLFile::fopen(filename, "wb"); /* Flawfinder: ignore */
if (out)
{
while((read = fread(buf, 1, 16384, in))) /* Flawfinder: ignore */
{
if (fwrite(buf, 1, read, out) != read)
{
llwarns << "Short write" << llendl;
}
}
fclose(out);
}
else
{
fclose(in);
error_message = llformat( "Unable to create output file: %s", filename.c_str());
args["[FILE]"] = filename;
upload_error(error_message, "UnableToCreateOutputFile", filename, args);
return;
}
fclose(in);
}
else
{
llinfos << "Couldn't open .lin file " << src_filename << llendl;
}
}
else if (exten == "bvh")
{
error_message = llformat("We do not currently support bulk upload of animation files\n");
upload_error(error_message, "DoNotSupportBulkAnimationUpload", filename, args);
return;
}
else
{
// Unknown extension
// *TODO: Translate?
error_message = llformat("Unknown file extension .%s\nExpected .wav, .tga, .bmp, .jpg, .jpeg, or .bvh", exten.c_str());
error = TRUE;;
}
// gen a new transaction ID for this asset
tid.generate();
if (!error)
{
uuid = tid.makeAssetID(gAgent.getSecureSessionID());
// copy this file into the vfs for upload
S32 file_size;
apr_file_t* fp = ll_apr_file_open(filename, LL_APR_RB, &file_size);
if (fp)
{
LLVFile file(gVFS, uuid, asset_type, LLVFile::WRITE);
file.setMaxSize(file_size);
const S32 buf_size = 65536;
U8 copy_buf[buf_size];
while ((file_size = ll_apr_file_read(fp, copy_buf, buf_size)))
{
file.write(copy_buf, file_size);
}
apr_file_close(fp);
}
else
{
error_message = llformat( "Unable to access output file: %s", filename.c_str());
error = TRUE;
}
}
if (!error)
{
std::string t_disp_name = display_name;
if (t_disp_name.empty())
{
t_disp_name = src_filename;
}
upload_new_resource(tid, asset_type, name, desc, compression_info, // tid
destination_folder_type, inv_type, next_owner_perm,
display_name, callback, userdata);
}
else
{
llwarns << error_message << llendl;
LLStringUtil::format_map_t args;
args["[ERROR_MESSAGE]"] = error_message;
gViewerWindow->alertXml("ErrorMessage", args);
if(LLFile::remove(filename) == -1)
{
lldebugs << "unable to remove temp file" << llendl;
}
LLFilePicker::instance().reset();
}
}
static void load_config(mapcache_context *ctx, char *filename)
{
apr_file_t *f;
apr_finfo_t finfo;
mapcache_cfg *old_cfg;
mapcache_cfg *cfg;
if((apr_file_open(&f, filename, APR_FOPEN_READ, APR_UREAD | APR_GREAD,
global_pool)) == APR_SUCCESS) {
apr_file_info_get(&finfo, APR_FINFO_MTIME, f);
apr_file_close(f);
} else {
if(!ctx->pool) ctx->pool = global_pool;
ctx->set_error(ctx,500,"failed to open config file %s",filename);
return;
}
if(ctx->config) {
//we already have a loaded configuration, check that the config file hasn't changed
if(finfo.mtime > mtime) {
ctx->log(ctx,MAPCACHE_INFO,"config file has changed, reloading");
} else {
return;
}
}
mtime = finfo.mtime;
/* either we have no config, or it has changed */
old_cfg = ctx->config;
apr_pool_create(&tmp_config_pool,global_pool);
cfg = mapcache_configuration_create(tmp_config_pool);
ctx->config = cfg;
ctx->pool = tmp_config_pool;
mapcache_configuration_parse(ctx,conffile,cfg,1);
if(GC_HAS_ERROR(ctx)) goto failed_load;
mapcache_configuration_post_config(ctx, cfg);
if(GC_HAS_ERROR(ctx)) goto failed_load;
if(mapcache_config_services_enabled(ctx,cfg) <= 0) {
ctx->set_error(ctx,500,"no mapcache <service>s configured/enabled, no point in continuing.");
goto failed_load;
}
/* no error, destroy the previous pool if we are reloading the config */
if(config_pool) {
apr_pool_destroy(config_pool);
}
config_pool = tmp_config_pool;
mapcache_connection_pool_create(&ctx->connection_pool, config_pool);
return;
failed_load:
/* we failed to load the config file */
if(config_pool) {
/* we already have a running configuration, keep it and only log the error to not
* interrupt the already running service */
ctx->log(ctx,MAPCACHE_ERROR,"failed to reload config file %s: %s", conffile,ctx->get_error_message(ctx));
ctx->clear_errors(ctx);
ctx->config = old_cfg;
ctx->pool = config_pool;
apr_pool_destroy(tmp_config_pool);
}
}
static int ssl_need_client_cert(SSL *ssl, X509 **cert, EVP_PKEY **pkey)
{
serf_ssl_context_t *ctx = SSL_get_app_data(ssl);
apr_status_t status;
if (ctx->cached_cert) {
*cert = ctx->cached_cert;
*pkey = ctx->cached_cert_pw;
return 1;
}
while (ctx->cert_callback) {
const char *cert_path;
apr_file_t *cert_file;
BIO *bio;
PKCS12 *p12;
int i;
int retrying_success = 0;
if (ctx->cert_file_success) {
status = APR_SUCCESS;
cert_path = ctx->cert_file_success;
ctx->cert_file_success = NULL;
retrying_success = 1;
} else {
status = ctx->cert_callback(ctx->cert_userdata, &cert_path);
}
if (status || !cert_path) {
break;
}
/* Load the x.509 cert file stored in PKCS12 */
status = apr_file_open(&cert_file, cert_path, APR_READ, APR_OS_DEFAULT,
ctx->pool);
if (status) {
continue;
}
bio = BIO_new(&bio_file_method);
bio->ptr = cert_file;
ctx->cert_path = cert_path;
p12 = d2i_PKCS12_bio(bio, NULL);
apr_file_close(cert_file);
i = PKCS12_parse(p12, NULL, pkey, cert, NULL);
if (i == 1) {
PKCS12_free(p12);
ctx->cached_cert = *cert;
ctx->cached_cert_pw = *pkey;
if (!retrying_success && ctx->cert_cache_pool) {
const char *c;
c = apr_pstrdup(ctx->cert_cache_pool, ctx->cert_path);
apr_pool_userdata_setn(c, "serf:ssl:cert",
apr_pool_cleanup_null,
ctx->cert_cache_pool);
}
return 1;
}
else {
int err = ERR_get_error();
ERR_clear_error();
if (ERR_GET_LIB(err) == ERR_LIB_PKCS12 &&
ERR_GET_REASON(err) == PKCS12_R_MAC_VERIFY_FAILURE) {
if (ctx->cert_pw_callback) {
const char *password;
if (ctx->cert_pw_success) {
status = APR_SUCCESS;
password = ctx->cert_pw_success;
ctx->cert_pw_success = NULL;
} else {
status = ctx->cert_pw_callback(ctx->cert_pw_userdata,
ctx->cert_path,
&password);
}
if (!status && password) {
i = PKCS12_parse(p12, password, pkey, cert, NULL);
if (i == 1) {
PKCS12_free(p12);
ctx->cached_cert = *cert;
ctx->cached_cert_pw = *pkey;
if (!retrying_success && ctx->cert_cache_pool) {
const char *c;
c = apr_pstrdup(ctx->cert_cache_pool,
ctx->cert_path);
apr_pool_userdata_setn(c, "serf:ssl:cert",
apr_pool_cleanup_null,
ctx->cert_cache_pool);
}
if (!retrying_success && ctx->cert_pw_cache_pool) {
const char *c;
c = apr_pstrdup(ctx->cert_pw_cache_pool,
password);
apr_pool_userdata_setn(c, "serf:ssl:certpw",
apr_pool_cleanup_null,
ctx->cert_pw_cache_pool);
}
return 1;
}
}
}
PKCS12_free(p12);
return 0;
}
else {
printf("OpenSSL cert error: %d %d %d\n", ERR_GET_LIB(err),
ERR_GET_FUNC(err),
ERR_GET_REASON(err));
PKCS12_free(p12);
}
}
}
return 0;
}
static void cache_the_file(cmd_parms *cmd, const char *filename, int mmap)
{
a_server_config *sconf;
a_file *new_file;
a_file tmp;
apr_file_t *fd = NULL;
apr_status_t rc;
const char *fspec;
fspec = ap_server_root_relative(cmd->pool, filename);
if (!fspec) {
ap_log_error(APLOG_MARK, APLOG_WARNING, APR_EBADPATH, cmd->server, APLOGNO(00794)
"invalid file path "
"%s, skipping", filename);
return;
}
if ((rc = apr_stat(&tmp.finfo, fspec, APR_FINFO_MIN,
cmd->temp_pool)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_WARNING, rc, cmd->server, APLOGNO(00795)
"unable to stat(%s), skipping", fspec);
return;
}
if (tmp.finfo.filetype != APR_REG) {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, cmd->server, APLOGNO(00796)
"%s isn't a regular file, skipping", fspec);
return;
}
if (tmp.finfo.size > AP_MAX_SENDFILE) {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, cmd->server, APLOGNO(00797)
"%s is too large to cache, skipping", fspec);
return;
}
rc = apr_file_open(&fd, fspec, APR_READ | APR_BINARY | APR_XTHREAD,
APR_OS_DEFAULT, cmd->pool);
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_WARNING, rc, cmd->server, APLOGNO(00798)
"unable to open(%s, O_RDONLY), skipping", fspec);
return;
}
apr_file_inherit_set(fd);
/* WooHoo, we have a file to put in the cache */
new_file = apr_pcalloc(cmd->pool, sizeof(a_file));
new_file->finfo = tmp.finfo;
#if APR_HAS_MMAP
if (mmap) {
/* MMAPFile directive. MMAP'ing the file
* XXX: APR_HAS_LARGE_FILES issue; need to reject this request if
* size is greater than MAX(apr_size_t) (perhaps greater than 1M?).
*/
if ((rc = apr_mmap_create(&new_file->mm, fd, 0,
(apr_size_t)new_file->finfo.size,
APR_MMAP_READ, cmd->pool)) != APR_SUCCESS) {
apr_file_close(fd);
ap_log_error(APLOG_MARK, APLOG_WARNING, rc, cmd->server, APLOGNO(00799)
"unable to mmap %s, skipping", filename);
return;
}
apr_file_close(fd);
new_file->is_mmapped = TRUE;
}
#endif
#if APR_HAS_SENDFILE
if (!mmap) {
/* CacheFile directive. Caching the file handle */
new_file->is_mmapped = FALSE;
new_file->file = fd;
}
#endif
new_file->filename = fspec;
apr_rfc822_date(new_file->mtimestr, new_file->finfo.mtime);
apr_snprintf(new_file->sizestr, sizeof new_file->sizestr, "%" APR_OFF_T_FMT, new_file->finfo.size);
sconf = ap_get_module_config(cmd->server->module_config, &file_cache_module);
apr_hash_set(sconf->fileht, new_file->filename, strlen(new_file->filename), new_file);
}
int a_svn_diff
(char *device_group, char *device_name, char *configured_by, char *repository_path,
char *temp_working_dir, apr_pool_t *apr_pool, apr_pool_t *svn_pool)
/*
*
* diff of a working copy and svn head (for a single file)
*
*/
{
svn_error_t* err;
int int_err;
apr_array_header_t *device_arr;
apr_file_t *diff_outfile;
apr_file_t *diff_errfile;
apr_array_header_t *array;
struct stat svn_diff_file_info;
int svn_diff_file_size = 0;
char temp_svn_path[MAXPATH];
char full_device_svn_path[MAXPATH];
char svn_diff_outfname[50]=".";
char svn_diff_errfname[50]=".";
svn_client_ctx_t* context;
svn_error_t *svn_err;
temp_svn_path[0] = 0x0;
full_device_svn_path[0] = 0x0;
strcat(temp_svn_path,temp_working_dir);
strcat(svn_diff_outfname,device_name);
strcat(svn_diff_outfname,".diff.tmp");
strcat(svn_diff_errfname,device_name);
strcat(svn_diff_errfname,".diff.err.tmp");
/* if device is in the device group - add group name to the SVN diff path: */
if(strstr(device_group,"none"))
snprintf(full_device_svn_path,MAXPATH,"%s/%s",repository_path,device_name);
else
snprintf(full_device_svn_path,MAXPATH,"%s/%s/%s",repository_path,device_group,device_name);
apr_file_open(&diff_outfile, svn_diff_outfname, (APR_READ | APR_WRITE | APR_CREATE ),
( APR_FPROT_UREAD | APR_FPROT_UWRITE |
APR_FPROT_GREAD | APR_FPROT_WREAD ),
apr_pool);
apr_file_open(&diff_errfile, svn_diff_errfname, (APR_READ | APR_WRITE | APR_CREATE ),
( APR_FPROT_UREAD | APR_FPROT_UWRITE |
APR_FPROT_GREAD | APR_FPROT_WREAD ),
apr_pool);
svn_err = svn_client_create_context( &context, svn_pool );
if(svn_err){a_logmsg("%s: svn error: %s",device_name,svn_err->message);
a_debug_info2(DEBUGLVL5,"a_svn_diff: svn error: %s",svn_err->message);
return -1;}
svn_opt_revision_t pegrevision;
pegrevision.kind = svn_opt_revision_unspecified;
svn_opt_revision_t revision1;
revision1.kind = svn_opt_revision_working;
svn_opt_revision_t revision2;
revision2.kind = svn_opt_revision_head;
strcat(temp_svn_path,"/");
strcat(temp_svn_path,device_name);
array = apr_array_make (apr_pool, 0, sizeof (const char *));
svn_err = svn_client_diff4(array,
svn_path_canonicalize(temp_svn_path,apr_pool),
&revision1,
svn_path_canonicalize(full_device_svn_path,apr_pool),
&revision2,
NULL,
svn_depth_empty,
FALSE,
TRUE,
FALSE,
APR_LOCALE_CHARSET,
diff_outfile,
diff_errfile,
NULL,
context,
svn_pool);
if(svn_err){
a_logmsg("%s: svn error: %s",device_name,svn_err->message);
a_debug_info2(DEBUGLVL5,"a_svn_diff: svn error: %s",svn_err->message);
return -1;
}
apr_file_close(diff_errfile);
remove(svn_diff_errfname);
apr_file_close(diff_outfile);
if( (stat(svn_diff_outfname,&svn_diff_file_info)) == -1)
a_debug_info2(DEBUGLVL5,"a_svn_diff: cannot stat %s!",svn_diff_outfname);
svn_diff_file_size = (int)svn_diff_file_info.st_size;
if((G_config_info.keep_changelog) && (svn_diff_file_size > 0))
if(!a_add_changelog_entry(svn_diff_outfname, svn_diff_file_size, device_name, configured_by))
{
a_logmsg("a_svn_diff: %s: cannot write changelog entry!",device_name);
a_debug_info2(DEBUGLVL5,"a_svn_diff: cannot write changelog entry!",device_name);
}
/* what we are returning here, is the length of a diff file */
/* if it is nonzero - revisions differ: */
remove(svn_diff_outfname);
return svn_diff_file_size;
}
void nx_config_cache_read()
{
nx_ctx_t *ctx;
apr_off_t offset = 0;
char *buf = NULL;
apr_status_t rv;
apr_size_t nbytes, bytesread, bytesleft;
nx_value_t *version = NULL;
apr_file_t *ccfile;
nx_exception_t e;
ctx = nx_ctx_get();
if ( ctx->nocache == TRUE )
{
return;
}
log_debug("reading config cache from %s", ctx->ccfilename);
rv = apr_file_open(&ccfile, ctx->ccfilename,
APR_READ, APR_OS_DEFAULT, ctx->pool);
if ( APR_STATUS_IS_ENOENT(rv) )
{ // nothing to read
return;
}
CHECKERR_MSG(rv, "couldn't open config cache '%s'", ctx->ccfilename);
try
{
CHECKERR_MSG(apr_file_seek(ccfile, APR_END, &offset),
"couldn't seek in cache file");
if ( offset > NX_CONFIG_CACHE_LIMIT )
{
throw_msg("cache file is too large (%d bytes)", offset);
}
if ( offset > 0 )
{
nbytes = (apr_size_t) offset;
buf = malloc((size_t) offset);
// seek back to start
offset = 0;
CHECKERR_MSG(apr_file_seek(ccfile, APR_SET, &offset),
"couldn't seek in cache file");
// read cache file into memory
if ( (rv = apr_file_read_full(ccfile, buf, nbytes, &bytesread)) != APR_SUCCESS )
{
if ( rv != APR_EOF )
{
CHECKERR_MSG(rv, "failed to read config cache file");
}
}
if ( nbytes != bytesread )
{
throw_msg("read %d bytes, wanted %d", (int) bytesread, (int) nbytes);
}
bytesleft = nbytes;
version = nx_value_from_membuf(buf, nbytes, &bytesread);
if ( version->type != NX_VALUE_TYPE_STRING )
{
throw_msg("string expected for config cache version");
}
if ( strcmp(version->string->buf, NX_CONFIG_CACHE_VERSION) != 0 )
{
throw_msg("config cache version mismatch, expected %s, got %s",
NX_CONFIG_CACHE_VERSION, version->string->buf);
}
bytesleft -= bytesread;
while ( bytesleft > 0 )
{
_read_item(buf + (nbytes - bytesleft), bytesleft,
ctx->config_cache, &bytesread);
ASSERT(bytesread <= bytesleft);
bytesleft -= bytesread;
}
}
}
catch(e)
{
apr_file_close(ccfile);
apr_file_remove(ctx->ccfilename, NULL);
if ( buf != NULL )
{
free(buf);
}
if ( version != NULL )
{
nx_value_free(version);
}
rethrow_msg(e, "failed to read config cache");
}
if ( buf != NULL )
{
free(buf);
}
if ( version != NULL )
{
nx_value_free(version);
}
apr_file_close(ccfile);
//apr_file_remove(ctx->ccfilename, NULL);
}
int
main(int argc, char **argv)
{
svn_error_t *err;
apr_status_t apr_err;
apr_file_t *source_file;
apr_file_t *target_file;
svn_stream_t *stdout_stream;
svn_txdelta_stream_t *txdelta_stream;
svn_txdelta_window_handler_t svndiff_handler;
svn_stream_t *encoder;
void *svndiff_baton;
apr_pool_t *pool;
int version = 0;
if (argc < 3)
{
printf("usage: %s source target [version]\n", argv[0]);
exit(0);
}
apr_initialize();
pool = svn_pool_create(NULL);
apr_err = apr_file_open(&source_file, argv[1], (APR_READ | APR_BINARY),
APR_OS_DEFAULT, pool);
if (apr_err)
{
fprintf(stderr, "unable to open \"%s\" for reading\n", argv[1]);
exit(1);
}
apr_err = apr_file_open(&target_file, argv[2], (APR_READ | APR_BINARY),
APR_OS_DEFAULT, pool);
if (apr_err)
{
fprintf(stderr, "unable to open \"%s\" for reading\n", argv[2]);
exit(1);
}
if (argc == 4)
version = atoi(argv[3]);
svn_txdelta(&txdelta_stream,
svn_stream_from_aprfile(source_file, pool),
svn_stream_from_aprfile(target_file, pool),
pool);
err = svn_stream_for_stdout(&stdout_stream, pool);
if (err)
svn_handle_error2(err, stdout, TRUE, "svndiff-test: ");
#ifdef QUOPRINT_SVNDIFFS
encoder = svn_quoprint_encode(stdout_stream, pool);
#else
encoder = svn_base64_encode(stdout_stream, pool);
#endif
/* use maximum compression level */
svn_txdelta_to_svndiff3(&svndiff_handler, &svndiff_baton,
encoder, version, 9, pool);
err = svn_txdelta_send_txstream(txdelta_stream,
svndiff_handler,
svndiff_baton,
pool);
if (err)
svn_handle_error2(err, stdout, TRUE, "svndiff-test: ");
apr_file_close(source_file);
apr_file_close(target_file);
svn_pool_destroy(pool);
apr_terminate();
exit(0);
}
/** \brief Load GSB database
*
* \param dcfg Pointer to directory configuration
* \param error_msg Error message
*
* \retval 1 On Success
* \retval 0 On Fail
*/
static int gsb_db_create(directory_config *dcfg, char **error_msg)
{
char errstr[1024];
apr_pool_t *mp = dcfg->mp;
gsb_db *gsb = dcfg->gsb;
apr_int32_t wanted = APR_FINFO_SIZE;
apr_finfo_t finfo;
apr_status_t rc;
apr_size_t nbytes;
char *buf = NULL, *p = NULL, *savedptr = NULL;
char *op = NULL;
if ((rc = apr_file_open(&gsb->db, gsb->dbfn, APR_READ, APR_OS_DEFAULT, mp)) != APR_SUCCESS) {
*error_msg = apr_psprintf(mp, "Could not open gsb database \"%s\": %s", gsb->dbfn, apr_strerror(rc, errstr, 1024));
return 0;
}
if ((rc = apr_file_info_get(&finfo, wanted, gsb->db)) != APR_SUCCESS) {
*error_msg = apr_psprintf(mp, "Could not cannot get gsb malware file information \"%s\": %s", gsb->dbfn, apr_strerror(rc, errstr, 1024));
apr_file_close(gsb->db);
return 0;
}
buf = (char *)malloc(finfo.size+1);
if (buf == NULL) {
*error_msg = apr_psprintf(mp, "Could not alloc memory for gsb data");
apr_file_close(gsb->db);
return 0;
}
rc = apr_file_read_full(gsb->db, buf, finfo.size, &nbytes);
gsb->gsb_table = apr_hash_make(dcfg->mp);
if (gsb->gsb_table == NULL) {
*error_msg = apr_psprintf(mp, "Could not alloc memory for gsb table");
free(buf);
buf = NULL;
apr_file_close(gsb->db);
return 0;
}
p = apr_strtok(buf,"\t",&savedptr);
while (p != NULL) {
op = strchr(p,'+');
if(op != NULL) {
char *hash = ++op;
if(strlen(hash) == 32)
apr_hash_set(gsb->gsb_table, hash, APR_HASH_KEY_STRING, "malware");
}
op = strchr(p,'-');
if(op != NULL) {
char *hash = ++op;
if(strlen(hash) == 32)
apr_hash_set(gsb->gsb_table, hash, APR_HASH_KEY_STRING, NULL);
}
p = apr_strtok(NULL,"\t",&savedptr);
}
apr_file_close(gsb->db);
free(buf);
buf = NULL;
return 1;
}
int
main(int argc, char **argv)
{
apr_file_t *source_file_A = NULL;
apr_file_t *target_file_A = NULL;
int count_A = 0;
apr_off_t len_A = 0;
apr_file_t *source_file_B = NULL;
apr_file_t *target_file_B = NULL;
int count_B = 0;
apr_off_t len_B = 0;
apr_pool_t *pool;
int quiet = 0;
if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'q')
{
quiet = 1;
--argc; ++argv;
}
apr_initialize();
pool = svn_pool_create(NULL);
if (argc == 2)
{
target_file_A = open_binary_read(argv[1], pool);
}
else if (argc == 3)
{
source_file_A = open_binary_read(argv[1], pool);
target_file_A = open_binary_read(argv[2], pool);
}
else if (argc == 4)
{
source_file_A = open_binary_read(argv[1], pool);
target_file_A = open_binary_read(argv[2], pool);
source_file_B = open_binary_read(argv[2], pool);
target_file_B = open_binary_read(argv[3], pool);
}
else
{
fprintf(stderr,
"Usage: vdelta-test [-q] <target>\n"
" or: vdelta-test [-q] <source> <target>\n"
" or: vdelta-test [-q] <source> <intermediate> <target>\n");
exit(1);
}
do_one_diff(source_file_A, target_file_A,
&count_A, &len_A, quiet, pool, "A ", stdout);
if (source_file_B)
{
apr_pool_t *fpool = svn_pool_create(pool);
apr_pool_t *wpool = svn_pool_create(pool);
svn_txdelta_stream_t *stream_A = NULL;
svn_txdelta_stream_t *stream_B = NULL;
svn_txdelta_window_t *window_A = NULL;
svn_txdelta_window_t *window_B = NULL;
svn_txdelta_window_t *window_AB = NULL;
int count_AB = 0;
apr_off_t len_AB = 0;
putc('\n', stdout);
do_one_diff(source_file_B, target_file_B,
&count_B, &len_B, quiet, pool, "B ", stdout);
putc('\n', stdout);
{
apr_off_t offset = 0;
apr_file_seek(source_file_A, APR_SET, &offset);
apr_file_seek(target_file_A, APR_SET, &offset);
apr_file_seek(source_file_B, APR_SET, &offset);
apr_file_seek(target_file_B, APR_SET, &offset);
}
svn_txdelta(&stream_A,
svn_stream_from_aprfile(source_file_A, fpool),
svn_stream_from_aprfile(target_file_A, fpool),
fpool);
svn_txdelta(&stream_B,
svn_stream_from_aprfile(source_file_B, fpool),
svn_stream_from_aprfile(target_file_B, fpool),
fpool);
for (count_AB = 0; count_AB < count_B; ++count_AB)
{
svn_error_t *err;
err = svn_txdelta_next_window(&window_A, stream_A, wpool);
if (err)
svn_handle_error2(err, stderr, TRUE, "vdelta-test: ");
err = svn_txdelta_next_window(&window_B, stream_B, wpool);
if (err)
svn_handle_error2(err, stderr, TRUE, "vdelta-test: ");
/* Note: It's not possible that window_B is null, we already
counted the number of windows in the second delta. */
assert(window_A != NULL || window_B->src_ops == 0);
if (window_B->src_ops == 0)
{
window_AB = window_B;
window_AB->sview_len = 0;
}
else
window_AB = svn_txdelta_compose_windows(window_A, window_B,
wpool);
len_AB += print_delta_window(window_AB, "AB", quiet, stdout);
svn_pool_clear(wpool);
}
fprintf(stdout, "AB: (LENGTH %" APR_OFF_T_FMT " +%d)\n",
len_AB, count_AB);
}
if (source_file_A) apr_file_close(source_file_A);
if (target_file_A) apr_file_close(target_file_A);
if (source_file_B) apr_file_close(source_file_B);
if (target_file_B) apr_file_close(source_file_B);
svn_pool_destroy(pool);
apr_terminate();
exit(0);
}
svn_error_t *
svn_cl__edit_string_externally(svn_string_t **edited_contents /* UTF-8! */,
const char **tmpfile_left /* UTF-8! */,
const char *editor_cmd,
const char *base_dir /* UTF-8! */,
const svn_string_t *contents /* UTF-8! */,
const char *filename,
apr_hash_t *config,
svn_boolean_t as_text,
const char *encoding,
apr_pool_t *pool)
{
const char *editor;
const char *cmd;
apr_file_t *tmp_file;
const char *tmpfile_name;
const char *tmpfile_native;
const char *tmpfile_apr, *base_dir_apr;
svn_string_t *translated_contents;
apr_status_t apr_err, apr_err2;
apr_size_t written;
apr_finfo_t finfo_before, finfo_after;
svn_error_t *err = SVN_NO_ERROR, *err2;
char *old_cwd;
int sys_err;
svn_boolean_t remove_file = TRUE;
SVN_ERR(find_editor_binary(&editor, editor_cmd, config));
/* Convert file contents from UTF-8/LF if desired. */
if (as_text)
{
const char *translated;
SVN_ERR(svn_subst_translate_cstring2(contents->data, &translated,
APR_EOL_STR, FALSE,
NULL, FALSE, pool));
translated_contents = svn_string_create("", pool);
if (encoding)
SVN_ERR(svn_utf_cstring_from_utf8_ex2(&translated_contents->data,
translated, encoding, pool));
else
SVN_ERR(svn_utf_cstring_from_utf8(&translated_contents->data,
translated, pool));
translated_contents->len = strlen(translated_contents->data);
}
else
translated_contents = svn_string_dup(contents, pool);
/* Move to BASE_DIR to avoid getting characters that need quoting
into tmpfile_name */
apr_err = apr_filepath_get(&old_cwd, APR_FILEPATH_NATIVE, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, _("Can't get working directory"));
/* APR doesn't like "" directories */
if (base_dir[0] == '\0')
base_dir_apr = ".";
else
SVN_ERR(svn_path_cstring_from_utf8(&base_dir_apr, base_dir, pool));
apr_err = apr_filepath_set(base_dir_apr, pool);
if (apr_err)
{
return svn_error_wrap_apr
(apr_err, _("Can't change working directory to '%s'"), base_dir);
}
/*** From here on, any problems that occur require us to cd back!! ***/
/* Ask the working copy for a temporary file named FILENAME-something. */
err = svn_io_open_uniquely_named(&tmp_file, &tmpfile_name,
"" /* dirpath */,
filename,
".tmp",
svn_io_file_del_none, pool, pool);
if (err && (APR_STATUS_IS_EACCES(err->apr_err) || err->apr_err == EROFS))
{
const char *temp_dir_apr;
svn_error_clear(err);
SVN_ERR(svn_io_temp_dir(&base_dir, pool));
SVN_ERR(svn_path_cstring_from_utf8(&temp_dir_apr, base_dir, pool));
apr_err = apr_filepath_set(temp_dir_apr, pool);
if (apr_err)
{
return svn_error_wrap_apr
(apr_err, _("Can't change working directory to '%s'"), base_dir);
}
err = svn_io_open_uniquely_named(&tmp_file, &tmpfile_name,
"" /* dirpath */,
filename,
".tmp",
svn_io_file_del_none, pool, pool);
}
if (err)
goto cleanup2;
/*** From here on, any problems that occur require us to cleanup
the file we just created!! ***/
/* Dump initial CONTENTS to TMP_FILE. */
apr_err = apr_file_write_full(tmp_file, translated_contents->data,
translated_contents->len, &written);
apr_err2 = apr_file_close(tmp_file);
if (! apr_err)
apr_err = apr_err2;
/* Make sure the whole CONTENTS were written, else return an error. */
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't write to '%s'"),
tmpfile_name);
goto cleanup;
}
err = svn_path_cstring_from_utf8(&tmpfile_apr, tmpfile_name, pool);
if (err)
goto cleanup;
/* Get information about the temporary file before the user has
been allowed to edit its contents. */
apr_err = apr_stat(&finfo_before, tmpfile_apr,
APR_FINFO_MTIME, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* Backdate the file a little bit in case the editor is very fast
and doesn't change the size. (Use two seconds, since some
filesystems have coarse granularity.) It's OK if this call
fails, so we don't check its return value.*/
apr_file_mtime_set(tmpfile_apr, finfo_before.mtime - 2000, pool);
/* Stat it again to get the mtime we actually set. */
apr_err = apr_stat(&finfo_before, tmpfile_apr,
APR_FINFO_MTIME | APR_FINFO_SIZE, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* Prepare the editor command line. */
err = svn_utf_cstring_from_utf8(&tmpfile_native, tmpfile_name, pool);
if (err)
goto cleanup;
cmd = apr_psprintf(pool, "%s %s", editor, tmpfile_native);
/* If the caller wants us to leave the file around, return the path
of the file we'll use, and make a note not to destroy it. */
if (tmpfile_left)
{
*tmpfile_left = svn_dirent_join(base_dir, tmpfile_name, pool);
remove_file = FALSE;
}
/* Now, run the editor command line. */
sys_err = system(cmd);
if (sys_err != 0)
{
/* Extracting any meaning from sys_err is platform specific, so just
use the raw value. */
err = svn_error_createf(SVN_ERR_EXTERNAL_PROGRAM, NULL,
_("system('%s') returned %d"), cmd, sys_err);
goto cleanup;
}
/* Get information about the temporary file after the assumed editing. */
apr_err = apr_stat(&finfo_after, tmpfile_apr,
APR_FINFO_MTIME | APR_FINFO_SIZE, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* If the file looks changed... */
if ((finfo_before.mtime != finfo_after.mtime) ||
(finfo_before.size != finfo_after.size))
{
svn_stringbuf_t *edited_contents_s;
err = svn_stringbuf_from_file2(&edited_contents_s, tmpfile_name, pool);
if (err)
goto cleanup;
*edited_contents = svn_stringbuf__morph_into_string(edited_contents_s);
/* Translate back to UTF8/LF if desired. */
if (as_text)
{
err = svn_subst_translate_string2(edited_contents, FALSE, FALSE,
*edited_contents, encoding, FALSE,
pool, pool);
if (err)
{
err = svn_error_quick_wrap
(err,
_("Error normalizing edited contents to internal format"));
goto cleanup;
}
}
}
else
{
/* No edits seem to have been made */
*edited_contents = NULL;
}
cleanup:
if (remove_file)
{
/* Remove the file from disk. */
err2 = svn_io_remove_file2(tmpfile_name, FALSE, pool);
/* Only report remove error if there was no previous error. */
if (! err && err2)
err = err2;
else
svn_error_clear(err2);
}
cleanup2:
/* If we against all probability can't cd back, all further relative
file references would be screwed up, so we have to abort. */
apr_err = apr_filepath_set(old_cwd, pool);
if (apr_err)
{
svn_handle_error2(svn_error_wrap_apr
(apr_err, _("Can't restore working directory")),
stderr, TRUE /* fatal */, "svn: ");
}
return svn_error_trace(err);
}
void nx_expr_proc__xm_fileop_file_write(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;
nx_expr_arg_t *val;
nx_value_t value;
nx_exception_t e;
apr_status_t rv;
apr_pool_t *pool;
apr_file_t *fd;
ASSERT(module != NULL);
ASSERT(args != NULL);
arg = NX_DLIST_FIRST(args);
ASSERT(arg != NULL);
ASSERT(arg->expr != NULL);
val = NX_DLIST_NEXT(arg, link);
ASSERT(val != NULL);
ASSERT(val->expr != NULL);
nx_expr_evaluate(eval_ctx, &file, arg->expr);
if ( file.defined != TRUE )
{
throw_msg("'file' is undef");
}
if ( file.type != NX_VALUE_TYPE_STRING )
{
nx_value_kill(&file);
throw_msg("string type required for 'file'");
}
try
{
nx_expr_evaluate(eval_ctx, &value, val->expr);
}
catch(e)
{
nx_value_kill(&file);
rethrow(e);
}
if ( value.defined != TRUE )
{
nx_value_kill(&file);
// do not write anything
return;
}
if ( value.type != NX_VALUE_TYPE_STRING )
{
nx_value_kill(&file);
nx_value_kill(&value);
throw_msg("string type required for 'value'");
}
pool = nx_pool_create_core();
if ( (rv = apr_file_open(&fd, file.string->buf, APR_WRITE | APR_CREATE | APR_APPEND,
APR_OS_DEFAULT, pool)) != APR_SUCCESS )
{
log_aprerror(rv, "failed to open file '%s' when trying to write",
file.string->buf);
}
if ( rv == APR_SUCCESS )
{
if ( (rv = apr_file_write_full(fd, value.string->buf, value.string->len, NULL)) != APR_SUCCESS )
{
log_aprerror(rv, "failed to write value to file '%s'", file.string->buf);
}
apr_file_close(fd);
}
apr_pool_destroy(pool);
nx_value_kill(&file);
nx_value_kill(&value);
}
static int
Ganglia_cfg_include(cfg_t *cfg, cfg_opt_t *opt, int argc,
const char **argv)
{
char *fname = (char*)argv[0];
struct stat statbuf;
DIR *dir;
struct dirent *entry;
if(argc != 1)
{
cfg_error(cfg, "wrong number of arguments to cfg_include()");
return 1;
}
if (stat (fname, &statbuf) == 0)
{
return cfg_include(cfg, opt, argc, argv);
}
else if (has_wildcard(fname))
{
int ret;
char *path = calloc(strlen(fname) + 1, sizeof(char));
char *pattern = NULL;
char *idx = strrchr(fname, '/');
apr_pool_t *p;
apr_file_t *ftemp;
char *dirname = NULL;
char tn[] = "gmond.tmp.XXXXXX";
if (idx == NULL) {
idx = strrchr(fname, '\\');
}
if (idx == NULL) {
strncpy (path, ".", 1);
pattern = fname;
}
else {
strncpy (path, fname, idx - fname);
pattern = idx + 1;
}
apr_pool_create(&p, NULL);
if (apr_temp_dir_get((const char**)&dirname, p) != APR_SUCCESS) {
#ifndef LINUX
cfg_error(cfg, "failed to determine the temp dir");
apr_pool_destroy(p);
return 1;
#else
/*
* workaround APR BUG46297 by using the POSIX shared memory
* ramdrive that is available since glibc 2.2
*/
dirname = apr_psprintf(p, "%s", "/dev/shm");
#endif
}
dirname = apr_psprintf(p, "%s/%s", dirname, tn);
if (apr_file_mktemp(&ftemp, dirname,
APR_CREATE | APR_READ | APR_WRITE | APR_DELONCLOSE,
p) != APR_SUCCESS) {
cfg_error(cfg, "unable to create a temporary file %s", dirname);
apr_pool_destroy(p);
return 1;
}
dir = opendir(path);
if(dir != NULL){
while((entry = readdir(dir)) != NULL) {
ret = fnmatch(pattern, entry->d_name,
FNM_PATHNAME|FNM_PERIOD);
if (ret == 0) {
char *newpath, *line;
newpath = apr_psprintf (p, "%s/%s", path, entry->d_name);
line = apr_pstrcat(p, "include ('", newpath, "')\n", NULL);
apr_file_puts(line, ftemp);
}
}
closedir(dir);
free (path);
argv[0] = dirname;
if (cfg_include(cfg, opt, argc, argv))
cfg_error(cfg, "failed to process include file %s", fname);
else
debug_msg("processed include file %s\n", fname);
}
apr_file_close(ftemp);
apr_pool_destroy(p);
argv[0] = fname;
}
else
{
cfg_error(cfg, "invalid include path");
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
apr_status_t status;
apr_pool_t *pool;
serf_bucket_alloc_t *bkt_alloc;
serf_context_t *context;
serf_connection_t **connections;
app_baton_t app_ctx;
handler_baton_t handler_ctx;
serf_bucket_t *req_hdrs = NULL;
apr_uri_t url;
const char *proxy = NULL;
const char *raw_url, *method, *req_body_path = NULL;
int count, inflight, conn_count;
int i;
int print_headers, debug;
const char *username = NULL;
const char *password = "";
const char *pem_path = NULL, *pem_pwd = NULL;
apr_getopt_t *opt;
int opt_c;
const char *opt_arg;
apr_initialize();
atexit(apr_terminate);
apr_pool_create(&pool, NULL);
/* serf_initialize(); */
bkt_alloc = serf_bucket_allocator_create(pool, NULL, NULL);
/* Default to one round of fetching with no limit to max inflight reqs. */
count = 1;
inflight = 0;
conn_count = 1;
/* Default to GET. */
method = "GET";
/* Do not print headers by default. */
print_headers = 0;
/* Do not debug by default. */
debug = 0;
apr_getopt_init(&opt, pool, argc, argv);
while ((status = apr_getopt_long(opt, options, &opt_c, &opt_arg)) ==
APR_SUCCESS) {
switch (opt_c) {
case 'U':
username = opt_arg;
break;
case 'P':
password = opt_arg;
break;
case 'd':
debug = 1;
break;
case 'f':
req_body_path = opt_arg;
break;
case 'h':
print_usage(pool);
exit(0);
break;
case 'H':
print_headers = 1;
break;
case 'm':
method = opt_arg;
break;
case 'n':
errno = 0;
count = apr_strtoi64(opt_arg, NULL, 10);
if (errno) {
printf("Problem converting number of times to fetch URL (%d)\n",
errno);
return errno;
}
break;
case 'c':
errno = 0;
conn_count = apr_strtoi64(opt_arg, NULL, 10);
if (errno) {
printf("Problem converting number of concurrent connections to use (%d)\n",
errno);
return errno;
}
if (conn_count <= 0) {
printf("Invalid number of concurrent connections to use (%d)\n",
conn_count);
return 1;
}
break;
case 'x':
errno = 0;
inflight = apr_strtoi64(opt_arg, NULL, 10);
if (errno) {
printf("Problem converting number of requests to have outstanding (%d)\n",
errno);
return errno;
}
break;
case 'p':
proxy = opt_arg;
break;
case 'r':
{
char *sep;
char *hdr_val;
if (req_hdrs == NULL) {
/* first request header, allocate bucket */
req_hdrs = serf_bucket_headers_create(bkt_alloc);
}
sep = strchr(opt_arg, ':');
if ((sep == NULL) || (sep == opt_arg) || (strlen(sep) <= 1)) {
printf("Invalid request header string (%s)\n", opt_arg);
return EINVAL;
}
hdr_val = sep + 1;
while (*hdr_val == ' ') {
hdr_val++;
}
serf_bucket_headers_setx(req_hdrs, opt_arg, (sep - opt_arg), 1,
hdr_val, strlen(hdr_val), 1);
}
break;
case CERTFILE:
pem_path = opt_arg;
break;
case CERTPWD:
pem_pwd = opt_arg;
break;
case 'v':
puts("Serf version: " SERF_VERSION_STRING);
exit(0);
default:
break;
}
}
if (opt->ind != opt->argc - 1) {
print_usage(pool);
exit(-1);
}
raw_url = argv[opt->ind];
apr_uri_parse(pool, raw_url, &url);
if (!url.port) {
url.port = apr_uri_port_of_scheme(url.scheme);
}
if (!url.path) {
url.path = "/";
}
if (strcasecmp(url.scheme, "https") == 0) {
app_ctx.using_ssl = 1;
}
else {
app_ctx.using_ssl = 0;
}
if (strcasecmp(method, "HEAD") == 0) {
app_ctx.head_request = 1;
}
else {
app_ctx.head_request = 0;
}
app_ctx.hostinfo = url.hostinfo;
app_ctx.pem_path = pem_path;
app_ctx.pem_pwd = pem_pwd;
context = serf_context_create(pool);
app_ctx.serf_ctx = context;
if (proxy)
{
apr_sockaddr_t *proxy_address = NULL;
apr_port_t proxy_port;
char *proxy_host;
char *proxy_scope;
status = apr_parse_addr_port(&proxy_host, &proxy_scope, &proxy_port, proxy, pool);
if (status)
{
printf("Cannot parse proxy hostname/port: %d\n", status);
apr_pool_destroy(pool);
exit(1);
}
if (!proxy_host)
{
printf("Proxy hostname must be specified\n");
apr_pool_destroy(pool);
exit(1);
}
if (!proxy_port)
{
printf("Proxy port must be specified\n");
apr_pool_destroy(pool);
exit(1);
}
status = apr_sockaddr_info_get(&proxy_address, proxy_host, APR_UNSPEC,
proxy_port, 0, pool);
if (status)
{
printf("Cannot resolve proxy address '%s': %d\n", proxy_host, status);
apr_pool_destroy(pool);
exit(1);
}
serf_config_proxy(context, proxy_address);
}
if (username)
{
serf_config_authn_types(context, SERF_AUTHN_ALL);
}
else
{
serf_config_authn_types(context, SERF_AUTHN_NTLM | SERF_AUTHN_NEGOTIATE);
}
serf_config_credentials_callback(context, credentials_callback);
/* Setup debug logging */
if (debug)
{
serf_log_output_t *output;
apr_status_t status;
status = serf_logging_create_stream_output(&output,
context,
SERF_LOG_DEBUG,
SERF_LOGCOMP_ALL_MSG,
SERF_LOG_DEFAULT_LAYOUT,
stderr,
pool);
if (!status)
serf_logging_add_output(context, output);
}
/* ### Connection or Context should have an allocator? */
app_ctx.bkt_alloc = bkt_alloc;
connections = apr_pcalloc(pool, conn_count * sizeof(serf_connection_t*));
for (i = 0; i < conn_count; i++)
{
conn_baton_t *conn_ctx = apr_pcalloc(pool, sizeof(*conn_ctx));
conn_ctx->app = &app_ctx;
conn_ctx->ssl_ctx = NULL;
status = serf_connection_create2(&connections[i], context, url,
conn_setup, conn_ctx,
closed_connection, conn_ctx,
pool);
if (status) {
printf("Error creating connection: %d\n", status);
apr_pool_destroy(pool);
exit(1);
}
serf_connection_set_max_outstanding_requests(connections[i], inflight);
}
handler_ctx.completed_requests = 0;
handler_ctx.print_headers = print_headers;
#if APR_VERSION_AT_LEAST(1, 3, 0)
apr_file_open_flags_stdout(&handler_ctx.output_file, APR_BUFFERED, pool);
#else
apr_file_open_stdout(&handler_ctx.output_file, pool);
#endif
handler_ctx.host = url.hostinfo;
handler_ctx.method = method;
handler_ctx.path = apr_pstrcat(pool,
url.path,
url.query ? "?" : "",
url.query ? url.query : "",
NULL);
handler_ctx.username = username;
handler_ctx.password = password;
handler_ctx.auth_attempts = 0;
handler_ctx.req_body_path = req_body_path;
handler_ctx.acceptor = accept_response;
handler_ctx.acceptor_baton = &app_ctx;
handler_ctx.handler = handle_response;
handler_ctx.req_hdrs = req_hdrs;
for (i = 0; i < count; i++) {
/* We don't need the returned request here. */
serf_connection_request_create(connections[i % conn_count],
setup_request, &handler_ctx);
}
while (1) {
status = serf_context_run(context, SERF_DURATION_FOREVER, pool);
if (APR_STATUS_IS_TIMEUP(status))
continue;
if (status) {
char buf[200];
const char *err_string;
err_string = serf_error_string(status);
if (!err_string) {
err_string = apr_strerror(status, buf, sizeof(buf));
}
printf("Error running context: (%d) %s\n", status, err_string);
apr_pool_destroy(pool);
exit(1);
}
if (apr_atomic_read32(&handler_ctx.completed_requests) >= count) {
break;
}
/* Debugging purposes only! */
serf_debug__closed_conn(app_ctx.bkt_alloc);
}
apr_file_close(handler_ctx.output_file);
for (i = 0; i < conn_count; i++)
{
serf_connection_close(connections[i]);
}
apr_pool_destroy(pool);
return 0;
}
static apr_status_t ap_xsendfile_output_filter(ap_filter_t *f, apr_bucket_brigade *in) {
request_rec *r = f->r, *sr = NULL;
xsendfile_conf_t
*dconf = (xsendfile_conf_t *)ap_get_module_config(r->per_dir_config, &xsendfile_module),
*sconf = (xsendfile_conf_t *)ap_get_module_config(r->server->module_config, &xsendfile_module),
*conf = xsendfile_config_merge(r->pool, sconf, dconf);
core_dir_config *coreconf = (core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module);
apr_status_t rv;
apr_bucket *e;
apr_file_t *fd = NULL;
apr_finfo_t finfo;
const char *file = NULL;
char *translated = NULL;
int errcode;
#ifdef _DEBUG
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: output_filter for %s", r->the_request);
#endif
/*
should we proceed with this request?
* sub-requests suck
* furthermore default-handled requests suck, as they actually shouldn't be able to set headers
*/
if (
r->status != HTTP_OK
|| r->main
|| (r->handler && strcmp(r->handler, "default-handler") == 0) /* those table-keys are lower-case, right? */
) {
#ifdef _DEBUG
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: not met [%d]", r->status);
#endif
ap_remove_output_filter(f);
return ap_pass_brigade(f->next, in);
}
/*
alright, look for x-sendfile
*/
file = apr_table_get(r->headers_out, AP_XSENDFILE_HEADER);
apr_table_unset(r->headers_out, AP_XSENDFILE_HEADER);
/* cgi/fastcgi will put the stuff into err_headers_out */
if (!file || !*file) {
file = apr_table_get(r->err_headers_out, AP_XSENDFILE_HEADER);
apr_table_unset(r->err_headers_out, AP_XSENDFILE_HEADER);
}
/* nothing there :p */
if (!file || !*file) {
#ifdef _DEBUG
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: nothing found");
#endif
ap_remove_output_filter(f);
return ap_pass_brigade(f->next, in);
}
/*
drop *everything*
might be pretty expensive to generate content first that goes straight to the bitbucket,
but actually the scripts that might set this flag won't output too much anyway
*/
while (!APR_BRIGADE_EMPTY(in)) {
e = APR_BRIGADE_FIRST(in);
apr_bucket_delete(e);
}
r->eos_sent = 0;
rv = ap_xsendfile_get_filepath(r, conf, file, &translated);
if (rv != OK) {
ap_log_rerror(
APLOG_MARK,
APLOG_ERR,
rv,
r,
"xsendfile: unable to find file: %s",
file
);
ap_remove_output_filter(f);
ap_die(HTTP_NOT_FOUND, r);
return HTTP_NOT_FOUND;
}
#ifdef _DEBUG
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: found %s", translated);
#endif
/*
ry open the file
*/
if ((rv = apr_file_open(
&fd,
translated,
APR_READ | APR_BINARY
#if APR_HAS_SENDFILE
| (coreconf->enable_sendfile == ENABLE_SENDFILE_ON ? APR_SENDFILE_ENABLED : 0)
#endif
,
0,
r->pool
)) != APR_SUCCESS) {
ap_log_rerror(
APLOG_MARK,
APLOG_ERR,
rv,
r,
"xsendfile: cannot open file: %s",
translated
);
ap_remove_output_filter(f);
ap_die(HTTP_NOT_FOUND, r);
return HTTP_NOT_FOUND;
}
#if APR_HAS_SENDFILE && defined(_DEBUG)
if (coreconf->enable_sendfile != ENABLE_SENDFILE_ON) {
ap_log_error(
APLOG_MARK,
APLOG_WARNING,
0,
r->server,
"xsendfile: sendfile configured, but not active %d",
coreconf->enable_sendfile
);
}
#endif
/* stat (for etag/cache/content-length stuff) */
if ((rv = apr_file_info_get(&finfo, APR_FINFO_NORM, fd)) != APR_SUCCESS) {
ap_log_rerror(
APLOG_MARK,
APLOG_ERR,
rv,
r,
"xsendfile: unable to stat file: %s",
translated
);
apr_file_close(fd);
ap_remove_output_filter(f);
ap_die(HTTP_FORBIDDEN, r);
return HTTP_FORBIDDEN;
}
/* no inclusion of directories! we're serving files! */
if (finfo.filetype != APR_REG) {
ap_log_rerror(
APLOG_MARK,
APLOG_ERR,
APR_EBADPATH,
r,
"xsendfile: not a file %s",
translated
);
apr_file_close(fd);
ap_remove_output_filter(f);
ap_die(HTTP_NOT_FOUND, r);
return HTTP_NOT_FOUND;
}
/*
need to cheat here a bit
as etag generator will use those ;)
and we want local_copy and cache
*/
r->finfo.inode = finfo.inode;
r->finfo.size = finfo.size;
/*
caching? why not :p
*/
r->no_cache = r->no_local_copy = 0;
/* some script (f?cgi) place stuff in err_headers_out */
if (
conf->ignoreLM == XSENDFILE_ENABLED
|| (
!apr_table_get(r->headers_out, "last-modified")
&& !apr_table_get(r->headers_out, "last-modified")
)
) {
apr_table_unset(r->err_headers_out, "last-modified");
ap_update_mtime(r, finfo.mtime);
ap_set_last_modified(r);
}
if (
conf->ignoreETag == XSENDFILE_ENABLED
|| (
!apr_table_get(r->headers_out, "etag")
&& !apr_table_get(r->err_headers_out, "etag")
)
) {
apr_table_unset(r->err_headers_out, "etag");
ap_set_etag(r);
}
apr_table_unset(r->err_headers_out, "content-length");
ap_set_content_length(r, finfo.size);
/* as we dropped all the content this field is not valid anymore! */
apr_table_unset(r->headers_out, "Content-Encoding");
apr_table_unset(r->err_headers_out, "Content-Encoding");
/* cache or something? */
if ((errcode = ap_meets_conditions(r)) != OK) {
#ifdef _DEBUG
ap_log_error(
APLOG_MARK,
APLOG_DEBUG,
0,
r->server,
"xsendfile: met condition %d for %s",
errcode,
file
);
#endif
apr_file_close(fd);
r->status = errcode;
}
else {
/* For platforms where the size of the file may be larger than
* that which can be stored in a single bucket (where the
* length field is an apr_size_t), split it into several
* buckets: */
if (sizeof(apr_off_t) > sizeof(apr_size_t)
&& finfo.size > AP_MAX_SENDFILE) {
apr_off_t fsize = finfo.size;
e = apr_bucket_file_create(fd, 0, AP_MAX_SENDFILE, r->pool,
in->bucket_alloc);
while (fsize > AP_MAX_SENDFILE) {
apr_bucket *ce;
apr_bucket_copy(e, &ce);
APR_BRIGADE_INSERT_TAIL(in, ce);
e->start += AP_MAX_SENDFILE;
fsize -= AP_MAX_SENDFILE;
}
e->length = (apr_size_t)fsize; /* Resize just the last bucket */
}
else {
e = apr_bucket_file_create(fd, 0, (apr_size_t)finfo.size,
r->pool, in->bucket_alloc);
}
#if APR_HAS_MMAP
if (coreconf->enable_mmap == ENABLE_MMAP_ON) {
apr_bucket_file_enable_mmap(e, 0);
}
#if defined(_DEBUG)
else {
ap_log_error(
APLOG_MARK,
APLOG_WARNING,
0,
r->server,
"xsendfile: mmap configured, but not active %d",
coreconf->enable_mmap
);
}
#endif /* _DEBUG */
#endif /* APR_HAS_MMAP */
APR_BRIGADE_INSERT_TAIL(in, e);
}
e = apr_bucket_eos_create(in->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(in, e);
/* remove ourselves from the filter chain */
ap_remove_output_filter(f);
#ifdef _DEBUG
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server, "xsendfile: sending %d bytes", (int)finfo.size);
#endif
/* send the data up the stack */
return ap_pass_brigade(f->next, in);
}
int
trell_send_reply_static_file( trell_sconf_t* sconf,
request_rec* r,
trell_dispatch_info_t* dinfo )
{
apr_status_t rv;
char* path = NULL;
if( dinfo->m_component == TRELL_COMPONENT_JOB ) {
path = apr_pstrcat( r->pool, sconf->m_job_www_root, "/", dinfo->m_requestname, NULL );
}
if( path == NULL ) {
ap_log_rerror( APLOG_MARK, APLOG_ERR, 0, r, "Empty file." );
}
apr_finfo_t finfo;
rv = apr_stat( &finfo, path, APR_FINFO_SIZE, r->pool);
if( rv != APR_SUCCESS ) {
ap_log_rerror( APLOG_MARK, APLOG_ERR, rv, r, "Failed to stat static file." );
return HTTP_NOT_FOUND;
}
ap_set_content_length( r, finfo.size );
// guess content type
size_t l = strlen( path );
if( (l>5) && (strcmp(&path[l-5], ".html") == 0 ) ) {
ap_set_content_type( r, "text/html" );
}
else if( (l>3) && (strcmp(&path[l-3], ".js") == 0 ) ) {
ap_set_content_type( r, "text/javascript" );
}
else if( (l>4) && (strcmp(&path[l-4], ".css" ) == 0 ) ) {
ap_set_content_type( r, "text/css" );
}
else if( (l>4) && (strcmp(&path[l-4], ".gif" ) == 0 ) ) {
ap_set_content_type( r, "image/gif" );
}
else if( (l>4) && (strcmp(&path[l-4], ".png" ) == 0 ) ) {
ap_set_content_type( r, "image/png" );
}
apr_file_t* fd;
rv = apr_file_open( &fd, path, APR_READ | APR_SENDFILE_ENABLED, APR_OS_DEFAULT, r->pool );
if( rv != APR_SUCCESS ) {
ap_log_rerror( APLOG_MARK, APLOG_ERR, rv, r, "Failed to open static file." );
return HTTP_NOT_FOUND;
}
apr_bucket_brigade* bb = apr_brigade_create( r->pool, r->connection->bucket_alloc );
APR_BRIGADE_INSERT_TAIL( bb, apr_bucket_file_create( fd, 0, finfo.size, r->pool, r->connection->bucket_alloc ) );
APR_BRIGADE_INSERT_TAIL( bb, apr_bucket_eos_create( bb->bucket_alloc ) );
rv = ap_pass_brigade( r->output_filters, bb );
if( rv != APR_SUCCESS ) {
apr_file_close( fd );
ap_log_rerror( APLOG_MARK, APLOG_ERR, rv, r, "Output error" );
return HTTP_INTERNAL_SERVER_ERROR;
}
else {
apr_file_close( fd );
return OK;
}
}
/* NAME, CMD and ARGS are the name, path to and arguments for the hook
program that is to be run. The hook's exit status will be checked,
and if an error occurred the hook's stderr output will be added to
the returned error.
If STDIN_HANDLE is non-null, pass it as the hook's stdin, else pass
no stdin to the hook.
If RESULT is non-null, set *RESULT to the stdout of the hook or to
a zero-length string if the hook generates no output on stdout. */
static svn_error_t *
run_hook_cmd(svn_string_t **result,
const char *name,
const char *cmd,
const char **args,
const char *const *hooks_env,
apr_file_t *stdin_handle,
apr_pool_t *pool)
{
apr_file_t *null_handle;
apr_status_t apr_err;
svn_error_t *err;
apr_proc_t cmd_proc;
if (result)
{
null_handle = NULL;
}
else
{
/* Redirect stdout to the null device */
apr_err = apr_file_open(&null_handle, SVN_NULL_DEVICE_NAME, APR_WRITE,
APR_OS_DEFAULT, pool);
if (apr_err)
return svn_error_wrap_apr
(apr_err, _("Can't create null stdout for hook '%s'"), cmd);
}
err = svn_io_start_cmd3(&cmd_proc, ".", cmd, args, hooks_env, FALSE,
FALSE, stdin_handle, result != NULL, null_handle,
TRUE, NULL, pool);
if (err)
{
/* CMD_PROC is not safe to use. Bail. */
return svn_error_createf
(SVN_ERR_REPOS_HOOK_FAILURE, err, _("Failed to start '%s' hook"), cmd);
}
else
{
err = check_hook_result(name, cmd, &cmd_proc, cmd_proc.err, pool);
}
/* Hooks are fallible, and so hook failure is "expected" to occur at
times. When such a failure happens we still want to close the pipe
and null file */
apr_err = apr_file_close(cmd_proc.err);
if (!err && apr_err)
return svn_error_wrap_apr
(apr_err, _("Error closing read end of stderr pipe"));
if (result)
{
svn_stringbuf_t *native_stdout;
SVN_ERR(svn_stringbuf_from_aprfile(&native_stdout, cmd_proc.out, pool));
apr_err = apr_file_close(cmd_proc.out);
if (!err && apr_err)
return svn_error_wrap_apr
(apr_err, _("Error closing read end of stderr pipe"));
*result = svn_stringbuf__morph_into_string(native_stdout);
}
else
{
apr_err = apr_file_close(null_handle);
if (!err && apr_err)
return svn_error_wrap_apr(apr_err, _("Error closing null file"));
}
return svn_error_trace(err);
}
std::string
Client::diff(const Path & tmpPath, const Path & path,
const Revision & revision1, const Revision & revision2,
const bool recurse, const bool ignoreAncestry,
const bool noDiffDeleted) throw(ClientException)
{
Pool pool;
svn_error_t * error;
apr_status_t status;
apr_file_t * outfile = nullptr;
const char * outfileName = nullptr;
apr_file_t * errfile = nullptr;
const char * errfileName = nullptr;
apr_array_header_t * options;
svn_stringbuf_t * stringbuf;
// svn_client_diff needs an options array, even if it is empty
options = apr_array_make(pool, 0, 0);
// svn_client_diff needs a temporary file to write diff output to
error = svn_io_open_unique_file(&outfile, &outfileName,
tmpPath.c_str(), ".tmp",
false, pool);
if (error != nullptr)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
throw ClientException(error);
}
// and another one to write errors to
error = svn_io_open_unique_file(&errfile, &errfileName,
tmpPath.c_str(), ".tmp",
false, pool);
if (error != nullptr)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
throw ClientException(error);
}
// run diff
error = svn_client_diff(options,
path.c_str(), revision1.revision(),
path.c_str(), revision2.revision(),
recurse, ignoreAncestry, noDiffDeleted,
outfile, errfile,
*m_context,
pool);
if (error != nullptr)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
throw ClientException(error);
}
// then we reopen outfile for reading
status = apr_file_close(outfile);
if (status)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
fail(pool, status, "failed to close '%s'", outfileName);
}
status = apr_file_open(&outfile, outfileName, APR_READ, APR_OS_DEFAULT, pool);
if (status)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
fail(pool, status, "failed to open '%s'", outfileName);
}
// now we can read the diff output from outfile and return that
error = svn_stringbuf_from_aprfile(&stringbuf, outfile, pool);
if (error != nullptr)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
throw ClientException(error);
}
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
return stringbuf->data;
}
BOOL decode_vorbis_file(LLVFS *vfs, const LLUUID &in_uuid, char *out_fname)
{
ov_callbacks vfs_callbacks;
vfs_callbacks.read_func = vfs_read;
vfs_callbacks.seek_func = vfs_seek;
vfs_callbacks.close_func = vfs_close;
vfs_callbacks.tell_func = vfs_tell;
char pcmout[4096]; /*Flawfinder: ignore*/
unsigned char temp[64]; /*Flawfinder: ignore*/
LLVFile *in_vfile;
U32 data_length = 0;
llinfos << "Vorbis decode from vfile: " << in_uuid << llendl;
in_vfile = new LLVFile(vfs, in_uuid, LLAssetType::AT_SOUND);
if (! in_vfile->getSize())
{
llwarning("unable to open vorbis source vfile for reading",0);
return(FALSE);
}
apr_file_t* outfp = ll_apr_file_open(out_fname,LL_APR_WPB);
if (!outfp)
{
llwarning("unable to open vorbis destination file for writing",0);
return(FALSE);
}
else
{
// write the .wav format header
//"RIFF"
temp[0] = 0x52;
temp[1] = 0x49;
temp[2] = 0x46;
temp[3] = 0x46;
// length = datalen + 36 (to be filled in later)
temp[4] = 0x00;
temp[5] = 0x00;
temp[6] = 0x00;
temp[7] = 0x00;
//"WAVE"
temp[8] = 0x57;
temp[9] = 0x41;
temp[10] = 0x56;
temp[11] = 0x45;
// "fmt "
temp[12] = 0x66;
temp[13] = 0x6D;
temp[14] = 0x74;
temp[15] = 0x20;
// chunk size = 16
temp[16] = 0x10;
temp[17] = 0x00;
temp[18] = 0x00;
temp[19] = 0x00;
// format (1 = PCM)
temp[20] = 0x01;
temp[21] = 0x00;
// number of channels
temp[22] = 0x01;
temp[23] = 0x00;
// samples per second
temp[24] = 0x44;
temp[25] = 0xAC;
temp[26] = 0x00;
temp[27] = 0x00;
// average bytes per second
temp[28] = 0x88;
temp[29] = 0x58;
temp[30] = 0x01;
temp[31] = 0x00;
// bytes to output at a single time
temp[32] = 0x02;
temp[33] = 0x00;
// 16 bits per sample
temp[34] = 0x10;
temp[35] = 0x00;
// "data"
temp[36] = 0x64;
temp[37] = 0x61;
temp[38] = 0x74;
temp[39] = 0x61;
// these are the length of the data chunk, to be filled in later
temp[40] = 0x00;
temp[41] = 0x00;
temp[42] = 0x00;
temp[43] = 0x00;
ll_apr_file_write(outfp, temp, 44);
}
OggVorbis_File vf;
int eof=0;
int current_section;
int r = ov_open_callbacks(in_vfile, &vf, NULL, 0, vfs_callbacks);
if(r < 0)
{
llwarns << r << " Input to vorbis decode does not appear to be an Ogg bitstream: " << in_uuid << llendl;
return(FALSE);
}
{
char **ptr=ov_comment(&vf,-1)->user_comments;
// vorbis_info *vi=ov_info(&vf,-1);
while(*ptr){
fprintf(stderr,"%s\n",*ptr);
++ptr;
}
// fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi->channels,vi->rate);
// fprintf(stderr,"\nDecoded length: %ld samples\n", (long)ov_pcm_total(&vf,-1));
// fprintf(stderr,"Encoded by: %s\n\n",ov_comment(&vf,-1)->vendor);
}
while(!eof){
long ret=ov_read(&vf,pcmout,sizeof(pcmout),0,2,1,¤t_section);
if (ret == 0) {
/* EOF */
eof=1;
// llinfos << "Vorbis EOF" << llendl;
} else if (ret < 0) {
/* error in the stream. Not a problem, just reporting it in
case we (the app) cares. In this case, we don't. */
llwarning("Error in vorbis stream",0);
break;
} else {
// llinfos << "Vorbis read " << ret << "bytes" << llendl;
/* we don't bother dealing with sample rate changes, etc, but.
you'll have to*/
data_length += ll_apr_file_write(outfp, pcmout, ret);
}
}
ov_clear(&vf);
// write "data" chunk length
ll_apr_file_seek(outfp,APR_SET,40);
ll_apr_file_write(outfp,&data_length,4);
// write overall "RIFF" length
data_length += 36;
ll_apr_file_seek(outfp,APR_SET,4);
ll_apr_file_write(outfp,&data_length,1*4);
// F**K!!! Vorbis encode/decode messes up loop point transitions (pop)
// do a cheap-and-cheesy crossfade
S16 *samplep;
S32 i;
S32 fade_length;
fade_length = llmin((S32)128,(S32)(data_length-36)/8);
ll_apr_file_seek(outfp,APR_SET,44);
ll_apr_file_read(outfp, pcmout,2*fade_length); //read first 16 samples
samplep = (S16 *)pcmout;
for (i = 0 ;i < fade_length; i++)
{
*samplep++ = ((F32)*samplep * ((F32)i/(F32)fade_length));
}
ll_apr_file_seek(outfp,APR_SET,44);
ll_apr_file_write(outfp,pcmout,2*fade_length); //write back xfaded first 16 samples
ll_apr_file_seek(outfp,APR_END,-fade_length*2);
ll_apr_file_read(outfp, pcmout,2*fade_length); //read last 16 samples
samplep = (S16 *)pcmout;
for (i = fade_length-1 ; i >= 0; i--)
{
*samplep++ = ((F32)*samplep * ((F32)i/(F32)fade_length));
}
ll_apr_file_seek(outfp,SEEK_END,-fade_length*2);
ll_apr_file_write(outfp,pcmout,2*fade_length); //write back xfaded last 16 samples
apr_file_close(outfp);
if ((36 == data_length) || (!(eof)))
{
llwarning("BAD Vorbis DECODE!, removing .wav!",0);
LLFile::remove(out_fname);
return (FALSE);
}
// fprintf(stderr,"Done.\n");
return(TRUE);
}
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;
}
static void test_file_redir(abts_case *tc, void *data)
{
apr_file_t *testout = NULL;
apr_file_t *testerr = NULL;
apr_off_t offset;
apr_status_t rv;
const char *args[2];
apr_procattr_t *attr;
apr_file_t *testfile = NULL;
apr_size_t length;
char *buf;
testfile = NULL;
rv = apr_file_open(&testfile, "data/stdin",
APR_READ | APR_WRITE | APR_CREATE | APR_EXCL,
APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_open(&testout, "data/stdout",
APR_READ | APR_WRITE | APR_CREATE | APR_EXCL,
APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_open(&testerr, "data/stderr",
APR_READ | APR_WRITE | APR_CREATE | APR_EXCL,
APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
length = strlen(TESTSTR);
apr_file_write(testfile, TESTSTR, &length);
offset = 0;
rv = apr_file_seek(testfile, APR_SET, &offset);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File position mismatch, expected 0", offset == 0);
rv = apr_procattr_create(&attr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_procattr_child_in_set(attr, testfile, NULL);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_procattr_child_out_set(attr, testout, NULL);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_procattr_child_err_set(attr, testerr, NULL);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_procattr_dir_set(attr, "data");
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_procattr_cmdtype_set(attr, APR_PROGRAM);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
args[0] = "proc_child";
args[1] = NULL;
rv = apr_proc_create(&newproc, "../" TESTBINPATH "proc_child" EXTENSION, args, NULL,
attr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_proc_wait(&newproc, NULL, NULL, APR_WAIT);
ABTS_INT_EQUAL(tc, APR_CHILD_DONE, rv);
offset = 0;
rv = apr_file_seek(testout, APR_SET, &offset);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
length = 256;
buf = apr_pcalloc(p, length);
rv = apr_file_read(testout, buf, &length);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, TESTSTR, buf);
apr_file_close(testfile);
apr_file_close(testout);
apr_file_close(testerr);
rv = apr_file_remove("data/stdin", p);;
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_remove("data/stdout", p);;
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_remove("data/stderr", p);;
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
/* This is a horrible name for this function. We are testing APR, not how
* Apache uses APR. And, this function tests _way_ too much stuff.
*/
static void test_mod_neg(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *f;
const char *s;
int i;
apr_size_t nbytes;
char buf[8192];
apr_off_t cur;
const char *fname = "data/modneg.dat";
rv = apr_file_open(&f, fname,
APR_FOPEN_CREATE | APR_FOPEN_WRITE, APR_UREAD | APR_UWRITE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
s = "body56789\n";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, strlen(s), nbytes);
for (i = 0; i < 7980; i++) {
s = "0";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, strlen(s), nbytes);
}
s = "end456789\n";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, strlen(s), nbytes);
for (i = 0; i < 10000; i++) {
s = "1";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, strlen(s), nbytes);
}
rv = apr_file_close(f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_open(&f, fname, APR_FOPEN_READ, 0, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_gets(buf, 11, f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "body56789\n", buf);
cur = 0;
rv = apr_file_seek(f, APR_CUR, &cur);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File Pointer Mismatch, expected 10", cur == 10);
nbytes = sizeof(buf);
rv = apr_file_read(f, buf, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, nbytes, sizeof(buf));
cur = -((apr_off_t)nbytes - 7980);
rv = apr_file_seek(f, APR_CUR, &cur);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File Pointer Mismatch, expected 7990", cur == 7990);
rv = apr_file_gets(buf, 11, f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "end456789\n", buf);
rv = apr_file_close(f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_remove(fname, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
SWITCH_DECLARE(switch_status_t) switch_file_close(switch_file_t *thefile)
{
return apr_file_close(thefile);
}
/*
* main
*/
int main(int argc, const char * const argv[])
{
apr_off_t max;
apr_time_t current, repeat, delay, previous;
apr_status_t status;
apr_pool_t *pool, *instance;
apr_getopt_t *o;
apr_finfo_t info;
int retries, isdaemon, limit_found, intelligent, dowork;
char opt;
const char *arg;
char *proxypath, *path;
interrupted = 0;
repeat = 0;
isdaemon = 0;
dryrun = 0;
limit_found = 0;
max = 0;
verbose = 0;
realclean = 0;
benice = 0;
deldirs = 0;
intelligent = 0;
previous = 0; /* avoid compiler warning */
proxypath = NULL;
if (apr_app_initialize(&argc, &argv, NULL) != APR_SUCCESS) {
return 1;
}
atexit(apr_terminate);
if (argc) {
shortname = apr_filepath_name_get(argv[0]);
}
if (apr_pool_create(&pool, NULL) != APR_SUCCESS) {
return 1;
}
apr_pool_abort_set(oom, pool);
apr_file_open_stderr(&errfile, pool);
apr_signal(SIGINT, setterm);
apr_signal(SIGTERM, setterm);
apr_getopt_init(&o, pool, argc, argv);
while (1) {
status = apr_getopt(o, "iDnvrtd:l:L:p:", &opt, &arg);
if (status == APR_EOF) {
break;
}
else if (status != APR_SUCCESS) {
usage();
}
else {
switch (opt) {
case 'i':
if (intelligent) {
usage();
}
intelligent = 1;
break;
case 'D':
if (dryrun) {
usage();
}
dryrun = 1;
break;
case 'n':
if (benice) {
usage();
}
benice = 1;
break;
case 't':
if (deldirs) {
usage();
}
deldirs = 1;
break;
case 'v':
if (verbose) {
usage();
}
verbose = 1;
break;
case 'r':
if (realclean) {
usage();
}
realclean = 1;
deldirs = 1;
break;
case 'd':
if (isdaemon) {
usage();
}
isdaemon = 1;
repeat = apr_atoi64(arg);
repeat *= SECS_PER_MIN;
repeat *= APR_USEC_PER_SEC;
break;
case 'l':
if (limit_found) {
usage();
}
limit_found = 1;
do {
apr_status_t rv;
char *end;
rv = apr_strtoff(&max, arg, &end, 10);
if (rv == APR_SUCCESS) {
if ((*end == 'K' || *end == 'k') && !end[1]) {
max *= KBYTE;
}
else if ((*end == 'M' || *end == 'm') && !end[1]) {
max *= MBYTE;
}
else if ((*end == 'G' || *end == 'g') && !end[1]) {
max *= GBYTE;
}
else if (*end && /* neither empty nor [Bb] */
((*end != 'B' && *end != 'b') || end[1])) {
rv = APR_EGENERAL;
}
}
if (rv != APR_SUCCESS) {
apr_file_printf(errfile, "Invalid limit: %s"
APR_EOL_STR APR_EOL_STR, arg);
usage();
}
} while(0);
break;
case 'p':
if (proxypath) {
usage();
}
proxypath = apr_pstrdup(pool, arg);
if (apr_filepath_set(proxypath, pool) != APR_SUCCESS) {
usage();
}
break;
} /* switch */
} /* else */
} /* while */
if (o->ind != argc) {
usage();
}
if (isdaemon && (repeat <= 0 || verbose || realclean || dryrun)) {
usage();
}
if (!isdaemon && intelligent) {
usage();
}
if (!proxypath || max <= 0) {
usage();
}
if (apr_filepath_get(&path, 0, pool) != APR_SUCCESS) {
usage();
}
baselen = strlen(path);
#ifndef DEBUG
if (isdaemon) {
apr_file_close(errfile);
apr_proc_detach(APR_PROC_DETACH_DAEMONIZE);
}
#endif
do {
apr_pool_create(&instance, pool);
now = apr_time_now();
APR_RING_INIT(&root, _entry, link);
delcount = 0;
unsolicited = 0;
dowork = 0;
switch (intelligent) {
case 0:
dowork = 1;
break;
case 1:
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
previous = info.mtime;
intelligent = 2;
}
dowork = 1;
break;
case 2:
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
if (previous != info.mtime) {
dowork = 1;
}
previous = info.mtime;
break;
}
intelligent = 1;
dowork = 1;
break;
}
if (dowork && !interrupted) {
if (!process_dir(path, instance) && !interrupted) {
purge(path, instance, max);
}
else if (!isdaemon && !interrupted) {
apr_file_printf(errfile, "An error occurred, cache cleaning "
"aborted." APR_EOL_STR);
return 1;
}
if (intelligent && !interrupted) {
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
previous = info.mtime;
intelligent = 2;
}
else {
intelligent = 1;
}
}
}
apr_pool_destroy(instance);
current = apr_time_now();
if (current < now) {
delay = repeat;
}
else if (current - now >= repeat) {
delay = repeat;
}
else {
delay = now + repeat - current;
}
/* we can't sleep the whole delay time here apiece as this is racy
* with respect to interrupt delivery - think about what happens
* if we have tested for an interrupt, then get scheduled
* before the apr_sleep() call and while waiting for the cpu
* we do get an interrupt
*/
if (isdaemon) {
while (delay && !interrupted) {
if (delay > APR_USEC_PER_SEC) {
apr_sleep(APR_USEC_PER_SEC);
delay -= APR_USEC_PER_SEC;
}
else {
apr_sleep(delay);
delay = 0;
}
}
}
} while (isdaemon && !interrupted);
if (!isdaemon && interrupted) {
apr_file_printf(errfile, "Cache cleaning aborted due to user "
"request." APR_EOL_STR);
return 1;
}
return 0;
}
APR_DECLARE(apr_status_t) apr_shm_attach(apr_shm_t **m,
const char *filename,
apr_pool_t *pool)
{
if (filename == NULL) {
/* It doesn't make sense to attach to a segment if you don't know
* the filename. */
return APR_EINVAL;
}
else {
#if APR_USE_SHMEM_MMAP_TMP || APR_USE_SHMEM_MMAP_SHM
apr_shm_t *new_m;
apr_status_t status;
int tmpfd;
apr_file_t *file; /* file where metadata is stored */
apr_size_t nbytes;
new_m = apr_palloc(pool, sizeof(apr_shm_t));
new_m->pool = pool;
new_m->filename = apr_pstrdup(pool, filename);
#if APR_USE_SHMEM_MMAP_SHM
const char *shm_name = make_shm_open_safe_name(filename, pool);
/* FIXME: SysV uses 0600... should we? */
tmpfd = shm_open(shm_name, O_RDWR, 0644);
if (tmpfd == -1) {
return errno;
}
status = apr_os_file_put(&file, &tmpfd,
APR_READ | APR_WRITE,
pool);
if (status != APR_SUCCESS) {
return status;
}
#elif APR_USE_SHMEM_MMAP_TMP
status = apr_file_open(&file, filename,
APR_READ | APR_WRITE,
APR_OS_DEFAULT, pool);
if (status != APR_SUCCESS) {
return status;
}
status = apr_os_file_get(&tmpfd, file);
if (status != APR_SUCCESS) {
return status;
}
#else
return APR_ENOTIMPL;
#endif
nbytes = sizeof(new_m->realsize);
status = apr_file_read(file, (void *)&(new_m->realsize),
&nbytes);
if (status != APR_SUCCESS) {
return status;
}
status = apr_os_file_get(&tmpfd, file);
if (status != APR_SUCCESS) {
apr_file_close(file); /* ignore errors, we're failing */
apr_file_remove(new_m->filename, new_m->pool);
return status;
}
new_m->reqsize = new_m->realsize - sizeof(apr_size_t);
new_m->base = mmap(NULL, new_m->realsize, PROT_READ | PROT_WRITE,
MAP_SHARED, tmpfd, 0);
/* FIXME: check for errors */
status = apr_file_close(file);
if (status != APR_SUCCESS) {
return status;
}
/* metadata isn't part of the usable segment */
new_m->usable = (char *)new_m->base + APR_ALIGN_DEFAULT(sizeof(apr_size_t));
apr_pool_cleanup_register(new_m->pool, new_m, shm_cleanup_attach,
apr_pool_cleanup_null);
*m = new_m;
return APR_SUCCESS;
#elif APR_USE_SHMEM_SHMGET
apr_shm_t *new_m;
apr_status_t status;
apr_file_t *file; /* file where metadata is stored */
apr_size_t nbytes;
new_m = apr_palloc(pool, sizeof(apr_shm_t));
status = apr_file_open(&file, filename,
APR_FOPEN_READ, APR_OS_DEFAULT, pool);
if (status != APR_SUCCESS) {
return status;
}
nbytes = sizeof(new_m->reqsize);
status = apr_file_read(file, (void *)&(new_m->reqsize),
&nbytes);
if (status != APR_SUCCESS) {
return status;
}
status = apr_file_close(file);
if (status != APR_SUCCESS) {
return status;
}
new_m->filename = apr_pstrdup(pool, filename);
new_m->pool = pool;
new_m->shmkey = our_ftok(filename);
if (new_m->shmkey == (key_t)-1) {
return errno;
}
if ((new_m->shmid = shmget(new_m->shmkey, 0, SHM_R | SHM_W)) == -1) {
return errno;
}
if ((new_m->base = shmat(new_m->shmid, NULL, 0)) == (void *)-1) {
return errno;
}
new_m->usable = new_m->base;
new_m->realsize = new_m->reqsize;
apr_pool_cleanup_register(new_m->pool, new_m, shm_cleanup_attach,
apr_pool_cleanup_null);
*m = new_m;
return APR_SUCCESS;
#else
return APR_ENOTIMPL;
#endif
}
}