static int output_body_sendfile(request_rec *r, const char *path)
{
apr_file_t *fd;
apr_status_t status;
apr_size_t len, nbytes;
apr_finfo_t finfo;
int rc;
status = apr_file_open(&fd, path, APR_READ|APR_BINARY, APR_OS_DEFAULT, r->pool);
if (status != APR_SUCCESS) {
return HTTP_INTERNAL_SERVER_ERROR;
}
apr_file_info_get(&finfo, APR_FINFO_NORM, fd);
len = finfo.size;
status = ap_send_fd(fd, r, 0, len, &nbytes);
apr_file_close(fd);
if (status == APR_SUCCESS) {
ap_set_content_length(r, nbytes);
rc = OK;
} else {
rc = HTTP_INTERNAL_SERVER_ERROR;
}
return rc;
}
static int write_http_response(mapcache_context_apache_request *ctx, mapcache_http_response *response) {
request_rec *r = ctx->request;
int rc;
if(response->mtime) {
ap_update_mtime(r, response->mtime);
if((rc = ap_meets_conditions(r)) != OK) {
return rc;
}
char *timestr = apr_palloc(r->pool, APR_RFC822_DATE_LEN);
apr_rfc822_date(timestr, response->mtime);
apr_table_setn(r->headers_out, "Last-Modified", timestr);
}
if(response->headers && !apr_is_empty_table(response->headers)) {
const apr_array_header_t *elts = apr_table_elts(response->headers);
int i;
for(i=0;i<elts->nelts;i++) {
apr_table_entry_t entry = APR_ARRAY_IDX(elts,i,apr_table_entry_t);
if(!strcasecmp(entry.key,"Content-Type")) {
ap_set_content_type(r,entry.val);
} else {
apr_table_set(r->headers_out, entry.key, entry.val);
}
}
}
if(response->data) {
ap_set_content_length(r,response->data->size);
ap_rwrite((void*)response->data->buf, response->data->size, r);
}
r->status = response->code;
return OK;
}
static dav_error *
dav_rawx_set_headers(request_rec *r, const dav_resource *resource)
{
if (!resource->exists)
return NULL;
DAV_DEBUG_REQ(r, 0, "%s(%s)", __FUNCTION__, resource_get_pathname(resource));
/* make sure the proper mtime is in the request record */
ap_update_mtime(r, resource->info->finfo.mtime);
ap_set_last_modified(r);
ap_set_etag(r);
/* we accept byte-ranges */
apr_table_setn(r->headers_out, apr_pstrdup(r->pool, "Accept-Ranges"),
apr_pstrdup(r->pool, "bytes"));
/* set up the Content-Length header */
ap_set_content_length(r, resource->info->finfo.size);
request_fill_headers(r, &(resource->info->chunk));
/* compute metadata_compress if compressed content */
if (resource->info->compression) {
char *buf = apr_pstrcat(r->pool, "compression=on;compression_algorithm=", resource->info->compress_algo,
";compression_blocksize=", apr_psprintf(r->pool, "%d", resource->info->cp_chunk.block_size), ";", NULL);
apr_table_setn(r->headers_out, apr_pstrdup(r->pool, "metadatacompress"), buf);
}
return NULL;
}
static int output_headers(request_rec *r, AV *headers)
{
dTHX;
SV *key_sv, *val_sv;
char *key;
r->content_type = NULL;
while (av_len(headers) > -1) {
key_sv = av_shift(headers);
val_sv = av_shift(headers);
if (key_sv == NULL || val_sv == NULL) break;
key = SvPV_nolen(key_sv);
if (strcmp(key, "Content-Type") == 0) {
r->content_type = apr_pstrdup(r->pool, SvPV_nolen(val_sv));
} else if (strcmp(key, "Content-Length") == 0) {
ap_set_content_length(r, SvIV(val_sv));
} else if (strcmp(key, "Status") == 0) {
server_error(r, "headers must not contain a Status");
return HTTP_INTERNAL_SERVER_ERROR;
} else {
apr_table_add(r->headers_out, key, SvPV_nolen(val_sv));
}
SvREFCNT_dec(key_sv);
SvREFCNT_dec(val_sv);
}
return OK;
}
static mrb_value ap_mrb_set_request_content_length(mrb_state *mrb,
mrb_value str)
{
mrb_int val;
request_rec *r = ap_mrb_get_request();
mrb_get_args(mrb, "i", &val);
ap_set_content_length(r, (apr_off_t)val);
return mrb_fixnum_value(val);
}
static int req_set_content_length(lua_State*L)
{
request_rec *r = CHECK_REQUEST_OBJECT(1);
int len = luaL_checkint(L, 2);
ap_set_content_length(r, len);
return 0;
}
static int
php_apache_sapi_header_handler(sapi_header_struct *sapi_header, sapi_header_op_enum op, sapi_headers_struct *sapi_headers)
{
php_struct *ctx;
char *val, *ptr;
ctx = SG(server_context);
switch(op) {
case SAPI_HEADER_DELETE:
apr_table_unset(ctx->r->headers_out, sapi_header->header);
return 0;
case SAPI_HEADER_DELETE_ALL:
apr_table_clear(ctx->r->headers_out);
return 0;
case SAPI_HEADER_ADD:
case SAPI_HEADER_REPLACE:
val = strchr(sapi_header->header, ':');
if (!val) {
sapi_free_header(sapi_header);
return 0;
}
ptr = val;
*val = '\0';
do {
val++;
} while (*val == ' ');
if (!strcasecmp(sapi_header->header, "content-type"))
ctx->r->content_type = apr_pstrdup(ctx->r->pool, val);
else if (!strcasecmp(sapi_header->header, "content-length"))
ap_set_content_length(ctx->r, strtol(val, (char **)NULL, 10));
else if (op == SAPI_HEADER_REPLACE)
apr_table_set(ctx->r->headers_out, sapi_header->header, val);
else
apr_table_add(ctx->r->headers_out, sapi_header->header, val);
*ptr = ':';
return SAPI_HEADER_ADD;
default:
return 0;
}
}
static int output_body_obj(request_rec *r, SV *obj, int type)
{
dTHX;
SV *buf_sv;
apr_off_t clen = 0;
STRLEN len;
dSP;
char *buf;
int count;
if (type == SVt_PVMG && !respond_to(obj, "getline")) {
server_error(r, "response body object must be able to getline");
return HTTP_INTERNAL_SERVER_ERROR;
}
ENTER;
SAVETMPS;
SAVESPTR(PL_rs);
PL_rs = newRV_inc(newSViv(AP_IOBUFSIZE));
while (1) {
PUSHMARK(SP);
XPUSHs(obj);
PUTBACK;
count = call_method("getline", G_SCALAR);
if (count != 1) croak("Big trouble\n");
SPAGAIN;
buf_sv = POPs;
if (SvOK(buf_sv)) {
buf = SvPV(buf_sv, len);
clen += len;
ap_rwrite(buf, len, r);
} else {
break;
}
}
if (clen > 0) {
ap_set_content_length(r, clen);
}
PUSHMARK(SP);
XPUSHs(obj);
PUTBACK;
call_method("close", G_DISCARD);
SPAGAIN;
PUTBACK;
FREETMPS;
LEAVE;
return OK;
}
static am_status_t set_custom_response(am_request_t *rq, const char *text, const char *cont_type) {
request_rec *r = (request_rec *) (rq != NULL ? rq->ctx : NULL);
if (r == NULL || !ISVALID(text)) return AM_EINVAL;
if (rq->status == AM_INTERNAL_REDIRECT) {
ap_internal_redirect(text, r);
rq->status = AM_DONE;
} else if (rq->status == AM_REDIRECT) {
apr_table_add(r->headers_out, "Location", text);
ap_custom_response(r, HTTP_MOVED_TEMPORARILY, text);
} else {
if (rq->status == AM_PDP_DONE) {
request_rec *sr = ap_sub_req_method_uri(am_method_num_to_str(rq->method),
rq->post_data_url, r, NULL);
sr->headers_in = r->headers_in;
sr->notes = r->notes;
am_log_debug(rq->instance_id, "set_custom_response(): issuing sub-request %s to %s",
sr->method, rq->post_data_url);
ap_run_sub_req(sr);
ap_destroy_sub_req(sr);
rq->status = AM_DONE;
} else {
size_t tl = strlen(text);
if (ISVALID(cont_type)) {
ap_set_content_type(r, cont_type);
}
ap_set_content_length(r, tl);
ap_rwrite(text, (int) tl, r);
ap_custom_response(r,
am_status_value(rq->status == AM_SUCCESS ||
rq->status == AM_DONE ? AM_SUCCESS : rq->status), text);
ap_rflush(r);
}
}
am_log_info(rq->instance_id, "set_custom_response(): status: %s", am_strerror(rq->status));
return AM_SUCCESS;
}
static int call_xquery (request_rec *r)
{
char *req_body = NULL;
char * buf = NULL; // get_response (r, req_body);
req_body = get_user_data (r);
buf = get_response(r, req_body, pc_glob);
ap_set_content_length (r, strlen(buf));
ap_send_http_header( r );
/* send response body */
ap_rprintf (r, buf);
#ifndef USE_POOL
free (req_body);
#endif
return OK;
}// call_xquery()
/*
* Callback functions for gsoap. We must parse the headers ourselves and
* we must handle send/receive properly.
*/
static int
http_post_header(struct soap *soap, const char *key, const char *value)
{
gsoapRequestConfiguration *pRqConf = getRequestConfiguration(soap);
request_rec *r = NULL == pRqConf ? NULL : pRqConf->r;
if (NULL != value)
{
if (0 == strcasecmp(key, "SOAPAction"))
{
apr_table_set(r->headers_out, key, value);
}
else if (0 == strcasecmp(key, "Content-Type"))
{
r->content_type = apr_pstrdup(r->pool, value);
}
else if (0 == strcasecmp(key, "Content-Length"))
{
ap_set_content_length(r, atoi(value));
}
}
return SOAP_OK;
}
static int output_body_ary(request_rec *r, AV *bodys)
{
dTHX;
SV **body;
I32 i;
I32 lastidx;
char *buf;
STRLEN len;
apr_off_t clen = 0;
lastidx = av_len(bodys);
for (i = 0; i <= lastidx; i++) {
body = av_fetch(bodys, i, 0);
if (SvOK(*body)) {
buf = SvPV(*body, len);
ap_rwrite(buf, len, r);
clen += len;
}
}
if (clen > 0) {
ap_set_content_length(r, clen);
}
return OK;
}
static int
php_apache_sapi_header_handler(sapi_header_struct *sapi_header, sapi_header_op_enum op, sapi_headers_struct *sapi_headers)
{
php_struct *ctx;
char *val, *ptr;
ctx = SG(server_context);
switch (op) {
case SAPI_HEADER_DELETE:
apr_table_unset(ctx->r->headers_out, sapi_header->header);
return 0;
case SAPI_HEADER_DELETE_ALL:
apr_table_clear(ctx->r->headers_out);
return 0;
case SAPI_HEADER_ADD:
case SAPI_HEADER_REPLACE:
val = strchr(sapi_header->header, ':');
if (!val) {
return 0;
}
ptr = val;
*val = '\0';
do {
val++;
} while (*val == ' ');
if (!strcasecmp(sapi_header->header, "content-type")) {
if (ctx->content_type) {
efree(ctx->content_type);
}
ctx->content_type = estrdup(val);
} else if (!strcasecmp(sapi_header->header, "content-length")) {
#ifdef PHP_WIN32
# ifdef APR_HAS_LARGE_FILES
ap_set_content_length(ctx->r, (apr_off_t) _strtoui64(val, (char **)NULL, 10));
# else
ap_set_content_length(ctx->r, (apr_off_t) strtol(val, (char **)NULL, 10));
# endif
#else
ap_set_content_length(ctx->r, (apr_off_t) strtol(val, (char **)NULL, 10));
#endif
} else if (op == SAPI_HEADER_REPLACE) {
apr_table_set(ctx->r->headers_out, sapi_header->header, val);
} else {
apr_table_add(ctx->r->headers_out, sapi_header->header, val);
}
*ptr = ':';
return SAPI_HEADER_ADD;
default:
return 0;
}
}
static int
php_apache_sapi_header_handler(sapi_header_struct *sapi_header, sapi_header_op_enum op, sapi_headers_struct *sapi_headers)
{
php_struct *ctx;
char *val, *ptr;
ctx = SG(server_context);
switch (op) {
case SAPI_HEADER_DELETE:
apr_table_unset(ctx->r->headers_out, sapi_header->header);
return 0;
case SAPI_HEADER_DELETE_ALL:
apr_table_clear(ctx->r->headers_out);
return 0;
case SAPI_HEADER_ADD:
case SAPI_HEADER_REPLACE:
val = strchr(sapi_header->header, ':');
if (!val) {
return 0;
}
ptr = val;
*val = '\0';
do {
val++;
} while (*val == ' ');
if (!strcasecmp(sapi_header->header, "content-type")) {
if (ctx->content_type) {
efree(ctx->content_type);
}
ctx->content_type = estrdup(val);
} else if (!strcasecmp(sapi_header->header, "content-length")) {
apr_off_t clen = 0;
if (APR_SUCCESS != apr_strtoff(&clen, val, (char **) NULL, 10)) {
/* We'll fall back to strtol, since that's what we used to
* do anyway. */
clen = (apr_off_t) strtol(val, (char **) NULL, 10);
}
ap_set_content_length(ctx->r, clen);
} else if (op == SAPI_HEADER_REPLACE) {
apr_table_set(ctx->r->headers_out, sapi_header->header, val);
} else {
apr_table_add(ctx->r->headers_out, sapi_header->header, val);
}
*ptr = ':';
return SAPI_HEADER_ADD;
default:
return 0;
}
}
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;
}
}
//
// Output filter.
//
static apr_status_t resize_output_filter(ap_filter_t* f, apr_bucket_brigade* in_bb)
{
request_rec* rec =f->r;
resize_conf* conf = (resize_conf*)ap_get_module_config(rec->per_dir_config, &resizeimage_module);
const char* content_type, *target_type = "JPEG";
const char* image_url, *resize_param, *image_hash=NULL;
Magick::Blob blob;
char* vlob = NULL;
size_t vlob_length = 0;
int cache_hit = FALSE;
AP_LOG_VERBOSE(rec, "Incoming %s.", __FUNCTION__);
// Pass thru by request types.
if(rec->status!=HTTP_OK || rec->main!=NULL || rec->header_only
|| (rec->handler!= NULL && strcmp(rec->handler, "default-handler") == 0)) goto PASS_THRU;
AP_LOG_VERBOSE(rec, "-- Checking responce headers.");
// Obtain and erase x-resize-image header or pass through.
image_url = get_and_unset_header(rec->headers_out, X_RESIZE);
if(image_url== NULL || image_url[0]=='\0') {
image_url = get_and_unset_header(rec->err_headers_out, X_RESIZE);
}
if(image_url==NULL || image_url[0]=='\0') goto PASS_THRU;
// Check content-type
content_type = rec->content_type;
if(content_type) {
if(strcasecmp(content_type, "image/jpeg")==0) {
target_type = "JPEG";
} else
if(strcasecmp(content_type, "image/png")==0) {
target_type = "PNG";
} else
if(strcasecmp(content_type, "image/gif")==0) {
target_type = "GIF";
} else goto PASS_THRU;
}
// Resize parameter
resize_param = get_and_unset_header(rec->headers_out, X_RESIZE_PARAM);
if(resize_param==NULL || resize_param[0]=='\0') {
resize_param = get_and_unset_header(rec->err_headers_out, X_RESIZE_PARAM);
}
if(resize_param[0]=='\0') resize_param = NULL;
// Image hash
image_hash = get_and_unset_header(rec->headers_out, X_RESIZE_HASH);
if(image_hash==NULL || image_hash[0]=='\0') {
image_hash = get_and_unset_header(rec->err_headers_out, X_RESIZE_HASH);
}
// Open image and resize.
AP_LOG_INFO(rec, "URL: %s, %s => %s (%s)", image_url, content_type, resize_param, image_hash);
if(image_hash) {
// Try memcached...
image_hash = apr_psprintf(rec->pool, "%s:%s:%s", image_hash, target_type, resize_param);
memcached_return r;
uint32_t flags;
vlob = memcached_get(conf->memc, image_hash, strlen(image_hash), &vlob_length, &flags, &r);
if(r==MEMCACHED_SUCCESS) {
AP_LOG_DEBUG(rec, "Restored from memcached: %s, len=%d", image_hash, vlob_length);
cache_hit = TRUE;
goto WRITE_DATA;
} else {
AP_LOG_DEBUG(rec, "Can't restore from memcached: %s - %s(%d)", image_hash, memcached_strerror(conf->memc, r), r);
}
}
// Reszize
try {
Magick::Image image;
image.read(image_url);
if(resize_param) image.zoom(resize_param);
image.magick(target_type);
image.quality(conf->jpeg_quality);
image.write(&blob);
vlob = (char*)blob.data();
vlob_length = blob.length();
}
catch(Magick::Exception& err) {
AP_LOG_ERR(rec, __FILE__ ": Magick failed: %s", err.what());
goto PASS_THRU;
}
if(image_hash) {
// Store to memcached...
memcached_return r = memcached_set(conf->memc, image_hash, strlen(image_hash), vlob, vlob_length, conf->expire, 0);
if(r==MEMCACHED_SUCCESS) {
AP_LOG_DEBUG(rec, "Stored to memcached: %s(len=%d)", image_hash, vlob_length);
} else {
AP_LOG_DEBUG(rec, "Can't store from memcached: %s(len=%d) - %s(%d)", image_hash, vlob_length,memcached_strerror(conf->memc, r), r);
}
}
WRITE_DATA:
AP_LOG_VERBOSE(rec, "-- Creating resize buckets.");
// Drop all content and headers related.
while(!APR_BRIGADE_EMPTY(in_bb)) {
apr_bucket* b = APR_BRIGADE_FIRST(in_bb);
apr_bucket_delete(b);
}
rec->eos_sent = 0;
rec->clength = 0;
unset_header(rec, "Content-Length");
unset_header(rec, "Content-Encoding");
unset_header(rec, "Last-Modified");
unset_header(rec, "ETag");
// Start resize bucket.
{
apr_off_t remain = vlob_length, offset = 0;
while(remain>0) {
apr_off_t bs = (remain<AP_MAX_SENDFILE)? remain: AP_MAX_SENDFILE;
char* heap = (char*)malloc(bs);
memcpy(heap, vlob+offset, bs);
apr_bucket* b = apr_bucket_heap_create(heap, bs, free, in_bb-> bucket_alloc);
APR_BRIGADE_INSERT_TAIL(in_bb, b);
remain -= bs;
offset += bs;
}
APR_BRIGADE_INSERT_TAIL(in_bb, apr_bucket_eos_create(in_bb->bucket_alloc));
ap_set_content_length(rec, vlob_length);
if(cache_hit) free(vlob);
}
AP_LOG_VERBOSE(rec, "-- Create done.");
PASS_THRU:
AP_LOG_VERBOSE(rec, "-- Filter done.");
ap_remove_output_filter(f);
return ap_pass_brigade(f->next, in_bb);
}
static int zipread_showfile(request_rec *r, const char *fname)
{
char *zipfile, *name;
ZZIP_DIR *dir;
unsigned int itnum;
if (!r->path_info) return HTTP_NOT_FOUND;
zipfile = r->filename;
if (!fname || !*fname)
{
name = apr_pstrdup(r->pool, r->path_info);
}
else
{
name = apr_pstrcat(r->pool, r->path_info, fname, NULL);
}
r->content_type = zipread_getcontenttype(r, name);
if (*name == '/') name++;
// ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile: %s - %s - %s", zipfile, fname, name);
for(itnum = 0; itnum < 5; itnum++)
{
dir = zzip_dir_open(zipfile, 0);
if (dir)
{
ZZIP_STAT st;
// fetch stat info of filename, before opening it
if (zzip_dir_stat(dir, name, &st, 0) != 0)
{
// check if a directory entry is available for that name.
name = apr_pstrcat(r->pool, name, "/", NULL);
if (zzip_dir_stat(dir, name, &st, 0) != 0)
{
zzip_dir_close(dir);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile stat failed: %d - %s",
zzip_error(dir), zzip_strerror(zzip_error(dir)));
return HTTP_NOT_FOUND;
}
// found a directory entry, do an external redirect to get the
// links in the directory listing right.
name = apr_pstrcat(r->pool, r->uri, "/", NULL);
apr_table_setn(r->headers_out, "Location", name);
// ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile directory entry.");
return HTTP_MOVED_PERMANENTLY;
}
ap_set_content_length(r, st.st_size);
// cannot check last-modified date of the file itself here, because
// zziplib doesnt extract it. instead we use the zip file's date
r->mtime = r->finfo.mtime;
ap_set_last_modified(r);
if (!r->header_only)
{
ZZIP_FILE *fp = zzip_file_open(dir, name, 0);
if (fp)
{
int len;
char buf[32769];
while ((len = zzip_file_read (fp, buf, 32768)))
{
ap_rwrite(buf, len, r);
}
zzip_file_close(fp);
zzip_dir_close(dir);
return OK;
}
else
{
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile file open failed: %d - %s.",
zzip_error(dir), zzip_strerror(zzip_error(dir)));
if (zzip_dir_stat(dir, name, &st, 0) != 0)
{
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile after stat failed: %d - %s",
zzip_error(dir), zzip_strerror(zzip_error(dir)));
break;
}
zzip_dir_close(dir);
continue;
}
}
zzip_dir_close(dir);
return OK;
}
else
{
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile zip file not open.");
return HTTP_NOT_FOUND;
}
}
zzip_dir_close (dir);
return HTTP_NOT_FOUND;
}
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);
}
static int handle_request(request_rec *r)
{
tmcdreq_t tmcdreq, *reqp = &tmcdreq;
tmcdresp_t *response = NULL;
char *command;
struct in_addr local_addr;
struct in_addr remote_addr;
struct sockaddr_in redir_client;
int tmcd_status;
int status = OK;
char *status_line = NULL;
char *args = NULL;
char *function_args = NULL;
char *p;
char **argv = NULL;
int argc, i;
reqp->istcp = 1;
reqp->isssl = 1; /* FIXME */
if (strcmp(r->handler, "tmcd")) {
status = DECLINED;
goto err;
}
#if 0
r->allowed |= (AP_METHOD_BIT << M_GET);
if (r->method_number != M_GET) {
status = DECLINED;
goto err;
}
#endif
memset(reqp, 0, sizeof(*reqp));
local_addr = r->connection->local_addr.sin_addr;
remote_addr = r->connection->remote_addr.sin_addr;
reqp->version = 1; /* FIXME need sane default */
tmcd_init(reqp, &local_addr, NULL);
command = r->path_info;
while (*command && *command == '/') {
command++;
}
if (command[0] == '\0') {
status = HTTP_BAD_REQUEST;
goto err;
}
if (r->args) {
args = malloc(strlen(r->args) + 1);
if (args == NULL) {
status = HTTP_INTERNAL_SERVER_ERROR;
goto err;
}
strcpy(args, r->args);
argv = make_argv(args, &argc, '&');
if (argv == NULL) {
status = HTTP_INTERNAL_SERVER_ERROR;
goto err;
}
for (i = 0; i < argc; i++) {
/* Unescape the arguments */
p = args;
while (*p) {
if (*p == '+')
*p = ' ';
p++;
}
status = ap_unescape_url(args);
if (status != OK) {
goto err;
}
if (strncasecmp(argv[i], "version=", 8) == 0) {
long version;
char *end;
version = strtol(argv[i] + 8, &end, 10);
if (*end != '\0' || *(argv[i] + 8) == '\0') {
status = HTTP_BAD_REQUEST;
status_line = "Invalid Version";
goto err;
}
reqp->version = version;
} else if (strncasecmp(argv[i], "redirect=", 9) == 0) {
if (inet_pton(AF_INET, argv[i] + 9,
&redir_client.sin_addr) <= 0) {
status = HTTP_BAD_REQUEST;
status_line = "Invalid IP Address";
goto err;
}
/* FIXME info message */
if (remote_addr.s_addr != local_addr.s_addr) {
status = HTTP_FORBIDDEN;
status_line = "Redirection Not Allowed";
goto err;
}
remote_addr =
redir_client.sin_addr;
} else if (strncasecmp(argv[i], "vnodeid=", 8) == 0) {
if (strlen(argv[i] + 8) >=
sizeof(reqp->vnodeid)) {
status = HTTP_BAD_REQUEST;
status_line =
"Virtual Node ID Too Long";
goto err;
}
reqp->isvnode = 1;
strcpy(reqp->vnodeid, argv[i] + 8);
} else if (strncasecmp(argv[i], "args=", 5) == 0) {
function_args = argv[i] + 5;
}
}
}
/* FIXME handle wanodekey */
if ((tmcd_status = iptonodeid(reqp, remote_addr, NULL))) {
if (reqp->isvnode) {
status_line = "Invalid Virtual Node";
}
else {
status_line = "Invalid Node";
}
status = HTTP_NOT_FOUND;
goto err;
}
if (reqp->tmcd_redirect[0]) {
/* FIXME what if https should be used? */
/* FIXME do I need to specify the args should be passed too? */
char *uri = ap_psprintf(r->pool, "http://%s%s?%s", reqp->tmcd_redirect,
r->uri, r->args);
ap_table_setn(r->headers_out, "Location", uri);
status = HTTP_MOVED_TEMPORARILY;
goto done;
}
tmcd_status = tmcd_handle_request(reqp, &response, command,
function_args);
if (tmcd_status == TMCD_STATUS_OK) {
r->content_type = response->type;
ap_set_content_length(r, response->length);
/* FIXME doctype */
ap_soft_timeout("tmcd response call trace", r);
ap_send_http_header(r);
ap_rprintf(r, "%s", response->data);
ap_kill_timeout(r);
status = OK;
goto done;
} else {
switch(tmcd_status) {
case TMCD_STATUS_UNKNOWN_COMMAND:
status = HTTP_NOT_FOUND;
status_line = "Unknown Command";
break;
case TMCD_STATUS_REQUIRES_ENCRYPTION:
status = HTTP_FORBIDDEN;
status_line = "SSL Required";
break;
case TMCD_STATUS_NODE_NOT_ALLOCATED:
status = HTTP_FORBIDDEN;
status_line = "Node Not Allocated";
break;
case TMCD_STATUS_COMMAND_FAILED:
status = HTTP_INTERNAL_SERVER_ERROR;
if (response && response->data) {
status_line = response->data;
}
break;
case TMCD_STATUS_MALLOC_FAILED:
status = HTTP_INTERNAL_SERVER_ERROR;
break;
}
goto err;
}
err:
done:
if (argv)
free(argv);
if (args)
free(args);
if (response)
tmcd_free_response(response);
if (status_line) {
r->status_line = ap_psprintf(r->pool, "%3.3u %s", status,
status_line);
}
return status;
}
/* The content handler */
static int rcache_handler(request_rec *r)
{
rcache_info *info;
info = ap_get_module_config(r->server->module_config, &rcache_module);
info->data = "";
info->r = r;
info->length = 0;
info->type = "";
apr_status_t rv;
const char *retrieve_url;
if (strcmp(r->handler, "rcache")) {
rv = DECLINED;
goto finish;
}
// redis context and connection
#ifdef CONN_PERSISTENT
redisContext *c = info->c;
redisReply *reply = info->reply;
if (!c) {
struct timeval timeout = { 1, 500000 }; // 1.5 seconds
c = redisConnectWithTimeout(info->hostname, info->port, timeout);
info->c = c;
// ping pong test
if ( !(c == NULL || c->err) ) {
reply = redisCommand(c,"PING");
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "PING: %s", reply->str);
#endif
}
}
#else
redisContext *c;
redisReply *reply;
struct timeval timeout = { 1, 500000 }; // 1.5 seconds
c = redisConnectWithTimeout(info->hostname, info->port, timeout);
#endif
// when redis connection error
if (c == NULL || c->err) {
if (c) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "Connection error: %s", c->errstr);
} else {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "Connection error: can't allocate redis context" );
}
rv = HTTP_INTERNAL_SERVER_ERROR;
goto finish;
}
#ifdef FLAG_WAIT
int wait = 0;
#endif
if ( (retrieve_url = apr_table_get(r->subprocess_env, info->env_retrieve_url)) ) {
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "%s", r->path_info);
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "%s", retrieve_url);
#endif
#ifdef FLAG_WAIT
// WAIT flag check.
reply = redisCommand(c, "GET %s%s", info->prefix_wait, r->path_info);
if( reply->type != REDIS_REPLY_NIL ) {
// cache hot-replace check.
if ( reply->type == REDIS_REPLY_STRING && 0 == strcmp(reply->str,"HOT") ){
redisCommand(c, "DEL %s%s", info->prefix_wait, r->path_info);
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "hot cache replace: %s", r->path_info );
#endif
goto gencache;
}
// wait cache create.
wait = 1;
int loop = 10;
while(loop){
reply = redisCommand(c, "GET %s%s", info->prefix_wait, r->path_info);
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server, "wait loop: remain %d sec", loop);
#endif
if( reply->type == REDIS_REPLY_NIL ) {
goto read;
}
sleep(1);
loop--;
}
// when timeup. delete flag.
redisCommand(c, "DEL %s%s", info->prefix_wait, r->path_info);
goto gencache;
}
#endif
read:
// read from redis.
reply = redisCommand(c, "HMGET %s%s CONTENT TYPE LENGTH MTIME", info->prefix, r->path_info);
if( reply->type == REDIS_REPLY_ARRAY ) {
if ( reply->element[0]->len == 0 ) goto gencache;
const char* tmp = apr_pstrdup(r->pool, reply->element[1]->str);
ap_set_content_type(r, tmp);
ap_set_content_length(r, atoi(reply->element[2]->str) );
apr_time_t time = atol(reply->element[3]->str);
ap_update_mtime(r, time);
ap_set_last_modified(r);
ap_set_etag(r);
apr_status_t rc = ap_meets_conditions(r);
if (rc != OK) {
rv = rc;
goto finish;
}
if (!r->header_only)
ap_rputs(reply->element[0]->str, r);
rv = OK;
goto finish;
}
}else{
rv = DECLINED;
goto finish;
}
gencache:
#ifdef FLAG_WAIT
if (wait == 0)
redisCommand(c, "SET %s%s 1", info->prefix_wait, r->path_info);
#endif
rv = rcache_curl(retrieve_url, info);
// set content to redis
if (rv == HTTP_OK) {
if (strcmp(info->type,""))
info->type = "text/html";
if (info->length == 0)
info->length = strlen(info->data);
redisCommand(c,"HMSET %s%s CONTENT %s TYPE %s LENGTH %d MTIME %ld",
info->prefix, r->path_info, info->data, info->type, info->length, info->mtime);
ap_set_content_type(r, info->type);
ap_set_content_length(r, info->length);
ap_update_mtime(r, info->mtime);
ap_set_last_modified(r);
ap_set_etag(r);
if (!r->header_only)
ap_rputs(info->data, r);
}
#ifdef FLAG_WAIT
redisCommand(c, "DEL %s%s", info->prefix_wait, r->path_info);
#endif
finish:
#ifndef CONN_PERSISTENT
freeReplyObject(reply);
redisFree(c);
#endif
return rv;
}
static int drive_flvx(request_rec *r)
{
apr_finfo_t fi;
apr_bucket_brigade *bb;
apr_off_t offset = 0;
apr_off_t length = 0;
apr_file_t *fp = NULL;
apr_status_t rv = APR_SUCCESS;
rv = apr_stat(&fi, r->filename, APR_FINFO_SIZE, r->pool);
if (rv) {
/* Let the core handle it. */
return DECLINED;
}
/* Open the file */
rv = apr_file_open(&fp, r->filename, APR_READ,
APR_OS_DEFAULT, r->pool);
if (rv) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"file permissions deny server access: %s", r->filename);
return HTTP_FORBIDDEN;
}
offset = get_start(r);
if (offset != 0 && offset < fi.size) {
length = fi.size - offset;
}
else {
length = fi.size;
/* Offset should be reset if invalid mod by Artur Bodera */
offset = 0;
}
bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
if (offset != 0) {
length += FLVX_HEADER_LEN;
rv = apr_brigade_write(bb, NULL, NULL, FLVX_HEADER, FLVX_HEADER_LEN);
if (rv) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"unable to write flv header in brigade");
return HTTP_INTERNAL_SERVER_ERROR;
}
}
apr_brigade_insert_file(bb, fp, offset, length, r->pool);
ap_set_content_type(r, "video/x-flv");
ap_set_content_length(r, length);
/* Add last-modified headers mod by Artur Bodera */
ap_update_mtime(r, r->finfo.mtime);
ap_set_last_modified(r);
return ap_pass_brigade(r->output_filters, bb);
}
static int read_response(request_rec* r, char* res_id)
{
apr_file_t* fd;
apr_status_t rv = 0;
apr_size_t bytes_sent;
apr_finfo_t fi;
char res_fn[256];
const char *res_content;
const char *res_status;
int rc = 0;
/***** For Http Header ******/
rc = GetHttpHeader(res_id, "Content-type", &res_content);
if(rc == DSO_NO_MATCH) {// in case without maching key
//true = success, false = failure
res_content = "text/xml";
}
if (rc == EXIT_FAILURE) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, NULL,
"*** mod_err *** : GetHttpHeader(res_id)");
return HTTP_INTERNAL_SERVER_ERROR;
}
r->content_type = (char *) apr_pstrdup(r->pool, res_content);
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_NOTICE, rv, NULL,
"*** mod *** : GetHttpHeader header = %s", res_content);
#endif
rc = GetHttpHeader(res_id, "status", &res_status);
if(rc == DSO_NO_MATCH) {// in the case without maching key
res_status = "200";
}
if (rc == EXIT_FAILURE) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, NULL,
"*** mod_err *** : GetHttpHeader(req_id)");
return HTTP_INTERNAL_SERVER_ERROR;
}
r->status = atoi(res_status);
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_NOTICE, rv, NULL,
"*** mod *** : GetHttpHeader header = %s", res_status);
#endif
/***** For Http Body ******/
rc = GetFileName(res_id, res_fn);
if (rc == EXIT_FAILURE) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, NULL,
"*** mod_err *** : GetFileName(res_id)");
return HTTP_INTERNAL_SERVER_ERROR;
}
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_NOTICE, rv, NULL,
"*** mod *** : GetFileName res_fn = %s", res_fn);
#endif
rv = apr_file_open(&fd, res_fn, APR_READ, -1, r->pool);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, NULL,
"*** mod_err *** : apr_file_open");
return HTTP_INTERNAL_SERVER_ERROR;
}
/****** Get file size of response message ******/
rv = apr_stat(&fi, res_fn, APR_FINFO_SIZE, r->pool);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, NULL,
"*** mod_err *** : apr_stat");
return HTTP_INTERNAL_SERVER_ERROR;
}
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_NOTICE, rv, NULL,
"*** mod *** : apr_stat res_size = %ld", (apr_off_t)fi.size);
#endif
WriteLog(9,"send to client start");
/* send the file with size if known */
if (r->proto_num <1001) ap_set_content_length(r,fi.size);
rv = ap_send_fd(fd, r, 0, ((fi.size > 0) ? fi.size : -1), &bytes_sent);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, NULL,
"*** mod_err *** : ap_send_fd");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* Must not file close
rv = apr_file_close(fd);
*/
return EXIT_SUCCESS;
}
// output_data
apr_status_t small_light_filter_imagemagick_output_data(
ap_filter_t *f,
apr_bucket_brigade *bb,
void *v_ctx,
apr_bucket *e)
{
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, f->r, "small_light_filter_imagemagick_output_data");
request_rec *r = f->r;
small_light_module_ctx_t* ctx = (small_light_module_ctx_t*)v_ctx;
small_light_module_imagemagick_ctx_t *lctx = ctx->lctx;
struct timeval t2, t21, t22, t23, t3;
MagickBooleanType status = MagickFalse;
// check data received.
if (lctx->image == NULL) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "no data received.");
r->status = HTTP_INTERNAL_SERVER_ERROR;
return APR_EGENERAL;
}
// start image modifing.
gettimeofday(&t2, NULL);
small_light_image_size_t sz;
small_light_calc_image_size(&sz, r, ctx, 10000.0, 10000.0);
// init wand
small_light_filter_imagemagick_output_data_init();
lctx->wand = NewMagickWand();
// prepare.
if (sz.jpeghint_flg != 0) {
char *jpeg_size_opt = (char *)apr_psprintf(r->pool, "%dx%d",
(int)sz.dw, (int)sz.dh);
MagickSetOption(lctx->wand, "jpeg:size", jpeg_size_opt);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickSetOption(jpeg:size, %s)", jpeg_size_opt);
}
// load image.
gettimeofday(&t21, NULL);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickReadImageBlob");
status = MagickReadImageBlob(lctx->wand, (void *)lctx->image, lctx->image_len);
if (status == MagickFalse) {
small_light_filter_imagemagick_output_data_fini(ctx);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "couldn't read image");
r->status = HTTP_INTERNAL_SERVER_ERROR;
return APR_EGENERAL;
}
// calc size.
gettimeofday(&t22, NULL);
double iw = (double)MagickGetImageWidth(lctx->wand);
double ih = (double)MagickGetImageHeight(lctx->wand);
small_light_calc_image_size(&sz, r, ctx, iw, ih);
// pass through.
if (sz.pt_flg != 0) {
small_light_filter_imagemagick_output_data_fini(ctx);
apr_bucket *b = apr_bucket_pool_create(lctx->image, lctx->image_len, r->pool, ctx->bb->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(ctx->bb, b);
APR_BRIGADE_INSERT_TAIL(ctx->bb, apr_bucket_eos_create(ctx->bb->bucket_alloc));
return ap_pass_brigade(f->next, ctx->bb);
}
// crop, scale.
status = MagickTrue;
if (sz.scale_flg != 0) {
char *crop_geo = (char *)apr_psprintf(r->pool, "%f!x%f!+%f+%f",
sz.sw, sz.sh, sz.sx, sz.sy);
char *size_geo = (char *)apr_psprintf(r->pool, "%f!x%f!", sz.dw, sz.dh);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"MagickTransformImage(wand, ""%s"", ""%s"")",
crop_geo, size_geo);
MagickWand *trans_wand;
trans_wand = MagickTransformImage(lctx->wand, crop_geo, size_geo);
if (trans_wand == NULL || trans_wand == lctx->wand) {
small_light_filter_imagemagick_output_data_fini(ctx);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "MagickTransformImage failed");
r->status = HTTP_INTERNAL_SERVER_ERROR;
return APR_EGENERAL;
}
DestroyMagickWand(lctx->wand);
lctx->wand = trans_wand;
} else {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "no scale");
}
// create canvas then draw image to the canvas.
if (sz.cw > 0.0 && sz.ch > 0.0) {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "NewMagickWand()");
MagickWand *canvas_wand = NewMagickWand();
PixelWand *canvas_color = NewPixelWand();
PixelSetRed(canvas_color, sz.cc.r / 255.0);
PixelSetGreen(canvas_color, sz.cc.g / 255.0);
PixelSetBlue(canvas_color, sz.cc.b / 255.0);
PixelSetAlpha(canvas_color, sz.cc.a / 255.0);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"MagickNewImage(canvas_wand, %f, %f, bgcolor)", sz.cw, sz.ch);
status = MagickNewImage(canvas_wand, sz.cw, sz.ch, canvas_color);
DestroyPixelWand(canvas_color);
if (status == MagickFalse) {
small_light_filter_imagemagick_output_data_fini(ctx);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"MagickNewImage(canvas_wand, %f, %f, bgcolor) failed", sz.cw, sz.ch);
r->status = HTTP_INTERNAL_SERVER_ERROR;
return APR_EGENERAL;
}
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"MagickCompositeImage(canvas_wand, wand, AtopCompositeOp, %f, %f)",
sz.dx, sz.dy);
status = MagickCompositeImage(canvas_wand, lctx->wand, AtopCompositeOp, sz.dx, sz.dy);
if (status == MagickFalse) {
small_light_filter_imagemagick_output_data_fini(ctx);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"MagickCompositeImage(canvas_wand, wand, AtopCompositeOp, %f, %f) failed",
sz.dx, sz.dy);
r->status = HTTP_INTERNAL_SERVER_ERROR;
return APR_EGENERAL;
}
DestroyMagickWand(lctx->wand);
lctx->wand = canvas_wand;
}
// effects.
char *unsharp = (char *)apr_table_get(ctx->prm, "unsharp");
if (unsharp) {
GeometryInfo geo;
ParseGeometry(unsharp, &geo);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"MagickUnsharpMaskImage(wand, %f, %f, %f, %f)",
geo.rho, geo.sigma, geo.xi, geo.psi);
status = MagickUnsharpMaskImage(lctx->wand, geo.rho, geo.sigma, geo.xi, geo.psi);
if (status == MagickFalse) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "unsharp failed");
}
}
char *sharpen = (char *)apr_table_get(ctx->prm, "sharpen");
if (sharpen) {
GeometryInfo geo;
ParseGeometry(sharpen, &geo);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"MagickSharpenImage(wand, %f, %f)",
geo.rho, geo.sigma);
status = MagickSharpenImage(lctx->wand, geo.rho, geo.sigma);
if (status == MagickFalse) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "sharpen failed");
}
}
char *blur = (char *)apr_table_get(ctx->prm, "blur");
if (blur) {
GeometryInfo geo;
ParseGeometry(blur, &geo);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"MagickBlurImage(wand, %f, %f)",
geo.rho, geo.sigma);
status = MagickBlurImage(lctx->wand, geo.rho, geo.sigma);
if (status == MagickFalse) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "blur failed");
}
}
// border.
if (sz.bw > 0.0 || sz.bh > 0.0) {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "draw border");
DrawingWand *border_wand = NewDrawingWand();
PixelWand *border_color;
border_color = NewPixelWand();
PixelSetRed(border_color, sz.bc.r / 255.0);
PixelSetGreen(border_color, sz.bc.g / 255.0);
PixelSetBlue(border_color, sz.bc.b / 255.0);
PixelSetAlpha(border_color, sz.bc.a / 255.0);
DrawSetFillColor(border_wand, border_color);
DrawSetStrokeColor(border_wand, border_color);
DrawSetStrokeWidth(border_wand, 1);
DrawRectangle(border_wand, 0, 0, sz.cw - 1, sz.bh - 1);
DrawRectangle(border_wand, 0, 0, sz.bw - 1, sz.ch - 1);
DrawRectangle(border_wand, 0, sz.ch - sz.bh, sz.cw - 1, sz.ch - 1);
DrawRectangle(border_wand, sz.cw - sz.bw, 0, sz.cw - 1, sz.ch - 1);
MagickDrawImage(lctx->wand, border_wand);
DestroyPixelWand(border_color);
DestroyDrawingWand(border_wand);
}
gettimeofday(&t23, NULL);
// set params.
double q = small_light_parse_double(r, (char *)apr_table_get(ctx->prm, "q"));
if (q > 0.0) {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"MagickSetImageComressionQualty(wand, %f)", q);
MagickSetImageCompressionQuality(lctx->wand, q);
}
char *of = (char *)apr_table_get(ctx->prm, "of");
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"MagickSetFormat(wand, '%s')", of);
MagickSetFormat(lctx->wand, of);
// get small_lighted image as binary.
unsigned char *canvas_buff;
const char *sled_image;
size_t sled_image_size;
canvas_buff = MagickGetImageBlob(lctx->wand, &sled_image_size);
sled_image = (const char *)apr_pmemdup(r->pool, canvas_buff, sled_image_size);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "sled_image_size = %d", sled_image_size);
// free buffer and wand.
MagickRelinquishMemory(canvas_buff);
small_light_filter_imagemagick_output_data_fini(ctx);
// insert new bucket to bucket brigade.
apr_bucket *b = apr_bucket_pool_create(sled_image, sled_image_size, r->pool, ctx->bb->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(ctx->bb, b);
// insert eos to bucket brigade.
APR_BRIGADE_INSERT_TAIL(ctx->bb, apr_bucket_eos_create(ctx->bb->bucket_alloc));
// set correct Content-Type and Content-Length.
char *cont_type = apr_psprintf(r->pool, "image/%s", of);
ap_set_content_type(r, cont_type);
ap_set_content_length(r, sled_image_size);
// end.
gettimeofday(&t3, NULL);
// http header.
int info = small_light_parse_int(r, (char *)apr_table_get(ctx->prm, "info"));
if (info != SMALL_LIGHT_INT_INVALID_VALUE && info != 0) {
char *info = (char *)apr_psprintf(r->pool,
"transfer=%ldms, modify image=%ldms (load=%ldms, scale=%ldms, save=%ldms)",
small_light_timeval_diff(&ctx->t, &t2) / 1000L,
small_light_timeval_diff(&t2, &t3) / 1000L,
small_light_timeval_diff(&t21, &t22) / 1000L,
small_light_timeval_diff(&t22, &t23) / 1000L,
small_light_timeval_diff(&t23, &t3) / 1000L
);
ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
"uri=%s, info=%s)", r->unparsed_uri, info);
apr_table_setn(r->headers_out, "X-SmallLight-Description", info);
}
return ap_pass_brigade(f->next, ctx->bb);
}
static int reflector_handler(request_rec * r)
{
apr_bucket_brigade *bbin, *bbout;
reflector_cfg *conf;
apr_status_t status;
if (strcmp(r->handler, "reflector")) {
return DECLINED;
}
conf = (reflector_cfg *) ap_get_module_config(r->per_dir_config,
&reflector_module);
ap_allow_methods(r, 1, "POST", "OPTIONS", NULL);
if (r->method_number == M_OPTIONS) {
return ap_send_http_options(r);
}
else if (r->method_number == M_POST) {
const char *content_length, *content_type;
int seen_eos;
/*
* Sometimes we'll get in a state where the input handling has
* detected an error where we want to drop the connection, so if
* that's the case, don't read the data as that is what we're trying
* to avoid.
*
* This function is also a no-op on a subrequest.
*/
if (r->main || r->connection->keepalive == AP_CONN_CLOSE ||
ap_status_drops_connection(r->status)) {
return OK;
}
/* copy headers from in to out if configured */
apr_table_do(header_do, r, conf->headers, NULL);
/* last modified defaults to now, unless otherwise set on the way in */
if (!apr_table_get(r->headers_out, "Last-Modified")) {
ap_update_mtime(r, apr_time_now());
ap_set_last_modified(r);
}
ap_set_accept_ranges(r);
/* reflect the content length, if present */
if ((content_length = apr_table_get(r->headers_in, "Content-Length"))) {
apr_off_t offset;
apr_strtoff(&offset, content_length, NULL, 10);
ap_set_content_length(r, offset);
}
/* reflect the content type, if present */
if ((content_type = apr_table_get(r->headers_in, "Content-Type"))) {
ap_set_content_type(r, content_type);
}
bbin = apr_brigade_create(r->pool, r->connection->bucket_alloc);
bbout = apr_brigade_create(r->pool, r->connection->bucket_alloc);
seen_eos = 0;
do {
apr_bucket *bucket;
status = ap_get_brigade(r->input_filters, bbin, AP_MODE_READBYTES,
APR_BLOCK_READ, HUGE_STRING_LEN);
if (status != APR_SUCCESS) {
if (status == AP_FILTER_ERROR) {
apr_brigade_destroy(bbin);
return status;
}
else {
apr_brigade_destroy(bbin);
return HTTP_BAD_REQUEST;
}
}
for (bucket = APR_BRIGADE_FIRST(bbin);
bucket != APR_BRIGADE_SENTINEL(bbin);
bucket = APR_BUCKET_NEXT(bucket)) {
const char *data;
apr_size_t len;
if (APR_BUCKET_IS_EOS(bucket)) {
seen_eos = 1;
break;
}
/* These are metadata buckets. */
if (bucket->length == 0) {
continue;
}
/*
* We MUST read because in case we have an unknown-length
* bucket or one that morphs, we want to exhaust it.
*/
status = apr_bucket_read(bucket, &data, &len, APR_BLOCK_READ);
if (status != APR_SUCCESS) {
apr_brigade_destroy(bbin);
return HTTP_BAD_REQUEST;
}
apr_brigade_write(bbout, NULL, NULL, data, len);
status = ap_pass_brigade(r->output_filters, bbout);
if (status != APR_SUCCESS) {
/* no way to know what type of error occurred */
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, status, r, APLOGNO(01410)
"reflector_handler: ap_pass_brigade returned %i",
status);
return HTTP_INTERNAL_SERVER_ERROR;
}
}
apr_brigade_cleanup(bbin);
} while (!seen_eos);
return OK;
}
else {
return HTTP_METHOD_NOT_ALLOWED;
}
}
