/*
* Empire - A multi-player, client/server Internet based war game.
- * Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ * Copyright (C) 1986-2004, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure
*
* This program is free software; you can redistribute it and/or modify
#include "misc.h"
#include "nat.h"
#include "file.h"
-#include "keyword.h"
#include "wantupd.h"
#include "optlist.h"
#include "common.h"
#include <sys/types.h>
#include <fcntl.h>
-#if defined(Rel4) || defined(_WIN32)
#include <time.h>
-#else /* Rel4 */
-#include <sys/time.h>
-#endif /* Rel4 */
void
update_policy_check(void)
{
- extern int update_policy,update_demandpolicy;
- extern int update_wantmin,blitz_time;
-
- if (update_policy < 0) update_policy = UDP_DEFAULT;
- if (update_policy > UDP_MAX) update_policy = UDP_DEFAULT;
- if (update_demandpolicy < 0) update_demandpolicy = UDDEM_DEFAULT;
- if (update_demandpolicy > UDDEM_MAX)
- update_demandpolicy = UDDEM_DEFAULT;
- if (update_wantmin < 0) update_wantmin = 0;
- if (update_wantmin > MAXNOC) update_wantmin = MAXNOC;
- if (blitz_time < 0) blitz_time = 0;
+ if (update_policy < 0)
+ update_policy = UDP_DEFAULT;
+ if (update_policy > UDP_MAX)
+ update_policy = UDP_DEFAULT;
+ if (update_demandpolicy < 0)
+ update_demandpolicy = UDDEM_DEFAULT;
+ if (update_demandpolicy > UDDEM_MAX)
+ update_demandpolicy = UDDEM_DEFAULT;
+ if (update_wantmin < 0)
+ update_wantmin = 0;
+ if (update_wantmin > MAXNOC)
+ update_wantmin = MAXNOC;
+ if (blitz_time < 0)
+ blitz_time = 0;
}
static int
demand_update_time(time_t *now)
{
- struct tm *tm;
- s_char *p;
- int curtime;
- int hour[2];
- extern s_char *update_demandtimes;
-
- tm = localtime(now);
- curtime = tm->tm_min + tm->tm_hour * 60;
- p=update_demandtimes;
- if (*p == 0) return(1);
- while (NULL != (p = kw_parse(CF_TIMERANGE, p, &hour[0]))) {
- if (curtime >= hour[0] && curtime < hour[1])
- return(1);
- }
- return(0);
+ struct tm *tm;
+
+ tm = localtime(now);
+ return is_daytime_allowed(60 * tm->tm_hour + tm->tm_min,
+ update_demandtimes);
}
/* When is the next regularly scheduled update from now. */
static void
regular_update_time(time_t *now, time_t *tim, time_t *delta)
{
- extern int s_p_etu;
- extern int etu_per_update;
- extern int adj_update;
- s_char *p;
- time_t tw;
- int secs_per_update;
-
- tw = *now + adj_update;
- secs_per_update = etu_per_update * s_p_etu;
- *delta = secs_per_update - (tw % secs_per_update);
- *tim = *now + *delta;
+ time_t tw;
+ int secs_per_update;
+
+ tw = *now + adj_update;
+ secs_per_update = etu_per_update * s_p_etu;
+ *delta = secs_per_update - (tw % secs_per_update);
+ *tim = *now + *delta;
}
/* Is this a valid time for a scheduled update. */
static int
-scheduled_update_time(time_t *now, int *which)
+scheduled_update_time(time_t *now)
{
- struct tm *tm;
- s_char *p, *p1;
- int curtime;
- int hour;
- extern int hourslop;
- extern s_char *update_times;
-
- *which = -1;
- p=update_times;
- if (*p == 0) return(0);
-
- tm = localtime(now);
- curtime = tm->tm_min + tm->tm_hour * 60;
- while (NULL != (p = kw_parse(CF_TIME, p, &hour))) {
- (*which) ++;
- if (curtime >= hour &&
- curtime < hour+hourslop)
- return(1);
- }
+ struct tm *tm;
- return 0;
+ tm = localtime(now);
+ return is_daytime_near(60 * tm->tm_hour + tm->tm_min,
+ update_times, hourslop);
}
static int
next_scheduled_time(time_t *now, time_t *tim, time_t *delta)
{
- struct tm *tm;
- s_char *p;
- int curtime;
- int hour;
- int mintime;
- extern s_char *update_times;
-
- p=update_times;
- if (*p == 0) return(0);
-
- tm = localtime(now);
- curtime = tm->tm_min + tm->tm_hour * 60; /* now - in minutes */
- mintime = curtime + 24*60+1; /* start with now + 1 day */
- while (NULL != (p = kw_parse(CF_TIME, p, &hour))) {
- if (hour <= curtime)
- hour += 24 * 60; /* this must be tomorrow */
- if (hour < mintime)
- mintime = hour; /* this is best bet so far */
- }
- *delta = 60*(mintime - curtime);
- *tim = *now + *delta - tm->tm_sec;
- return(1);
+ struct tm *tm;
+ int d;
+
+ tm = localtime(now);
+ d = min_to_next_daytime(60 * tm->tm_hour + tm->tm_min, update_times);
+ if (d < 0)
+ return 0;
+ *delta = 60 * d;
+ *tim = *now + *delta - tm->tm_sec;
+ return 1;
}
int
demand_update_want(int *want, int *pop, int which)
{
- natid cn;
- struct natstr *natp;
- int totpop;
- int totwant;
- int whichwants;
-
- whichwants = totpop = totwant = 0;
- for (cn = 1; 0 != (natp = getnatp(cn)); cn++) {
- /* Only countries which are normal. */
- /* Should probably include sanctuaries ..... */
- if (((natp->nat_stat & NORM) == NORM) &&
- ((natp->nat_stat & GOD) != GOD)) {
- totpop++;
- if ((natp->nat_update & WUPD_WANT) == WUPD_WANT) {
- totwant++;
- if (which == cn)
- whichwants++;
- }
- }
+ natid cn;
+ struct natstr *natp;
+ int totpop;
+ int totwant;
+ int whichwants;
+
+ whichwants = totpop = totwant = 0;
+ for (cn = 1; 0 != (natp = getnatp(cn)); cn++) {
+ /* Only countries which are normal. */
+ /* Should probably include sanctuaries ..... */
+ if (((natp->nat_stat & NORM) == NORM) &&
+ ((natp->nat_stat & GOD) != GOD)) {
+ totpop++;
+ if ((natp->nat_update & WUPD_WANT) == WUPD_WANT) {
+ totwant++;
+ if (which == cn)
+ whichwants++;
+ }
}
- *want = totwant;
- *pop = totpop;
- return(whichwants);
+ }
+ *want = totwant;
+ *pop = totpop;
+ return (whichwants);
}
static int
demand_check(void)
{
- extern int update_wantmin,update_missed;
- struct natstr *natp;
- int want, pop, cn, veto;
- time_t now;
- time_t cur;
- extern long last_demand_update;
-
- time(&cur);
-
-/*
- if (last_demand_update == 0){
- natp=getnatp(0);
- last_demand_update = natp->nat_reserve;
+ struct natstr *natp;
+ int want, pop, cn, veto;
+ time_t now;
+ time_t cur;
+
+ time(&cur);
+
+ if (0 == update_wantmin) {
+ logerror("no demand update allowed, wantmin = 0");
+ return (0);
+ }
+
+ demand_update_want(&want, &pop, 0);
+ if (want < update_wantmin) {
+ logerror("no demand update, want = %d, min = %d",
+ want, update_wantmin);
+ return (0);
+ }
+
+ time(&now);
+ if (!demand_update_time(&now)) {
+ logerror("no demand update, not within hours allowed.");
+ return (0);
+ }
+
+
+ veto = 0;
+ for (cn = 1; 0 != (natp = getnatp(cn)); cn++) {
+ if (((natp->nat_stat & NORM) == NORM) &&
+ ((natp->nat_stat & GOD) != GOD)) {
+ if (natp->nat_missed >= update_missed)
+ veto = cn + 1;
}
+ }
- logerror("last_demand_update = %d\n",last_demand_update);
- logerror("update_between = %d\n",update_between());
- logerror("now = %d\n",cur);
- diff = (cur-(last_demand_update + update_between()));
- logerror("diff = %d\n",diff);
- if (diff >= 0){
- logerror("Forced update!\n");
- last_demand_update = cur;
- for (cn = 1; natp = getnatp(cn); cn++){
- if (((natp->nat_stat & NORM) == NORM) &&
- ((natp->nat_stat & GOD) != GOD)){
- natp->nat_missed = 0;
- }
- }
- return(1);
- }
+ if (veto) {
+ logerror("no demand update, %d has missed more than %d updates",
+ veto - 1, update_missed);
+ return (0);
+ }
- logerror("No forced update!\n");
-*/
- if (0 == update_wantmin) {
- logerror("no demand update allowed, wantmin = 0");
- return(0);
- }
-
- demand_update_want(&want, &pop, 0);
- if (want < update_wantmin) {
- logerror("no demand update, want = %d, min = %d",
- want, update_wantmin);
- return(0);
- }
-
- time(&now);
- if (!demand_update_time(&now)) {
- logerror("no demand update, not within hours allowed.");
- return(0);
- }
-
-
- veto=0;
- for (cn = 1; 0 != (natp = getnatp(cn)); cn++){
- if (((natp->nat_stat & NORM) == NORM) &&
- ((natp->nat_stat & GOD) != GOD)){
- if (natp->nat_missed >= update_missed)
- veto=cn+1;
- }
- }
-
- if (veto){
- logerror("no demand update, %d has missed more than %d updates",
- veto-1, update_missed);
- return(0);
- }
-
- last_demand_update = cur;
- natp=getnatp(0);
- /* A dumb way to do it, but simple */
- last_demand_update = natp->nat_reserve;
- return(1);
+ return (1);
}
/* Check if enough countries want an update,
int
demandupdatecheck(void)
{
- extern int update_demandpolicy;
-
- if (UDDEM_COMSET != update_demandpolicy) {
- logerror("no demand update, not policy.");
- return(0);
- }
+ if (UDDEM_COMSET != update_demandpolicy) {
+ logerror("no demand update, not policy.");
+ return (0);
+ }
- return(demand_check());
+ return (demand_check());
}
/* Is it time for a regular or scheduled update?
int
updatetime(time_t *now)
{
- extern int update_policy;
- int which;
-
- if (opt_BLITZ && update_policy == UDP_BLITZ) {
- logerror("BLITZ Update.");
- return(1);
- }
-
- if (UDP_NORMAL == update_policy) {
- logerror("Regular update, etu type.");
- return(1);
+ if (opt_BLITZ && update_policy == UDP_BLITZ) {
+ logerror("BLITZ Update.");
+ return (1);
+ }
+
+ if (UDP_NORMAL == update_policy) {
+ logerror("Regular update, etu type.");
+ return (1);
+ }
+
+ if (UDP_TIMES == update_policy) {
+ if (scheduled_update_time(now)) {
+ logerror("Scheduled update.");
+ return (1);
}
-
- if (UDP_TIMES == update_policy) {
- if (scheduled_update_time(now, &which)) {
- logerror("Scheduled update, %d.", which);
- return(1);
- }
+ }
+ if (opt_DEMANDUPDATE) {
+ if (demand_check()) {
+ logerror("Demand update, at check time.");
+ return (1);
}
- if (opt_DEMANDUPDATE) {
- if (demand_check()) {
- logerror("Demand update, at check time.");
- return(1);
- }
- }
- return(0);
+ }
+ return (0);
}
/* Return the time, and delta seconds, of the next update.
*/
void
next_update_time(time_t *now, time_t *tim, time_t *delta)
- /* From when */
- /* Time of next update */
- /* Seconds till next update */
+ /* From when */
+ /* Time of next update */
+ /* Seconds till next update */
{
- extern int update_policy;
- time_t stim, sdelta;
- extern int blitz_time;
-
- switch (update_policy) {
- case UDP_NORMAL:
- regular_update_time(now, tim, delta);
- break;
- case UDP_TIMES:
- if (!next_scheduled_time(now, tim, delta))
- regular_update_time(now, tim, delta);
- break;
- case UDP_BLITZ:
- *delta = (blitz_time * 60) - (*now % (blitz_time * 60));
- *tim = *now + *delta;
- break;
-
- case UDP_NOREG:
- default:
- regular_update_time(now, tim, delta);
- if (next_scheduled_time(now, &stim, &sdelta)) {
- if (*delta > sdelta) {
- *delta = sdelta;
- *tim = stim;
- }
- }
- break;
+ time_t stim, sdelta;
+
+ switch (update_policy) {
+ case UDP_NORMAL:
+ regular_update_time(now, tim, delta);
+ break;
+ case UDP_TIMES:
+ if (!next_scheduled_time(now, tim, delta))
+ regular_update_time(now, tim, delta);
+ break;
+ case UDP_BLITZ:
+ *delta = (blitz_time * 60) - (*now % (blitz_time * 60));
+ *tim = *now + *delta;
+ break;
+
+ case UDP_NOREG:
+ default:
+ regular_update_time(now, tim, delta);
+ if (next_scheduled_time(now, &stim, &sdelta)) {
+ if (*delta > sdelta) {
+ *delta = sdelta;
+ *tim = stim;
+ }
}
+ break;
+ }
}
void
next_update_check_time(time_t *now, time_t *tim, time_t *delta)
- /* From when */
- /* Time of next update */
- /* Seconds till next update check */
+ /* From when */
+ /* Time of next update */
+ /* Seconds till next update check */
{
- extern int update_policy;
- time_t stim, sdelta;
- extern int blitz_time;
-
- switch (update_policy) {
- case UDP_NORMAL:
- regular_update_time(now, tim, delta);
- break;
- case UDP_BLITZ:
- *delta = (blitz_time * 60) - (*now % (blitz_time * 60));
- *tim = *now + *delta;
- break;
- case UDP_TIMES:
- case UDP_NOREG:
- default:
- regular_update_time(now, tim, delta);
- if (next_scheduled_time(now, &stim, &sdelta)) {
- if (*delta > sdelta) {
- *delta = sdelta;
- *tim = stim;
- }
- }
+ time_t stim, sdelta;
+
+ switch (update_policy) {
+ case UDP_NORMAL:
+ regular_update_time(now, tim, delta);
+ break;
+ case UDP_BLITZ:
+ *delta = (blitz_time * 60) - (*now % (blitz_time * 60));
+ *tim = *now + *delta;
+ break;
+ case UDP_TIMES:
+ case UDP_NOREG:
+ default:
+ regular_update_time(now, tim, delta);
+ if (next_scheduled_time(now, &stim, &sdelta)) {
+ if (*delta > sdelta) {
+ *delta = sdelta;
+ *tim = stim;
+ }
}
+ }
}
int
updates_disabled(void)
{
- extern s_char *disablefil;
- int fd;
+ int fd;
- if ((fd = open(disablefil, O_RDONLY, 0)) < 0)
- return 0;
- close(fd);
- return 1;
+ if ((fd = open(disablefil, O_RDONLY, 0)) < 0)
+ return 0;
+ close(fd);
+ return 1;
}
projects / empserver / blobdiff