Browse Source

[multiple] extern log_epoch_secs

replace srv->cur_ts
personal/stbuehler/ci-build
Glenn Strauss 2 years ago
parent
commit
c8cd7cf49b
  1. 3
      src/base.h
  2. 2
      src/connections-glue.c
  3. 46
      src/connections.c
  4. 28
      src/gw_backend.c
  5. 9
      src/log.c
  6. 5
      src/log.h
  7. 13
      src/mod_accesslog.c
  8. 4
      src/mod_auth.c
  9. 2
      src/mod_expire.c
  10. 4
      src/mod_rrdtool.c
  11. 2
      src/mod_secdownload.c
  12. 6
      src/mod_status.c
  13. 5
      src/mod_trigger_b4_dl.c
  14. 2
      src/mod_usertrack.c
  15. 4
      src/mod_wstunnel.c
  16. 2
      src/response.c
  17. 19
      src/server.c
  18. 10
      src/stat_cache.c
  19. 3
      src/t/test_keyvalue.c
  20. 2
      src/t/test_request.c

3
src/base.h

@ -348,9 +348,6 @@ struct server {
uint32_t max_conns;
/* Timestamps */
time_t cur_ts;
log_error_st *errh;
server_config srvconf;

2
src/connections-glue.c

@ -418,7 +418,7 @@ handler_t connection_handle_read_post_state(connection *con) {
int is_closed = 0;
if (con->is_readable) {
con->read_idle_ts = con->srv->cur_ts;
con->read_idle_ts = log_epoch_secs;
switch(con->network_read(con, con->read_queue, MAX_READ_LIMIT)) {
case -1:

46
src/connections.c

@ -152,7 +152,7 @@ static int connection_close(server *srv, connection *con) {
return 0;
}
static void connection_read_for_eos_plain(connection * const con, const time_t cur_ts) {
static void connection_read_for_eos_plain(connection * const con) {
/* we have to do the linger_on_close stuff regardless
* of con->keep_alive; even non-keepalive sockets may
* still have unread data, and closing before reading
@ -172,26 +172,25 @@ static void connection_read_for_eos_plain(connection * const con, const time_t c
#endif
/* 0 == len || (len < 0 && (errno is a non-recoverable error)) */
con->close_timeout_ts = cur_ts - (HTTP_LINGER_TIMEOUT+1);
con->close_timeout_ts = log_epoch_secs - (HTTP_LINGER_TIMEOUT+1);
}
static void connection_read_for_eos_ssl(connection * const con, const time_t cur_ts) {
static void connection_read_for_eos_ssl(connection * const con) {
if (con->network_read(con, con->read_queue, MAX_READ_LIMIT) < 0)
con->close_timeout_ts = cur_ts - (HTTP_LINGER_TIMEOUT+1);
con->close_timeout_ts = log_epoch_secs - (HTTP_LINGER_TIMEOUT+1);
chunkqueue_reset(con->read_queue);
}
static void connection_read_for_eos(connection * const con, const time_t cur_ts) {
static void connection_read_for_eos(connection * const con) {
!con->is_ssl_sock
? connection_read_for_eos_plain(con, cur_ts)
: connection_read_for_eos_ssl(con, cur_ts);
? connection_read_for_eos_plain(con)
: connection_read_for_eos_ssl(con);
}
static void connection_handle_close_state(server *srv, connection *con) {
const time_t cur_ts = srv->cur_ts;
connection_read_for_eos(con, cur_ts);
connection_read_for_eos(con);
if (cur_ts - con->close_timeout_ts > HTTP_LINGER_TIMEOUT) {
if (log_epoch_secs - con->close_timeout_ts > HTTP_LINGER_TIMEOUT) {
connection_close(srv, con);
}
}
@ -206,7 +205,7 @@ static void connection_handle_shutdown(connection *con) {
/* close the connection */
if (con->fd >= 0
&& (con->is_ssl_sock || 0 == shutdown(con->fd, SHUT_WR))) {
con->close_timeout_ts = srv->cur_ts;
con->close_timeout_ts = log_epoch_secs;
connection_set_state(con, CON_STATE_CLOSE);
if (srv->srvconf.log_state_handling) {
@ -241,8 +240,7 @@ static void connection_handle_response_end_state(connection *con) {
if (con->keep_alive) {
connection_reset(con);
#if 0
con->request_start = con->srv->cur_ts;
con->read_idle_ts = con->srv->cur_ts;
con->request_start = con->read_idle_ts = log_epoch_secs;
#endif
connection_set_state(con, CON_STATE_REQUEST_START);
} else {
@ -485,7 +483,7 @@ static void connection_handle_write(connection *con) {
/* not finished yet -> WRITE */
break;
}
con->write_request_ts = con->srv->cur_ts;
con->write_request_ts = log_epoch_secs;
}
static void connection_handle_write_state(connection *con) {
@ -719,7 +717,7 @@ static void connection_discard_blank_line(connection *con, const char * const s,
static chunk * connection_read_header_more(connection *con, chunkqueue *cq, chunk *c, const size_t olen) {
if ((NULL == c || NULL == c->next) && con->is_readable) {
con->read_idle_ts = con->srv->cur_ts;
con->read_idle_ts = log_epoch_secs;
if (0 != con->network_read(con, cq, MAX_READ_LIMIT))
connection_set_state(con, CON_STATE_ERROR);
}
@ -816,11 +814,11 @@ static int connection_handle_read_state(server * const srv, connection * const c
if (0 != con->bytes_read) {
/* update request_start timestamp when first byte of
* next request is received on a keep-alive connection */
con->request_start = srv->cur_ts;
con->request_start = log_epoch_secs;
if (con->conf.high_precision_timestamps)
log_clock_gettime_realtime(&con->request_start_hp);
}
if (pipelined_request_start && c) con->read_idle_ts = srv->cur_ts;
if (pipelined_request_start && c) con->read_idle_ts = log_epoch_secs;
}
if (NULL == c) return 0; /* incomplete request headers */
@ -904,7 +902,7 @@ static handler_t connection_handle_fdevent(server *srv, void *context, int reven
if (con->state == CON_STATE_CLOSE) {
/* flush the read buffers */
connection_read_for_eos(con, srv->cur_ts);
connection_read_for_eos(con);
}
@ -913,7 +911,7 @@ static handler_t connection_handle_fdevent(server *srv, void *context, int reven
if ((revents & ~(FDEVENT_IN | FDEVENT_OUT)) && con->state != CON_STATE_ERROR) {
if (con->state == CON_STATE_CLOSE) {
con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
con->close_timeout_ts = log_epoch_secs - (HTTP_LINGER_TIMEOUT+1);
} else if (revents & FDEVENT_HUP) {
connection_set_state(con, CON_STATE_ERROR);
} else if (revents & FDEVENT_RDHUP) {
@ -1118,7 +1116,7 @@ connection *connection_accepted(server *srv, server_socket *srv_socket, sock_add
connection_set_state(con, CON_STATE_REQUEST_START);
con->connection_start = srv->cur_ts;
con->connection_start = log_epoch_secs;
con->dst_addr = *cnt_addr;
buffer_copy_string(con->dst_addr_buf, inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
con->srv_socket = srv_socket;
@ -1265,7 +1263,7 @@ int connection_state_machine(server *srv, connection *con) {
switch ((ostate = con->state)) {
case CON_STATE_REQUEST_START: /* transient */
con->request_start = con->read_idle_ts = srv->cur_ts;
con->request_start = con->read_idle_ts = log_epoch_secs;
if (con->conf.high_precision_timestamps)
log_clock_gettime_realtime(&con->request_start_hp);
@ -1374,10 +1372,10 @@ int connection_state_machine(server *srv, connection *con) {
if (r != events) {
/* update timestamps when enabling interest in events */
if ((r & FDEVENT_IN) && !(events & FDEVENT_IN)) {
con->read_idle_ts = srv->cur_ts;
con->read_idle_ts = log_epoch_secs;
}
if ((r & FDEVENT_OUT) && !(events & FDEVENT_OUT)) {
con->write_request_ts = srv->cur_ts;
con->write_request_ts = log_epoch_secs;
}
fdevent_fdnode_event_set(srv->ev, con->fdn, r);
}
@ -1491,7 +1489,7 @@ void connection_graceful_shutdown_maint (server *srv) {
* (from zero) *up to* one more second, but no more */
if (HTTP_LINGER_TIMEOUT > 1)
con->close_timeout_ts -= (HTTP_LINGER_TIMEOUT - 1);
if (srv->cur_ts - con->close_timeout_ts > HTTP_LINGER_TIMEOUT)
if (log_epoch_secs - con->close_timeout_ts > HTTP_LINGER_TIMEOUT)
changed = 1;
}
else if (con->state == CON_STATE_READ && con->request_count > 1

28
src/gw_backend.c

@ -213,7 +213,7 @@ static int gw_extension_insert(gw_exts *ext, const buffer *key, gw_host *fh) {
static void gw_proc_connect_success(connection *con, gw_host *host, gw_proc *proc, int debug) {
gw_proc_tag_inc(host, proc, CONST_STR_LEN(".connected"));
proc->last_used = con->srv->cur_ts;
proc->last_used = log_epoch_secs;
if (debug) {
log_error(con->conf.errh, __FILE__, __LINE__,
@ -224,7 +224,7 @@ static void gw_proc_connect_success(connection *con, gw_host *host, gw_proc *pro
__attribute_cold__
static void gw_proc_connect_error(connection *con, gw_host *host, gw_proc *proc, pid_t pid, int errnum, int debug) {
const time_t cur_ts = con->srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
log_error_st * const errh = con->conf.errh;
log_error(errh, __FILE__, __LINE__,
"establishing connection failed: socket: %s: %s",
@ -298,7 +298,7 @@ static void gw_proc_release(gw_host *host, gw_proc *proc, int debug, log_error_s
}
static void gw_proc_check_enable(server *srv, gw_host *host, gw_proc *proc) {
if (srv->cur_ts <= proc->disabled_until) return;
if (log_epoch_secs <= proc->disabled_until) return;
if (proc->state != PROC_STATE_OVERLOADED) return;
gw_proc_set_state(host, proc, PROC_STATE_RUNNING);
@ -353,7 +353,7 @@ static int gw_proc_waitpid(server *srv, gw_host *host, gw_proc *proc) {
proc->pid = 0;
if (proc->state != PROC_STATE_KILLED)
proc->disabled_until = srv->cur_ts;
proc->disabled_until = log_epoch_secs;
gw_proc_set_state(host, proc, PROC_STATE_DIED);
return 1;
}
@ -572,12 +572,12 @@ static int gw_spawn_connection(server *srv, gw_host *host, gw_proc *proc, int de
log_error(srv->errh, __FILE__, __LINE__,
"gw-backend failed to start: %s", host->bin_path->ptr);
proc->pid = 0;
proc->disabled_until = srv->cur_ts;
proc->disabled_until = log_epoch_secs;
return -1;
}
/* register process */
proc->last_used = srv->cur_ts;
proc->last_used = log_epoch_secs;
proc->is_local = 1;
/* wait */
@ -614,7 +614,7 @@ static void gw_proc_spawn(server *srv, gw_host *host, int debug) {
/* (proc->pid <= 0 indicates PROC_STATE_DIED, not PROC_STATE_KILLED) */
if (proc->pid > 0) continue;
/* (do not attempt to spawn another proc if a proc just exited) */
if (proc->disabled_until >= srv->cur_ts) return;
if (proc->disabled_until >= log_epoch_secs) return;
break;
}
if (proc) {
@ -995,7 +995,7 @@ static void gw_restart_dead_procs(server *srv, gw_host *host, int debug, int tri
/*(state should not happen in workers if server.max-worker > 0)*/
/*(if PROC_STATE_DIED_WAIT_FOR_PID is used in future, might want
* to save proc->disabled_until before gw_proc_waitpid() since
* gw_proc_waitpid will set proc->disabled_until to srv->cur_ts,
* gw_proc_waitpid will set proc->disabled_until to log_epoch_secs,
* and so process will not be restarted below until one sec later)*/
if (0 == gw_proc_waitpid(srv, host, proc)) {
gw_proc_check_enable(srv, host, proc);
@ -1014,7 +1014,7 @@ static void gw_restart_dead_procs(server *srv, gw_host *host, int debug, int tri
if (proc->load != 0) break;
/* avoid spinning if child exits too quickly */
if (proc->disabled_until >= srv->cur_ts) break;
if (proc->disabled_until >= log_epoch_secs) break;
/* restart the child */
@ -1723,7 +1723,7 @@ int gw_get_defaults_balance(server *srv, const buffer *b) {
static void gw_set_state(gw_handler_ctx *hctx, gw_connection_state_t state) {
hctx->state = state;
/*hctx->state_timestamp = hctx->remote_conn->srv->cur_ts;*/
/*hctx->state_timestamp = log_epoch_secs;*/
}
@ -2144,7 +2144,7 @@ static handler_t gw_recv_response(gw_handler_ctx *hctx, connection *con) {
physpath = con->physical.path;
}
proc->last_used = con->srv->cur_ts;
proc->last_used = log_epoch_secs;
gw_backend_close(hctx, con);
handler_ctx_clear(hctx);
@ -2185,7 +2185,7 @@ static handler_t gw_recv_response(gw_handler_ctx *hctx, connection *con) {
&& proc->state != PROC_STATE_DIED
&& 0 == con->srv->srvconf.max_worker) {
/* intentionally check proc->disabed_until before gw_proc_waitpid */
if (proc->disabled_until < con->srv->cur_ts
if (proc->disabled_until < log_epoch_secs
&& 0 != gw_proc_waitpid(con->srv, host, proc)) {
if (hctx->conf.debug) {
log_error(errh, __FILE__, __LINE__,
@ -2560,7 +2560,7 @@ static void gw_handle_trigger_host(server *srv, gw_host *host, int debug) {
gw_proc_spawn(srv, host, debug);
}
idle_timestamp = srv->cur_ts - host->idle_timeout;
idle_timestamp = log_epoch_secs - host->idle_timeout;
for (proc = host->first; proc; proc = proc->next) {
if (host->num_procs <= host->min_procs) break;
if (0 != proc->load) continue;
@ -2676,7 +2676,7 @@ handler_t gw_handle_waitpid_cb(server *srv, void *p_d, pid_t pid, int status) {
* or global scope (for convenience))
* (unable to use p->defaults.debug since gw_plugin_config
* might be part of a larger plugin_config) */
const time_t cur_ts = srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
gw_exts *exts = conf->exts;
for (uint32_t j = 0; j < exts->used; ++j) {
gw_extension *ex = exts->exts+j;

9
src/log.c

@ -27,6 +27,8 @@
#endif
#endif
time_t log_epoch_secs = 0;
int log_clock_gettime_realtime (struct timespec *ts) {
#ifdef HAVE_CLOCK_GETTIME
return clock_gettime(CLOCK_REALTIME, ts);
@ -81,8 +83,8 @@ static int log_buffer_prepare(const log_error_st *errh, const char *filename, un
case ERRORLOG_FD:
if (-1 == errh->errorlog_fd) return -1;
/* cache the generated timestamp */
if (tlast != *errh->cur_ts) {
tlast = *errh->cur_ts;
if (tlast != log_epoch_secs) {
tlast = log_epoch_secs;
tlen = strftime(tstr, sizeof(tstr),
"%Y-%m-%d %H:%M:%S", localtime(&tlast));
}
@ -249,14 +251,13 @@ log_error_multiline_buffer (const log_error_st * const restrict errh,
log_error_st *
log_error_st_init (time_t *cur_ts_ptr)
log_error_st_init (void)
{
log_error_st *errh = calloc(1, sizeof(log_error_st));
force_assert(errh);
errh->errorlog_fd = STDERR_FILENO;
errh->errorlog_mode = ERRORLOG_FD;
errh->b = buffer_init();
errh->cur_ts = cur_ts_ptr;
return errh;
}

5
src/log.h

@ -5,6 +5,8 @@
#include "base_decls.h"
#include "buffer.h"
extern time_t log_epoch_secs;
struct timespec; /* declaration */
int log_clock_gettime_realtime (struct timespec *ts);
@ -14,11 +16,10 @@ struct log_error_st {
enum { ERRORLOG_FILE, ERRORLOG_FD, ERRORLOG_SYSLOG, ERRORLOG_PIPE } errorlog_mode;
int errorlog_fd;
buffer *b;
time_t *cur_ts;
};
__attribute_cold__
log_error_st * log_error_st_init (time_t *cur_ts_ptr);
log_error_st * log_error_st_init (void);
__attribute_cold__
void log_error_st_free (log_error_st *errh);

13
src/mod_accesslog.c

@ -733,9 +733,10 @@ static void log_access_flush(plugin_data * const p) {
}
TRIGGER_FUNC(log_access_periodic_flush) {
/* flush buffered access logs every 4 seconds */
if (0 == (srv->cur_ts & 3)) log_access_flush((plugin_data *)p_d);
return HANDLER_GO_ON;
/* flush buffered access logs every 4 seconds */
if (0 == (log_epoch_secs & 3)) log_access_flush((plugin_data *)p_d);
UNUSED(srv);
return HANDLER_GO_ON;
}
SIGHUP_FUNC(log_access_cycle) {
@ -798,7 +799,7 @@ REQUESTDONE_FUNC(log_access_write) {
if (f->opt & ~(FORMAT_FLAG_TIME_BEGIN|FORMAT_FLAG_TIME_END)) {
if (f->opt & FORMAT_FLAG_TIME_SEC) {
time_t t = (!(f->opt & FORMAT_FLAG_TIME_BEGIN)) ? con->srv->cur_ts : con->request_start;
time_t t = (!(f->opt & FORMAT_FLAG_TIME_BEGIN)) ? log_epoch_secs : con->request_start;
buffer_append_int(b, (intmax_t)t);
} else if (f->opt & (FORMAT_FLAG_TIME_MSEC|FORMAT_FLAG_TIME_USEC|FORMAT_FLAG_TIME_NSEC)) {
off_t t; /*(expected to be 64-bit since large file support enabled)*/
@ -863,7 +864,7 @@ REQUESTDONE_FUNC(log_access_write) {
#endif /* HAVE_STRUCT_TM_GMTOFF */
if (!(f->opt & FORMAT_FLAG_TIME_BEGIN)) {
const time_t cur_ts = con->srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
if (parsed_format->last_generated_accesslog_ts == cur_ts) {
buffer_append_string_buffer(b, ts_accesslog_str);
break;
@ -920,7 +921,7 @@ REQUESTDONE_FUNC(log_access_write) {
case FORMAT_TIME_USED:
case FORMAT_TIME_USED_US:
if (f->opt & FORMAT_FLAG_TIME_SEC) {
buffer_append_int(b, con->srv->cur_ts - con->request_start);
buffer_append_int(b, log_epoch_secs - con->request_start);
} else {
const struct timespec * const bs = &con->request_start_hp;
off_t tdiff; /*(expected to be 64-bit since large file support enabled)*/

4
src/mod_auth.c

@ -1171,7 +1171,7 @@ static handler_t mod_auth_check_digest(connection *con, void *p_d, const struct
for (i = 0; i < 8 && light_isxdigit(nonce_uns[i]); ++i) {
ts = (ts << 4) + hex2int(nonce_uns[i]);
}
const time_t cur_ts = con->srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
if (nonce[i] != ':'
|| ts > cur_ts || cur_ts - ts > 600) { /*(10 mins)*/
/* nonce is stale; have client regenerate digest */
@ -1197,7 +1197,7 @@ static handler_t mod_auth_check_digest(connection *con, void *p_d, const struct
static handler_t mod_auth_send_401_unauthorized_digest(connection *con, const struct http_auth_require_t *require, int nonce_stale) {
server *srv = con->srv;
mod_auth_digest_www_authenticate(srv->tmp_buf, srv->cur_ts, require, nonce_stale);
mod_auth_digest_www_authenticate(srv->tmp_buf, log_epoch_secs, require, nonce_stale);
http_header_response_set(con, HTTP_HEADER_OTHER, CONST_STR_LEN("WWW-Authenticate"), CONST_BUF_LEN(srv->tmp_buf));
con->http_status = 401;

2
src/mod_expire.c

@ -307,7 +307,7 @@ CONNECTION_FUNC(mod_expire_handler) {
if (NULL != vb) {
time_t ts, expires;
const time_t cur_ts = con->srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
stat_cache_entry *sce = NULL;
switch(mod_expire_get_offset(con->conf.errh, vb, &ts)) {

4
src/mod_rrdtool.c

@ -357,7 +357,7 @@ static int mod_rrd_write_data(server *srv, plugin_data *p, rrd_config *s) {
s->bytes_read = 0;
}
else if (!(strstr(resp, "(minimum one second step)")
&& srv->cur_ts - srv->startup_ts < 3)) {
&& log_epoch_secs - srv->startup_ts < 3)) {
/* don't fail on this error if we just started (above condition)
* (graceful restart, the old one might have just updated too) */
log_error(srv->errh, __FILE__, __LINE__,
@ -391,7 +391,7 @@ TRIGGER_FUNC(mod_rrd_trigger) {
if (0 == p->rrdtool_pid) return HANDLER_GO_ON;
/* write data once a minute */
if ((srv->cur_ts % 60) != 0) return HANDLER_GO_ON;
if ((log_epoch_secs % 60) != 0) return HANDLER_GO_ON;
if (!p->rrdtool_running) {
if (srv->pid != p->srv_pid) return HANDLER_GO_ON;

2
src/mod_secdownload.c

@ -470,7 +470,7 @@ URIHANDLER_FUNC(mod_secdownload_uri_handler) {
ts = (ts << 4) + hex2int(ts_str[i]);
}
const time_t cur_ts = con->srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
/* timed-out */
if ( (cur_ts > ts && (unsigned int) (cur_ts - ts) > p->conf.timeout) ||

6
src/mod_status.c

@ -179,7 +179,7 @@ static handler_t mod_status_handle_server_status_html(server *srv, connection *c
char multiplier = '\0';
char buf[32];
time_t ts;
const time_t cur_ts = srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
int days, hours, mins, seconds;
@ -590,7 +590,7 @@ static handler_t mod_status_handle_server_status_text(server *srv, connection *c
/* output uptime */
buffer_append_string_len(b, CONST_STR_LEN("Uptime: "));
buffer_append_int(b, srv->cur_ts - srv->startup_ts);
buffer_append_int(b, log_epoch_secs - srv->startup_ts);
buffer_append_string_len(b, CONST_STR_LEN("\n"));
/* output busy servers */
@ -664,7 +664,7 @@ static handler_t mod_status_handle_server_status_json(server *srv, connection *c
/* output uptime */
buffer_append_string_len(b, CONST_STR_LEN("\t\"Uptime\": "));
buffer_append_int(b, srv->cur_ts - srv->startup_ts);
buffer_append_int(b, log_epoch_secs - srv->startup_ts);
buffer_append_string_len(b, CONST_STR_LEN(",\n"));
/* output busy servers */

5
src/mod_trigger_b4_dl.c

@ -397,7 +397,7 @@ URIHANDLER_FUNC(mod_trigger_b4_dl_uri_handler) {
log_error(con->conf.errh, __FILE__, __LINE__, "(debug) remote-ip: %s", remote_ip->ptr);
}
const time_t cur_ts = con->srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
/* check if URL is a trigger -> insert IP into DB */
if ((n = pcre_exec(p->conf.trigger_regex, NULL, CONST_BUF_LEN(con->uri.path), 0, 0, ovec, 3 * N)) < 0) {
@ -560,8 +560,9 @@ static void mod_trigger_b4_dl_trigger_gdbm(GDBM_FILE db, const time_t cur_ts, co
TRIGGER_FUNC(mod_trigger_b4_dl_handle_trigger) {
/* check DB each minute */
const time_t cur_ts = srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
if (cur_ts % 60 != 0) return HANDLER_GO_ON;
UNUSED(srv);
plugin_data * const p = p_d;

2
src/mod_usertrack.c

@ -168,7 +168,7 @@ static handler_t mod_usertrack_set_cookie(connection *con, plugin_data *p) {
li_MD5_Update(&Md5Ctx, CONST_BUF_LEN(con->uri.path));
li_MD5_Update(&Md5Ctx, CONST_STR_LEN("+"));
len = li_itostrn(hh, sizeof(hh), con->srv->cur_ts);
len = li_itostrn(hh, sizeof(hh), log_epoch_secs);
li_MD5_Update(&Md5Ctx, (unsigned char *)hh, len);
len = li_itostrn(hh, sizeof(hh), li_rand_pseudo());
li_MD5_Update(&Md5Ctx, (unsigned char *)hh, len);

4
src/mod_wstunnel.c

@ -377,7 +377,7 @@ static handler_t wstunnel_create_env(gw_handler_ctx *gwhctx) {
con->http_status = 101; /* Switching Protocols */
con->file_started = 1;
hctx->ping_ts = con->srv->cur_ts;
hctx->ping_ts = log_epoch_secs;
gw_set_transparent(&hctx->gw);
return HANDLER_GO_ON;
@ -604,7 +604,7 @@ static handler_t mod_wstunnel_check_extension(connection *con, void *p_d) {
TRIGGER_FUNC(mod_wstunnel_handle_trigger) {
const plugin_data * const p = p_d;
const time_t cur_ts = srv->cur_ts + 1;
const time_t cur_ts = log_epoch_secs + 1;
gw_handle_trigger(srv, p_d);

2
src/response.c

@ -103,7 +103,7 @@ int http_response_write_header(connection *con) {
buffer_append_string_len(b, CONST_STR_LEN("\r\nDate: "));
/* cache the generated timestamp */
const time_t cur_ts = con->srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
if (tlast != cur_ts) {
tlast = cur_ts;
tlen = strftime(tstr, sizeof(tstr),

19
src/server.c

@ -246,10 +246,9 @@ static server *server_init(void) {
li_rand_reseed();
srv->cur_ts = time(NULL);
srv->startup_ts = srv->cur_ts;
srv->startup_ts = log_epoch_secs = time(NULL);
srv->errh = log_error_st_init(&srv->cur_ts);
srv->errh = log_error_st_init();
config_init(srv);
@ -1418,7 +1417,7 @@ static int server_main (server * const srv, int argc, char **argv) {
int status;
if (-1 != (pid = wait(&status))) {
srv->cur_ts = time(NULL);
log_epoch_secs = time(NULL);
if (plugins_call_handle_waitpid(srv, pid, status) != HANDLER_GO_ON) {
if (!timer) alarm((timer = 5));
continue;
@ -1442,7 +1441,7 @@ static int server_main (server * const srv, int argc, char **argv) {
} else {
switch (errno) {
case EINTR:
srv->cur_ts = time(NULL);
log_epoch_secs = time(NULL);
/**
* if we receive a SIGHUP we have to close our logs ourself as we don't
* have the mainloop who can help us here
@ -1461,7 +1460,7 @@ static int server_main (server * const srv, int argc, char **argv) {
handle_sig_alarm = 0;
timer = 0;
plugins_call_handle_trigger(srv);
fdevent_restart_logger_pipes(srv->cur_ts);
fdevent_restart_logger_pipes(log_epoch_secs);
}
break;
default:
@ -1620,7 +1619,7 @@ static void server_handle_sigalrm (server * const srv, time_t min_ts, time_t las
plugins_call_handle_trigger(srv);
srv->cur_ts = min_ts;
log_epoch_secs = min_ts;
/* check idle time limit, if enabled */
if (idle_limit && idle_limit < min_ts - last_active_ts && !graceful_shutdown) {
@ -1667,7 +1666,7 @@ static void server_handle_sigchld (server * const srv) {
}
if (0 == srv->srvconf.max_worker) {
/* check piped-loggers and restart, even if shutting down */
if (fdevent_waitpid_logger_pipe_pid(pid, srv->cur_ts)) {
if (fdevent_waitpid_logger_pipe_pid(pid, log_epoch_secs)) {
continue;
}
}
@ -1694,7 +1693,7 @@ static int server_main_loop (server * const srv) {
handle_sig_alarm = 0;
#endif
time_t min_ts = time(NULL);
if (min_ts != srv->cur_ts) {
if (min_ts != log_epoch_secs) {
server_handle_sigalrm(srv, min_ts, last_active_ts);
}
#ifdef USE_ALARM
@ -1725,7 +1724,7 @@ static int server_main_loop (server * const srv) {
}
if (fdevent_poll(srv->ev, 1000) > 0) {
last_active_ts = srv->cur_ts;
last_active_ts = log_epoch_secs;
}
for (uint32_t ndx = 0; ndx < joblist->used; ++ndx) {

10
src/stat_cache.c

@ -430,7 +430,7 @@ static fam_dir_entry * fam_dir_monitor(server *srv, stat_cache_fam *scf, char *f
/* directory already registered */
}
const time_t cur_ts = srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
struct stat lst;
int ck_dir = fn_is_dir;
if (!fn_is_dir && (NULL==fam_dir || cur_ts - fam_dir->stat_ts >= 16)) {
@ -733,7 +733,7 @@ void stat_cache_update_entry(server *srv, const char *name, size_t len,
stat_cache_entry *sce =
stat_cache_sptree_find(sptree, name, len);
if (sce && buffer_is_equal_string(sce->name, name, len)) {
sce->stat_ts = srv->cur_ts;
sce->stat_ts = log_epoch_secs;
sce->st = *st; /* etagb might be NULL to clear etag (invalidate) */
buffer_copy_string_len(sce->etag, CONST_BUF_LEN(etagb));
#if defined(HAVE_XATTR) || defined(HAVE_EXTATTR)
@ -894,7 +894,7 @@ handler_t stat_cache_get_entry(connection *con, buffer *name, stat_cache_entry *
*/
server * const srv = con->srv;
const time_t cur_ts = srv->cur_ts;
const time_t cur_ts = log_epoch_secs;
sc = srv->stat_cache;
@ -1114,7 +1114,7 @@ int stat_cache_trigger_cleanup(server *srv) {
#ifdef HAVE_FAM_H
if (srv->srvconf.stat_cache_engine == STAT_CACHE_ENGINE_FAM) {
if (srv->cur_ts & 0x1F) return 0;
if (log_epoch_secs & 0x1F) return 0;
/* once every 32 seconds (0x1F == 31) */
max_age = 32;
fam_dir_periodic_cleanup(srv);
@ -1125,7 +1125,7 @@ int stat_cache_trigger_cleanup(server *srv) {
}
#endif
stat_cache_periodic_cleanup(srv->stat_cache, max_age, srv->cur_ts);
stat_cache_periodic_cleanup(srv->stat_cache, max_age, log_epoch_secs);
return 0;
}

3
src/t/test_keyvalue.c

@ -13,10 +13,9 @@
#ifdef HAVE_PCRE_H
static pcre_keyvalue_buffer * test_keyvalue_test_kvb_init (void) {
static time_t cur_ts;
pcre_keyvalue_buffer *kvb = pcre_keyvalue_buffer_init();
log_error_st * const errh = log_error_st_init(&cur_ts);
log_error_st * const errh = log_error_st_init();
/* strings must be persistent for pcre_keyvalue_buffer_append() */
static const buffer kvstr[] = {

2
src/t/test_request.c

@ -581,7 +581,7 @@ int main (void)
connection con;
memset(&srv, 0, sizeof(server));
srv.errh = log_error_st_init(&srv.cur_ts);
srv.errh = log_error_st_init();
srv.errh->errorlog_fd = -1; /* (disable) */
memset(&con, 0, sizeof(connection));

Loading…
Cancel
Save