configure.in: Remove no-longer-used check for FMT_TIME_T.
src/*.c: Convert time_t and time adjustment values to unsigned long.
src/*.h: Likewise.
src/config.h.win32: Remove definition of FMT_TIME_T.
dnl Check for post-C89 keywords
AC_C_INLINE
-dnl Now figure out how to printf() a time_t
-AC_MSG_CHECKING(for time_t format)
-AC_CACHE_VAL(ac_cv_fmt_time_t, [
-ac_cv_fmt_time_t=no
-AC_COMPILE_IFELSE([#include <sys/types.h>
-#include <stdio.h>
-void myfunc(void) {
- time_t test=0;
- printf("%li", test);
-}], ac_cv_fmt_time_t="\"%li\"")
-if test $ac_cv_fmt_time_t = no; then
-AC_COMPILE_IFELSE([#include <sys/types.h>
-#include <stdio.h>
-void myfunc(void) {
- time_t test=0;
- printf("%i", test);
-}], ac_cv_fmt_time_t="\"%i\"")
-fi
-if test $ac_cv_fmt_time_t = no; then
-AC_MSG_ERROR([Cannot detect format string for time_t
-Please check sys/types.h for the typedef of time_t and submit to a developer])
-fi
-])
-AC_DEFINE_UNQUOTED(FMT_TIME_T, $ac_cv_fmt_time_t, [Define to printf format for a time_t variable])
-AC_MSG_RESULT($ac_cv_fmt_time_t)
-
dnl How to copy one va_list to another?
AC_CACHE_CHECK([for va_copy], ac_cv_c_va_copy, [AC_LINK_IFELSE(
[AC_LANG_PROGRAM([#include <stdarg.h>], [va_list ap1, ap2; va_copy(ap1, ap2);])],
unsigned long channel_expire_frequency;
unsigned long dnr_expire_frequency;
- long info_delay;
- unsigned int adjust_delay;
- long channel_expire_delay;
+ unsigned long info_delay;
+ unsigned long adjust_delay;
+ unsigned long channel_expire_delay;
unsigned int nodelete_level;
unsigned int adjust_threshold;
}
static struct userData*
-add_channel_user(struct chanData *channel, struct handle_info *handle, unsigned short access, time_t seen, const char *info)
+add_channel_user(struct chanData *channel, struct handle_info *handle, unsigned short access, unsigned long seen, const char *info)
{
struct userData *ud;
static void expire_ban(void *data);
static struct banData*
-add_channel_ban(struct chanData *channel, const char *mask, char *owner, time_t set, time_t triggered, time_t expires, char *reason)
+add_channel_ban(struct chanData *channel, const char *mask, char *owner, unsigned long set, unsigned long triggered, unsigned long expires, char *reason)
{
struct banData *bd;
unsigned int ii, l1, l2;
}
static struct do_not_register *
-chanserv_add_dnr(const char *chan_name, const char *setter, time_t expires, const char *reason)
+chanserv_add_dnr(const char *chan_name, const char *setter, unsigned long expires, const char *reason)
{
struct do_not_register *dnr = calloc(1, sizeof(*dnr)+strlen(reason));
safestrncpy(dnr->chan_name, chan_name, sizeof(dnr->chan_name));
struct userNode *user;
char buf1[INTERVALLEN];
char buf2[INTERVALLEN];
+ time_t feh;
user = extra;
if(dnr->set)
- strftime(buf1, sizeof(buf1), "%d %b %Y", localtime(&dnr->set));
+ {
+ feh = dnr->set;
+ strftime(buf1, sizeof(buf1), "%d %b %Y", localtime(&feh));
+ }
if(dnr->expires)
{
- strftime(buf2, sizeof(buf2), "%d %b %Y", localtime(&dnr->expires));
+ feh = dnr->expires;
+ strftime(buf2, sizeof(buf2), "%d %b %Y", localtime(&feh));
send_message(user, chanserv, "CSMSG_DNR_INFO_SET_EXPIRES", dnr->chan_name, buf1, dnr->setter, buf2, dnr->reason);
}
else if(dnr->set)
static CHANSERV_FUNC(cmd_noregister)
{
const char *target;
- time_t expiry, duration;
+ unsigned long expiry, duration;
unsigned int matches;
if(argc < 2)
char *chan_mask;
char *setter_mask;
char *reason_mask;
- time_t min_set, max_set;
- time_t min_expires, max_expires;
+ unsigned long min_set, max_set;
+ unsigned long min_expires, max_expires;
unsigned int limit;
};
struct banData *bData, *next;
char interval[INTERVALLEN];
unsigned int count;
- time_t limit;
+ unsigned long limit;
count = 0;
limit = now - duration;
struct userData *actor, *uData, *next;
char interval[INTERVALLEN];
unsigned int count;
- time_t limit;
+ unsigned long limit;
actor = GetChannelAccess(channel->channel_info, user->handle_info);
if(min_access > max_access)
/* If the ban matches an existing one exactly,
extend the expiration time if the provided
duration is longer. */
- if(duration && ((time_t)(now + duration) > bData->expires))
+ if(duration && (now + duration > bData->expires))
{
bData->expires = now + duration;
reset = 1;
static CHANSERV_FUNC(cmd_netinfo)
{
- extern time_t boot_time;
+ extern unsigned long boot_time;
extern unsigned long burst_length;
char interval[INTERVALLEN];
{
struct suspended *suspended;
char reason[MAXLEN];
- time_t expiry, duration;
+ unsigned long expiry, duration;
struct userData *uData;
REQUIRE_PARAMS(3);
char *name;
char *registrar;
- time_t unvisited;
- time_t registered;
+ unsigned long unvisited;
+ unsigned long registered;
unsigned long flags;
unsigned int limit;
static CHANSERV_FUNC(cmd_unvisited)
{
struct chanData *cData;
- time_t interval = chanserv_conf.channel_expire_delay;
+ unsigned long interval = chanserv_conf.channel_expire_delay;
char buffer[INTERVALLEN];
unsigned int limit = 25, matches = 0;
}
curr_user = owner;
}
- else if(!force && (now < (time_t)(cData->ownerTransfer + chanserv_conf.giveownership_period)))
+ else if(!force && (now < cData->ownerTransfer + chanserv_conf.giveownership_period))
{
char delay[INTERVALLEN];
intervalString(delay, cData->ownerTransfer + chanserv_conf.giveownership_period - now, user->handle_info);
struct handle_info *handle;
struct userData *uData;
char *seen, *inf, *flags;
- time_t last_seen;
+ unsigned long last_seen;
unsigned short access;
if(rd->type != RECDB_OBJECT || !dict_size(rd->d.object))
inf = database_get_data(rd->d.object, KEY_INFO, RECDB_QSTRING);
seen = database_get_data(rd->d.object, KEY_SEEN, RECDB_QSTRING);
- last_seen = seen ? (signed)strtoul(seen, NULL, 0) : now;
+ last_seen = seen ? strtoul(seen, NULL, 0) : now;
flags = database_get_data(rd->d.object, KEY_FLAGS, RECDB_QSTRING);
handle = get_handle_info(key);
if(!handle)
{
struct banData *bData;
char *set, *triggered, *s_duration, *s_expires, *reason, *owner;
- time_t set_time, triggered_time, expires_time;
+ unsigned long set_time, triggered_time, expires_time;
if(rd->type != RECDB_OBJECT || !dict_size(rd->d.object))
{
if (!reason || !owner)
return;
- set_time = set ? (time_t)strtoul(set, NULL, 0) : now;
- triggered_time = triggered ? (time_t)strtoul(triggered, NULL, 0) : 0;
+ set_time = set ? strtoul(set, NULL, 0) : now;
+ triggered_time = triggered ? strtoul(triggered, NULL, 0) : 0;
if(s_expires)
- expires_time = (time_t)strtoul(s_expires, NULL, 0);
+ expires_time = strtoul(s_expires, NULL, 0);
else if(s_duration)
expires_time = set_time + atoi(s_duration);
else
dict_t previous;
str = database_get_data(obj, KEY_EXPIRES, RECDB_QSTRING);
- suspended->expires = str ? (time_t)strtoul(str, NULL, 0) : 0;
+ suspended->expires = str ? strtoul(str, NULL, 0) : 0;
str = database_get_data(obj, KEY_REVOKED, RECDB_QSTRING);
- suspended->revoked = str ? (time_t)strtoul(str, NULL, 0) : 0;
+ suspended->revoked = str ? strtoul(str, NULL, 0) : 0;
str = database_get_data(obj, KEY_ISSUED, RECDB_QSTRING);
- suspended->issued = str ? (time_t)strtoul(str, NULL, 0) : 0;
+ suspended->issued = str ? strtoul(str, NULL, 0) : 0;
suspended->suspender = strdup(database_get_data(obj, KEY_SUSPENDER, RECDB_QSTRING));
suspended->reason = strdup(database_get_data(obj, KEY_REASON, RECDB_QSTRING));
previous = database_get_data(obj, KEY_PREVIOUS, RECDB_OBJECT);
}
str = database_get_data(channel, KEY_REGISTERED, RECDB_QSTRING);
- cData->registered = str ? (time_t)strtoul(str, NULL, 0) : now;
+ cData->registered = str ? strtoul(str, NULL, 0) : now;
str = database_get_data(channel, KEY_VISITED, RECDB_QSTRING);
- cData->visited = str ? (time_t)strtoul(str, NULL, 0) : now;
+ cData->visited = str ? strtoul(str, NULL, 0) : now;
str = database_get_data(channel, KEY_OWNER_TRANSFER, RECDB_QSTRING);
- cData->ownerTransfer = str ? (time_t)strtoul(str, NULL, 0) : 0;
+ cData->ownerTransfer = str ? strtoul(str, NULL, 0) : 0;
str = database_get_data(channel, KEY_MAX, RECDB_QSTRING);
cData->max = str ? atoi(str) : 0;
str = database_get_data(channel, KEY_GREETING, RECDB_QSTRING);
{
const char *setter, *reason, *str;
struct do_not_register *dnr;
- time_t expiry;
+ unsigned long expiry;
setter = database_get_data(hir->d.object, KEY_DNR_SETTER, RECDB_QSTRING);
if(!setter)
return;
}
str = database_get_data(hir->d.object, KEY_EXPIRES, RECDB_QSTRING);
- expiry = str ? (time_t)strtoul(str, NULL, 0) : 0;
+ expiry = str ? strtoul(str, NULL, 0) : 0;
if(expiry && expiry <= now)
return;
dnr = chanserv_add_dnr(key, setter, expiry, reason);
if(chanserv_conf.refresh_period)
{
- time_t next_refresh;
+ unsigned long next_refresh;
next_refresh = (now + chanserv_conf.refresh_period - 1) / chanserv_conf.refresh_period * chanserv_conf.refresh_period;
timeq_add(next_refresh, chanserv_refresh_topics, NULL);
}
struct chanNode *channel;
struct mod_chanmode modes;
- time_t registered;
- time_t visited;
- time_t limitAdjusted;
- time_t ownerTransfer;
+ unsigned long registered;
+ unsigned long visited;
+ unsigned long limitAdjusted;
+ unsigned long ownerTransfer;
char *topic;
char *greeting;
struct chanData *channel;
char *info;
- time_t seen;
+ unsigned long seen;
unsigned short access;
unsigned int present : 1;
unsigned int flags : USER_FLAGS_SIZE;
char owner[NICKLEN+1];
struct chanData *channel;
- time_t set;
- time_t triggered;
- time_t expires;
+ unsigned long set;
+ unsigned long triggered;
+ unsigned long expires;
char *reason;
struct chanData *cData;
char *suspender;
char *reason;
- time_t issued, expires, revoked;
+ unsigned long issued;
+ unsigned long expires;
+ unsigned long revoked;
struct suspended *previous;
};
{
char chan_name[CHANNELLEN+1];
char setter[NICKSERV_HANDLE_LEN+1];
- time_t set, expires;
+ unsigned long set;
+ unsigned long expires;
char reason[1];
};
/* and because saxdb is tied in to lots of stuff.. */
-time_t now;
+unsigned long now;
void *conf_get_data(UNUSED_ARG(const char *full_path), UNUSED_ARG(enum recdb_type type)) {
return NULL;
void reg_exit_func(UNUSED_ARG(exit_func_t handler)) {
}
-void timeq_add(UNUSED_ARG(time_t when), UNUSED_ARG(timeq_func func), UNUSED_ARG(void *data)) {
+void timeq_add(UNUSED_ARG(unsigned long when), UNUSED_ARG(timeq_func func), UNUSED_ARG(void *data)) {
}
-void timeq_del(UNUSED_ARG(time_t when), UNUSED_ARG(timeq_func func), UNUSED_ARG(void *data), UNUSED_ARG(int mask)) {
+void timeq_del(UNUSED_ARG(unsigned long when), UNUSED_ARG(timeq_func func), UNUSED_ARG(void *data), UNUSED_ARG(int mask)) {
}
int send_message(UNUSED_ARG(struct userNode *dest), UNUSED_ARG(struct userNode *src), UNUSED_ARG(const char *message), ...) {
# define verify(ptr) (void)(ptr)
#endif
-extern time_t now;
+extern unsigned long now;
extern int quit_services;
extern struct log_type *MAIN_LOG;
extern const char git_version[];
#define INTERVALLEN 50
struct handle_info;
-char *intervalString(char *output, time_t interval, struct handle_info *hi);
+char *intervalString(char *output, unsigned long interval, struct handle_info *hi);
int getipbyname(const char *name, unsigned long *ip);
int set_policer_param(const char *param, void *data, void *extra);
const char *strtab(unsigned int ii);
/* Define if tokenized P10 desired */
#define ENABLE_TOKENS 1
-/* Define to printf format for a time_t variable */
-#define FMT_TIME_T "%ld"
-
/* Define to 1 if you have `alloca', as a function or macro. */
#define HAVE_ALLOCA 1
static void
gline_expire(UNUSED_ARG(void *data))
{
- time_t stopped;
+ unsigned long stopped;
void *wraa;
stopped = 0;
}
struct gline *
-gline_add(const char *issuer, const char *target, unsigned long duration, const char *reason, time_t issued, time_t lastmod, int announce)
+gline_add(const char *issuer, const char *target, unsigned long duration, const char *reason, unsigned long issued, unsigned long lastmod, int announce)
{
struct gline *ent;
struct gline *prev_first;
ent = dict_find(gline_dict, target, NULL);
if (ent) {
heap_remove_pred(gline_heap, gline_for_p, (char*)target);
- if (ent->expires < (time_t)(now + duration))
+ if (ent->expires < now + duration)
ent->expires = now + duration;
if (ent->lastmod < lastmod)
ent->lastmod = lastmod;
{
struct record_data *rd = data;
const char *issuer, *reason, *dstr;
- time_t issued, expiration, lastmod;
+ unsigned long issued, expiration, lastmod;
if (!(reason = database_get_data(rd->d.object, KEY_REASON, RECDB_QSTRING))) {
log_module(MAIN_LOG, LOG_ERROR, "Missing reason for gline %s", key);
#include "hash.h"
struct gline {
- time_t issued;
- time_t lastmod;
- time_t expires;
+ unsigned long issued;
+ unsigned long lastmod;
+ unsigned long expires;
char *issuer;
char *target;
char *reason;
char *target_mask;
char *alt_target_mask;
char *reason_mask;
- time_t max_issued;
- time_t min_expire;
- time_t min_lastmod;
- time_t max_lastmod;
+ unsigned long max_issued;
+ unsigned long min_expire;
+ unsigned long min_lastmod;
+ unsigned long max_lastmod;
};
void gline_init(void);
-struct gline *gline_add(const char *issuer, const char *target, unsigned long duration, const char *reason, time_t issued, time_t lastmod, int announce);
+struct gline *gline_add(const char *issuer, const char *target, unsigned long duration, const char *reason, unsigned long issued, unsigned long lastmod, int announce);
struct gline *gline_find(const char *target);
int gline_remove(const char *target, int announce);
void gline_refresh_server(struct server *srv);
unsigned long id;
long flags;
- time_t posted;
+ unsigned long posted;
char posted_s[24];
unsigned long duration;
static struct service *global_service;
static struct globalMessage *messageList;
static long messageCount;
-static time_t last_max_alert;
+static unsigned long last_max_alert;
static struct log_type *G_LOG;
static struct
void message_expire(void *data);
static struct globalMessage*
-message_add(long flags, time_t posted, unsigned long duration, char *from, const char *msg)
+message_add(long flags, unsigned long posted, unsigned long duration, char *from, const char *msg)
{
struct globalMessage *message;
- struct tm tm;
+ time_t feh;
message = malloc(sizeof(struct globalMessage));
if(!message)
message->message = strdup(msg);
if ((flags & MESSAGE_OPTION_IMMEDIATE) == 0) {
- localtime_r(&message->posted, &tm);
+ feh = message->posted;
strftime(message->posted_s, sizeof(message->posted_s),
- "%I:%M %p, %m/%d/%Y", &tm);
+ "%I:%M %p, %m/%d/%Y", localtime(&feh));
}
if(messageList)
global_saxdb_read(struct dict *db)
{
struct record_data *hir;
- time_t posted;
+ unsigned long posted;
long flags;
unsigned long duration;
char *str, *from, *message;
dict_t clients;
dict_t servers;
unsigned int max_clients, invis_clients;
-time_t max_clients_time;
+unsigned long max_clients_time;
struct userList curr_opers;
static void hash_cleanup(void);
int rel_age;
static void
-wipeout_channel(struct chanNode *cNode, time_t new_time, char **modes, unsigned int modec) {
+wipeout_channel(struct chanNode *cNode, unsigned long new_time, char **modes, unsigned int modec) {
unsigned int orig_limit;
chan_mode_t orig_modes;
char orig_key[KEYLEN+1];
}
struct chanNode *
-AddChannel(const char *name, time_t time_, const char *modes, char *banlist)
+AddChannel(const char *name, unsigned long time_, const char *modes, char *banlist)
{
struct chanNode *cNode;
char new_modes[MAXLEN], *argv[MAXNUMPARAMS];
irc_in_addr_t ip; /* User's IP address */
long modes; /* user flags +isw etc... */
- time_t timestamp; /* Time of last nick change */
- time_t idle_since;
- struct server *uplink; /* Server that user is connected to */
+ unsigned long timestamp; /* Time of last nick change */
+ unsigned long idle_since; /* Last time user did something on or to a channel */
+ struct server *uplink; /* Server that user is connected to */
struct modeList channels; /* Vector of channels user is in */
/* from nickserv */
struct chanNode {
chan_mode_t modes;
- unsigned int limit, locks;
+ unsigned int limit;
+ unsigned int locks;
char key[KEYLEN + 1];
char upass[KEYLEN + 1];
char apass[KEYLEN + 1];
- time_t timestamp; /* creation time */
+ unsigned long timestamp; /* creation time */
char topic[TOPICLEN + 1];
char topic_nick[NICKLEN + 1];
- time_t topic_time;
+ unsigned long topic_time;
struct modeList members;
struct banList banlist;
struct banNode {
char ban[NICKLEN + USERLEN + HOSTLEN + 3]; /* 1 for '\0', 1 for ! and 1 for @ = 3 */
char who[NICKLEN + 1]; /* who set ban */
- time_t set; /* time ban was set */
+ unsigned long set; /* time ban was set */
};
struct modeNode {
struct userNode *user;
unsigned short modes;
short oplevel;
- time_t idle_since;
+ unsigned long idle_since;
};
#define SERVERNAMEMAX 64
struct server {
char name[SERVERNAMEMAX+1];
- time_t boot;
- time_t link;
+ unsigned long boot;
+ unsigned long link;
char description[SERVERDESCRIPTMAX+1];
#ifdef WITH_PROTOCOL_P10
char numeric[COMBO_NUMERIC_LEN+1];
extern dict_t clients;
extern dict_t servers;
extern unsigned int max_clients, invis_clients;
-extern time_t max_clients_time;
+extern unsigned long max_clients_time;
extern struct userList curr_opers, curr_helpers;
struct server* GetServerH(const char *name); /* using full name */
typedef void (*del_channel_func_t) (struct chanNode *chan);
void reg_del_channel_func(del_channel_func_t handler);
-struct chanNode* AddChannel(const char *name, time_t time_, const char *modes, char *banlist);
+struct chanNode* AddChannel(const char *name, unsigned long time_, const char *modes, char *banlist);
void LockChannel(struct chanNode *channel);
void UnlockChannel(struct chanNode *channel);
/* prepackaged comparators */
int
-int_comparator(const void *a, const void *b)
+ulong_comparator(const void *a, const void *b)
{
- return (time_t)a-(time_t)b;
+ return (unsigned long)a-(unsigned long)b;
}
/* useful comparators */
/* int strcmp(const char *s1, const char *s2); from <string.h> can be used */
-int int_comparator(const void*, const void*);
+int ulong_comparator(const void*, const void*);
int timeval_comparator(const void*, const void*);
#endif /* ndef HEAP_H */
}
gettimeofday(&now, NULL);
if (select_timeout) {
- log_module(MAIN_LOG, LOG_DEBUG, "%s, at "FMT_TIME_T".%06ld:%s (timeout "FMT_TIME_T".%06ld)", msg, now.tv_sec, now.tv_usec, buf, select_timeout->tv_sec, select_timeout->tv_usec);
+ log_module(MAIN_LOG, LOG_DEBUG, "%s, at %lu.%06lu:%s (timeout %lu.%06lu)", msg, (unsigned long)now.tv_sec, (unsigned long)now.tv_usec, buf, (unsigned long)select_timeout->tv_sec, (unsigned long)select_timeout->tv_usec);
} else {
- log_module(MAIN_LOG, LOG_DEBUG, "%s, at "FMT_TIME_T".%06ld:%s (no timeout)", msg, now.tv_sec, now.tv_usec, buf);
+ log_module(MAIN_LOG, LOG_DEBUG, "%s, at %lu.%06lu:%s (no timeout)", msg, (unsigned long)now.tv_sec, (unsigned long)now.tv_usec, buf);
}
}
#endif
ioset_run(void) {
extern struct io_fd *socket_io_fd;
struct timeval timeout;
- time_t wakey;
+ unsigned long wakey;
while (!quit_services) {
while (!socket_io_fd)
/* How long to sleep? (fill in select_timeout) */
wakey = timeq_next();
- if ((wakey - now) < 0)
+ if (wakey < now)
timeout.tv_sec = 0;
else
timeout.tv_sec = wakey - now;
/* remove old elements from the linked list */
while (type->log_count > type->max_count)
log_type_free_oldest(type);
- while (type->log_oldest && (type->log_oldest->time + (time_t)type->max_age < now))
+ while (type->log_oldest && (type->log_oldest->time + type->max_age < now))
log_type_free_oldest(type);
if (type->log_oldest)
type->log_oldest->prev = 0;
/* generic helper functions */
static void
-log_format_timestamp(time_t when, struct string_buffer *sbuf)
+log_format_timestamp(unsigned long when, struct string_buffer *sbuf)
{
struct tm local;
- localtime_r(&when, &local);
+ time_t feh;
+ feh = when;
+ localtime_r(&feh, &local);
if (sbuf->size < 24) {
sbuf->size = 24;
free(sbuf->list);
struct logEntry
{
/* field nullable in real entries? */
- time_t time;
- enum log_severity slvl;
+ unsigned long time; /* no */
+ enum log_severity slvl; /* no */
struct userNode *bot; /* no */
char *channel_name; /* yes */
char *user_nick; /* no */
char *user_account; /* yes */
char *user_hostmask; /* yes */
char *command; /* no */
- char *default_desc;
+ char *default_desc; /* no */
struct logEntry *next;
struct logEntry *prev;
};
{
struct logEntry masks;
struct log_type *type;
- time_t min_time;
- time_t max_time;
+ unsigned long min_time;
+ unsigned long max_time;
unsigned int limit;
unsigned int severities;
};
extern FILE *replay_file;
-time_t boot_time, burst_begin, now;
+unsigned long boot_time;
+unsigned long burst_begin;
+unsigned long now;
unsigned long burst_length;
struct log_type *MAIN_LOG;
{ "MSG_DB_UNKNOWN", "I do not know of a database named %s." },
{ "MSG_DB_IS_MONDO", "Database %s is in the \"mondo\" database and cannot be written separately." },
{ "MSG_DB_WRITE_ERROR", "Error while writing database %s." },
- { "MSG_DB_WROTE_DB", "Wrote database %s (in "FMT_TIME_T".%06lu seconds)." },
- { "MSG_DB_WROTE_ALL", "Wrote all databases (in "FMT_TIME_T".%06lu seconds)." },
+ { "MSG_DB_WROTE_DB", "Wrote database %s (in %lu.%06lu seconds)." },
+ { "MSG_DB_WROTE_ALL", "Wrote all databases (in %lu.%06lu seconds)." },
{ "MSG_AND", "and" },
{ "MSG_0_SECONDS", "0 seconds" },
{ "MSG_YEAR", "year" },
* mostly to get the right value of "now" for when we do the
* irc_introduce. */
replay_read_line();
- boot_time = now;
} else {
- boot_time = time(&now);
+ now = time(NULL);
}
+ boot_time = now;
fprintf(stdout, "Initializing daemon...\n");
if (!conf_read(services_config)) {
free(msg);
}
} else {
- srand(time(&now));
+ now = time(NULL);
+ srand(now);
ioset_run();
}
return 0;
/* General */
#define HSFMT_TIME "%a, %d %b %Y %H:%M:%S %Z"
static const struct message_entry msgtab[] = {
- { "HSMSG_READHELP_SUCCESS", "Read HelpServ help database in "FMT_TIME_T".%03ld seconds." },
+ { "HSMSG_READHELP_SUCCESS", "Read HelpServ help database in %lu.%03lu seconds." },
{ "HSMSG_INVALID_BOT", "This command requires a valid HelpServ bot name." },
{ "HSMSG_ILLEGAL_CHANNEL", "$b%s$b is an illegal channel; cannot use it." },
{ "HSMSG_INTERNAL_COMMAND", "$b%s$b appears to be an internal HelpServ command, sorry." },
char user_escape;
} helpserv_conf;
-static time_t last_stats_update;
+static unsigned long last_stats_update;
static int shutting_down;
static FILE *reqlog_f;
static struct log_type *HS_LOG;
unsigned int helpchan_empty : 1;
- time_t registered;
- time_t last_active;
+ unsigned long registered;
+ unsigned long last_active;
char *registrar;
};
unsigned int week_start : 3;
enum helpserv_level level;
/* statistics */
- time_t join_time; /* when they joined, or 0 if not in channel */
+ unsigned long join_time; /* when they joined, or 0 if not in channel */
/* [0] through [3] are n weeks ago, [4] is the total of everything before that */
unsigned int time_per_week[5]; /* how long they've were in the channel the past 4 weeks */
unsigned int picked_up[5]; /* how many requests they have picked up */
struct handle_info *handle;
unsigned long id;
- time_t opened;
- time_t assigned;
- time_t updated;
+ unsigned long opened;
+ unsigned long assigned;
+ unsigned long updated;
};
#define DEFINE_LIST_ALLOC(STRUCTNAME) \
static void run_empty_interval(void *data);
-static void helpserv_interval(char *output, time_t interval) {
+static void helpserv_interval(char *output, unsigned long interval) {
int num_hours = interval / 3600;
int num_minutes = (interval % 3600) / 60;
sprintf(output, "%u hour%s, %u minute%s", num_hours, num_hours == 1 ? "" : "s", num_minutes, num_minutes == 1 ? "" : "s");
assert(reason != NULL);
if (!(ctx = saxdb_open_context(reqlog_f)))
return;
- sprintf(key, "%s-" FMT_TIME_T "-%lu", req->hs->helpserv->nick, req->opened, req->id);
+ sprintf(key, "%s-%lu-%lu", req->hs->helpserv->nick, (unsigned long)req->opened, req->id);
if ((res = setjmp(ctx->jbuf)) != 0) {
log_module(HS_LOG, LOG_ERROR, "Unable to log helpserv request: %s.", strerror(res));
} else {
req->user = user;
req->handle = user->handle_info;
if (from_join && self->burst) {
- extern time_t burst_begin;
+ extern unsigned long burst_begin;
/* We need to keep all the requests during a burst join together,
* even if the burst takes more than 1 second. ircu seems to burst
* in reverse-join order. */
helpserv_msguser(user, "HSMSG_USERCMD_UNKNOWN", cmdname);
return;
} else if (hs->intervals[INTERVAL_STALE_DELAY]
- && (req->updated < (time_t)(now - hs->intervals[INTERVAL_STALE_DELAY]))
+ && (req->updated < now - hs->intervals[INTERVAL_STALE_DELAY])
&& (!hs->req_maxlen || req->text->used < hs->req_maxlen)) {
char buf[MAX_LINE_SIZE], updatestr[INTERVALLEN], timestr[MAX_LINE_SIZE];
+ time_t feh;
- strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&req->opened));
+ feh = req->opened;
+ strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
intervalString(updatestr, now - req->updated, user->handle_info);
if (req->helper && (hs->notify >= NOTIFY_USER))
if (user->handle_info)
helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_UPD_REQUEST_AUTHED", req->id, user->nick, user->handle_info->handle, timestr, updatestr);
else
helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_UPD_REQUEST_NOT_AUTHED", req->id, user->nick, timestr, updatestr);
- strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&now));
+ feh = now;
+ strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
snprintf(buf, MAX_LINE_SIZE, "[Stale request updated at %s]", timestr);
string_list_append(req->text, strdup(buf));
}
stop.tv_sec -= 1;
stop.tv_usec += 1000000;
}
- helpserv_notice(user, "HSMSG_READHELP_SUCCESS", stop.tv_sec, stop.tv_usec/1000);
+ helpserv_notice(user, "HSMSG_READHELP_SUCCESS", (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec/1000);
return 1;
}
unsigned int nn;
char buf[MAX_LINE_SIZE];
char buf2[INTERVALLEN];
+ time_t feh;
if (req->user)
if (req->handle)
helpserv_notice(user, "HSMSG_REQ_INFO_2d", req->handle->handle);
else
helpserv_notice(user, "HSMSG_REQ_INFO_2e");
- strftime(buf, MAX_LINE_SIZE, HSFMT_TIME, localtime(&req->opened));
+ feh = req->opened;
+ strftime(buf, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
intervalString(buf2, now - req->opened, user->handle_info);
helpserv_notice(user, "HSMSG_REQ_INFO_3", buf, buf2);
helpserv_notice(user, "HSMSG_REQ_INFO_4");
struct helpserv_request *req;
struct helpserv_user *hs_user=GetHSUser(hs, user->handle_info);
int num_requests=0;
+ time_t feh;
REQUIRE_PARMS(3);
note = unsplit_string(argv+2, argc-2, NULL);
- strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&now));
+ feh = now;
+ strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
snprintf(text, MAX_LINE_SIZE, "[Helper note at %s]:", timestr);
string_list_append(req->text, strdup(text));
snprintf(text, MAX_LINE_SIZE, " <%s> %s", user->handle_info->handle, note);
for (unh = hs->unhandled; unh; unh = unh->next_unhandled) {
queuesize++;
- if ((now - unh->opened) >= (time_t)hs->intervals[INTERVAL_WHINE_DELAY]) {
+ if ((now - unh->opened) >= hs->intervals[INTERVAL_WHINE_DELAY]) {
helpserv_reqlist_append(&reqlist, unh);
}
}
if (reqlist.used) {
char strwhinedelay[INTERVALLEN];
- intervalString(strwhinedelay, (time_t)hs->intervals[INTERVAL_WHINE_DELAY], NULL);
+ intervalString(strwhinedelay, hs->intervals[INTERVAL_WHINE_DELAY], NULL);
#if ANNOYING_ALERT_PAGES
tbl.length = reqlist.used + 1;
tbl.width = 4;
tbl.contents[i][3] = strdup(idle_time);
}
- intervalString(stridledelay, (time_t)hs->intervals[INTERVAL_IDLE_DELAY], NULL);
+ intervalString(stridledelay, hs->intervals[INTERVAL_IDLE_DELAY], NULL);
helpserv_page(PGSRC_STATUS, "HSMSG_PAGE_IDLE_HEADER", mode_list.used, hs->helpchan->name, stridledelay);
table_send(hs->helpserv, hs->page_targets[PGSRC_STATUS]->name, 0, page_types[hs->page_types[PGSRC_STATUS]].func, tbl);
log_module(HS_LOG, LOG_ERROR, "Request %s:%s has a nonexistant opening time. Using time(NULL).", hs->helpserv->nick, key);
request->opened = time(NULL);
} else {
- request->opened = (time_t)strtoul(str, NULL, 0);
+ request->opened = strtoul(str, NULL, 0);
}
str = database_get_data(rd->d.object, KEY_REQUEST_ASSIGNED, RECDB_QSTRING);
if (str)
- request->assigned = (time_t)strtoul(str, NULL, 0);
+ request->assigned = strtoul(str, NULL, 0);
str = database_get_data(rd->d.object, KEY_REQUEST_HELPER, RECDB_QSTRING);
if (str) {
hs->notify = str ? notification_from_name(str) : NOTIFY_NONE;
str = database_get_data(GET_RECORD_OBJECT(br), KEY_REGISTERED, RECDB_QSTRING);
if (str)
- hs->registered = (time_t)strtol(str, NULL, 0);
+ hs->registered = strtol(str, NULL, 0);
str = database_get_data(GET_RECORD_OBJECT(br), KEY_IDWRAP, RECDB_QSTRING);
if (str)
hs->id_wrap = strtoul(str, NULL, 0);
str = database_get_data(GET_RECORD_OBJECT(br), KEY_AUTO_DEVOICE, RECDB_QSTRING);
hs->auto_devoice = str ? enabled_string(str) : 0;
str = database_get_data(GET_RECORD_OBJECT(br), KEY_LAST_ACTIVE, RECDB_QSTRING);
- hs->last_active = str ? atoi(str) : now;
+ hs->last_active = str ? strtoul(str, NULL, 0) : now;
dict_foreach(users, user_read_helper, hs);
}
str = database_get_data(conf_db, KEY_LAST_STATS_UPDATE, RECDB_QSTRING);
- last_stats_update = str ? (time_t)strtol(str, NULL, 0) : now;
+ last_stats_update = str ? strtoul(str, NULL, 0) : now;
return 0;
}
for (j=1; j <= helper_reqs.used; j++) {
struct helpserv_request *req=helper_reqs.list[j-1];
char reqid[12], timestr[MAX_LINE_SIZE];
+ time_t feh;
tbl.contents[j] = alloca(tbl.width * sizeof(**tbl.contents));
tbl.contents[j][0] = req->hs->helpserv->nick;
tbl.contents[j][1] = strdup(reqid);
tbl.contents[j][2] = req->user ? req->user->nick : "Not online";
tbl.contents[j][3] = req->handle ? req->handle->handle : "Not authed";
- strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&req->opened));
+ feh = req->opened;
+ strftime(timestr, MAX_LINE_SIZE, HSFMT_TIME, localtime(&feh));
tbl.contents[j][4] = strdup(timestr);
}
}
}
-static time_t helpserv_next_stats(time_t after_when) {
+static unsigned long helpserv_next_stats(time_t after_when) {
struct tm *timeinfo = localtime(&after_when);
/* This works because mktime(3) says it will accept out-of-range values
}
/* If data != NULL, then don't add to the timeq */
-static void helpserv_run_stats(time_t when) {
- struct tm when_s;
+static void helpserv_run_stats(unsigned long when) {
struct helpserv_bot *hs;
struct helpserv_user *hs_user;
+ time_t feh;
+ unsigned int day;
int i;
dict_iterator_t it, it2;
last_stats_update = when;
- localtime_r(&when, &when_s);
+ feh = when;
+ day = localtime(&feh)->tm_wday;
for (it=dict_first(helpserv_bots_dict); it; it=iter_next(it)) {
hs = iter_data(it);
hs_user = iter_data(it2);
/* Skip the helper if it's not their week-start day. */
- if (hs_user->week_start != when_s.tm_wday)
+ if (hs_user->week_start != day)
continue;
/* Adjust their credit if they are in-channel at rollover. */
/* Make up for downtime... though this will only really affect the
* time_per_week */
if (last_stats_update && (helpserv_next_stats(last_stats_update) < now)) {
- time_t statsrun = last_stats_update;
+ unsigned long statsrun = last_stats_update;
while ((statsrun = helpserv_next_stats(statsrun)) < now)
helpserv_run_stats(statsrun);
}
struct memo_account *recipient;
struct memo_account *sender;
char *message;
- time_t sent;
+ unsigned long sent;
unsigned int is_read : 1;
};
static struct {
struct userNode *bot;
- int message_expiry;
+ unsigned long message_expiry;
} memoserv_conf;
const char *memoserv_module_deps[] = { NULL };
}
static struct memo*
-add_memo(time_t sent, struct memo_account *recipient, struct memo_account *sender, char *message)
+add_memo(unsigned long sent, struct memo_account *recipient, struct memo_account *sender, char *message)
{
struct memo *memo;
struct memo *memo;
unsigned int ii;
char posted[24];
- struct tm tm;
+ time_t feh;
if (!(ma = memoserv_get_account(user->handle_info)))
return 0;
reply("MSMSG_LIST_HEAD");
for (ii = 0; (ii < ma->recvd.used) && (ii < 15); ++ii) {
memo = ma->recvd.list[ii];
- localtime_r(&memo->sent, &tm);
- strftime(posted, sizeof(posted), "%I:%M %p, %m/%d/%Y", &tm);
+ feh = memo->sent;
+ strftime(posted, sizeof(posted), "%I:%M %p, %m/%d/%Y", localtime(&feh));
reply("MSMSG_LIST_FORMAT", ii, memo->sender->handle->handle, posted);
}
if (ii == 0)
unsigned int memoid;
struct memo *memo;
char posted[24];
- struct tm tm;
+ time_t feh;
if (!(ma = memoserv_get_account(user->handle_info)))
return 0;
if (!(memo = find_memo(user, cmd, ma, argv[1], &memoid)))
return 0;
- localtime_r(&memo->sent, &tm);
- strftime(posted, sizeof(posted), "%I:%M %p, %m/%d/%Y", &tm);
+ strftime(posted, sizeof(posted), "%I:%M %p, %m/%d/%Y", localtime(&feh));
reply("MSMSG_MEMO_HEAD", memoid, memo->sender->handle->handle, posted);
send_message_type(4, user, cmd->parent->bot, "%s", memo->message);
memo->is_read = 1;
struct record_data *hir;
struct memo *memo;
dict_iterator_t it;
- time_t sent;
+ unsigned long sent;
for (it = dict_first(db); it; it = iter_next(it)) {
hir = iter_data(it);
log_module(MS_LOG, LOG_ERROR, "Date sent not present in memo %s; skipping", iter_key(it));
continue;
}
- sent = atoi(str);
+ sent = strtoul(str, NULL, 0);
if (!(str = database_get_data(hir->d.object, KEY_RECIPIENT, RECDB_QSTRING))) {
log_module(MS_LOG, LOG_ERROR, "Recipient not present in memo %s; skipping", iter_key(it));
#include <arpa/inet.h>
#endif
-extern time_t now;
static struct {
struct chanNode *channel;
struct userNode *bot;
int snoop_finalize(void);
#define SNOOP(FORMAT, ARGS...) send_channel_message(snoop_cfg.channel, snoop_cfg.bot, "%s "FORMAT, timestamp , ## ARGS)
-#define UPDATE_TIMESTAMP() strftime(timestamp, sizeof(timestamp), "[%H:%M:%S]", localtime(&now))
+#define UPDATE_TIMESTAMP() do { time_t feh = now; strftime(timestamp, sizeof(timestamp), "[%H:%M:%S]", localtime(&feh)); } while (0)
static void
snoop_nick_change(struct userNode *user, const char *old_nick) {
typedef struct {
irc_in_addr_t addr;
const char *reason;
- time_t last_touched;
+ unsigned long last_touched;
enum sockcheck_decision decision;
char hostname[IRC_NTOP_MAX_SIZE]; /* acts as key for checked_ip_dict */
} *sockcheck_cache_info;
sockcheck_print_client(const struct sockcheck_client *client)
{
static const char *decs[] = {"CHECKING", "ACCEPT", "REJECT"};
- log_module(PC_LOG, LOG_INFO, "client %p: { addr = %p { decision = %s; last_touched = "FMT_TIME_T"; reason = %s; hostname = \"%s\" }; "
+ log_module(PC_LOG, LOG_INFO, "client %p: { addr = %p { decision = %s; last_touched = %lu; reason = %s; hostname = \"%s\" }; "
"test_index = %d; state = %p { port = %d; type = %s; template = \"%s\"; ... }; "
"fd = %p(%d); read = %p; read_size = %d; read_used = %d; read_pos = %d; }",
- client, client->addr, decs[client->addr->decision], client->addr->last_touched,
+ client, client->addr, decs[client->addr->decision],
+ client->addr->last_touched,
client->addr->reason, client->addr->hostname,
client->test_index, client->state,
(client->state ? client->state->port : 0),
/* We are already checking this host. */
return;
case ACCEPT:
- if ((sci->last_touched + sockcheck_conf.max_cache_age) >= (unsigned)now) return;
+ if (sci->last_touched + sockcheck_conf.max_cache_age >= now) {
+ return;
+ }
break;
case REJECT:
- if ((sci->last_touched + sockcheck_conf.gline_duration) >= (unsigned)now) {
+ if (sci->last_touched + sockcheck_conf.gline_duration >= now) {
sockcheck_issue_gline(sci);
return;
}
string_buffer_append_string(&sb, client_list[nn]->addr->hostname);
}
string_buffer_append(&sb, '\0');
- log_module(PC_LOG, LOG_INFO, "Cleaning sockcheck cache at "FMT_TIME_T"; current clients: %s.", now, sb.list);
+ log_module(PC_LOG, LOG_INFO, "Cleaning sockcheck cache at %lu; current clients: %s.", (unsigned long)now, sb.list);
string_buffer_clean(&sb);
} else {
for (curr_clients = dict_new(), nn=0; nn < sockcheck_conf.max_clients; nn++) {
if (((sci->last_touched + max_age) < now)
&& !dict_find(curr_clients, sci->hostname, NULL)) {
if (SOCKCHECK_DEBUG) {
- log_module(PC_LOG, LOG_INFO, " .. nuking %s (last touched "FMT_TIME_T").", sci->hostname, sci->last_touched);
+ log_module(PC_LOG, LOG_INFO, " .. nuking %s (last touched %lu).", sci->hostname, sci->last_touched);
}
dict_remove(checked_ip_dict, sci->hostname);
}
{ "MCMSG_HELPFILE_UNBOUND", "Since that was the last command from module %s on the service, the helpfile for %s was removed." },
{ "MCMSG_NO_HELPFILE", "Module %s does not have a help file." },
{ "MCMSG_HELPFILE_ERROR", "Syntax error reading %s; help contents not changed." },
- { "MCMSG_HELPFILE_READ", "Read %s help database in "FMT_TIME_T".%03lu seconds." },
- { "MCMSG_COMMAND_TIME", "Command $b%s$b finished in "FMT_TIME_T".%06lu seconds." },
+ { "MCMSG_HELPFILE_READ", "Read %s help database in %lu.%03lu seconds." },
+ { "MCMSG_COMMAND_TIME", "Command $b%s$b finished in %lu.%06lu seconds." },
{ "MCMSG_NEED_OPSERV_LEVEL", "You must have $O access of at least $b%u$b." },
{ "MCMSG_NEED_CHANSERV_LEVEL", "You must have $C access of at least $b%u$b in the channel." },
{ "MCMSG_NEED_ACCOUNT_FLAGS", "You must have account flags $b%s$b." },
irc_notice_user(bot,user, "\x01PING\x01");
}
} else if (!irccasecmp(text, "TIME")) {
- struct tm tm;
- localtime_r(&now, &tm);
- strftime(response, sizeof(response), "\x01TIME %a %b %d %H:%M:%S %Y\x01", &tm);
+ time_t feh;
+ feh = now;
+ strftime(response, sizeof(response), "\x01TIME %a %b %d %H:%M:%S %Y\x01", localtime(&feh));
irc_notice_user(bot, user, response);
} else if (!irccasecmp(text, "USERINFO")) {
snprintf(response, sizeof(response), "\x01USERINFO %s\x01", bot->info);
stop.tv_sec -= 1;
stop.tv_usec += 1000000;
}
- reply("MCMSG_HELPFILE_READ", module->name, stop.tv_sec, stop.tv_usec/1000);
+ reply("MCMSG_HELPFILE_READ", module->name, (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec/1000);
return 1;
}
stop.tv_sec -= 1;
stop.tv_usec += 1000000;
}
- reply("MCMSG_COMMAND_TIME", cmd_text, stop.tv_sec, stop.tv_usec);
+ reply("MCMSG_COMMAND_TIME", cmd_text, (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec);
return 1;
}
{ "NSMSG_SET_FLAG", "Applied flags $b%s$b to %s's $N account." },
{ "NSMSG_FLAG_PRIVILEGED", "You have insufficient access to set flag %c." },
{ "NSMSG_DB_UNREADABLE", "Unable to read database file %s; check the log for more information." },
- { "NSMSG_DB_MERGED", "$N merged DB from %s (in "FMT_TIME_T".%03lu seconds)." },
+ { "NSMSG_DB_MERGED", "$N merged DB from %s (in %lu.%03lu seconds)." },
{ "NSMSG_HANDLE_CHANGED", "$b%s$b's account name has been changed to $b%s$b." },
{ "NSMSG_BAD_HANDLE", "Account $b%s$b not registered because it is in use by a network service, is too long, or contains invalid characters." },
{ "NSMSG_BAD_NICK", "Nickname $b%s$b not registered because it is in use by a network service, is too long, or contains invalid characters." },
struct userNode *target, *next_un;
struct handle_info *hi;
const char *nsmsg_none;
+ time_t feh;
if (argc < 2) {
if (!(hi = user->handle_info)) {
#ifdef WITH_PROTOCOL_BAHAMUT
reply("NSMSG_HANDLEINFO_ID", hi->id);
#endif
- reply("NSMSG_HANDLEINFO_REGGED", ctime(&hi->registered));
+ feh = hi->registered;
+ reply("NSMSG_HANDLEINFO_REGGED", ctime(&feh));
if (!hi->users) {
intervalString(buff, now - hi->lastseen, user->handle_info);
struct nickserv_discrim {
unsigned long flags_on, flags_off;
- time_t min_registered, max_registered;
- time_t lastseen;
+ unsigned long min_registered, max_registered;
+ unsigned long lastseen;
unsigned int limit;
int min_level, max_level;
int min_karma, max_karma;
discrim->max_level = INT_MAX;
discrim->limit = 50;
discrim->min_registered = 0;
- discrim->max_registered = INT_MAX;
- discrim->lastseen = LONG_MAX;
+ discrim->max_registered = ULONG_MAX;
+ discrim->lastseen = ULONG_MAX;
discrim->min_karma = INT_MIN;
discrim->max_karma = INT_MAX;
if (str)
hi->infoline = strdup(str);
str = database_get_data(obj, KEY_REGISTER_ON, RECDB_QSTRING);
- hi->registered = str ? (time_t)strtoul(str, NULL, 0) : now;
+ hi->registered = str ? strtoul(str, NULL, 0) : now;
str = database_get_data(obj, KEY_LAST_SEEN, RECDB_QSTRING);
- hi->lastseen = str ? (time_t)strtoul(str, NULL, 0) : hi->registered;
+ hi->lastseen = str ? strtoul(str, NULL, 0) : hi->registered;
str = database_get_data(obj, KEY_KARMA, RECDB_QSTRING);
hi->karma = str ? strtoul(str, NULL, 0) : 0;
/* We want to read the nicks even if disable_nicks is set. This is so
stop.tv_sec -= 1;
stop.tv_usec += 1000000;
}
- reply("NSMSG_DB_MERGED", argv[1], stop.tv_sec, stop.tv_usec/1000);
+ reply("NSMSG_DB_MERGED", argv[1], (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec/1000);
return 1;
}
expire_handles(UNUSED_ARG(void *data))
{
dict_iterator_t it, next;
- time_t expiry;
+ unsigned long expiry;
struct handle_info *hi;
for (it=dict_first(nickserv_handle_dict); it; it=next) {
struct handle_info *hi;
char *data;
enum cookie_type type;
- time_t expires;
+ unsigned long expires;
char cookie[COOKIELEN+1];
};
struct handle_note {
struct handle_note *next;
- time_t expires;
- time_t set;
+ unsigned long expires;
+ unsigned long set;
int id;
char setter[NICKSERV_HANDLE_LEN+1];
char note[1];
#ifdef WITH_PROTOCOL_BAHAMUT
unsigned long id;
#endif
- time_t registered;
- time_t lastseen;
+ unsigned long registered;
+ unsigned long lastseen;
int karma;
unsigned short flags;
unsigned short opserv_level;
char *issuer;
char *reason;
unsigned long limit;
- time_t issued;
- time_t expires;
+ unsigned long issued;
+ unsigned long expires;
};
struct gag_entry {
char *mask;
char *owner;
char *reason;
- time_t expires;
+ unsigned long expires;
struct gag_entry *next;
};
char *mask_nick, *mask_ident, *mask_host, *mask_info, *server, *reason, *notice_target, *accountmask;
irc_in_addr_t ip_mask;
unsigned long limit;
- time_t min_ts, max_ts;
+ unsigned long min_ts, max_ts;
unsigned int min_level, max_level, domain_depth, duration, min_clones, min_channels, max_channels;
unsigned char ip_mask_bits;
unsigned int match_opers : 1, match_trusted : 1, option_log : 1;
const char *fmt;
struct banNode *ban;
struct modeNode *moden;
+ time_t feh;
unsigned int n;
reply("OSMSG_CHANINFO_HEADER", channel->name);
fmt = user_find_message(user, "OSMSG_CHANINFO_TIMESTAMP");
- strftime(buffer, sizeof(buffer), fmt, gmtime(&channel->timestamp));
+ feh = channel->timestamp;
+ strftime(buffer, sizeof(buffer), fmt, gmtime(&feh));
send_message_type(4, user, cmd->parent->bot, "%s", buffer);
irc_make_chanmode(channel, buffer);
if (channel->bad_channel)
reply("OSMSG_CHANINFO_MODES", buffer);
if (channel->topic_time) {
fmt = user_find_message(user, "OSMSG_CHANINFO_TOPIC");
- strftime(buffer, sizeof(buffer), fmt, gmtime(&channel->topic_time));
+ feh = channel->topic_time;
+ strftime(buffer, sizeof(buffer), fmt, gmtime(&feh));
send_message_type(4, user, cmd->parent->bot, buffer, channel->topic_nick, channel->topic);
} else {
irc_fetchtopic(cmd->parent->bot, channel->name);
fmt = user_find_message(user, "OSMSG_CHANINFO_BAN");
for (n = 0; n < channel->banlist.used; n++) {
ban = channel->banlist.list[n];
- strftime(buffer, sizeof(buffer), fmt, localtime(&ban->set));
+ feh = ban->set;
+ strftime(buffer, sizeof(buffer), fmt, localtime(&feh));
send_message_type(4, user, cmd->parent->bot, buffer, ban->ban, ban->who);
}
}
static MODCMD_FUNC(cmd_stats_max) {
- reply("OSMSG_MAX_CLIENTS", max_clients, asctime(localtime(&max_clients_time)));
+ time_t feh;
+ feh = max_clients_time;
+ reply("OSMSG_MAX_CLIENTS", max_clients, asctime(localtime(&feh)));
return 1;
}
static MODCMD_FUNC(cmd_stats_uptime) {
extern int lines_processed;
- extern time_t boot_time;
+ extern unsigned long boot_time;
double kernel_time;
double user_time;
char uptime[INTERVALLEN];
}
static void
-opserv_add_trusted_host(const char *ipaddr, unsigned int limit, const char *issuer, time_t issued, time_t expires, const char *reason)
+opserv_add_trusted_host(const char *ipaddr, unsigned int limit, const char *issuer, unsigned long issued, unsigned long expires, const char *reason)
{
struct trusted_host *th;
th = calloc(1, sizeof(*th));
if (!self->uplink) return 0;
discrim = calloc(1, sizeof(*discrim));
discrim->limit = dict_size(clients);
- discrim->max_level = ~0;
- discrim->max_ts = now;
+ discrim->max_level = UINT_MAX;
+ discrim->max_ts = ULONG_MAX;
discrim->max_channels = INT_MAX;
discrim->authed = -1;
discrim->info_space = -1;
}
unsigned int
-gag_create(const char *mask, const char *owner, const char *reason, time_t expires)
+gag_create(const char *mask, const char *owner, const char *reason, unsigned long expires)
{
struct gag_entry *gag;
{
struct record_data *rd = data;
char *owner, *reason, *expstr;
- time_t expires;
+ unsigned long expires;
owner = database_get_data(rd->d.object, KEY_OWNER, RECDB_QSTRING);
reason = database_get_data(rd->d.object, KEY_REASON, RECDB_QSTRING);
{
struct record_data *rd = data;
const char *limit, *str, *reason, *issuer;
- time_t issued, expires;
+ unsigned long issued, expires;
if (rd->type == RECDB_QSTRING) {
/* old style host by itself */
static MODCMD_FUNC(cmd_settime)
{
const char *srv_name_mask = "*";
- time_t new_time = now;
+ unsigned long new_time = now;
if (argc > 1)
srv_name_mask = argv[1];
discrim = calloc(1, sizeof(*discrim));
discrim->limit = 250;
- discrim->max_level = ~0;
- discrim->max_ts = INT_MAX;
+ discrim->max_level = UINT_MAX;
+ discrim->max_ts = ULONG_MAX;
discrim->domain_depth = 2;
discrim->max_channels = INT_MAX;
discrim->authed = -1;
char *name, *topic;
unsigned int min_users, max_users;
- time_t min_ts, max_ts;
+ unsigned long min_ts, max_ts;
unsigned int limit;
} *cdiscrim_t;
static cdiscrim_t opserv_cdiscrim_create(struct userNode *user, unsigned int argc, char *argv[]);
static unsigned int opserv_cdiscrim_search(cdiscrim_t discrim, cdiscrim_search_func dsf, void *data);
-static time_t
+static unsigned long
smart_parse_time(const char *str) {
/* If an interval-style string is given, treat as time before now.
* If it's all digits, treat directly as a Unix timestamp. */
- return str[strspn(str, "0123456789")] ? (time_t)(now - ParseInterval(str)) : (time_t)atoi(str);
+ return str[strspn(str, "0123456789")] ? (now - ParseInterval(str)) : strtoul(str, NULL, 0);
}
static cdiscrim_t
discrim = calloc(1, sizeof(*discrim));
discrim->limit = 25;
- discrim->max_users = ~0;
- /* So, time_t is frequently signed. Fun. */
- discrim->max_ts = (1ul << (CHAR_BIT * sizeof(time_t) - 1)) - 1;
+ discrim->max_users = UINT_MAX;
+ discrim->max_ts = ULONG_MAX;
for (i = 0; i < argc; i++) {
/* Assume all criteria require arguments. */
#define _opserv_h
void init_opserv(const char *nick);
-unsigned int gag_create(const char *mask, const char *owner, const char *reason, time_t expires);
+unsigned int gag_create(const char *mask, const char *owner, const char *reason, unsigned long expires);
int opserv_bad_channel(const char *name);
#endif
void irc_svsmode(struct userNode *target, char *modes, unsigned long stamp);
struct server *
-AddServer(struct server *uplink, const char *name, int hops, time_t boot, time_t link, UNUSED_ARG(const char *numeric), const char *description) {
+AddServer(struct server *uplink, const char *name, int hops, unsigned long boot, unsigned long link, UNUSED_ARG(const char *numeric), const char *description) {
struct server* sNode;
sNode = calloc(1, sizeof(*sNode));
}
struct userNode *
-AddUser(struct server* uplink, const char *nick, const char *ident, const char *hostname, const char *modes, const char *userinfo, time_t timestamp, irc_in_addr_t realip, const char *stamp) {
+AddUser(struct server* uplink, const char *nick, const char *ident, const char *hostname, const char *modes, const char *userinfo, unsigned long timestamp, irc_in_addr_t realip, const char *stamp) {
struct userNode *uNode, *oldUser;
unsigned int nn, dummy;
struct userNode *
AddLocalUser(const char *nick, const char *ident, const char *hostname, const char *desc, const char *modes)
{
- time_t timestamp = now;
+ unsigned long timestamp = now;
struct userNode *old_user = GetUserH(nick);
static const irc_in_addr_t ipaddr;
if (IsReggedNick(user)) modes[modelen++] = 'r';
if (IsGlobal(user)) modes[modelen++] = 'g';
modes[modelen] = 0;
- putsock("NICK %s %d "FMT_TIME_T" +%s %s %s %s %d %u :%s",
- user->nick, user->uplink->hops+2, user->timestamp, modes,
- user->ident, user->hostname, user->uplink->name, 0, ntohl(user->ip.in6_32[3]), user->info);
+ putsock("NICK %s %d %lu +%s %s %s %s %d %u :%s",
+ user->nick, user->uplink->hops+2, (unsigned long)user->timestamp,
+ modes, user->ident, user->hostname, user->uplink->name, 0,
+ ntohl(user->ip.in6_32[3]), user->info);
}
void
dict_insert(service_msginfo_dict, user->nick, smi);
}
}
- putsock(":%s NICK %s :"FMT_TIME_T, old_nick, user->nick, user->timestamp);
+ putsock(":%s NICK %s :%lu", old_nick, user->nick, (unsigned long)user->timestamp);
}
void
void
irc_svinfo() {
- putsock("SVINFO 3 3 0 :"FMT_TIME_T, now);
+ putsock("SVINFO 3 3 0 :%lu", (unsigned long)now);
}
void
irc_introduce(const char *passwd) {
- extern time_t burst_begin;
+ extern unsigned long burst_begin;
irc_pass(passwd);
irc_capab();
void
irc_join(struct userNode *who, struct chanNode *what) {
if (what->members.used == 1) {
- putsock(":%s SJOIN "FMT_TIME_T" %s + :@%s", self->name, what->timestamp, what->name, who->nick);
+ putsock(":%s SJOIN %lu %s + :@%s", self->name, (unsigned long)what->timestamp, what->name, who->nick);
} else {
- putsock(":%s SJOIN "FMT_TIME_T" %s", who->nick, what->timestamp, what->name);
+ putsock(":%s SJOIN %lu %s", who->nick, (unsigned long)what->timestamp, what->name);
}
}
void
irc_mode(struct userNode *who, struct chanNode *target, const char *modes) {
- putsock(":%s MODE %s "FMT_TIME_T" %s", who->nick, target->name, target->timestamp, modes);
+ putsock(":%s MODE %s %lu %s", who->nick, target->name, (unsigned long)target->timestamp, modes);
}
void
irc_svsmode(struct userNode *target, char *modes, unsigned long stamp) {
extern struct userNode *nickserv;
if (stamp) {
- putsock(":%s SVSMODE %s "FMT_TIME_T" %s %lu", nickserv->nick, target->nick, target->timestamp, modes, stamp);
+ putsock(":%s SVSMODE %s %lu %s %lu", nickserv->nick, target->nick, (unsigned long)target->timestamp, modes, stamp);
} else {
- putsock(":%s SVSMODE %s "FMT_TIME_T" %s", nickserv->nick, target->nick, target->timestamp, modes);
+ putsock(":%s SVSMODE %s %lu %s", nickserv->nick, target->nick, (unsigned long)target->timestamp, modes);
}
}
if (len > ArrayLength(ident)) len = ArrayLength(ident);
safestrncpy(ident, gline->target, len);
safestrncpy(host, sep+1, ArrayLength(host));
- putsock(":%s AKILL %s %s "FMT_TIME_T" %s "FMT_TIME_T" :%s", self->name, host, ident, gline->expires-gline->issued, gline->issuer, gline->issued, gline->reason);
+ putsock(":%s AKILL %s %s %lu %s %lu :%s", self->name, host, ident, (unsigned long)(gline->expires-gline->issued), gline->issuer, (unsigned long)gline->issued, gline->reason);
}
void
-irc_settime(UNUSED_ARG(const char *srv_name_mask), UNUSED_ARG(time_t new_time))
+irc_settime(UNUSED_ARG(const char *srv_name_mask), UNUSED_ARG(unsigned long new_time))
{
/* Bahamut has nothing like this, so ignore it. */
}
void
irc_svsnick(struct userNode *from, struct userNode *target, const char *newnick)
{
- putsock(":%s SVSNICK %s %s :"FMT_TIME_T, from->nick, target->nick, newnick, now);
+ putsock(":%s SVSNICK %s %s :%lu", from->nick, target->nick, newnick, (unsigned long)now);
}
void
if (!chan->members.used) return;
/* send list of users in the channel.. */
- base_len = sprintf(line, ":%s SJOIN "FMT_TIME_T" %s ", self->name, chan->timestamp, chan->name);
+ base_len = sprintf(line, ":%s SJOIN %lu %s ", self->name, (unsigned long)chan->timestamp, chan->name);
len = irc_make_chanmode(chan, line+base_len);
pos = base_len + len;
line[pos++] = ' ';
line[pos] = 0;
putsock("%s", line);
/* now send the bans.. */
- base_len = sprintf(line, ":%s MODE "FMT_TIME_T" %s +", self->name, chan->timestamp, chan->name);
+ base_len = sprintf(line, ":%s MODE %lu %s +", self->name, (unsigned long)chan->timestamp, chan->name);
pos = sizeof(line)-1;
line[pos] = 0;
for (nn=queued=0; nn<chan->banlist.used; nn++) {
extern unsigned int nuf_size, nuf_used;
extern del_user_func_t *duf_list;
extern unsigned int duf_size, duf_used;
-extern time_t boot_time;
+extern unsigned long boot_time;
void received_ping(void);
replay_read_line(void)
{
struct tm timestamp;
- time_t new_time;
+ unsigned long new_time;
if (replay_line[0]) return;
read_line:
timestamp.tm_year = strtoul(replay_line+16, NULL, 10) - 1900;
timestamp.tm_isdst = 0;
new_time = mktime(×tamp);
- if (new_time == -1) {
+ if (new_time == (unsigned long)-1) {
log_module(MAIN_LOG, LOG_ERROR, "Unable to parse time struct tm_sec=%d tm_min=%d tm_hour=%d tm_mday=%d tm_mon=%d tm_year=%d", timestamp.tm_sec, timestamp.tm_min, timestamp.tm_hour, timestamp.tm_mday, timestamp.tm_mon, timestamp.tm_year);
} else {
now = new_time;
return 0;
switch (argv[1][0]) {
case 'u': {
- unsigned int uptime = now - boot_time;
+ unsigned long uptime;
+ uptime = now - boot_time;
irc_numeric(un, RPL_STATSUPTIME, ":Server Up %d days %d:%02d:%02d",
uptime/(24*60*60), (uptime/(60*60))%24, (uptime/60)%60, uptime%60);
irc_numeric(un, RPL_MAXCONNECTIONS, ":Highest connection count: %d (%d clients)",
static char *his_servername;
static char *his_servercomment;
-static struct userNode *AddUser(struct server* uplink, const char *nick, const char *ident, const char *hostname, const char *modes, const char *numeric, const char *userinfo, time_t timestamp, const char *realip);
+static struct userNode *AddUser(struct server* uplink, const char *nick, const char *ident, const char *hostname, const char *modes, const char *numeric, const char *userinfo, unsigned long timestamp, const char *realip);
extern int off_channel;
inttobase64(extranum, srv->num_mask, (srv->numeric[1] || (srv->num_mask >= 64*64)) ? 3 : 2);
if (srv == self) {
/* The +s, ignored by Run's ircu, means "service" to Undernet's ircu */
- putsock(P10_SERVER " %s %d %li %li J10 %s%s +s6 :%s",
+ putsock(P10_SERVER " %s %d %lu %lu J10 %s%s +s6 :%s",
srv->name, srv->hops+1, srv->boot, srv->link, srv->numeric, extranum, srv->description);
} else {
- putsock("%s " P10_SERVER " %s %d %li %li %c10 %s%s +s6 :%s",
+ putsock("%s " P10_SERVER " %s %d %lu %lu %c10 %s%s +s6 :%s",
self->numeric, srv->name, srv->hops+1, srv->boot, srv->link, (srv->self_burst ? 'J' : 'P'), srv->numeric, extranum, srv->description);
}
}
modes[modelen] = 0;
/* we don't need to put the + in modes because it's in the format string. */
- putsock("%s " P10_NICK " %s %d %li %s %s +%s %s %s :%s",
- user->uplink->numeric, user->nick, user->uplink->hops+1, user->timestamp, user->ident, user->hostname, modes, b64ip, user->numeric, user->info);
+ putsock("%s " P10_NICK " %s %d %lu %s %s +%s %s %s :%s",
+ user->uplink->numeric, user->nick, user->uplink->hops+1, (unsigned long)user->timestamp, user->ident, user->hostname, modes, b64ip, user->numeric, user->info);
} else {
- putsock("%s " P10_NICK " %s %d %li %s %s %s %s :%s",
- user->uplink->numeric, user->nick, user->uplink->hops+1, user->timestamp, user->ident, user->hostname, b64ip, user->numeric, user->info);
+ putsock("%s " P10_NICK " %s %d %lu %s %s %s %s :%s",
+ user->uplink->numeric, user->nick, user->uplink->hops+1, (unsigned long)user->timestamp, user->ident, user->hostname, b64ip, user->numeric, user->info);
}
}
void
irc_nick(struct userNode *user, UNUSED_ARG(const char *old_nick))
{
- putsock("%s " P10_NICK " %s "FMT_TIME_T, user->numeric, user->nick, now);
+ putsock("%s " P10_NICK " %s %lu", user->numeric, user->nick, (unsigned long)now);
}
void
orig.tv_usec = (*delim == '.') ? strtoul(delim + 1, NULL, 10) : 0;
gettimeofday(&now, NULL);
diff = (now.tv_sec - orig.tv_sec) * 1000 + (now.tv_usec - orig.tv_usec) / 1000;
- putsock("%s " P10_PONG " %s %s %d " FMT_TIME_T ".%06u", self->numeric, who, orig_ts, diff, now.tv_sec, (unsigned)now.tv_usec);
+ putsock("%s " P10_PONG " %s %s %d %lu.%06lu", self->numeric, who, orig_ts, diff, (unsigned long)now.tv_sec, (unsigned long)now.tv_usec);
}
void
irc_gline(struct server *srv, struct gline *gline)
{
if (gline->lastmod)
- putsock("%s " P10_GLINE " %s +%s %ld %ld :%s",
- self->numeric, (srv ? srv->numeric : "*"), gline->target, gline->expires-now, gline->lastmod, gline->reason);
+ putsock("%s " P10_GLINE " %s +%s %lu %lu :%s",
+ self->numeric, (srv ? srv->numeric : "*"), gline->target, (unsigned long)(gline->expires-now), (unsigned long)gline->lastmod, gline->reason);
else
- putsock("%s " P10_GLINE " %s +%s %ld :%s",
- self->numeric, (srv ? srv->numeric : "*"), gline->target, gline->expires-now, gline->reason);
+ putsock("%s " P10_GLINE " %s +%s %lu :%s",
+ self->numeric, (srv ? srv->numeric : "*"), gline->target, (unsigned long)(gline->expires-now), gline->reason);
}
void
-irc_settime(const char *srv_name_mask, time_t new_time)
+irc_settime(const char *srv_name_mask, unsigned long new_time)
{
ioset_set_time(new_time);
if (!strcmp(srv_name_mask, "*"))
srv_name_mask = "";
- putsock("%s " P10_SETTIME " " FMT_TIME_T " %s", self->numeric, new_time, srv_name_mask);
+ putsock("%s " P10_SETTIME " %lu %s", self->numeric, new_time, srv_name_mask);
}
void
unsigned int first_ban;
unsigned int n;
- base_len = sprintf(burst_line, "%s " P10_BURST " %s " FMT_TIME_T " ",
- self->numeric, chan->name, chan->timestamp);
+ base_len = sprintf(burst_line, "%s " P10_BURST " %s %lu ",
+ self->numeric, chan->name,
+ (unsigned long)chan->timestamp);
len = irc_make_chanmode(chan, burst_line+base_len);
pos = base_len + len;
if (len > 0 && chan->members.used > 0)
void
irc_mode(struct userNode *from, struct chanNode *target, const char *modes)
{
- putsock("%s " P10_MODE " %s %s "FMT_TIME_T,
+ putsock("%s " P10_MODE " %s %s %lu",
(from ? from->numeric : self->numeric),
- target->name, modes, target->timestamp);
+ target->name, modes, (unsigned long)target->timestamp);
}
void
{
if (what->members.used == 1) {
putsock("%s " P10_CREATE " %s %lu",
- who->numeric, what->name, what->timestamp);
+ who->numeric, what->name, (unsigned long)what->timestamp);
} else {
- putsock("%s " P10_JOIN " %s %lu", who->numeric, what->name, what->timestamp);
+ putsock("%s " P10_JOIN " %s %lu", who->numeric, what->name,
+ (unsigned long)what->timestamp);
}
}
void
irc_svsnick(struct userNode *from, struct userNode *target, const char *newnick)
{
- putsock("%s " P10_SVSNICK " %s %s "FMT_TIME_T, from->uplink->numeric, target->numeric, newnick, now);
+ putsock("%s " P10_SVSNICK " %s %s %lu", from->uplink->numeric, target->numeric, newnick, (unsigned long)now);
}
void
if (srv->boot <= PREHISTORY) {
/* Server from the mists of time.. */
if (srv->hops == 1) {
- log_module(MAIN_LOG, LOG_ERROR, "Server %s claims to have booted at time "FMT_TIME_T". This is absurd.", srv->name, srv->boot);
+ log_module(MAIN_LOG, LOG_ERROR, "Server %s claims to have booted at time %lu. This is absurd.", srv->name, (unsigned long)srv->boot);
}
} else if ((str = conf_get_data("server/reliable_clock", RECDB_QSTRING))
&& enabled_string(str)) {
}
}
if (srv == self->uplink) {
- extern time_t burst_begin;
+ extern unsigned long burst_begin;
burst_begin = now;
}
return 1;
static CMD_FUNC(cmd_eob_ack)
{
- extern time_t burst_begin;
+ extern unsigned long burst_begin;
if (GetServerH(origin) == self->uplink) {
burst_length = now - burst_begin;
struct create_desc {
struct userNode *user;
- time_t when;
+ unsigned long when;
};
static void
long mode;
int oplevel = -1;
char *user, *end, sep;
- time_t in_timestamp;
+ unsigned long in_timestamp;
if (argc < 3)
return 0;
static CMD_FUNC(cmd_topic)
{
struct chanNode *cn;
- time_t chan_ts, topic_ts;
+ unsigned long chan_ts, topic_ts;
if (argc < 3)
return 0;
static CMD_FUNC(cmd_num_gline)
{
- time_t lastmod;
+ unsigned long lastmod;
if (argc < 6)
return 0;
lastmod = (argc > 5) ? strtoul(argv[5], NULL, 0) : 0;
static CMD_FUNC(cmd_gline)
{
- time_t lastmod;
+ unsigned long lastmod;
if (argc < 3)
return 0;
}
struct server *
-AddServer(struct server *uplink, const char *name, int hops, time_t boot, time_t link, const char *numeric, const char *description)
+AddServer(struct server *uplink, const char *name, int hops, unsigned long boot, unsigned long link, const char *numeric, const char *description)
{
struct server* sNode;
int slen, mlen;
{
char numeric[COMBO_NUMERIC_LEN+1];
int local_num = get_local_numeric();
- time_t timestamp = now;
+ unsigned long timestamp = now;
struct userNode *old_user = GetUserH(nick);
if (!modes)
{
char numeric[COMBO_NUMERIC_LEN+1];
int local_num = get_local_numeric();
- time_t timestamp = now;
+ unsigned long timestamp = now;
struct userNode *old_user = GetUserH(nick);
if (old_user) {
}
static struct userNode*
-AddUser(struct server* uplink, const char *nick, const char *ident, const char *hostname, const char *modes, const char *numeric, const char *userinfo, time_t timestamp, const char *realip)
+AddUser(struct server* uplink, const char *nick, const char *ident, const char *hostname, const char *modes, const char *numeric, const char *userinfo, unsigned long timestamp, const char *realip)
{
struct userNode *oldUser, *uNode;
unsigned int n, ignore_user, dummy;
/* network maintenance */
void irc_gline(struct server *srv, struct gline *gline);
-void irc_settime(const char *srv_name_mask, time_t new_time);
+void irc_settime(const char *srv_name_mask, unsigned long new_time);
void irc_ungline(const char *mask);
void irc_error(const char *to, const char *message);
void irc_kill(struct userNode *from, struct userNode *target, const char *message);
int IsChannelName(const char *name);
int is_valid_nick(const char *nick);
struct userNode *AddLocalUser(const char *nick, const char *ident, const char *hostname, const char *desc, const char *modes);
-struct server* AddServer(struct server* uplink, const char *name, int hops, time_t boot, time_t link, const char *numeric, const char *description);
+struct server* AddServer(struct server* uplink, const char *name, int hops, unsigned long boot, unsigned long link, const char *numeric, const char *description);
void DelServer(struct server* serv, int announce, const char *message);
void DelUser(struct userNode* user, struct userNode *killer, int announce, const char *why);
/* Most protocols will want to make an AddUser helper function. */
sar_request_abort(req);
}
-static time_t next_sar_timeout;
+static unsigned long next_sar_timeout;
static void
sar_timeout_cb(void *data)
{
dict_iterator_t it;
dict_iterator_t next;
- time_t next_timeout = INT_MAX;
+ unsigned long next_timeout = INT_MAX;
for (it = dict_first(sar_requests); it; it = next) {
struct sar_request *req;
}
static void
-sar_check_timeout(time_t when)
+sar_check_timeout(unsigned long when)
{
if (!next_sar_timeout || when < next_sar_timeout) {
timeq_del(0, sar_timeout_cb, NULL, TIMEQ_IGNORE_WHEN | TIMEQ_IGNORE_DATA);
*/
struct sar_request {
int id;
- time_t expiry;
+ unsigned long expiry;
sar_request_ok_cb cb_ok;
sar_request_fail_cb cb_fail;
unsigned char *body;
saxdb_reader_func_t *reader;
saxdb_writer_func_t *writer;
unsigned int write_interval;
- time_t last_write;
+ unsigned long last_write;
unsigned int last_write_duration;
struct saxdb *prev;
};
struct saxdb_context ctx;
char tmp_fname[MAXLEN];
int res, res2;
- time_t start, finish;
+ unsigned long start, finish;
assert(db->filename);
sprintf(tmp_fname, "%s.new", db->filename);
stop.tv_sec -= 1;
stop.tv_usec += 1000000;
}
- reply("MSG_DB_WROTE_DB", db->name, stop.tv_sec, stop.tv_usec);
+ reply("MSG_DB_WROTE_DB", db->name, (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec);
written++;
}
}
stop.tv_sec -= 1;
stop.tv_usec += 1000000;
}
- reply("MSG_DB_WROTE_ALL", stop.tv_sec, stop.tv_usec);
+ reply("MSG_DB_WROTE_ALL", (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec);
return 1;
}
static void
timeq_init(void)
{
- timeq = heap_new(int_comparator);
+ timeq = heap_new(ulong_comparator);
reg_exit_func(timeq_cleanup);
}
-time_t
+unsigned long
timeq_next(void)
{
void *time;
if (!timeq)
return ~0;
heap_peek(timeq, &time, 0);
- return (time_t)time;
+ return (unsigned long)time;
}
void
-timeq_add(time_t when, timeq_func func, void *data)
+timeq_add(unsigned long when, timeq_func func, void *data)
{
struct timeq_entry *ent;
void *w;
}
struct timeq_extra {
- time_t when;
+ unsigned long when;
timeq_func func;
void *data;
int mask;
{
struct timeq_entry *a = data;
struct timeq_extra *b = extra;
- if (((b->mask & TIMEQ_IGNORE_WHEN) || ((time_t)key == b->when))
+ if (((b->mask & TIMEQ_IGNORE_WHEN) || ((unsigned long)key == b->when))
&& ((b->mask & TIMEQ_IGNORE_FUNC) || (a->func == b->func))
&& ((b->mask & TIMEQ_IGNORE_DATA) || (a->data == b->data))) {
free(data);
}
void
-timeq_del(time_t when, timeq_func func, void *data, int mask)
+timeq_del(unsigned long when, timeq_func func, void *data, int mask)
{
struct timeq_extra extra;
extra.when = when;
struct timeq_entry *ent;
while (heap_size(timeq) > 0) {
heap_peek(timeq, &k, &d);
- if ((time_t)k > now)
+ if ((unsigned long)k > now)
break;
ent = d;
heap_pop(timeq);
#define TIMEQ_IGNORE_FUNC 0x02
#define TIMEQ_IGNORE_DATA 0x04
-void timeq_add(time_t when, timeq_func func, void *data);
-void timeq_del(time_t when, timeq_func func, void *data, int mask);
-time_t timeq_next(void);
+void timeq_add(unsigned long when, timeq_func func, void *data);
+void timeq_del(unsigned long when, timeq_func func, void *data, int mask);
+unsigned long timeq_next(void);
unsigned int timeq_size(void);
void timeq_run(void);
}
char *
-intervalString(char *output, time_t interval, struct handle_info *hi)
+intervalString(char *output, unsigned long interval, struct handle_info *hi)
{
static const struct {
const char *msg_single;
const char *msg_plural;
- long length;
+ unsigned long length;
} unit[] = {
{ "MSG_YEAR", "MSG_YEARS", 365 * 24 * 60 * 60 },
{ "MSG_WEEK", "MSG_WEEKS", 7 * 24 * 60 * 60 },
projects / srvx.git / commitdiff