Example #1
0
/* The sample content handler */
static int apm_test_handler(request_rec *r)
{
    if (strcmp(r->handler, "apm_test")) {
        return DECLINED;
    }
    r->content_type = "text/html";      

    if (!r->header_only){

      apm_test_cfg *conf = 
	(apm_test_cfg *)
	ap_get_module_config(r->per_dir_config, &apm_test_module);
      apm_test_server_cfg *sv_conf =
	(apm_test_server_cfg *)
	ap_get_module_config(r->server->module_config, &apm_test_module);

      if(conf->is_val_a_set){
        ap_rputs("mod_apm_test val a is set\n", r);
      }else{
        ap_rputs("mod_apm_test val a is not set\n", r);
      }

      ap_rprintf(r, "## server parameter %ld\n", sv_conf->server_param);
    }
    return OK;
}
static int helloworld_handler(request_rec* r) {
    if ( !r->handler || strcmp(r->handler, "helloworld") ) {
        return DECLINED ;   /* none of our business */
        }
    if ( r->method_number != M_GET ) {
        return HTTP_METHOD_NOT_ALLOWED ;  /* Reject other methods */
        }
    ap_set_content_type(r, "text/html;charset=ascii") ;
    ap_rputs(
        "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\">\n", r) ;
    ap_rputs(
        "<html><head><title>Apache HelloWorld Module</title></head>", r) ;
    ap_rputs("<body><h1>Hello World!</h1>", r) ;
    ap_rputs("<p>This is the Apache HelloWorld module!</p>", r) ;

    /* Print the headers and env */
    /* Note that the response headers and environment may be empty at
     * this point.  The CGI environment is an overhead we dispense
     * with in a module, unless another module that requires it
     * (e.g. mod_rewrite) has set it up.
     */
    printtable(r, r->headers_in, "Request Headers", "Header", "Value") ;
    printtable(r, r->headers_out, "Response Headers", "Header", "Value") ;
    printtable(r, r->subprocess_env, "Environment", "Variable", "Value") ;

    ap_rputs("</body></html>", r) ;
    return OK ;
    }
/* This does some initial checking, like if we're running on a SSL line or not */
static int checkInitial(request_rec *r) 
{
  return OK;
  yubiauth_dir_cfg *cfg = ap_get_module_config(r->per_dir_config, &authn_yubikey_module);
  ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_DEBUG, 0, r,
                LOG_PREFIX "requireSecure: %d", cfg->requireSecure);
  /* If no securiy is wanted or scheme is already https */
    if (!cfg->requireSecure || !strncmp(ap_http_scheme(r), "https", 5)) {
      return OK;
    }
    ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
		  LOG_PREFIX "The server is configured to use HTTPS on URI: %s", r->uri);
    if(cfg->externalErrorPage == TRUE){
      /* We explicitly want that to be overridable */
      //return HTTP_BAD_REQUEST;
      return HTTP_NOT_ACCEPTABLE;
    } 
      
    /* Tell the user/admin what's going on instead of just showing BAD_REQUEST */
    ap_rputs(DOCTYPE_HTML_4_0T, r);
    ap_set_content_type(r, "text/html;");
    ap_rputs(ERROR_TEXT, r);
    ap_finalize_request_protocol(r);
    return HTTP_BAD_REQUEST;
}
static void zipread_showheader(request_rec * r, char *fn)
{
    ap_rputs("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"\n\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n<html>\n<head>\n",r);
    ap_rprintf(r,"<title>Index of %s</title>\n", fn);
    ap_rputs("</head>\n<body bgcolor=\"#ffffff\" text=\"#000000\">\n\n<table><tr><td bgcolor=\"#ffffff\" class=\"title\">\n<font size=\"+3\" face=\"Helvetica,Arial,sans-serif\">\n",r);
    ap_rprintf(r,"<b>Index of %s</b></font>\n", fn);
    ap_rputs("</td></tr></table><pre>",r);
}
static void jsonEndDocument( struct tabix_callback_t* handler)
	{
	ap_rputs("}\n",handler->r);
	if(handler->jsonp_callback!=NULL)
		{
		ap_rputs(");\n",handler->r);
		}
	}
Example #6
0
static void write_headers(request_rec *r, const char **names)
{
	ap_rputs("<tr>", r);
	const char **n;
	for (n = names; *n; n++) {
		ap_rprintf(r, "<th>%s</th>", *n);
	}
	ap_rputs("<tr/>\n", r);
}
static int xmlPrintBody(struct tabix_callback_t* handler,const kstring_t *line)
	{
	int i,prev=0,n_field=0;
	ap_rputs("<tr>",handler->r);
	for(i=0;i<= line->l;++i)
		{
		if(line->s[i]=='\t' || i==line->l)
			{
			ap_rputs("<td",handler->r);
			if(n_field==0 && (handler->file_format==E_FORMAT_VCF || handler->file_format==E_FORMAT_BED))
				{
				ap_rputs(" type=\"chrom\"",handler->r);
				}
			else if(n_field==1 && handler->file_format==E_FORMAT_VCF)
				{
				ap_rputs(" type=\"pos\"",handler->r);
				}
			else if(n_field==1 && handler->file_format==E_FORMAT_BED)
				{
				ap_rputs(" type=\"start\"",handler->r);
				}
			else if(n_field==2 && handler->file_format==E_FORMAT_BED)
				{
				ap_rputs(" type=\"end\"",handler->r);
				}
			ap_rputs(">",handler->r);
			ap_xmlNPuts(&(line->s)[prev],i-prev,handler->r);
			ap_rputs("</td>",handler->r);
			if(i==line->l) break;
			++n_field;
			prev=i+1;
			}
		}
	return ap_rputs("</tr>\n",handler->r);
	}
Example #8
0
static void write_global_stats_full(request_rec *r, const global_snapshot *ss)
{
	ap_rputs("<dl>\n", r);
	ap_rprintf(r, "<dt>%d files saved, totalizing %s (%ld discarded)</dt>\n",
			ss->rec_count, format_mbyte(r->pool, ss->total_mb), ss->discarded);
	ap_rprintf(r, "<dt><strong>Queue time</strong>: Total: %s - Avg: %.3f ms </dt>\n",
			format_msec(r->pool, ss->total_queuetime_ms), ss->avg_queuetime_ms);
	ap_rprintf(r, "<dt><strong>Write time</strong>: Total: %s - Avg: %.3f ms - Bandwidth: %.1f Mb/s</dt>\n",
			format_msec(r->pool, ss->total_writetime_ms), ss->avg_writetime_ms, ss->bandwidth);
	ap_rputs("</dl>\n", r);
}
Example #9
0
static void write_process_stats(request_rec *r, int i, process_snapshot *ss)
{
	ap_rputs("<tr>", r);
	ap_rprintf(r, "<td><strong>%d</strong></td>",  i);
	ap_rprintf(r, "<td>%d</td>",                   ss->pid);
	ap_rprintf(r, "<td>%d/%d</td>",                ss->count_process, ss->count_slot);
	ap_rprintf(r, "<td><strong>%s</strong></td>",  status_str(ss->status));
	ap_rprintf(r, "<td>%d</td>",                   ss->queue_len);
	ap_rprintf(r, "<td>%ld</td>",                  ss->discarded);
	ap_rputs("</tr>", r);
}
Example #10
0
// this function takes a ", " separated list of groups and attempts to add
// CSS to the page from the config
static void add_group_css(request_rec *r, void *config, char * group) {
	moon_svr_cfg* cfg = config;
	char * css = apr_pcalloc(r->pool,1);
	char * next_css;
	char * temp_css;
	char * begin_ptr = NULL;
	char * end_ptr = NULL;
	char buf[MAX_GROUP_STR_LEN];
	int diff = 0;
	if(group != NULL) {
		end_ptr = strchr(group, ',');
		begin_ptr = group;
		while(end_ptr != NULL) {
			diff =  end_ptr - begin_ptr;
			if(diff >= MAX_GROUP_STR_LEN) {
				ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, r->server, "group name too long");
				continue;
			}
			strncpy(buf,begin_ptr,diff);
			buf[diff] = '\0';
			next_css = apr_hash_get(cfg->group_to_css, buf, APR_HASH_KEY_STRING);
			if(next_css != NULL) {
				temp_css = apr_palloc(r->pool, strlen(css)+strlen(next_css)+1);
				strcpy(temp_css,css);
				strcat(temp_css,next_css);
				css = temp_css;
			}
			begin_ptr = end_ptr+2;
			end_ptr = strchr(begin_ptr, ',');
		}
		strcpy(buf,begin_ptr);
		next_css = apr_hash_get(cfg->group_to_css, buf, APR_HASH_KEY_STRING);
		if(next_css != NULL) {
			temp_css = apr_palloc(r->pool, strlen(css)+strlen(next_css)+1);
			strcpy(temp_css,css);
			strcat(temp_css,next_css);
			css = temp_css;
		}
		
		if(strlen(css)==0) {
				css = apr_hash_get(cfg->group_to_css, "", APR_HASH_KEY_STRING);
		}
	}
	else {
		css = apr_hash_get(cfg->group_to_css, "", APR_HASH_KEY_STRING);
	}
	if(css == NULL) {
		return;
	}
	ap_rputs(OPEN_STYLE,r);
	ap_rprintf(r,"#%s{%s}",ELEMENT_ID_FOR_USER,css);
	ap_rputs(CLOSE_STYLE,r);
}
static int less_handler(request_rec* r)
{
	struct stat info;
	struct stat lessinfo;
	char * lessfilename = NULL;
	char * command = NULL;
	int status;
	int newer = 0;
	int error = 0;
	char * errornum = NULL;

	if (!r->handler || strcmp(r->handler, "less"))
	return DECLINED;

	if (r->method_number != M_GET)
	return HTTP_METHOD_NOT_ALLOWED;

	asprintf(&lessfilename, "%s.less", r->filename);
	asprintf(&command, "lessc %s > %s", r->filename, lessfilename);

	if (!file_exists(lessfilename)){

		status = system(command);
		if(status != 0)
			return DECLINED;

	}

	if (file_exists(lessfilename)){

		if ((stat(r->filename,&info) == 0) && (stat(lessfilename,&lessinfo) == 0) && (info.st_mtime > lessinfo.st_mtime))
			status = system(command);
		
		if ((error = read_file(lessfilename)) != 1){
			ap_set_content_type(r, "text/css");
        		ap_rputs(source,r);
			free(source);
			return OK;

		} else {

			asprintf(&errornum, "%d", error);
			ap_set_content_type(r, "text/css");
        		ap_rputs(errornum,r);
			free(source);
			return OK;

		}

	}
    	
}
Example #12
0
mrb_value ap_mrb_rputs(mrb_state *mrb, mrb_value str)
{
    mrb_value msg;

    mrb_get_args(mrb, "o", &msg);
    if (mrb_type(msg) == MRB_TT_STRING) {
        ap_rputs(RSTRING_PTR(msg), ap_mrb_get_request()); 
    } else {
        ap_rputs("not string", ap_mrb_get_request()); 
    }

    return str;
}
void markdown_output(MMIOT *doc, request_rec *r)
{
    char *title;
    int ret;
    int size;
    char *p;
    markdown_conf *conf;
    list_t *css;

    conf = (markdown_conf *) ap_get_module_config(r->per_dir_config,
                                                  &markdown_module);
    ret = mkd_compile(doc, MKD_TOC|MKD_AUTOLINK);
    ap_rputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n", r);
    ap_rputs("<!DOCTYPE html PUBLIC \n"
             "          \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n"
             "          \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n",
             r);
    ap_rputs("<html xmlns=\"http://www.w3.org/1999/xhtml\">\n", r);
    ap_rputs("<head>\n", r);

    if (conf->css) {
        ap_rputs("<meta http-equiv=\"Content-Type\""
                 " content=\"text/html; charset=UTF-8\" />\n", r);
        ap_rputs("<meta http-equiv=\"Content-Style-Type\""
                 " content=\"text/css\" />\n", r);
		css = conf->css;
		do{
            ap_rprintf(r,
                       "<link rel=\"stylesheet\" href=\"%s\""
                       " type=\"text/css\" />\n",
                       (char *)css->data);
            css = (list_t *)css->next;
		}while(css);
    }
    title = mkd_doc_title(doc);
    if (title) {
        ap_rprintf(r, "<title>%s</title>\n", title);
    }
    ap_rputs("</head>\n", r);
    ap_rputs("<body>\n", r);
    if (title) {
        ap_rprintf(r, "<h1 class=\"title\">%s</h1>\n", title);
    }
    if ((size = mkd_document(doc, &p)) != EOF) {
        ap_rwrite(p, size, r);
    }
    ap_rputc('\n', r);
    ap_rputs("</body>\n", r);
    ap_rputs("</html>\n", r);
    mkd_cleanup(doc);
}
Example #14
0
/*  _________________________________________________________________
**
**  SSL Extension to mod_status
**  _________________________________________________________________
*/
static int ssl_ext_status_hook(request_rec *r, int flags)
{
    SSLSrvConfigRec *sc = mySrvConfig(r->server);

    if (sc == NULL || flags & AP_STATUS_SHORT)
        return OK;

    ap_rputs("<hr>\n", r);
    ap_rputs("<table cellspacing=0 cellpadding=0>\n", r);
    ap_rputs("<tr><td bgcolor=\"#000000\">\n", r);
    ap_rputs("<b><font color=\"#ffffff\" face=\"Arial,Helvetica\">SSL/TLS Session Cache Status:</font></b>\r", r);
    ap_rputs("</td></tr>\n", r);
    ap_rputs("<tr><td bgcolor=\"#ffffff\">\n", r);

    if (sc->mc->nSessionCacheMode == SSL_SCMODE_DBM)
        ssl_scache_dbm_status(r, flags, r->pool);
    else if (sc->mc->nSessionCacheMode == SSL_SCMODE_SHMCB)
        ssl_scache_shmcb_status(r, flags, r->pool);
#ifdef HAVE_DISTCACHE
    else if (sc->mc->nSessionCacheMode == SSL_SCMODE_DC)
        ssl_scache_dc_status(r, flags, r->pool);
#endif

    ap_rputs("</td></tr>\n", r);
    ap_rputs("</table>\n", r);
    return OK;
}
Example #15
0
/** HTML handlers ***************************************************/
static void htmlStartDocument( struct tabix_callback_t* handler)
	{
	const char* region=HttpParamGet(handler->httParams,"region");

	ap_set_content_type(handler->r, MIME_TYPE_HTML);
	ap_rputs("<!doctype html>\n<html lang=\"en\">",handler->r);
	ap_rputs("<head>",handler->r);
	printDefaulthtmlHead(handler->r);
	ap_rputs("</head>",handler->r);
	ap_rputs("<body>",handler->r);
	ap_rputs("<form>"
		"<label for='format'>Format:</label> <select  id='format' name='format'>"
		"<option value='html'>html</option>"
		"<option value='json'>json</option>"
		"<option value='xml'>xml</option>"
		"<option value='text'>text</option>"
		"</select> "
		"<label for='limit'>Limit:</label> <input id='limit' name='limit' type='number' value='10'/> "
		"<label for='region'>Region:</label> <input id='region' name='region' placeholder='chrom:start-end' "
		,handler->r);
	
	if(region!=NULL)
	    {
	    ap_rputs(" value=\"",handler->r);
	    ap_xmlPuts(region,handler->r);
	    ap_rputs("\"",handler->r);
	    }

	ap_rputs("/> <input type='submit'/></form><div>",handler->r);
	}
Example #16
0
static void jsonStartDocument( struct tabix_callback_t* handler)
	{
	if(handler->jsonp_callback!=NULL)
			{
			ap_set_content_type(handler->r, MIME_TYPE_JAVASCRIPT);
			ap_rputs(handler->jsonp_callback,handler->r);
			ap_rputc('(',handler->r);
			}
	else
			{
			ap_set_content_type(handler->r, MIME_TYPE_JSON);
			}
	ap_rputs("{",handler->r);
	}
Example #17
0
/**
 * Called by other modules to print their "jmx beans" to the response in
 * whatever format was requested by the client.
 */
static apr_status_t bmx_bean_print_text_plain(request_rec *r,
                                              const struct bmx_bean *bean)
{
    apr_size_t objectname_strlen = bmx_objectname_strlen(bean->objectname) + 1;
    char *objectname_str = apr_palloc(r->pool, objectname_strlen);
    (void)bmx_objectname_str(bean->objectname, objectname_str,
                             objectname_strlen);
    (void)ap_rputs("Name: ", r);
    (void)ap_rputs(objectname_str, r);
    (void)ap_rputs("\n", r);

    /* for each element in bean->bean_properties, print it */
    if (!APR_RING_EMPTY(&(bean->bean_props), bmx_property, link)) {
        struct bmx_property *p = NULL;
        const char *value;
        for (p = APR_RING_FIRST(&(bean->bean_props));
             p != APR_RING_SENTINEL(&(bean->bean_props), bmx_property, link);
             p = APR_RING_NEXT(p, link)) {
            (void)ap_rputs(p->key, r);
            (void)ap_rputs(": ", r);
            value = property_print(r->pool, p);
            if (value)
                (void)ap_rputs(value, r);
            (void)ap_rputs("\n", r);
        }
    }
    (void)ap_rputs("\n", r);
    return APR_SUCCESS;
}
// Multicast index handler
static int multicast_index_handler(request_rec *rec)
{
  multicast_conf* conf = ap_get_module_config(rec->per_dir_config, &multicast_index_module);
  apr_status_t status = APR_SUCCESS;
  apr_finfo_t finfo;
  apr_dir_t* dir;

  if(strcasecmp(rec->handler, MULTICAST_INDEX)) return DECLINED;
  if(!conf || !conf->enabled) return DECLINED;
  if(rec->method_number!=M_GET) return DECLINED;

  // setup content-type of response.
  rec->content_type = "text/json";

  // do request
  status = apr_dir_open(&dir, rec->filename, rec->pool);
  if(status!=APR_SUCCESS) {
    // 404 Not Found.
    rec->status = HTTP_NOT_FOUND;
    return multicast_404_not_found(rec, conf);
  }

  // 200 OK.
  if(!rec->header_only) {
    int the_first = TRUE;
    ap_rputs("[", rec);
    while((status=apr_dir_read(&finfo, APR_FINFO_NAME|APR_FINFO_TYPE, dir))==APR_SUCCESS) {
      if((strcmp(finfo.name, ".")==0) || (strcmp(finfo.name, "..")==0)) continue;
      if(the_first) { the_first = FALSE; } else { ap_rputs(",", rec); }
      switch(finfo.filetype) {
      case APR_DIR:
        ap_rprintf(rec, "\"%s/\"", finfo.name);
        break;
      case APR_REG:
        ap_rprintf(rec, "\"%s\"", finfo.name);
        break;
      case APR_LNK:
        ap_rprintf(rec, "\"%[email protected]\"", finfo.name);
        break;
      default:
        break;
      }
    }
    ap_rputs("]\n", rec);
    rec->status = HTTP_OK;
  }
  apr_dir_close(dir);

  return multicast_200_ok(rec, conf);
}
Example #19
0
/*  _________________________________________________________________
**
**  SSL Extension to mod_status
**  _________________________________________________________________
*/
static int ssl_ext_status_hook(request_rec *r, int flags)
{
    SSLModConfigRec *mc = myModConfig(r->server);

    if (mc == NULL || flags & AP_STATUS_SHORT || mc->sesscache == NULL)
        return OK;

    ap_rputs("<hr>\n", r);
    ap_rputs("<table cellspacing=0 cellpadding=0>\n", r);
    ap_rputs("<tr><td bgcolor=\"#000000\">\n", r);
    ap_rputs("<b><font color=\"#ffffff\" face=\"Arial,Helvetica\">SSL/TLS Session Cache Status:</font></b>\r", r);
    ap_rputs("</td></tr>\n", r);
    ap_rputs("<tr><td bgcolor=\"#ffffff\">\n", r);

    if (mc->sesscache->flags & AP_SOCACHE_FLAG_NOTMPSAFE) {
        ssl_mutex_on(r->server);
    }

    mc->sesscache->status(mc->sesscache_context, r, flags);

    if (mc->sesscache->flags & AP_SOCACHE_FLAG_NOTMPSAFE) {
        ssl_mutex_off(r->server);
    }

    ap_rputs("</td></tr>\n", r);
    ap_rputs("</table>\n", r);
    return OK;
}
Example #20
0
static void write_stats_full(request_rec *r, global_snapshot *gs, process_snapshot **sn)
{
	ap_rputs("<hr><h2>Tee status</h2>\n", r);
	write_global_stats_full(r, gs);
	ap_rputs("<table>\n", r);
	const char *headers[] = { "Slot", "PID", "Acc", "Status", "Queue Len", "Discarded", NULL };
	write_headers(r, headers);
	int i;
	for (i = 0; i < global_stats->count; i++) {
		if (sn[i])
			write_process_stats(r, i, sn[i]);
	}
	ap_rputs("</table>\n", r);
	ap_rputs(legend, r);
}
Example #21
0
/*
 * Display an XHTML MIME structure
 * 'link' must already be properly URI-escaped
 */
void mbox_mime_display_static_structure(request_rec *r,
                                        mbox_mime_message_t *m, char *link)
{
    int i;

    if (!m) {
        return;
    }

    ap_rputs("<li>", r);

    if (m->body_len) {
        ap_rprintf(r, "<a rel=\"nofollow\" href=\"%s\">", link);
    }

    if (m->content_name) {
        ap_rprintf(r, "%s (%s)",
                   ESCAPE_OR_BLANK(r->pool, m->content_name),
                   ESCAPE_OR_BLANK(r->pool, m->content_type));
    }
    else {
        ap_rprintf(r, "Unnamed %s", ESCAPE_OR_BLANK(r->pool, m->content_type));
    }

    if (m->body_len) {
        ap_rputs("</a>", r);
    }

    ap_rprintf(r, " (%s, %s, %" APR_SIZE_T_FMT " bytes)</li>\n",
               m->content_disposition, mbox_cte_to_char(m->cte), m->body_len);

    if (!m->sub) {
        return;
    }

    for (i = 0; i < m->sub_count; i++) {
        ap_rputs("<ul>\n", r);

        if (link[strlen(link) - 1] == '/') {
            link[strlen(link) - 1] = 0;
        }

        mbox_mime_display_static_structure(r, m->sub[i],
                                           apr_psprintf(r->pool, "%s/%d",
                                                        link, i + 1));
        ap_rputs("</ul>\n", r);
    }
}
Example #22
0
static int write_msg(request_rec *r, msg_t *msg)
{
    ap_set_content_type(r, "application/octet-stream");
    ap_rputs(msg->data, r);

    return OK;
}
Example #23
0
/* The sample content handler */
static int logtest_handler(request_rec *r)
{
    //if (strcmp(r->handler, "logtest")) {
    //    return DECLINED;
    //}
    r->content_type = "text/html";      

	SemanticLogger log(r);
	SemanticLogRoute* route = new SemanticLogFileRoute();
	route->setLogFile("/tmp/output");
	route->setRotate(true);
	log.addRoute(route);
	log.applicationLog(1, "error\n", SemanticLogger::INFO, "aaa.aa.aaaaa", "test", "{\"ssss\":12344 }");

	std::map<std::string, std::string> itms;  // 文字×文字のmapを指定
	itms.insert(std::pair<std::string, std::string>("01", "C++"));  // 値を挿入
	itms.insert(std::pair<std::string, std::string>("02", "C#"));
	itms.insert(std::pair<std::string, std::string>("03", "VB"));
	itms.insert(std::pair<std::string, std::string>("04", "Java"));
	itms.insert(std::pair<std::string, std::string>("05", "XML"));
	log.applicationLog(2, "trace\n", SemanticLogger::TRACE, "aaa.aa.aaaaa", itms);
	log.applicationLog(3, "info\n", SemanticLogger::INFO, "aaa.aa.aaaaa");

    if (!r->header_only)
	{
        ap_rputs("The sample page from mod_logtest.c\n", r);
		ap_rprintf(r, "handler: %s", r->handler);
	}
    return OK;
}
Example #24
0
/**
define write_raw(text: String)

This writes 'text' directly to the server without performing any HTML character
escaping. Use this only if you are certain that there is no possibility of HTML
injection.
*/
void lily_apache_server_write_raw(lily_vm_state *vm, uint16_t argc, uint16_t *code)
{
    lily_value **vm_regs = vm->vm_regs;
    char *value = vm_regs[code[1]]->value.string->string;

    ap_rputs(value, (request_rec *)vm->data);
}
Example #25
0
// ## void Request.puts(String s)
static KMETHOD Request_puts(KonohaContext *kctx, KonohaStack *sfp)
{
    kRequest *self = (kRequest *) sfp[0].asObject;
    kString *data = sfp[1].asString;
    ap_rputs(kString_text(data), self->r);
    KReturnVoid();
}
Example #26
0
void util_ldap_compare_node_display(request_rec *r, util_ald_cache_t *cache, void *n)
{
    util_compare_node_t *node = (util_compare_node_t *)n;
    char date_str[APR_CTIME_LEN+1];
    char *buf, *cmp_result;

    apr_ctime(date_str, node->lastcompare);

    if (node->result == LDAP_COMPARE_TRUE) {
        cmp_result = "LDAP_COMPARE_TRUE";
    }
    else if (node->result == LDAP_COMPARE_FALSE) {
        cmp_result = "LDAP_COMPARE_FALSE";
    }
    else {
        cmp_result = apr_itoa(r->pool, node->result);
    }

    buf = apr_psprintf(r->pool, 
             "<tr valign='top'>"
             "<td nowrap>%s</td>"
             "<td nowrap>%s</td>"
             "<td nowrap>%s</td>"
             "<td nowrap>%s</td>"
             "<td nowrap>%s</td>"
             "<tr>",
         node->dn,
         node->attrib,
         node->value,
         date_str,
         cmp_result);

    ap_rputs(buf, r);
}
Example #27
0
/*
 * Provide information for "status" logic
 */
static void advertise_info(request_rec *r)
{
    server_rec *s = main_server;
    /* Find the VirtualHost (Server) that does the Advertise */
    while (s) {
        void *sconf = s->module_config;
        mod_advertise_config *mconf = ap_get_module_config(sconf, &advertise_module);
        ap_rprintf(r, "Server: %s ", s->server_hostname);
        if (s->is_virtual && s->addrs) {
           server_addr_rec *srec = s->addrs;
           ap_rprintf(r, "VirtualHost: %s:%d", srec->virthost, srec->host_port);
        }
        if (mconf->ma_advertise_server != NULL) {
            ap_rprintf(r, " Advertising on Group %s Port %d ", mconf->ma_advertise_adrs, mconf->ma_advertise_port);
            ap_rprintf(r, "for %s://%s:%d every %d seconds<br/>",
                       mconf->ma_advertise_srvm, mconf->ma_advertise_srvs,
                       mconf-> ma_advertise_srvp,
                       apr_time_sec(mconf->ma_advertise_freq)
                       );
        } else {
            ap_rputs("<br/>", r);
        }
        s = s->next;
    }
}
Example #28
0
static void ssl_ext_ms_display_cb(char *str, void *_r)
{
    request_rec *r = (request_rec *)_r;
    if (str != NULL)
        ap_rputs(str, r);
    return;
}
/* The sample content handler */
static int helloworld_handler(request_rec *r)
{
    r->content_type = "text/html";      
    ap_send_http_header(r);
    if (!r->header_only)
        ap_rputs("The sample page from mod_helloworld.c\n", r);
    return OK;
}
Example #30
0
// this function takes a user name and the server config and attempts to add CSS rules
// to the page if they exist
static void add_user_css(request_rec *r, void *config, char * user) {
	moon_svr_cfg* cfg = config;
	char * css;

	if(user != NULL) {
		css = apr_hash_get(cfg->user_to_css, user, APR_HASH_KEY_STRING);
		if(css == NULL) {
			css = apr_hash_get(cfg->user_to_css, "", APR_HASH_KEY_STRING);
		}
	} 
	else {
		css = apr_hash_get(cfg->user_to_css, "", APR_HASH_KEY_STRING);
	}
	if(css==NULL) {
		return;
	}
	ap_rputs(OPEN_STYLE,r);
	ap_rprintf(r,"#%s{%s}",ELEMENT_ID_FOR_USER,css);
	ap_rputs(CLOSE_STYLE,r);
}