#include "apr.h"
#include "apr_strings.h"
#include "apr_lib.h"
+#include "apr_md5.h" /* for apr_password_validate */
#define APR_WANT_STDIO
#define APR_WANT_STRFUNC
#ifdef HAVE_GRP_H
#include <grp.h>
#endif
+#ifdef HAVE_SYS_LOADAVG_H
+#include <sys/loadavg.h>
+#endif
+
+#include "ap_mpm.h"
/* A bunch of functions in util.c scan strings looking for certain characters.
* To make that more efficient we encode a lookup table. The test_char_table
while ((semi > intype) && apr_isspace(semi[-1])) {
semi--;
}
- return apr_pstrndup(p, intype, semi - intype);
+ return apr_pstrmemdup(p, intype, semi - intype);
}
}
AP_DECLARE(int) ap_is_matchexp(const char *str)
{
- register int x;
+ int x;
for (x = 0; str[x]; x++)
if ((str[x] == '*') || (str[x] == '?'))
int cflags)
{
ap_regex_t *preg = apr_palloc(p, sizeof *preg);
-
- if (ap_regcomp(preg, pattern, cflags)) {
+ int err = ap_regcomp(preg, pattern, cflags);
+ if (err) {
+ if (err == AP_REG_ESPACE)
+ ap_abort_on_oom();
return NULL;
}
static apr_status_t regsub_core(apr_pool_t *p, char **result,
struct ap_varbuf *vb, const char *input,
- const char *source, size_t nmatch,
+ const char *source, apr_size_t nmatch,
ap_regmatch_t pmatch[], apr_size_t maxlen)
{
const char *src = input;
char *dst;
char c;
- size_t no;
+ apr_size_t no;
apr_size_t len = 0;
AP_DEBUG_ASSERT((result && p && !vb) || (vb && !p && !result));
*result = dst = apr_palloc(p, len + 1);
}
else {
- if (vb->buf && vb->strlen == AP_VARBUF_UNKNOWN)
+ if (vb->strlen == AP_VARBUF_UNKNOWN)
vb->strlen = strlen(vb->buf);
ap_varbuf_grow(vb, vb->strlen + len);
dst = vb->buf + vb->strlen;
src = input;
while ((c = *src++) != '\0') {
- if (c == '&')
- no = 0;
- else if (c == '$' && apr_isdigit(*src))
+ if (c == '$' && apr_isdigit(*src))
no = *src++ - '0';
else
no = AP_MAX_REG_MATCH;
if (no >= AP_MAX_REG_MATCH) { /* Ordinary character. */
- if (c == '\\' && (*src == '$' || *src == '&'))
+ if (c == '\\' && *src)
c = *src++;
*dst++ = c;
}
#define AP_PREGSUB_MAXLEN (HUGE_STRING_LEN * 8)
#endif
AP_DECLARE(char *) ap_pregsub(apr_pool_t *p, const char *input,
- const char *source, size_t nmatch,
+ const char *source, apr_size_t nmatch,
ap_regmatch_t pmatch[])
{
char *result;
AP_DECLARE(apr_status_t) ap_pregsub_ex(apr_pool_t *p, char **result,
const char *input, const char *source,
- size_t nmatch, ap_regmatch_t pmatch[],
+ apr_size_t nmatch, ap_regmatch_t pmatch[],
apr_size_t maxlen)
{
apr_status_t rc = regsub_core(p, result, NULL, input, source, nmatch,
while (name[l] != '\0') {
if (name[l] == '.' && name[l + 1] == '.' && IS_SLASH(name[l + 2])
&& (l == 0 || IS_SLASH(name[l - 1]))) {
- register int m = l + 3, n;
+ int m = l + 3, n;
l = l - 2;
if (l >= 0) {
AP_DECLARE(int) ap_count_dirs(const char *path)
{
- register int x, n;
+ int x, n;
for (x = 0, n = 0; path[x]; x++)
if (path[x] == '/')
char *res;
if (!pos) {
- size_t len = strlen(*line);
+ apr_size_t len = strlen(*line);
res = apr_pstrmemdup(atrans, *line, len);
*line += len;
return res;
}
- res = apr_pstrndup(atrans, *line, pos - *line);
+ res = apr_pstrmemdup(atrans, *line, pos - *line);
++pos;
static char *substring_conf(apr_pool_t *p, const char *start, int len,
char quote)
{
- char *result = apr_palloc(p, len + 2);
+ char *result = apr_palloc(p, len + 1);
char *resp = result;
int i;
char *res;
char quote;
- while (*str && apr_isspace(*str))
+ while (apr_isspace(*str))
++str;
if (!*str) {
res = substring_conf(p, str, strend - str, 0);
}
- while (*strend && apr_isspace(*strend))
+ while (apr_isspace(*strend))
++strend;
*line = strend;
return res;
AP_DECLARE(int) ap_cfg_closefile(ap_configfile_t *cfp)
{
#ifdef DEBUG
- ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL, APLOGNO(00551)
"Done with config file %s", cfp->name);
#endif
return (cfp->close == NULL) ? 0 : cfp->close(cfp->param);
return apr_file_getc(ch, param);
}
-static apr_status_t cfg_getstr(void *buf, size_t bufsiz, void *param)
+static apr_status_t cfg_getstr(void *buf, apr_size_t bufsiz, void *param)
{
return apr_file_gets(buf, bufsiz, param);
}
#endif
if (name == NULL) {
- ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL,
+ ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, APLOGNO(00552)
"Internal error: pcfg_openfile() called with NULL filename");
return APR_EBADF;
}
status = apr_file_open(&file, name, APR_READ | APR_BUFFERED,
APR_OS_DEFAULT, p);
#ifdef DEBUG
- ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL, APLOGNO(00553)
"Opening config file %s (%s)",
name, (status != APR_SUCCESS) ?
apr_strerror(status, buf, sizeof(buf)) : "successful");
#else
strcmp(name, "/dev/null") != 0) {
#endif /* WIN32 || OS2 */
- ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL,
+ ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, APLOGNO(00554)
"Access to file %s denied by server: not a regular file",
name);
apr_file_close(file);
AP_DECLARE(ap_configfile_t *) ap_pcfg_open_custom(
apr_pool_t *p, const char *descr, void *param,
apr_status_t (*getc_func) (char *ch, void *param),
- apr_status_t (*gets_func) (void *buf, size_t bufsize, void *param),
+ apr_status_t (*gets_func) (void *buf, apr_size_t bufsize, void *param),
apr_status_t (*close_func) (void *param))
{
ap_configfile_t *new_cfg = apr_palloc(p, sizeof(*new_cfg));
AP_DECLARE(const char *) ap_pcfg_strerror(apr_pool_t *p, ap_configfile_t *cfp,
apr_status_t rc)
{
- char buf[MAX_STRING_LEN];
if (rc == APR_SUCCESS)
return NULL;
- return apr_psprintf(p, "Error reading %s at line %d: %s",
- cfp->name, cfp->line_number,
- rc == APR_ENOSPC ? "Line too long"
- : apr_strerror(rc, buf, sizeof(buf)));
+
+ if (rc == APR_ENOSPC)
+ return apr_psprintf(p, "Error reading %s at line %d: Line too long",
+ cfp->name, cfp->line_number);
+
+ return apr_psprintf(p, "Error reading %s at line %d: %pm",
+ cfp->name, cfp->line_number, &rc);
}
/* Read one line from open ap_configfile_t, strip LF, increase line number */
/* If custom handler does not define a getstr() function, read char by char */
-static apr_status_t ap_cfg_getline_core(char *buf, size_t bufsize,
+static apr_status_t ap_cfg_getline_core(char *buf, apr_size_t bufsize,
ap_configfile_t *cfp)
{
apr_status_t rc;
if (cfp->getstr != NULL) {
char *cp;
char *cbuf = buf;
- size_t cbufsize = bufsize;
+ apr_size_t cbufsize = bufsize;
while (1) {
++cfp->line_number;
}
} else {
/* No "get string" function defined; read character by character */
- size_t i = 0;
+ apr_size_t i = 0;
if (bufsize < 2) {
/* too small, assume caller is crazy */
if (start != buf)
memmove(buf, start, end - start + 2);
#ifdef DEBUG_CFG_LINES
- ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, NULL, "Read config: '%s'", buf);
+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, NULL, APLOGNO(00555) "Read config: '%s'", buf);
#endif
return end - start + 1;
}
/* Read one line from open ap_configfile_t, strip LF, increase line number */
/* If custom handler does not define a getstr() function, read char by char */
-AP_DECLARE(apr_status_t) ap_cfg_getline(char *buf, size_t bufsize, ap_configfile_t *cfp)
+AP_DECLARE(apr_status_t) ap_cfg_getline(char *buf, apr_size_t bufsize,
+ ap_configfile_t *cfp)
{
apr_status_t rc = ap_cfg_getline_core(buf, bufsize, cfp);
if (rc == APR_SUCCESS)
apr_size_t max_len)
{
apr_status_t rc;
+ apr_size_t new_len;
vb->strlen = 0;
*vb->buf = '\0';
+ if (vb->strlen == AP_VARBUF_UNKNOWN)
+ vb->strlen = strlen(vb->buf);
+ if (vb->avail - vb->strlen < 3) {
+ new_len = vb->avail * 2;
+ if (new_len > max_len)
+ new_len = max_len;
+ else if (new_len < 3)
+ new_len = 3;
+ ap_varbuf_grow(vb, new_len);
+ }
+
for (;;) {
- apr_size_t new_len;
rc = ap_cfg_getline_core(vb->buf + vb->strlen, vb->avail - vb->strlen, cfp);
if (rc == APR_ENOSPC || rc == APR_SUCCESS)
vb->strlen += strlen(vb->buf + vb->strlen);
ap_varbuf_grow(vb, new_len);
--cfp->line_number;
}
+ if (vb->strlen > max_len)
+ return APR_ENOSPC;
if (rc == APR_SUCCESS)
vb->strlen = cfg_trim_line(vb->buf);
return rc;
return token;
}
+typedef enum ap_etag_e {
+ AP_ETAG_NONE,
+ AP_ETAG_WEAK,
+ AP_ETAG_STRONG
+} ap_etag_e;
+
/* Find an item in canonical form (lowercase, no extra spaces) within
* an HTTP field value list. Returns 1 if found, 0 if not found.
* This would be much more efficient if we stored header fields as
* an array of list items as they are received instead of a plain string.
*/
-AP_DECLARE(int) ap_find_list_item(apr_pool_t *p, const char *line,
- const char *tok)
+static int find_list_item(apr_pool_t *p, const char *line,
+ const char *tok, ap_etag_e type)
{
const unsigned char *pos;
const unsigned char *ptr = (const unsigned char *)line;
int good = 0, addspace = 0, in_qpair = 0, in_qstr = 0, in_com = 0;
- if (!line || !tok)
+ if (!line || !tok) {
return 0;
+ }
+ if (type == AP_ETAG_STRONG && *tok != '\"') {
+ return 0;
+ }
+ if (type == AP_ETAG_WEAK) {
+ if (*tok == 'W' && (*(tok+1)) == '/' && (*(tok+2)) == '\"') {
+ tok += 2;
+ }
+ else if (*tok != '\"') {
+ return 0;
+ }
+ }
do { /* loop for each item in line's list */
/* Find first non-comma, non-whitespace byte */
-
- while (*ptr == ',' || apr_isspace(*ptr))
+ while (*ptr == ',' || apr_isspace(*ptr)) {
++ptr;
+ }
+
+ /* Account for strong or weak Etags, depending on our search */
+ if (type == AP_ETAG_STRONG && *ptr != '\"') {
+ break;
+ }
+ if (type == AP_ETAG_WEAK) {
+ if (*ptr == 'W' && (*(ptr+1)) == '/' && (*(ptr+2)) == '\"') {
+ ptr += 2;
+ }
+ else if (*ptr != '\"') {
+ break;
+ }
+ }
if (*ptr)
good = 1; /* until proven otherwise for this item */
if (in_com || in_qstr)
good = good && (*pos++ == *ptr);
else
- good = good && (*pos++ == apr_tolower(*ptr));
+ good = good
+ && (apr_tolower(*pos++) == apr_tolower(*ptr));
addspace = 0;
break;
}
return good;
}
+/* Find an item in canonical form (lowercase, no extra spaces) within
+ * an HTTP field value list. Returns 1 if found, 0 if not found.
+ * This would be much more efficient if we stored header fields as
+ * an array of list items as they are received instead of a plain string.
+ */
+AP_DECLARE(int) ap_find_list_item(apr_pool_t *p, const char *line,
+ const char *tok)
+{
+ return find_list_item(p, line, tok, AP_ETAG_NONE);
+}
+
+/* Find a strong Etag in canonical form (lowercase, no extra spaces) within
+ * an HTTP field value list. Returns 1 if found, 0 if not found.
+ */
+AP_DECLARE(int) ap_find_etag_strong(apr_pool_t *p, const char *line,
+ const char *tok)
+{
+ return find_list_item(p, line, tok, AP_ETAG_STRONG);
+}
+
+/* Find a weak ETag in canonical form (lowercase, no extra spaces) within
+ * an HTTP field value list. Returns 1 if found, 0 if not found.
+ */
+AP_DECLARE(int) ap_find_etag_weak(apr_pool_t *p, const char *line,
+ const char *tok)
+{
+ return find_list_item(p, line, tok, AP_ETAG_WEAK);
+}
+
+/* Grab a list of tokens of the format 1#token (from RFC7230) */
+AP_DECLARE(const char *) ap_parse_token_list_strict(apr_pool_t *p,
+ const char *str_in,
+ apr_array_header_t **tokens,
+ int skip_invalid)
+{
+ int in_leading_space = 1;
+ int in_trailing_space = 0;
+ int string_end = 0;
+ const char *tok_begin;
+ const char *cur;
+
+ if (!str_in) {
+ return NULL;
+ }
+
+ tok_begin = cur = str_in;
+
+ while (!string_end) {
+ const unsigned char c = (unsigned char)*cur;
+
+ if (!TEST_CHAR(c, T_HTTP_TOKEN_STOP) && c != '\0') {
+ /* Non-separator character; we are finished with leading
+ * whitespace. We must never have encountered any trailing
+ * whitespace before the delimiter (comma) */
+ in_leading_space = 0;
+ if (in_trailing_space) {
+ return "Encountered illegal whitespace in token";
+ }
+ }
+ else if (c == ' ' || c == '\t') {
+ /* "Linear whitespace" only includes ASCII CRLF, space, and tab;
+ * we can't get a CRLF since headers are split on them already,
+ * so only look for a space or a tab */
+ if (in_leading_space) {
+ /* We're still in leading whitespace */
+ ++tok_begin;
+ }
+ else {
+ /* We must be in trailing whitespace */
+ ++in_trailing_space;
+ }
+ }
+ else if (c == ',' || c == '\0') {
+ if (!in_leading_space) {
+ /* If we're out of the leading space, we know we've read some
+ * characters of a token */
+ if (*tokens == NULL) {
+ *tokens = apr_array_make(p, 4, sizeof(char *));
+ }
+ APR_ARRAY_PUSH(*tokens, char *) =
+ apr_pstrmemdup((*tokens)->pool, tok_begin,
+ (cur - tok_begin) - in_trailing_space);
+ }
+ /* We're allowed to have null elements, just don't add them to the
+ * array */
+
+ tok_begin = cur + 1;
+ in_leading_space = 1;
+ in_trailing_space = 0;
+ string_end = (c == '\0');
+ }
+ else {
+ /* Encountered illegal separator char */
+ if (skip_invalid) {
+ /* Skip to the next separator */
+ const char *temp;
+ temp = ap_strchr_c(cur, ',');
+ if(!temp) {
+ temp = ap_strchr_c(cur, '\0');
+ }
+
+ /* Act like we haven't seen a token so we reset */
+ cur = temp - 1;
+ in_leading_space = 1;
+ in_trailing_space = 0;
+ }
+ else {
+ return apr_psprintf(p, "Encountered illegal separator "
+ "'\\x%.2x'", (unsigned int)c);
+ }
+ }
+
+ ++cur;
+ }
+
+ return NULL;
+}
/* Retrieve a token, spacing over it and returning a pointer to
* the first non-white byte afterwards. Note that these tokens
const char *ptr = *accept_line;
const char *tok_start;
char *token;
- int tok_len;
/* Find first non-white byte */
- while (*ptr && apr_isspace(*ptr))
+ while (apr_isspace(*ptr))
++ptr;
tok_start = ptr;
break;
}
- tok_len = ptr - tok_start;
- token = apr_pstrndup(p, tok_start, tok_len);
+ token = apr_pstrmemdup(p, tok_start, ptr - tok_start);
/* Advance accept_line pointer to the next non-white byte */
- while (*ptr && apr_isspace(*ptr))
+ while (apr_isspace(*ptr))
++ptr;
*accept_line = ptr;
static char x2c(const char *what)
{
- register char digit;
+ char digit;
#if !APR_CHARSET_EBCDIC
digit = ((what[0] >= 'A') ? ((what[0] & 0xdf) - 'A') + 10
static int unescape_url(char *url, const char *forbid, const char *reserved)
{
- register int badesc, badpath;
+ int badesc, badpath;
char *x, *y;
badesc = 0;
AP_DECLARE(char *) ap_os_escape_path(apr_pool_t *p, const char *path, int partial)
{
- char *copy = apr_palloc(p, 3 * strlen(path) + 3);
+ /* Allocate +3 for potential "./" and trailing NULL.
+ * Allocate another +1 to allow the caller to add a trailing '/' (see
+ * comment in 'ap_sub_req_lookup_dirent')
+ */
+ char *copy = apr_palloc(p, 3 * strlen(path) + 3 + 1);
const unsigned char *s = (const unsigned char *)path;
unsigned char *d = (unsigned char *)copy;
unsigned c;
char *ret;
unsigned char *d;
const unsigned char *s;
+ apr_size_t length, escapes = 0;
if (!str) {
return NULL;
}
- ret = apr_palloc(p, 4 * strlen(str) + 1); /* Be safe */
+ /* Compute how many characters need to be escaped */
+ s = (const unsigned char *)str;
+ for (; *s; ++s) {
+ if (TEST_CHAR(*s, T_ESCAPE_LOGITEM)) {
+ escapes++;
+ }
+ }
+
+ /* Compute the length of the input string, including NULL */
+ length = s - (const unsigned char *)str + 1;
+
+ /* Fast path: nothing to escape */
+ if (escapes == 0) {
+ return apr_pmemdup(p, str, length);
+ }
+
+ /* Each escaped character needs up to 3 extra bytes (0 --> \x00) */
+ ret = apr_palloc(p, length + 3 * escapes);
d = (unsigned char *)ret;
s = (const unsigned char *)str;
for (; *s; ++s) {
-
if (TEST_CHAR(*s, T_ESCAPE_LOGITEM)) {
*d++ = '\\';
switch(*s) {
return (d - (unsigned char *)dest);
}
+AP_DECLARE(void) ap_bin2hex(const void *src, apr_size_t srclen, char *dest)
+{
+ const unsigned char *in = src;
+ apr_size_t i;
+
+ for (i = 0; i < srclen; i++) {
+ *dest++ = c2x_table[in[i] >> 4];
+ *dest++ = c2x_table[in[i] & 0xf];
+ }
+ *dest = '\0';
+}
+
+AP_DECLARE(int) ap_has_cntrl(const char *str)
+{
+ while (*str) {
+ if (apr_iscntrl(*str))
+ return 1;
+ str++;
+ }
+ return 0;
+}
+
AP_DECLARE(int) ap_is_directory(apr_pool_t *p, const char *path)
{
apr_finfo_t finfo;
*/
AP_DECLARE(int) ap_is_url(const char *u)
{
- register int x;
+ int x;
for (x = 0; u[x] != ':'; x++) {
if ((!u[x]) ||
- ((!apr_isalpha(u[x])) && (!apr_isdigit(u[x])) &&
+ ((!apr_isalnum(u[x])) &&
(u[x] != '+') && (u[x] != '-') && (u[x] != '.'))) {
return 0;
}
char *hostname;
if (apr_gethostname(str, sizeof(str) - 1, a) != APR_SUCCESS) {
- ap_log_perror(APLOG_MARK, APLOG_STARTUP | APLOG_WARNING, 0, a,
+ ap_log_perror(APLOG_MARK, APLOG_STARTUP | APLOG_WARNING, 0, a, APLOGNO(00556)
"%s: apr_gethostname() failed to determine ServerName",
ap_server_argv0);
} else {
server_hostname = apr_pstrdup(a, hostname);
}
} else {
- ap_log_perror(APLOG_MARK, APLOG_STARTUP | APLOG_WARNING, 0, a,
+ ap_log_perror(APLOG_MARK, APLOG_STARTUP | APLOG_WARNING, 0, a, APLOGNO(00557)
"%s: apr_sockaddr_info_get() failed for %s",
ap_server_argv0, str);
}
if (!server_hostname)
server_hostname = apr_pstrdup(a, "127.0.0.1");
- ap_log_perror(APLOG_MARK, APLOG_ALERT|APLOG_STARTUP, 0, a,
+ ap_log_perror(APLOG_MARK, APLOG_ALERT|APLOG_STARTUP, 0, a, APLOGNO(00558)
"%s: Could not reliably determine the server's fully qualified "
"domain name, using %s. Set the 'ServerName' directive globally "
"to suppress this message",
/* sanity check - we only support forms for now */
ct = apr_table_get(r->headers_in, "Content-Type");
- if (!ct || strcmp("application/x-www-form-urlencoded", ct)) {
+ if (!ct || strncasecmp("application/x-www-form-urlencoded", ct, 33)) {
return ap_discard_request_body(r);
}
APR_BLOCK_READ, HUGE_STRING_LEN);
if (rv != APR_SUCCESS) {
apr_brigade_destroy(bb);
- return (rv == AP_FILTER_ERROR) ? rv : HTTP_BAD_REQUEST;
+ return ap_map_http_request_error(rv, HTTP_BAD_REQUEST);
}
for (bucket = APR_BRIGADE_FIRST(bb);
struct ap_varbuf_info *new_info;
char *new;
+ AP_DEBUG_ASSERT(vb->strlen == AP_VARBUF_UNKNOWN || vb->avail >= vb->strlen);
+
if (new_len <= vb->avail)
return;
i++;
}
if (buf->avail && buf->strlen) {
+ if (buf->strlen == AP_VARBUF_UNKNOWN)
+ buf->strlen = strlen(buf->buf);
vec[i].iov_base = (void *)buf->buf;
- vec[i].iov_len = (buf->strlen == AP_VARBUF_UNKNOWN) ? buf->avail
- : buf->strlen;
+ vec[i].iov_len = buf->strlen;
i++;
}
if (append) {
AP_DECLARE(apr_status_t) ap_varbuf_regsub(struct ap_varbuf *vb,
const char *input,
- const char *source, size_t nmatch,
+ const char *source,
+ apr_size_t nmatch,
ap_regmatch_t pmatch[],
apr_size_t maxlen)
{
ap_abort_on_oom();
return p;
}
+
+AP_DECLARE(void) ap_get_sload(ap_sload_t *ld)
+{
+ int i, j, server_limit, thread_limit;
+ int ready = 0;
+ int busy = 0;
+ int total;
+ ap_generation_t mpm_generation;
+
+ /* preload errored fields, we overwrite */
+ ld->idle = -1;
+ ld->busy = -1;
+ ld->bytes_served = 0;
+ ld->access_count = 0;
+
+ ap_mpm_query(AP_MPMQ_GENERATION, &mpm_generation);
+ ap_mpm_query(AP_MPMQ_HARD_LIMIT_THREADS, &thread_limit);
+ ap_mpm_query(AP_MPMQ_HARD_LIMIT_DAEMONS, &server_limit);
+
+ for (i = 0; i < server_limit; i++) {
+ process_score *ps;
+ ps = ap_get_scoreboard_process(i);
+
+ for (j = 0; j < thread_limit; j++) {
+ int res;
+ worker_score *ws = NULL;
+ ws = &ap_scoreboard_image->servers[i][j];
+ res = ws->status;
+
+ if (!ps->quiescing && ps->pid) {
+ if (res == SERVER_READY && ps->generation == mpm_generation) {
+ ready++;
+ }
+ else if (res != SERVER_DEAD &&
+ res != SERVER_STARTING && res != SERVER_IDLE_KILL &&
+ ps->generation == mpm_generation) {
+ busy++;
+ }
+ }
+
+ if (ap_extended_status && !ps->quiescing && ps->pid) {
+ if (ws->access_count != 0
+ || (res != SERVER_READY && res != SERVER_DEAD)) {
+ ld->access_count += ws->access_count;
+ ld->bytes_served += ws->bytes_served;
+ }
+ }
+ }
+ }
+ total = busy + ready;
+ if (total) {
+ ld->idle = ready * 100 / total;
+ ld->busy = busy * 100 / total;
+ }
+}
+
+AP_DECLARE(void) ap_get_loadavg(ap_loadavg_t *ld)
+{
+ /* preload errored fields, we overwrite */
+ ld->loadavg = -1.0;
+ ld->loadavg5 = -1.0;
+ ld->loadavg15 = -1.0;
+
+#if HAVE_GETLOADAVG
+ {
+ double la[3];
+ int num;
+
+ num = getloadavg(la, 3);
+ if (num > 0) {
+ ld->loadavg = (float)la[0];
+ }
+ if (num > 1) {
+ ld->loadavg5 = (float)la[1];
+ }
+ if (num > 2) {
+ ld->loadavg15 = (float)la[2];
+ }
+ }
+#endif
+}
+
+static const char * const pw_cache_note_name = "conn_cache_note";
+struct pw_cache {
+ /* varbuf contains concatenated password and hash */
+ struct ap_varbuf vb;
+ apr_size_t pwlen;
+ apr_status_t result;
+};
+
+AP_DECLARE(apr_status_t) ap_password_validate(request_rec *r,
+ const char *username,
+ const char *passwd,
+ const char *hash)
+{
+ struct pw_cache *cache;
+ apr_size_t hashlen;
+
+ cache = (struct pw_cache *)apr_table_get(r->connection->notes, pw_cache_note_name);
+ if (cache != NULL) {
+ if (strncmp(passwd, cache->vb.buf, cache->pwlen) == 0
+ && strcmp(hash, cache->vb.buf + cache->pwlen) == 0) {
+ return cache->result;
+ }
+ /* make ap_varbuf_grow below not copy the old data */
+ cache->vb.strlen = 0;
+ }
+ else {
+ cache = apr_palloc(r->connection->pool, sizeof(struct pw_cache));
+ ap_varbuf_init(r->connection->pool, &cache->vb, 0);
+ apr_table_setn(r->connection->notes, pw_cache_note_name, (void *)cache);
+ }
+ cache->pwlen = strlen(passwd);
+ hashlen = strlen(hash);
+ ap_varbuf_grow(&cache->vb, cache->pwlen + hashlen + 1);
+ memcpy(cache->vb.buf, passwd, cache->pwlen);
+ memcpy(cache->vb.buf + cache->pwlen, hash, hashlen + 1);
+ cache->result = apr_password_validate(passwd, hash);
+ return cache->result;
+}
+
+AP_DECLARE(char *) ap_get_exec_line(apr_pool_t *p,
+ const char *cmd,
+ const char * const * argv)
+{
+ char buf[MAX_STRING_LEN];
+ apr_procattr_t *procattr;
+ apr_proc_t *proc;
+ apr_file_t *fp;
+ apr_size_t nbytes = 1;
+ char c;
+ int k;
+
+ if (apr_procattr_create(&procattr, p) != APR_SUCCESS)
+ return NULL;
+ if (apr_procattr_io_set(procattr, APR_FULL_BLOCK, APR_FULL_BLOCK,
+ APR_FULL_BLOCK) != APR_SUCCESS)
+ return NULL;
+ if (apr_procattr_dir_set(procattr,
+ ap_make_dirstr_parent(p, cmd)) != APR_SUCCESS)
+ return NULL;
+ if (apr_procattr_cmdtype_set(procattr, APR_PROGRAM) != APR_SUCCESS)
+ return NULL;
+ proc = apr_pcalloc(p, sizeof(apr_proc_t));
+ if (apr_proc_create(proc, cmd, argv, NULL, procattr, p) != APR_SUCCESS)
+ return NULL;
+ fp = proc->out;
+
+ if (fp == NULL)
+ return NULL;
+ /* XXX: we are reading 1 byte at a time here */
+ for (k = 0; apr_file_read(fp, &c, &nbytes) == APR_SUCCESS
+ && nbytes == 1 && (k < MAX_STRING_LEN-1) ; ) {
+ if (c == '\n' || c == '\r')
+ break;
+ buf[k++] = c;
+ }
+ buf[k] = '\0';
+ apr_file_close(fp);
+
+ return apr_pstrndup(p, buf, k);
+}
projects / apache / blobdiff