Пример #1
0
const char *nss_cmd_NSSRequire(cmd_parms *cmd,
                               void *dcfg,
                               const char *arg)
{
    SSLDirConfigRec *dc = (SSLDirConfigRec *)dcfg;
    nss_expr *expr;
    nss_require_t *require;

    if (!(expr = nss_expr_comp(cmd->pool, (char *)arg))) {
        return apr_pstrcat(cmd->pool, "NSSRequire: ",
                           nss_expr_get_error(), NULL);
    }

    require = apr_array_push(dc->aRequirement);
    require->cpExpr = apr_pstrdup(cmd->pool, arg);
    require->mpExpr = expr;

    return NULL;
}
Пример #2
0
static const char *set_sqlalias_filter(cmd_parms *cmd, void *mconfig, const char *arg)
{
	ap_regex_t *regexp = NULL;

	server_rec *s = cmd->server;
	sqlalias_conf_t *s_cfg = (sqlalias_conf_t *) ap_get_module_config(s->module_config, &sqlalias_module);

	sqlalias_filter_entry *filter;

	filter = (sqlalias_filter_entry *) apr_array_push(s_cfg->filters);
	filter->pattern = apr_pstrdup(cmd->pool, (char *) arg);

	if ((regexp = (ap_regex_t *)ap_pregcomp(cmd->pool, filter->pattern, 0)) == NULL) {
		return apr_pstrcat(cmd->pool, "SQLAliasFilter: cannot compile regular expression '", filter->pattern , "'", NULL);
	}

	filter->regexp = regexp;
	return NULL;
}
Пример #3
0
/* Returns in PRISTINE_ABSPATH a new string allocated from RESULT_POOL,
   holding the local absolute path to the file location that is dedicated
   to hold CHECKSUM's pristine file, relating to the pristine store
   configured for the working copy indicated by PDH. The returned path
   does not necessarily currently exist.

   Any other allocations are made in SCRATCH_POOL. */
static svn_error_t *
get_pristine_fname(const char **pristine_abspath,
                   const char *wcroot_abspath,
                   const svn_checksum_t *sha1_checksum,
                   apr_pool_t *result_pool,
                   apr_pool_t *scratch_pool)
{
  const char *base_dir_abspath;
  const char *hexdigest = svn_checksum_to_cstring(sha1_checksum, scratch_pool);
  char subdir[3];

  /* ### code is in transition. make sure we have the proper data.  */
  SVN_ERR_ASSERT(pristine_abspath != NULL);
  SVN_ERR_ASSERT(svn_dirent_is_absolute(wcroot_abspath));
  SVN_ERR_ASSERT(sha1_checksum != NULL);
  SVN_ERR_ASSERT(sha1_checksum->kind == svn_checksum_sha1);

  base_dir_abspath = svn_dirent_join_many(scratch_pool,
                                          wcroot_abspath,
                                          svn_wc_get_adm_dir(scratch_pool),
                                          PRISTINE_STORAGE_RELPATH,
                                          SVN_VA_NULL);

  /* We should have a valid checksum and (thus) a valid digest. */
  SVN_ERR_ASSERT(hexdigest != NULL);

  /* Get the first two characters of the digest, for the subdir. */
  subdir[0] = hexdigest[0];
  subdir[1] = hexdigest[1];
  subdir[2] = '\0';

  hexdigest = apr_pstrcat(scratch_pool, hexdigest, PRISTINE_STORAGE_EXT,
                          SVN_VA_NULL);

  /* The file is located at DIR/.svn/pristine/XX/XXYYZZ...svn-base */
  *pristine_abspath = svn_dirent_join_many(result_pool,
                                           base_dir_abspath,
                                           subdir,
                                           hexdigest,
                                           SVN_VA_NULL);
  return SVN_NO_ERROR;
}
Пример #4
0
static int papi_cookie_checked (request_rec *r, papi_dir_config *d)
{
	int valid_date;
	char *code;
	poa_request_t *request = NULL;
	
	char *req_id = papi_test_gpoa_url (r, d, &code, &valid_date);
	if (req_id) {
		request = papi_load_request (r, d, req_id);
	}
	
	if (request == NULL) {
		char *redir = apr_pstrcat (r->pool, "http://",
								   r->hostname,
								   d->loc, NULL);
		APACHE_LOG (APLOG_ERR, "Invalid requestID received from GPoA/AS");
		return papi_redirect_url (r, redir);
	}
	
	char *url  = papi_uri_get_arg (r->pool, request->args, "URL");
	char *data = papi_uri_get_arg (r->pool, request->args, "DATA");
	
	if (valid_date == 0) {
		APACHE_LOG (APLOG_WARNING, "Invalid GPoA/AS answer for %s",
					 ap_construct_url (r->pool, r->unparsed_uri, r));
		return papi_redirect_error_url (r, d, url, data);
	}
	
	char *userdata = papi_gen_user_data (r, d, url, code);
	char *rdata = papi_encrypt_gen_code (r, d, userdata, valid_date, data);
	url = papi_uri_add_arg (r->pool, url, "ACTION", "CHECKED");
	url = papi_uri_add_arg (r->pool, url, "DATA", rdata);
	
	if (valid_date > 1) {
		char *lcook = papi_gen_lcook (r, d, (int)time(NULL), code);
		APACHE_LOG (APLOG_DEBUG, "(%s:%d) New Lcook: %s", 
					 __FILE__, __LINE__, lcook);
		return papi_redirect_with_cookies (r, url, lcook);
	}
	
	return papi_redirect_url (r, url);
}
Пример #5
0
APR_DECLARE(apr_status_t) apr_env_set(const char *envvar,
                                      const char *value,
                                      apr_pool_t *pool)
{
#if defined(HAVE_SETENV)

    if (0 > setenv(envvar, value, 1))
        return APR_ENOMEM;
    return APR_SUCCESS;

#elif defined(HAVE_PUTENV)

    if (0 > putenv(apr_pstrcat(pool, envvar, "=", value, NULL)))
        return APR_ENOMEM;
    return APR_SUCCESS;

#else
    return APR_ENOTIMPL;
#endif
}
Пример #6
0
/* Set *ABSOLUTE_URL to the absolute URL represented by RELATIVE_URL
 * relative to REPOS_ROOT_URL.
 * *ABSOLUTE_URL will end with a peg revision specifier if RELATIVE_URL did.
 * RELATIVE_URL is in repository-relative syntax:
 * "^/[REL-URL][@PEG]",
 * REPOS_ROOT_URL is the absolute URL of the repository root.
 * All strings are in UTF-8 encoding.
 * Allocate *ABSOLUTE_URL in POOL.
 *
 * REPOS_ROOT_URL and RELATIVE_URL do not have to be properly URI-encoded,
 * canonical, or valid in any other way.  The caller is expected to perform
 * canonicalization on *ABSOLUTE_URL after the call to the function.
 */
static svn_error_t *
resolve_repos_relative_url(const char **absolute_url,
                           const char *relative_url,
                           const char *repos_root_url,
                           apr_pool_t *pool)
{
  if (! arg_is_repos_relative_url(relative_url))
    return svn_error_createf(SVN_ERR_BAD_URL, NULL,
                             _("Improper relative URL '%s'"),
                             relative_url);

  /* No assumptions are made about the canonicalization of the input
   * arguments, it is presumed that the output will be canonicalized after
   * this function, which will remove any duplicate path separator.
   */
  *absolute_url = apr_pstrcat(pool, repos_root_url, relative_url + 1,
                              (char *)NULL);

  return SVN_NO_ERROR;
}
Пример #7
0
const char *DownloadFlowController::dump_list(apr_pool_t *pool,
                                              DownloadFlowController *flow_controller)
{
    const char *dump;

    dump = apr_psprintf(pool, "%-24s : %" APR_SIZE_T_FMT "\n",
                        "total count", flow_controller->downloader_count_);
    for (apr_size_t i = 0; i < DLD_MAX_SESSION_COUNT; i++) {
        if (flow_controller->downloader_list_[i].session_count == 0) {
            continue;
        }
        dump = apr_pstrcat
            (pool, dump,
             dump_downloader(pool,
                             flow_controller->downloader_list_ + i),
             NULL);
    }

    return dump;
}
Пример #8
0
static ezxml_t _wmts_operations_metadata(mapcache_context *ctx, const char *onlineresource, const char *operationstr)
{
  ezxml_t http;
  ezxml_t dcp;
  ezxml_t get;
  ezxml_t constraint;
  ezxml_t allowedvalues;
  ezxml_t operation = ezxml_new("ows:Operation");
  ezxml_set_attr(operation,"name",operationstr);
  dcp = ezxml_add_child(operation,"ows:DCP",0);
  http = ezxml_add_child(dcp,"ows:HTTP",0);
  get = ezxml_add_child(http,"ows:Get",0);
  ezxml_set_attr(get,"xlink:href",apr_pstrcat(ctx->pool,onlineresource,"wmts?",NULL));
  constraint = ezxml_add_child(get,"ows:Constraint",0);
  ezxml_set_attr(constraint,"name","GetEncoding");
  allowedvalues = ezxml_add_child(constraint,"ows:AllowedValues",0);
  ezxml_set_txt(ezxml_add_child(allowedvalues,"ows:Value",0),"KVP");
  return operation;

}
Пример #9
0
static const char *set_server_file_slot(cmd_parms *cmd,
                                     		 void *struct_ptr,
                                     		 const char *arg)
{
	void *ptr = ap_get_module_config(cmd->server->module_config,
			&log_sql_module);
	int offset = (int)(long)cmd->info;
    const char *path;

    path = ap_server_root_relative(cmd->pool, (char *)arg);

    if (!path) {
        return apr_pstrcat(cmd->pool, "Invalid file path ",
                           arg, NULL);
    }

    *(const char **)((char*)ptr + offset) = path;

    return NULL;
}
Пример #10
0
const char *ssl_cmd_SSLRequire(cmd_parms *cmd,
                               void *dcfg,
                               const char *arg)
{
    SSLDirConfigRec *dc = (SSLDirConfigRec *)dcfg;
    ssl_expr *expr;
    ssl_require_t *require;

    if (!(expr = ssl_expr_comp(cmd->pool, (char *)arg))) {
        return apr_pstrcat(cmd->pool, "SSLRequire: ",
                           ssl_expr_get_error(), NULL);
    }

    require = apr_array_push(dc->aRequirement);
    require->cpExpr = apr_pstrdup(cmd->pool, arg);
    require->mpExpr = expr;

    apn_set_unsupport(cmd, "SSLRequire: No relevant directive in Nginx.");
    return NULL;
}
Пример #11
0
static svn_error_t *
handle_proxy_basic_auth(svn_ra_serf__session_t *session,
                        svn_ra_serf__connection_t *conn,
                        serf_request_t *request,
                        serf_bucket_t *response,
                        char *auth_hdr,
                        char *auth_attr,
                        apr_pool_t *pool)
{
  const char *tmp;
  apr_size_t tmp_len;
  int i;

  tmp = apr_pstrcat(session->pool,
                    session->proxy_username, ":", 
                    session->proxy_password, NULL);
  tmp_len = strlen(tmp);

  session->proxy_auth_attempts++;

  if (session->proxy_auth_attempts > 1)
    {
      /* No more credentials. */
      return svn_error_create(SVN_ERR_AUTHN_FAILED, NULL,
                "Proxy authentication failed");
    }

  svn_ra_serf__encode_auth_header(session->proxy_auth_protocol->auth_name, 
                                  &session->proxy_auth_value,
                                  tmp, tmp_len, pool);
  session->proxy_auth_header = "Proxy-Authorization";

  /* FIXME Come up with a cleaner way of changing the connection auth. */
  for (i = 0; i < session->num_conns; i++)
    {
      session->conns[i]->proxy_auth_header = session->proxy_auth_header;
      session->conns[i]->proxy_auth_value = session->proxy_auth_value;
    }

  return SVN_NO_ERROR;
}
Пример #12
0
static apr_status_t _bdb_reslist_get_connection(void **conn_, void *params, apr_pool_t *pool) {
   int ret;
   mapcache_cache_bdb *cache = (mapcache_cache_bdb*)params;
   char *dbfile = apr_pstrcat(pool,cache->basedir,"/",cache->cache.name,".db",NULL);
   struct bdb_env *benv = apr_pcalloc(pool,sizeof(struct bdb_env));

   ret = db_env_create(&benv->env, 0);
   if(ret) { 
      cache->ctx->set_error(cache->ctx,500,"bdb cache failure for db_env_create: %s", db_strerror(ret));
      return APR_EGENERAL;
   }
   ret = benv->env->set_cachesize(benv->env,0,CACHESIZE,1); /* set a larger cache size than default */
   if(ret) { 
      cache->ctx->set_error(cache->ctx,500,"bdb cache failure for db->set_cachesize: %s", db_strerror(ret));
      return APR_EGENERAL;
   }
   int env_flags = DB_INIT_CDB|DB_INIT_MPOOL|DB_CREATE;
   ret = benv->env->open(benv->env,cache->basedir,env_flags,0);
   if(ret) { 
      cache->ctx->set_error(cache->ctx,500,"bdb cache failure for env->open: %s", db_strerror(ret));
      return APR_EGENERAL;
   }

   if ((ret = db_create(&benv->db, benv->env, 0)) != 0) {
      cache->ctx->set_error(cache->ctx,500,"bdb cache failure for db_create: %s", db_strerror(ret));
      return APR_EGENERAL;
   }
   int mode = DB_BTREE;
   ret = benv->db->set_pagesize(benv->db,PAGESIZE); /* set pagesize to maximum allowed, as tile data is usually pretty large */
   if(ret) { 
      cache->ctx->set_error(cache->ctx,500,"bdb cache failure for db->set_pagesize: %s", db_strerror(ret));
      return APR_EGENERAL;
   }

   if ((ret = benv->db->open(benv->db, NULL, dbfile, NULL, mode, DB_CREATE, 0664)) != 0) {
      cache->ctx->set_error(cache->ctx,500,"bdb cache failure 1 for db->open: %s", db_strerror(ret));
      return APR_EGENERAL;
   }
   *conn_ = benv;
   return APR_SUCCESS;
}
Пример #13
0
END_TEST

START_TEST(readCASCacheFile_test) {
  apr_file_t *f;
  apr_size_t sz;
  cas_cache_entry cache;
  char *fname = "0123456789abcdef0123456789abcdef", *path;
  const char *contents = "<cacheEntry "
      "xmlns=\"http://uconn.edu/cas/mod_auth_cas\">"
      "<user>foo</user>"
      "<issued>86400</issued>"
      "<lastactive>87000</lastactive>"
      "<path>/foo</path>"
      "<ticket>ST-1234</ticket>"
      "<renewed />"
      "<secure />"
      "</cacheEntry>";

  cas_cfg *c = ap_get_module_config(request->server->module_config,
                                    &auth_cas_module);

  c->CASCookiePath = "/tmp/";
  path = apr_pstrcat(request->pool, c->CASCookiePath, fname, NULL);
  apr_file_open(&f, path, APR_CREATE|APR_WRITE|APR_TRUNCATE, APR_OS_DEFAULT,
                request->pool);
  sz = strlen(contents);
  apr_file_write(f, contents, &sz);
  apr_file_close(f);

  readCASCacheFile(request, c, fname, &cache);

  fail_unless(strcmp(cache.user, "foo") == 0);
  fail_unless(cache.issued == 86400);
  fail_unless(cache.lastactive == 87000);
  fail_unless(strcmp(cache.path, "/foo") == 0);
  fail_unless(strcmp(cache.ticket, "ST-1234") == 0);
  fail_if(cache.renewed == FALSE);
  fail_if(cache.secure == FALSE);
  /* TODO(pames): test w/attributes */
  apr_file_remove(path, request->pool);
}
Пример #14
0
const char *
JNIUtil::thrownExceptionToCString(SVN::Pool &in_pool)
{
  const char *msg = NULL;
  JNIEnv *env = getEnv();
  apr_pool_t *pool = in_pool.getPool();
  if (env->ExceptionCheck())
    {
      jthrowable t = env->ExceptionOccurred();
      jclass cls = env->GetObjectClass(t);

      jstring jclass_name;
      {
        jmethodID mid = env->GetMethodID(cls, "getClass", "()Ljava/lang/Class;");
        jobject clsobj = env->CallObjectMethod(t, mid);
        jclass basecls = env->GetObjectClass(clsobj);
        mid = env->GetMethodID(basecls, "getName", "()Ljava/lang/String;");
        jclass_name = (jstring) env->CallObjectMethod(clsobj, mid);
      }

      jstring jmessage;
      {
        jmethodID mid = env->GetMethodID(cls, "getMessage",
                                         "()Ljava/lang/String;");
        jmessage = (jstring) env->CallObjectMethod(t, mid);
      }

      JNIStringHolder class_name(jclass_name);
      if (jmessage)
        {
          JNIStringHolder message(jmessage);
          msg = apr_pstrcat(pool,
                            static_cast<const char*>(class_name), ": ",
                            static_cast<const char*>(message), NULL);
        }
      else
        msg = class_name.pstrdup(pool);
      // ### Conditionally add t.printStackTrace() to msg?
    }
  return msg;
}
Пример #15
0
apr_status_t lfd_cmdio_write(struct lfd_sess * sess, int cmd, const char *msg, ...)
{
	va_list		  ap;
	char		* buff = NULL;
	apr_size_t	  len;
	apr_status_t	 rc = APR_SUCCESS;

	buff = apr_pstrcat(sess->loop_pool, "AAAA", msg, "\r\n", NULL);
	cmd_to_str(cmd, buff);

	va_start(ap, msg);
	buff = apr_pvsprintf(sess->loop_pool, buff, ap);
	len = strlen(buff);
	rc = apr_socket_send(sess->comm_sock, buff, &len);
	va_end(ap);

	if (lfd_config_debug)
		fprintf(stderr, "-> %s", buff);

	return rc;
}
Пример #16
0
svn_error_t *
sbox_wc_switch(svn_test__sandbox_t *b,
               const char *path,
               const char *url,
               svn_depth_t depth)
{
  svn_client_ctx_t *ctx;
  svn_revnum_t result_rev;
  svn_opt_revision_t head_rev = { svn_opt_revision_head, {0} };

  url = apr_pstrcat(b->pool, b->repos_url, url, (char*)NULL);
  SVN_ERR(svn_client_create_context2(&ctx, NULL, b->pool));
  ctx->wc_ctx = b->wc_ctx;
  return svn_client_switch3(&result_rev, sbox_wc_path(b, path), url,
                            &head_rev, &head_rev, depth,
                            FALSE /* depth_is_sticky */,
                            TRUE /* ignore_externals */,
                            FALSE /* allow_unver_obstructions */,
                            TRUE /* ignore_ancestry */,
                            ctx, b->pool);
}
/* user apr_table_do to set session information in header http */
static int Auth_memCookie_DoSetHeader(void *rec, const char *szKey, const char *szValue)
{
    // strAuth_memCookie_config_rec *conf = NULL;
    request_rec *r = (request_rec*)rec;
    const char *szHeaderName = szKey;

    /* if key does not start with X-, preprent X-MCAC_ */
    if (strncasecmp(szHeaderName, "x-", 2) != 0)
        szHeaderName = apr_pstrcat(r->pool, "X-", szHeaderName, NULL);

    ap_log_rerror(APLOG_MARK,APLOG_DEBUG, 0,r,ERRTAG  "adding header: %s ", szHeaderName);

	/* set string header */
    if (apr_table_get(r->headers_in, szHeaderName) == NULL) {
        apr_table_addn(r->headers_in, szHeaderName, szValue);
    }
    else {
        apr_table_set(r->headers_in, szHeaderName, szValue);
    }
    return 1;
}
Пример #18
0
static char *fixed_name(const char *fname, apr_pool_t *pool)
{
    char *semname;

    if (fname == NULL)
        semname = NULL;
    else {
        /* Semaphores don't live in the file system, fix up the name */
        while (*fname == '/' || *fname == '\\') {
            fname++;
        }

        semname = apr_pstrcat(pool, "/SEM32/", fname, NULL);

        if (semname[8] == ':') {
            semname[8] = '$';
        }
    }

    return semname;
}
Пример #19
0
/**
 * Remove an RFC2965 compliant cookie.
 *
 * @param r The request
 * @param name2 The name of the cookie.
 */
AP_DECLARE(apr_status_t) ap_cookie_remove2(request_rec * r, const char *name2, const char *attrs2, ...)
{
    apr_table_t *t;
    va_list vp;

    /* create RFC2965 compliant cookie */
    const char *rfc2965 = apr_pstrcat(r->pool, name2, "=;Max-Age=0;",
                                attrs2 ? attrs2 : CLEAR_ATTRS, NULL);
    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(00010) LOG_PREFIX
                  "user '%s' removed cookie2: '%s'", r->user, rfc2965);

    /* write the cookie to the header table(s) provided */
    va_start(vp, attrs2);
    while ((t = va_arg(vp, apr_table_t *))) {
        apr_table_addn(t, SET_COOKIE2, rfc2965);
    }
    va_end(vp);

    return APR_SUCCESS;

}
Пример #20
0
APR_DECLARE(apr_status_t) apr_shm_attach(apr_shm_t **m,
                                         const char *filename,
                                         apr_pool_t *pool)
{
    int rc;
    apr_shm_t *newm = (apr_shm_t *)apr_palloc(pool, sizeof(apr_shm_t));
    char *name = NULL;
    ULONG flags = PAG_READ|PAG_WRITE;

    newm->pool = pool;
    name = apr_pstrcat(pool, "\\SHAREMEM\\", filename, NULL);

    rc = DosGetNamedSharedMem(&(newm->memblock), name, flags);

    if (rc) {
        return APR_FROM_OS_ERROR(rc);
    }

    *m = newm;
    return APR_SUCCESS;
}
Пример #21
0
static void *h2_config_merge(apr_pool_t *pool, void *basev, void *addv)
{
    h2_config *base = (h2_config *)basev;
    h2_config *add = (h2_config *)addv;
    h2_config *n = (h2_config *)apr_pcalloc(pool, sizeof(h2_config));
    char *name = apr_pstrcat(pool, "merged[", add->name, ", ", base->name, "]", NULL);
    n->name = name;

    n->h2_max_streams       = H2_CONFIG_GET(add, base, h2_max_streams);
    n->h2_window_size       = H2_CONFIG_GET(add, base, h2_window_size);
    n->min_workers          = H2_CONFIG_GET(add, base, min_workers);
    n->max_workers          = H2_CONFIG_GET(add, base, max_workers);
    n->max_worker_idle_secs = H2_CONFIG_GET(add, base, max_worker_idle_secs);
    n->stream_max_mem_size  = H2_CONFIG_GET(add, base, stream_max_mem_size);
    n->alt_svcs             = add->alt_svcs? add->alt_svcs : base->alt_svcs;
    n->alt_svc_max_age      = H2_CONFIG_GET(add, base, alt_svc_max_age);
    n->serialize_headers    = H2_CONFIG_GET(add, base, serialize_headers);
    n->h2_direct            = H2_CONFIG_GET(add, base, h2_direct);
    n->modern_tls_only      = H2_CONFIG_GET(add, base, modern_tls_only);
    n->h2_upgrade           = H2_CONFIG_GET(add, base, h2_upgrade);
    n->tls_warmup_size      = H2_CONFIG_GET(add, base, tls_warmup_size);
    n->tls_cooldown_secs    = H2_CONFIG_GET(add, base, tls_cooldown_secs);
    n->h2_push              = H2_CONFIG_GET(add, base, h2_push);
    if (add->priorities && base->priorities) {
        n->priorities       = apr_hash_overlay(pool, add->priorities, base->priorities);
    }
    else {
        n->priorities       = add->priorities? add->priorities : base->priorities;
    }
    n->push_diary_size      = H2_CONFIG_GET(add, base, push_diary_size);
    n->copy_files           = H2_CONFIG_GET(add, base, copy_files);
    if (add->push_list && base->push_list) {
        n->push_list        = apr_array_append(pool, base->push_list, add->push_list);
    }
    else {
        n->push_list        = add->push_list? add->push_list : base->push_list;
    }
    n->early_hints          = H2_CONFIG_GET(add, base, early_hints);
    return n;
}
Пример #22
0
static const char *
__gen_stats(const dav_resource *resource, apr_pool_t *pool)
{
	DAV_XDEBUG_POOL(pool, 0, "%s()", __FUNCTION__);

	dav_rainx_server_conf *c = resource_get_server_config(resource);

	apr_global_mutex_lock(c->lock.handle);
	struct shm_stats_s *stats = apr_shm_baseaddr_get(c->shm.handle);
	apr_global_mutex_unlock(c->lock.handle);

	return apr_pstrcat(pool,
			STR_KV(time_all,       "counter req.time"),
			STR_KV(time_put,       "counter req.time.put"),
			STR_KV(time_get,       "counter req.time.get"),
			STR_KV(time_del,       "counter req.time.del"),
			STR_KV(time_stat,      "counter req.time.stat"),
			STR_KV(time_info,      "counter req.time.info"),
			STR_KV(time_raw,       "counter req.time.raw"),
			STR_KV(time_other,     "counter req.time.other"),

			STR_KV(req_all,       "counter req.hits"),
			STR_KV(req_chunk_put, "counter req.hits.put"),
			STR_KV(req_chunk_get, "counter req.hits.get"),
			STR_KV(req_chunk_del, "counter req.hits.del"),
			STR_KV(req_stat,      "counter req.hits.stat"),
			STR_KV(req_info,      "counter req.hits.info"),
			STR_KV(req_raw,       "counter req.hits.raw"),
			STR_KV(req_other,     "counter req.hits.other"),

			STR_KV(rep_2XX,       "counter rep.hits.2xx"),
			STR_KV(rep_4XX,       "counter rep.hits.4xx"),
			STR_KV(rep_5XX,       "counter rep.hits.5xx"),
			STR_KV(rep_other,     "counter rep.hits.other"),
			STR_KV(rep_403,       "counter rep.hits.403"),
			STR_KV(rep_404,       "counter rep.hits.404"),
			STR_KV(rep_bread,     "counter rep.bread"),
			STR_KV(rep_bwritten,  "counter rep.bwritten"),
			NULL);
}
Пример #23
0
/*
 * delete a single file
 */
static void delete_file(char *path, char *basename, apr_pool_t *pool)
{
    char *nextpath;
    apr_pool_t *p;

    if (dryrun) {
        return;
    }

    /* temp pool, otherwise lots of memory could be allocated */
    apr_pool_create(&p, pool);
    nextpath = apr_pstrcat(p, path, "/", basename, NULL);
    apr_file_remove(nextpath, p);
    apr_pool_destroy(p);

    if (benice) {
        if (++delcount >= DELETE_NICE) {
            apr_sleep(NICE_DELAY);
            delcount = 0;
        }
    }
}
Пример #24
0
static const char *modperl_cmd_parse_args(apr_pool_t *p,
                                          const char *args,
                                          apr_table_t **t)
{
    const char *orig_args = args;
    char *pair, *key, *val;
    *t = apr_table_make(p, 2);

    while (*(pair = ap_getword(p, &args, ',')) != '\0') {
        key = ap_getword_nc(p, &pair, '=');
        val = pair;

        if (!(*key && *val)) {
            return apr_pstrcat(p, "invalid args spec: ",
                               orig_args, NULL);
        }

        apr_table_set(*t, key, val);
    }

    return NULL;
}
static apr_status_t htdbm_save(htdbm_t *htdbm, int *changed)
{
    apr_datum_t key, val;

    if (!htdbm->username)
        return APR_SUCCESS;

    key.dptr = htdbm->username;
    key.dsize = strlen(htdbm->username);
    if (apr_dbm_exists(htdbm->dbm, key))
        *changed = 1;

    val.dsize = strlen(htdbm->ctx.passwd);
    if (!htdbm->comment)
        val.dptr  = htdbm->ctx.passwd;
    else {
        val.dptr = apr_pstrcat(htdbm->ctx.pool, htdbm->ctx.passwd, ":",
                               htdbm->comment, NULL);
        val.dsize += (strlen(htdbm->comment) + 1);
    }
    return apr_dbm_store(htdbm->dbm, key, val);
}
int slayer_server_log_request(slayer_server_log_manager_t *manager, apr_pool_t *mpool, apr_socket_t *conn,
                               const char *request_line, int response_code, int nbytes_sent, apr_int64_t time_toservice) {
	//generate data
	char dstring[1024];
	apr_int64_t current_time = apr_time_now();
	apr_size_t result_size;
	apr_time_exp_t ltime;
	apr_time_exp_lt(&ltime,current_time);
	apr_strftime (dstring, &result_size, sizeof(dstring), "%d/%b/%Y:%H:%M:%S %z", &ltime );

	apr_sockaddr_t *client_addr;
	char *client_ip;
	apr_socket_addr_get(&client_addr,0,conn);
	apr_sockaddr_ip_get(&client_ip,client_addr);
	if (manager->fhandle) {
		char *message = apr_pstrcat(mpool,client_ip," - - ","[",dstring,"] \"",request_line,"\" ",
		                            apr_itoa(mpool,response_code)," ",apr_itoa(mpool,nbytes_sent), " ",apr_ltoa(mpool,time_toservice), "\n",NULL);
		slayer_server_log_message(manager,message);
	}
	slayer_server_log_add_entry(manager,mpool,client_ip,current_time,request_line,response_code,nbytes_sent,time_toservice);
	return 0;
}
Пример #27
0
static void _mapcache_cache_sqlite_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) {
   ezxml_t cur_node;
   mapcache_cache_sqlite *dcache;
   sqlite3_initialize();
   sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
   dcache = (mapcache_cache_sqlite*)cache;
   if ((cur_node = ezxml_child(node,"base")) != NULL) {
      dcache->dbname_template = apr_pstrcat(ctx->pool,cur_node->txt,"/{tileset}#{grid}.db",NULL);
   }
   if ((cur_node = ezxml_child(node,"dbname_template")) != NULL) {
      dcache->dbname_template = apr_pstrdup(ctx->pool,cur_node->txt);
   }
   if ((cur_node = ezxml_child(node,"hitstats")) != NULL) {
      if(!strcasecmp(cur_node->txt,"true")) {
         dcache->hitstats = 1;
      }
   }
   if(!dcache->dbname_template) {
      ctx->set_error(ctx,500,"sqlite cache \"%s\" is missing <dbname_template> entry",cache->name);
      return;
   }
}
Пример #28
0
static ezxml_t _wmts_capabilities(mapcache_context *ctx, mapcache_cfg *cfg)
{
  char *schemaLocation = "http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd";

  ezxml_t node = ezxml_new("Capabilities");
  ezxml_set_attr(node,"xmlns","http://www.opengis.net/wmts/1.0");
  ezxml_set_attr(node,"xmlns:ows","http://www.opengis.net/ows/1.1");
  ezxml_set_attr(node,"xmlns:xlink","http://www.w3.org/1999/xlink");
  ezxml_set_attr(node,"xmlns:xsi","http://www.w3.org/2001/XMLSchema-instance");
  ezxml_set_attr(node,"xmlns:gml","http://www.opengis.net/gml");

  if( apr_table_get(cfg->metadata,"inspire_profile") ) {
    ezxml_set_attr(node,"xmlns:inspire_common","http://inspire.ec.europa.eu/schemas/common/1.0");
    ezxml_set_attr(node,"xmlns:inspire_vs","http://inspire.ec.europa.eu/schemas/inspire_vs_ows11/1.0");
    schemaLocation = apr_pstrcat(ctx->pool,schemaLocation," http://inspire.ec.europa.eu/schemas/inspire_vs_ows11/1.0 http://inspire.ec.europa.eu/schemas/inspire_vs_ows11/1.0/inspire_vs_ows_11.xsd",NULL);
  }

  ezxml_set_attr(node,"xsi:schemaLocation",schemaLocation);
  ezxml_set_attr(node,"version","1.0.0");

  return node;
}
Пример #29
0
/* Validate access to the given user for the subtree starting at the
 * given path.  This function walks the whole authz file in search of
 * rules applying to paths in the requested subtree which deny the
 * requested access.
 *
 * As soon as one is found, or else when the whole ACL file has been
 * searched, return the updated authorization status.
 */
static svn_boolean_t
authz_get_tree_access(svn_config_t *cfg, const char *repos_name,
                      const char *path, const char *user,
                      svn_repos_authz_access_t required_access,
                      apr_pool_t *pool)
{
  struct authz_lookup_baton baton = { 0 };

  baton.config = cfg;
  baton.user = user;
  baton.required_access = required_access;
  baton.repos_path = path;
  baton.qualified_repos_path = apr_pstrcat(pool, repos_name,
                                           ":", path, SVN_VA_NULL);
  /* Default to access granted if no rules say otherwise. */
  baton.access = TRUE;

  svn_config_enumerate_sections2(cfg, authz_parse_section,
                                 &baton, pool);

  return baton.access;
}
Пример #30
0
 RequestIntRedirFiltCond::RequestIntRedirFiltCond(apr_pool_t *p, Logger *l,
                                                  Phases::Phase phase__,
                                                  apr_ssize_t cmID,
                                                  bool isIntRedir)
     : FiltCond(p, l, phase__, cmID),
       isIntRedir_(isIntRedir),
       asStr_(apr_pstrcat(pool(), "RequestIntRedirFiltCond: ",
                          isIntRedir_ ? "true" : "false", NULL)),
       blobID_(pool(), 0, 0, false)
 {
     apr_ssize_t bSize = sizeof(phase__) +
                         sizeof(cmID) +
                         strlen(asStr_);
     void *bData = apr_palloc(blobID_.pool(), bSize);
     char *cp = static_cast<char *>(bData);
     memcpy(cp, &phase__, sizeof(phase__));
     cp += sizeof(phase__);
     memcpy(cp, &cmID, sizeof(cmID));
     cp += sizeof(cmID);
     memcpy(cp, asStr_, strlen(asStr_));
     blobID_.set(bData, bSize, false);
 }