/**
* Parse an Alt-Svc specifier as described in "HTTP Alternative Services"
* (https://tools.ietf.org/html/draft-ietf-httpbis-alt-svc-04)
* with the following changes:
* - do not percent encode token values
* - do not use quotation marks
*/
h2_alt_svc *h2_alt_svc_parse(const char *s, apr_pool_t *pool) {
const char *sep = ap_strchr_c(s, '=');
if (sep) {
const char *alpn = apr_pstrndup(pool, s, sep - s);
const char *host = NULL;
int port = 0;
s = sep + 1;
sep = ap_strchr_c(s, ':'); /* mandatory : */
if (sep) {
if (sep != s) { /* optional host */
host = apr_pstrndup(pool, s, sep - s);
}
s = sep + 1;
if (*s) { /* must be a port number */
port = (int)apr_atoi64(s);
if (port > 0 && port < (0x1 << 16)) {
h2_alt_svc *as = apr_pcalloc(pool, sizeof(*as));
as->alpn = alpn;
as->host = host;
as->port = port;
return as;
}
}
}
}
return NULL;
}
static const char* interpolate_env(request_rec *r, const char *str) {
/* Interpolate an env str in a configuration string
* Syntax ${var} --> value_of(var)
* Method: replace one var, and recurse on remainder of string
* Nothing clever here, and crap like nested vars may do silly things
* but we'll at least avoid sending the unwary into a loop
*/
const char *start;
const char *end;
const char *var;
const char *val;
const char *firstpart;
start = ap_strstr(str, "${");
if (start == NULL) {
return str;
}
end = ap_strchr(start+2, '}');
if (end == NULL) {
return str;
}
/* OK, this is syntax we want to interpolate. Is there such a var ? */
var = apr_pstrndup(r->pool, start+2, end-(start+2));
val = apr_table_get(r->subprocess_env, var);
firstpart = apr_pstrndup(r->pool, str, (start-str));
if (val == NULL) {
return apr_pstrcat(r->pool, firstpart, interpolate_env(r, end+1), NULL);
} else {
return apr_pstrcat(r->pool, firstpart, val,
interpolate_env(r, end+1), NULL);
}
}
static apr_status_t find_self_exe( const char **exe_name )
{
apr_status_t rv = APR_SUCCESS;
char buffer[1024];
#ifdef __MacOS_X__
uint32_t length = sizeof (buffer);
if (_NSGetExecutablePath( buffer, &length ) == 0 && buffer[0] == '/') {
*exe_name = apr_pstrndup( _mp, buffer, length );
}
else {
ERROR( "failed to find exe: %s", strerror(errno) );
rv = APR_FROM_OS_ERROR( errno );
}
#else
ssize_t size = readlink( "/proc/self/exe", buffer, sizeof( buffer ) );
if( size < 0 ) {
ERROR( "readlink failed: %s", strerror(errno) );
rv = APR_FROM_OS_ERROR( errno );
}
else {
*exe_name = apr_pstrndup( _mp, buffer, size );
}
#endif
return rv;
}
static size_t rcache_curl_header_cb(const void* ptr, size_t size, size_t nmemb, void* _info)
{
rcache_info* info = _info;
if (strncmp(ptr, "HTTP/1.", sizeof("HTTP/1.") - 1) == 0) {
int minor_ver, status;
if (sscanf(ptr, "HTTP/1.%d %d ", &minor_ver, &status) == 2 && (status != 200 || status != 301 || status != 302) )
info->r->status = status;
} else if (strncasecmp(ptr, "content-type:", sizeof("content-type:") - 1) == 0) {
const char* s = (const char*)ptr + sizeof("content-type:") - 1,
* e = (const char*)ptr + size * nmemb - 1;
for (; s <= e; --e)
if (*e != '\r' && *e != '\n')
break;
for (; s <= e; ++s)
if (*s != ' ' && *s != '\t')
break;
if (s <= e)
info->type = apr_pstrndup(info->r->pool, s, e - s + 1);
} else if (strncasecmp(ptr, "content-length:", sizeof("content-length:") - 1) == 0) {
const char* s = (const char*)ptr + sizeof("content-length:") - 1,
* e = (const char*)ptr + size * nmemb - 1;
for (; s <= e; --e)
if (*e != '\r' && *e != '\n')
break;
for (; s <= e; ++s)
if (*s != ' ' && *s != '\t')
break;
if (s <= e)
info->length = atoi( apr_pstrndup(info->r->pool, s, e - s + 1) );
}
info->mtime = apr_time_now();
return nmemb;
}
static xmlCharEncoding sniff_encoding(saxctxt* ctx, const char* cbuf, size_t bytes)
{
request_rec* r = ctx->f->r;
cdn_conf* cfg = ctx->cfg;
xmlCharEncoding ret;
char* p;
ap_regmatch_t match[2];
char* buf = (char*)cbuf;
const char *encoding = 0;
/* If we've got it in the HTTP headers, there's nothing to do */
if(r->content_type && (p = ap_strcasestr(r->content_type, "charset=")) && p != NULL) {
p += 8;
if((encoding = apr_pstrndup(r->pool, p, strcspn(p, " ;")))) {
ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r->server,
"sniff_encoding: found charset %s in Content-Type", encoding);
ret = xmlParseCharEncoding(encoding);
if(((ret != XML_CHAR_ENCODING_ERROR) && (ret != XML_CHAR_ENCODING_NONE)))
return ret;
}
}
/* to sniff, first we look for BOM */
if(encoding == NULL) {
if((ret = xmlDetectCharEncoding((const xmlChar*)buf, bytes)) != XML_CHAR_ENCODING_NONE) {
ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r->server,
"sniff_encoding: got charset from XML rules");
return ret;
}
/* If none of the above, look for a META-thingey */
if(ap_regexec(seek_meta_ctype, buf, 1, match, 0) == 0) {
p = apr_pstrndup(r->pool, buf + match[0].rm_so, match[0].rm_eo - match[0].rm_so);
if(ap_regexec(seek_charset, p, 2, match, 0) == 0)
encoding = apr_pstrndup(r->pool, p+match[1].rm_so, match[1].rm_eo - match[1].rm_so);
}
}
/* either it's set to something we found or it's still the default */
if(encoding) {
ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r->server,
"sniff_encoding: got charset %s from HTML META", encoding);
ret = xmlParseCharEncoding(encoding);
if(ret != XML_CHAR_ENCODING_ERROR && ret != XML_CHAR_ENCODING_NONE)
return ret;
ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r->server,
"sniff_encoding: charset %s not supported", encoding);
}
/* Use configuration default as a last resort */
ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r->server,
"sniff_encoding: no suitable charset information");
return (cfg->default_encoding == XML_CHAR_ENCODING_NONE)
? XML_CHAR_ENCODING_8859_1 : cfg->default_encoding ;
}
apr_status_t h2_request_add_header(h2_request *req, apr_pool_t *pool,
const char *name, size_t nlen,
const char *value, size_t vlen)
{
apr_status_t status = APR_SUCCESS;
if (nlen <= 0) {
return status;
}
if (name[0] == ':') {
/* pseudo header, see ch. 8.1.2.3, always should come first */
if (!apr_is_empty_table(req->headers)) {
ap_log_perror(APLOG_MARK, APLOG_ERR, 0, pool,
APLOGNO(02917)
"h2_request(%d): pseudo header after request start",
req->id);
return APR_EGENERAL;
}
if (H2_HEADER_METHOD_LEN == nlen
&& !strncmp(H2_HEADER_METHOD, name, nlen)) {
req->method = apr_pstrndup(pool, value, vlen);
}
else if (H2_HEADER_SCHEME_LEN == nlen
&& !strncmp(H2_HEADER_SCHEME, name, nlen)) {
req->scheme = apr_pstrndup(pool, value, vlen);
}
else if (H2_HEADER_PATH_LEN == nlen
&& !strncmp(H2_HEADER_PATH, name, nlen)) {
req->path = apr_pstrndup(pool, value, vlen);
}
else if (H2_HEADER_AUTH_LEN == nlen
&& !strncmp(H2_HEADER_AUTH, name, nlen)) {
req->authority = apr_pstrndup(pool, value, vlen);
}
else {
char buffer[32];
memset(buffer, 0, 32);
strncpy(buffer, name, (nlen > 31)? 31 : nlen);
ap_log_perror(APLOG_MARK, APLOG_WARNING, 0, pool,
APLOGNO(02954)
"h2_request(%d): ignoring unknown pseudo header %s",
req->id, buffer);
}
}
else {
/* non-pseudo header, append to work bucket of stream */
status = add_h1_header(req, pool, name, nlen, value, vlen);
}
return status;
}
/*--------------------------------------------------------------------------*/
static const char *cmd_advertise_m(cmd_parms *cmd, void *dummy,
const char *arg, const char *opt)
{
mod_advertise_config *mconf = ap_get_module_config(cmd->server->module_config, &advertise_module);
if (mconf->ma_advertise_srvs)
return "Duplicate ServerAdvertise directives are not allowed";
if (strcasecmp(arg, "Off") == 0)
mconf->ma_advertise_mode = ma_advertise_off;
else if (strcasecmp(arg, "On") == 0)
mconf->ma_advertise_mode = ma_advertise_on;
else
return "ServerAdvertise must be Off or On";
if (opt) {
const char *p = ap_strstr_c(opt, "://");
if (p) {
mconf->ma_advertise_srvm = apr_pstrndup(cmd->pool, opt, p - opt);
opt = p + 3;
}
if (apr_parse_addr_port(&mconf->ma_advertise_srvs,
&mconf->ma_advertise_srvi,
&mconf->ma_advertise_srvp,
opt, cmd->pool) != APR_SUCCESS ||
!mconf->ma_advertise_srvs ||
!mconf->ma_advertise_srvp)
return "Invalid ServerAdvertise Address";
}
mconf->ma_advertise_server = cmd->server;
return NULL;
}
int lua_apr_stat(lua_State *L)
{
const char *path, *name, *dir;
apr_pool_t *memory_pool;
lua_apr_stat_context context = { 0 };
apr_status_t status;
memory_pool = to_pool(L);
path = luaL_checkstring(L, 1);
name = apr_filepath_name_get(path);
dir = apr_pstrndup(memory_pool, path, name - path);
context.firstarg = 2;
context.lastarg = lua_gettop(L);
check_stat_request(L, &context);
status = apr_stat(&context.info, path, context.wanted, memory_pool);
if (status != APR_SUCCESS && !APR_STATUS_IS_INCOMPLETE(status))
return push_error_status(L, status);
/* XXX apr_stat() doesn't fill in finfo.name (tested on Linux) */
if (!(context.info.valid & APR_FINFO_NAME)) {
context.info.valid |= APR_FINFO_NAME;
context.info.name = name;
}
return push_stat_results(L, &context, dir);
}
static void cdata_handler(void *userdata, const char *data, int len)
{
apr_xml_parser *parser = userdata;
apr_xml_elem *elem;
apr_text_header *hdr;
const char *s;
/* punt once we find an error */
if (parser->error)
return;
elem = parser->cur_elem;
s = apr_pstrndup(parser->p, data, len);
if (elem->last_child == NULL) {
/* no children yet. this cdata follows the start tag */
hdr = &elem->first_cdata;
}
else {
/* child elements exist. this cdata follows the last child. */
hdr = &elem->last_child->following_cdata;
}
apr_text_append(parser->p, hdr, s);
}
size_t _mapcache_curl_header_callback( void *ptr, size_t size, size_t nmemb, void *userdata)
{
char *colonptr;
struct _header_struct *h = (struct _header_struct*)userdata;
char *header = apr_pstrndup(h->ctx->pool,ptr,size*nmemb);
char *endptr = strstr(header,"\r\n");
if(!endptr) {
endptr = strstr(header,"\n");
if(!endptr) {
/* skip invalid header */
#ifdef DEBUG
h->ctx->log(h->ctx,MAPCACHE_DEBUG,"received header %s with no trailing \\r\\n",header);
#endif
return size*nmemb;
}
}
colonptr = strchr(header,':');
if(colonptr) {
*colonptr = '\0';
*endptr = '\0';
apr_table_setn(h->headers,header,colonptr+2);
}
return size*nmemb;
}
static apr_dbd_t *dbd_mysql_open(apr_pool_t *pool, const char *params)
{
static const char *const delims = " \r\n\t;|,";
const char *ptr;
int i;
const char *key;
size_t klen;
const char *value;
size_t vlen;
struct {
const char *field;
const char *value;
} fields[] = {
{"host", NULL},
{"user", NULL},
{"pass", NULL},
{"dbname", NULL},
{"port", NULL},
{"sock", NULL},
{NULL, NULL}
};
unsigned int port = 0;
apr_dbd_t *sql = apr_pcalloc(pool, sizeof(apr_dbd_t));
sql->conn = mysql_init(sql->conn);
if ( sql->conn == NULL ) {
return NULL;
}
for (ptr = strchr(params, '='); ptr; ptr = strchr(ptr, '=')) {
for (key = ptr-1; isspace(*key); --key);
klen = 0;
while (isalpha(*key)) {
/* don't parse backwards off the start of the string */
if (key == params) {
--key;
++klen;
break;
}
--key;
++klen;
}
++key;
for (value = ptr+1; isspace(*value); ++value);
vlen = strcspn(value, delims);
for (i=0; fields[i].field != NULL; ++i) {
if (!strncasecmp(fields[i].field, key, klen)) {
fields[i].value = apr_pstrndup(pool, value, vlen);
break;
}
}
ptr = value+vlen;
}
if (fields[4].value != NULL) {
port = atoi(fields[4].value);
}
sql->conn = mysql_real_connect(sql->conn, fields[0].value,
fields[1].value, fields[2].value,
fields[3].value, port,
fields[5].value, 0);
return sql;
}
const char *get_json_callback_param(request_rec *r) {
char *p, *start_p, *end_p;
int i;
const char *callback;
if (r->args) {
i = 0;
p = r->args;
do {
int len = strlen(p);
if (len >= 9 && strncasecmp(p, "callback=", 9) == 0) {
i = 1;
break;
}
if (len<=0)
break;
}
while(p++);
if (i) {
i = 0;
start_p = p += 9;
end_p = r->args + strlen(r->args);
while (p <= end_p && *p++ != '&') {
i++;
}
return apr_pstrndup(r->connection->pool, start_p, p-start_p-1);
}
}
return callback;
}
const char *get_progress_id(request_rec *r) {
char *p, *start_p, *end_p;
int i;
//try to find progress id in headers
const char *id = apr_table_get(r->headers_in, PROGRESS_ID);
//if not found check args
if(id == NULL) {
if (r->args) {
i = 0;
p = r->args;
do {
int len = strlen(p);
if (len >= 14 && strncasecmp(p, "X-Progress-ID=", 14) == 0) {
i = 1;
break;
}
if (len<=0)
break;
}
while(p++);
if (i) {
i = 0;
start_p = p += 14;
end_p = r->args + strlen(r->args);
while (p <= end_p && *p++ != '&') {
i++;
}
return apr_pstrndup(r->connection->pool, start_p, p-start_p-1);
}
}
}
return id;
}
/* count the number of users */
static int get_unique ( void )
{
apr_pool_t *subpool;
apr_hash_t *hashuser;
char *name;
void *user;
unsigned int numunique = 0;
struct utmp *utmpstruct;
apr_pool_create(&subpool, pool);
hashuser = apr_hash_make(subpool);
apr_thread_mutex_lock(mutex);
setutent();
while ((utmpstruct = getutent())) {
if ((utmpstruct->ut_type == USER_PROCESS) &&
(utmpstruct->ut_name[0] != '\0')) {
name = apr_pstrndup(subpool, utmpstruct->ut_name, UT_NAMESIZE);
user = name; /* use key for value, not interested in it anyway */
apr_hash_set(hashuser, name, APR_HASH_KEY_STRING, user);
}
}
endutent();
apr_thread_mutex_unlock(mutex);
numunique = apr_hash_count(hashuser);
apr_pool_destroy(subpool);
return numunique;
}
char *
svn_fs__next_entry_name(const char **next_p,
const char *path,
apr_pool_t *pool)
{
const char *end;
/* Find the end of the current component. */
end = strchr(path, '/');
if (! end)
{
/* The path contains only one component, with no trailing
slashes. */
*next_p = 0;
return apr_pstrdup(pool, path);
}
else
{
/* There's a slash after the first component. Skip over an arbitrary
number of slashes to find the next one. */
const char *next = end;
while (*next == '/')
next++;
*next_p = next;
return apr_pstrndup(pool, path, end - path);
}
}
/**
* find certain header line, return copy of first part (up to first ";")
* @param p pool to allocate from
* @param name name of the header
* @param string input: pointer to pointer string where to find the header;
* output: pointer to the ";" or "\n" after the copied value
* @param end pointer where to stop searching
* @note string must be NUL-terminated (but the NUL may be after *end)
* @return copy of the header value or NULL if not found
*/
static char *mbox_mime_get_header(apr_pool_t *p, const char *name,
char **string, const char *end)
{
char *ptr;
int namelen = strlen(name);
for (ptr = *string;
ptr && *ptr && ptr < end ;
ptr = ap_strchr(ptr + 1, '\n') + 1)
{
int l;
if (strncasecmp(ptr, name, namelen) != 0)
continue;
ptr += namelen;
if (*ptr != ':')
continue;
ptr++;
while (*ptr == ' ')
ptr++;
if (ptr >= end)
break;
l = strcspn(ptr, ";\n");
*string = ptr + l;
while (apr_isspace(ptr[l]) && l > 0)
l--;
return apr_pstrndup(p, ptr, l);
}
return NULL;
}
static const char * format_location(request_rec * r, const char * url, const char *login) {
const char * out = "";
const char * p = url;
const char * append = NULL;
while (*p) {
if (*p == '%') {
if (*(p + 1) == '%') {
append = "%";
} else if (*(p + 1) == 's') {
append = ap_construct_url(r->pool, r->uri, r);
if (r->args) {
append = apr_pstrcat(r->pool, append, "?", r->args, NULL);
}
} else if (*(p + 1) == 'u') {
append = login;
}
}
if (append) {
char * prefix = "";
if (p != url) {
prefix = apr_pstrndup(r->pool, url, p - url);
}
out = apr_pstrcat(r->pool, out, prefix, ap_escape_urlencoded(r->pool, append), NULL);
p++;
url = p + 1;
append = NULL;
}
p++;
}
if (p != url) {
out = apr_pstrcat(r->pool, out, url, NULL);
}
return out;
}
/*
* Hook and mod_cache callback functions
*/
static int create_entity(cache_handle_t *h, request_rec *r, const char *key, apr_off_t len)
{
disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
&disk_cache_module);
cache_object_t *obj;
disk_cache_object_t *dobj;
if (conf->cache_root == NULL) {
return DECLINED;
}
/* Allocate and initialize cache_object_t and disk_cache_object_t */
h->cache_obj = obj = apr_pcalloc(r->pool, sizeof(*obj));
obj->vobj = dobj = apr_pcalloc(r->pool, sizeof(*dobj));
obj->key = apr_pstrdup(r->pool, key);
dobj->name = obj->key;
dobj->prefix = NULL;
/* Save the cache root */
dobj->root = apr_pstrndup(r->pool, conf->cache_root, conf->cache_root_len);
dobj->root_len = conf->cache_root_len;
dobj->datafile = data_file(r->pool, conf, dobj, key);
dobj->hdrsfile = header_file(r->pool, conf, dobj, key);
dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);
return OK;
}
/* return each comma separated token, one at a time */
CACHE_DECLARE(const char *)ap_cache_tokstr(apr_pool_t *p, const char *list,
const char **str)
{
apr_size_t i;
const char *s;
s = ap_strchr_c(list, ',');
if (s != NULL) {
i = s - list;
do
s++;
while (apr_isspace(*s))
; /* noop */
}
else
i = strlen(list);
while (i > 0 && apr_isspace(list[i - 1]))
i--;
*str = s;
if (i)
return apr_pstrndup(p, list, i);
else
return NULL;
}
int main(int argc,char **argv) {
apr_initialize();
apr_pool_t *pool;
apr_pool_create(&pool,NULL);
apr_status_t st;
apr_dbm_t *dbm;
st=apr_dbm_open(&dbm,"friends",APR_DBM_RWCREATE,APR_OS_DEFAULT ,pool);
apr_datum_t key,value;
key.dptr="laomeng";
key.dsize=strlen(key.dptr);
value.dptr="*****@*****.**";
value.dsize=strlen(value.dptr);
st=apr_dbm_store(dbm,key,value);
apr_datum_t pvalue;
st=apr_dbm_fetch(dbm,key,&pvalue);
char *pstr=apr_pstrndup(pool,pvalue.dptr,pvalue.dsize);
printf("value => %s\n",pstr);
apr_dbm_close(dbm);
apr_pool_destroy(pool);
apr_terminate();
return 0;
}
void
svn_stringbuf_replace(svn_stringbuf_t *str,
apr_size_t pos,
apr_size_t old_count,
const char *bytes,
apr_size_t new_count)
{
if (bytes + new_count > str->data && bytes < str->data + str->blocksize)
{
/* special case: BYTES overlaps with this string -> copy the source */
const char *temp = apr_pstrndup(str->pool, bytes, new_count);
svn_stringbuf_replace(str, pos, old_count, temp, new_count);
}
else
{
if (pos > str->len)
pos = str->len;
if (pos + old_count > str->len)
old_count = str->len - pos;
if (old_count < new_count)
{
apr_size_t delta = new_count - old_count;
svn_stringbuf_ensure(str, str->len + delta);
}
if (old_count != new_count)
memmove(str->data + pos + new_count, str->data + pos + old_count,
str->len - pos - old_count + 1);
memcpy(str->data + pos, bytes, new_count);
str->len += new_count - old_count;
}
}
/*
* perform compact serialization on a JWT and return the resulting string
*/
char *oidc_jwt_serialize(apr_pool_t *pool, oidc_jwt_t *jwt,
oidc_jose_error_t *err) {
cjose_err cjose_err;
const char *cser = NULL;
if (strcmp(jwt->header.alg, "none") != 0) {
if (cjose_jws_export(jwt->cjose_jws, &cser, &cjose_err) == FALSE) {
oidc_jose_error(err, "cjose_jws_export failed: %s",
oidc_cjose_e2s(pool, cjose_err));
return NULL;
}
} else {
char *s_payload = json_dumps(jwt->payload.value.json,
JSON_PRESERVE_ORDER | JSON_COMPACT);
char *out = NULL;
size_t out_len;
if (cjose_base64url_encode((const uint8_t *)s_payload, strlen(s_payload), &out, &out_len,
&cjose_err) == FALSE)
return FALSE;
cser = apr_pstrndup(pool, out, out_len);
cjose_get_dealloc()(out);
free(s_payload);
cser = apr_psprintf(pool, "eyJhbGciOiJub25lIn0.%s.", cser);
}
return apr_pstrdup(pool, cser);
}
static char * add_qstring_ignore_token(apr_pool_t *pool, saxctxt *ctx, apr_uri_t *u)
{
char *where;
const char *arg = ctx->cfg->ignore_token_arg_relative;
if(!u->query || !ctx->cfg->ignore_token || !arg)
return u->query;
ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, ctx->f->r->server,
"add_qstring_ignore_token: adding ignore token %s to %s relative to %s",
ctx->cfg->ignore_token, u->query, arg);
/*
* doing this rather than just a basic strstr for arg makes sure we
* find an argument name, and not the string within a value
*/
where = (!strncmp(u->query, arg, strlen(arg))) ? u->query :
strstr(u->query, apr_pstrcat(pool, "&", arg, 0));
if(!where) { /* give up, can't find the argument */
ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, ctx->f->r->server,
"add_qstring_ignore_token: can't find %s", arg);
return u->query;
}
if(ctx->cfg->ignore_token_direction == BEFORE) {
/* put the ignore_token before arg_relative in the query string */
if(where == u->query) /* at the beginning of the qstring */
return apr_pstrcat(pool, ctx->cfg->ignore_token, "&", u->query, 0);
else { /* somewhere in the middle */
char *start = apr_pstrndup(pool, u->query, where - u->query);
return apr_pstrcat(pool, start, "&", ctx->cfg->ignore_token, where, 0);
}
} else {
/*
* put the ignore_token after arg_relative in the query string
* first find the end of the argument/value
*/
char *end = strchr(where, '&');
if(end) {
char *start = apr_pstrndup(pool, u->query, end - u->query);
return apr_pstrcat(pool, start, "&", ctx->cfg->ignore_token, end, 0);
} else
return apr_pstrcat(pool, u->query, "&", ctx->cfg->ignore_token, 0);
}
}
void svn_cstring_split_endline_append (apr_array_header_t *array,
const char *input,
apr_pool_t *pool) {
int start = 0, end;
int len = strlen(input);
for (end = 0; end < len; end++){
if (input[end] == '\n') {
char *sub = apr_pstrndup(pool,(input+start),(end-start));
*(char **)apr_array_push(array) = sub;
start = end+1;
}
}
if (start < end) {
char *sub = apr_pstrndup(pool,(input+start),(len-start));
*(char **)apr_array_push(array) = sub;
}
}
APR_DECLARE(apr_status_t) apr_uid_get(apr_uid_t *uid, apr_gid_t *gid,
const char *username, apr_pool_t *p)
{
#ifdef _WIN32_WCE
return APR_ENOTIMPL;
#else
SID_NAME_USE sidtype;
char anydomain[256];
char *domain;
DWORD sidlen = 0;
DWORD domlen = sizeof(anydomain);
DWORD rv;
char *pos;
if (pos = strchr(username, '/')) {
domain = apr_pstrndup(p, username, pos - username);
username = pos + 1;
}
else if (pos = strchr(username, '\\')) {
domain = apr_pstrndup(p, username, pos - username);
username = pos + 1;
}
else {
domain = NULL;
}
/* Get nothing on the first pass ... need to size the sid buffer
*/
rv = LookupAccountName(domain, username, domain, &sidlen,
anydomain, &domlen, &sidtype);
if (sidlen) {
/* Give it back on the second pass
*/
*uid = apr_palloc(p, sidlen);
domlen = sizeof(anydomain);
rv = LookupAccountName(domain, username, *uid, &sidlen,
anydomain, &domlen, &sidtype);
}
if (!sidlen || !rv) {
return apr_get_os_error();
}
/* There doesn't seem to be a simple way to retrieve the primary group sid
*/
*gid = NULL;
return APR_SUCCESS;
#endif
}
static void set_body(upload_ctx* ctx, const char* data) {
const char* cr = strchr(data, '\r') ;
char* tmp = apr_pstrndup(ctx->pool, data, cr-data) ;
if ( ctx->val )
ctx->val = apr_pstrcat(ctx->pool, ctx->val, tmp, NULL) ;
else
ctx->val = tmp ;
}
static size_t rcache_curl_write_cb(const void* ptr, size_t size, size_t nmemb, void* _info)
{
rcache_info* info = _info;
if (nmemb == 0) return 0;
const char* tmp = apr_pstrndup(info->r->pool, ptr, size * nmemb);
info->data = apr_pstrcat(info->r->pool, info->data, tmp, NULL);
return nmemb;
}
static const char *mag_cred_store(cmd_parms *parms, void *mconfig,
const char *w)
{
struct mag_config *cfg = (struct mag_config *)mconfig;
gss_key_value_element_desc *elements;
uint32_t count;
size_t size;
const char *p;
char *value;
char *key;
p = strchr(w, ':');
if (!p) {
ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, parms->server,
"%s [%s]", "Invalid syntax for GssapiCredStore option", w);
return NULL;
}
key = apr_pstrndup(parms->pool, w, (p-w));
value = apr_pstrdup(parms->pool, p + 1);
if (!key || !value) {
ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, parms->server,
"%s", "OOM handling GssapiCredStore option");
return NULL;
}
if (!cfg->cred_store) {
cfg->cred_store = apr_pcalloc(parms->pool,
sizeof(gss_key_value_set_desc));
if (!cfg->cred_store) {
ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, parms->server,
"%s", "OOM handling GssapiCredStore option");
return NULL;
}
size = sizeof(gss_key_value_element_desc) * MAX_CRED_OPTIONS;
cfg->cred_store->elements = apr_palloc(parms->pool, size);
if (!cfg->cred_store->elements) {
ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, parms->server,
"%s", "OOM handling GssapiCredStore option");
}
}
elements = cfg->cred_store->elements;
count = cfg->cred_store->count;
if (count >= MAX_CRED_OPTIONS) {
ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, parms->server,
"Too many GssapiCredStore options (MAX: %d)",
MAX_CRED_OPTIONS);
return NULL;
}
cfg->cred_store->count++;
elements[count].key = key;
elements[count].value = value;
return NULL;
}
AP_DECLARE(void) ap_add_cgi_vars(request_rec *r)
{
apr_table_t *e = r->subprocess_env;
apr_table_setn(e, "GATEWAY_INTERFACE", "CGI/1.1");
apr_table_setn(e, "SERVER_PROTOCOL", r->protocol);
apr_table_setn(e, "REQUEST_METHOD", r->method);
apr_table_setn(e, "QUERY_STRING", r->args ? r->args : "");
apr_table_setn(e, "REQUEST_URI", original_uri(r));
/* Note that the code below special-cases scripts run from includes,
* because it "knows" that the sub_request has been hacked to have the
* args and path_info of the original request, and not any that may have
* come with the script URI in the include command. Ugh.
*/
if (!strcmp(r->protocol, "INCLUDED")) {
apr_table_setn(e, "SCRIPT_NAME", r->uri);
if (r->path_info && *r->path_info) {
apr_table_setn(e, "PATH_INFO", r->path_info);
}
}
else if (!r->path_info || !*r->path_info) {
apr_table_setn(e, "SCRIPT_NAME", r->uri);
}
else {
int path_info_start = ap_find_path_info(r->uri, r->path_info);
apr_table_setn(e, "SCRIPT_NAME",
apr_pstrndup(r->pool, r->uri, path_info_start));
apr_table_setn(e, "PATH_INFO", r->path_info);
}
if (r->path_info && r->path_info[0]) {
/*
* To get PATH_TRANSLATED, treat PATH_INFO as a URI path.
* Need to re-escape it for this, since the entire URI was
* un-escaped before we determined where the PATH_INFO began.
*/
request_rec *pa_req;
pa_req = ap_sub_req_lookup_uri(ap_escape_uri(r->pool, r->path_info), r,
NULL);
if (pa_req->filename) {
char *pt = apr_pstrcat(r->pool, pa_req->filename, pa_req->path_info,
NULL);
#ifdef WIN32
/* We need to make this a real Windows path name */
apr_filepath_merge(&pt, "", pt, APR_FILEPATH_NATIVE, r->pool);
#endif
apr_table_setn(e, "PATH_TRANSLATED", pt);
}
ap_destroy_sub_req(pa_req);
}
}
int rc_matchByStringsPattern(pool* p, char* regex, char* value, array_header** matches){
int ret=0;
regex_t *preg=NULL;
regmatch_t pmatch[9];
int i=0;
memset(pmatch,-1, sizeof(pmatch));
//match vars
array_header* nmatches=NULL;
char** foundPlace=NULL, *found=NULL;
int chars=0;
//do regex match
preg=apr_palloc(p,sizeof(regex_t));
#ifdef NGX_TCREWRITE_PCRE
// set custom pcre func for NGX_TCREWRITE_PCRE
pool *ip = (pool *) iota_pcre_malloc_init(p);
#endif
ret=regcomp(preg,regex,0);
if(ret!=0){
#ifdef NGX_TCREWRITE_PCRE
// reset pcre func for NGX_TCREWRITE_PCRE
iota_pcre_malloc_done(ip);
#endif
return -555;
}
if(matches!=NULL){
ret=regexec(preg,value,9,pmatch,0);
if(pmatch[0].rm_so!=-1){
nmatches=apr_array_make(p,4,sizeof(char*));
for(i=0;i<9;i++){
if(pmatch[i].rm_so!=-1){
chars=pmatch[i].rm_eo-pmatch[i].rm_so;
found=apr_pstrndup(p,value+(int)pmatch[i].rm_so,chars);
foundPlace=(char**)apr_array_push(nmatches);
*foundPlace=found;
}
}
*matches=nmatches;
}
}else{
ret=regexec(preg,value,0,NULL,0);
}
regfree(preg);
#ifdef NGX_TCREWRITE_PCRE
// reset pcre func for NGX_TCREWRITE_PCRE
iota_pcre_malloc_done(ip);
#endif
return ret;
}
