void BalloonMgr::post()
{
if (_pending.empty())
return; // No active balloon!?
// Post balloon tip
Balloon &balloon = _pending.front();
NOTIFYICONDATA nid;
nid.hWnd = balloon.hwnd;
nid.cbSize = sizeof(nid);
nid.uID = IDI_APCUPSD;
nid.uFlags = NIF_INFO;
astrncpy(nid.szInfo, balloon.text.c_str(), sizeof(nid.szInfo));
astrncpy(nid.szInfoTitle, balloon.title.c_str(), sizeof(nid.szInfoTitle));
nid.uTimeout = MAX_TIMEOUT;
nid.dwInfoFlags = NIIF_INFO;
Shell_NotifyIcon(NIM_MODIFY, &nid);
// Set a timeout to clear the balloon
LARGE_INTEGER timeout;
if (_pending.size() > 1) // More balloons pending: use minimum timeout
timeout.QuadPart = -(MIN_TIMEOUT * 10000);
else // No other balloons pending: Use maximum timeout
timeout.QuadPart = -(MAX_TIMEOUT * 10000);
SetWaitableTimer(_timer, &timeout, 0, NULL, NULL, false);
// Remember the time at which we started the timer
gettimeofday(&_time, NULL);
}
local Player * CreateFakePlayer(const char *name, Arena *arena, int ship, int freq)
{
Player *p;
/* create pid */
p = pd->NewPlayer(T_FAKE);
if (!p) return NULL;
/* set up pdata struct and pretend he's logged in */
strncpy(p->pkt.name, name, 20);
astrncpy(p->name, name, 21);
strncpy(p->pkt.squad, "", 20);
astrncpy(p->squad, "", 21);
astrncpy(p->clientname, "<internal fake player>", sizeof(p->clientname));
p->p_ship = ship;
p->p_freq = freq;
p->arena = arena;
SET_SEND_DAMAGE(p);
/* enter arena */
if (net) net->SendToArena(arena, p, (byte*)&p->pkt, 64, NET_RELIABLE);
if (chatnet) chatnet->SendToArena(arena, p,
"ENTERING:%s:%d:%d", p->name, ship, freq);
p->status = S_PLAYING;
if (lm)
lm->Log(L_INFO, "<fake> {%s} [%s] fake player created",
arena->name,
p->name);
return p;
}
local void hash_password(const char *name, const char *pwd,
unsigned char out[HASHLEN], char work[NAMELEN+PWLEN])
{
struct MD5Context ctx;
memset(work, 0, NAMELEN+PWLEN);
astrncpy(work, name, NAMELEN);
ToLowerStr(work);
astrncpy(work + NAMELEN, pwd, PWLEN);
MD5Init(&ctx);
MD5Update(&ctx, (unsigned char *)work, NAMELEN+PWLEN);
MD5Final(out, &ctx);
}
local void RemoveGroup(Player *p, const char *info)
{
pdata *pdata = PPDATA(p, pdkey);
if (!p->arena)
return;
/* in all cases, set current group to default */
astrncpy(pdata->group, DEFAULT, MAXGROUPLEN);
switch (pdata->source)
{
case src_default:
/* player is in the default group already, nothing to do */
break;
case src_global:
cfg->SetStr(staff_conf, AG_GLOBAL, p->name, DEFAULT, info, TRUE);
break;
case src_arena:
cfg->SetStr(staff_conf, p->arena->basename, p->name, DEFAULT, info, TRUE);
break;
#ifdef CFG_USE_ARENA_STAFF_LIST
case src_arenalist:
cfg->SetStr(p->arena->cfg, "Staff", p->name, DEFAULT, info);
break;
#endif
case src_temp:
break;
}
}
void ReopenLog(void)
{
const char *ln;
char fname[256];
pthread_mutex_lock(&logmtx);
if (logfile)
fclose(logfile);
/* cfghelp: Log:LogFile, global, string, def: asss.log
* The name of the log file. */
ln = cfg->GetStr(GLOBAL, "Log", "SmodLogFile");
if (!ln) ln = "smod.log";
/* if it has a /, treat it as an absolute path. otherwise, prepend
* 'log/' */
if (strchr(ln, '/'))
astrncpy(fname, ln, sizeof(fname));
else
snprintf(fname, sizeof(fname), "log/%s", ln);
logfile = fopen(fname, "a");
pthread_mutex_unlock(&logmtx);
LogFile("I <log_smod> opening log file ==================================");
}
local void SetTempGroup(Player *p, const char *newgroup)
{
pdata *pdata = PPDATA(p, pdkey);
if (newgroup)
{
astrncpy(pdata->group, newgroup, MAXGROUPLEN);
pdata->source = src_temp;
}
}
local void update_group(Player *p, pdata *pdata, Arena *arena, int log)
{
const char *g;
if (!p->flags.authenticated)
{
/* if the player hasn't been authenticated against either the
* biller or password file, don't assign groups based on name. */
astrncpy(pdata->group, DEFAULT, MAXGROUPLEN);
pdata->source = src_default;
return;
}
if (arena && (g = cfg->GetStr(staff_conf, arena->basename, p->name)))
{
astrncpy(pdata->group, g, MAXGROUPLEN);
pdata->source = src_arena;
if (log)
lm->LogP(L_DRIVEL, "capman", p, "assigned to group '%s' (arena)", pdata->group);
}
#ifdef CFG_USE_ARENA_STAFF_LIST
else if (arena && arena->cfg && (g = cfg->GetStr(arena->cfg, "Staff", p->name)))
{
astrncpy(pdata->group, g, MAXGROUPLEN);
pdata->source = src_arenalist;
if (log)
lm->LogP(L_DRIVEL, "capman", p, "assigned to group '%s' (arenaconf)", pdata->group);
}
#endif
else if ((g = cfg->GetStr(staff_conf, AG_GLOBAL, p->name)))
{
/* only global groups available for now */
astrncpy(pdata->group, g, MAXGROUPLEN);
pdata->source = src_global;
if (log)
lm->LogP(L_DRIVEL, "capman", p, "assigned to group '%s' (global)", pdata->group);
}
else
{
astrncpy(pdata->group, DEFAULT, MAXGROUPLEN);
pdata->source = src_default;
}
}
local void paction(Player *p, int action, Arena *arena)
{
pdata *pdata = PPDATA(p, pdkey);
if (action == PA_PREENTERARENA)
update_group(p, pdata, arena, TRUE);
else if (action == PA_CONNECT)
update_group(p, pdata, NULL, TRUE);
else if (action == PA_DISCONNECT || action == PA_LEAVEARENA)
astrncpy(pdata->group, "none", MAXGROUPLEN);
}
local void SetPermGroup(Player *p, const char *group, int global, const char *info)
{
pdata *pdata = PPDATA(p, pdkey);
/* first set it for the current session */
astrncpy(pdata->group, group, MAXGROUPLEN);
/* now set it permanently */
if (global)
{
cfg->SetStr(staff_conf, AG_GLOBAL, p->name, group, info, TRUE);
pdata->source = src_global;
}
else if (p->arena)
{
cfg->SetStr(staff_conf, p->arena->basename, p->name, group, info, TRUE);
pdata->source = src_arena;
}
}
local void FlagLost(Arena *a, Player *p, int fid, int how)
{
DEF_AD(a);
BDEF_PD(p);
if(how == CLEANUP_DROPPED)
{
FlagOwner *owner = amalloc(sizeof(FlagOwner));
owner->Arena = a;
astrncpy(owner->Name, p->name, sizeof(p->name));
owner->Freq = p->pkt.freq;
owner->FlagID = fid;
ad->FlagOwners[fid] = owner;
pdat->DroppedFlags++;
FlagTeam *team = GetFlagTeam(a, p->pkt.freq);
team->DroppedFlags++;
}
}
local void aaction_work(void *clos)
{
Arena *arena = clos;
LinkedList *dls = P_ARENA_DATA(arena, dlkey);
struct MapDownloadData *data = NULL;
char fname[256];
/* first add the map itself */
/* cfghelp: General:Map, arena, string
* The name of the level file for this arena. */
if (mapdata->GetMapFilename(arena, fname, sizeof(fname), NULL))
data = compress_map(fname, TRUE);
if (!data)
{
/* emergency hardcoded map: */
byte emergencymap[] =
{
0x2a, 0x74, 0x69, 0x6e, 0x79, 0x6d, 0x61, 0x70,
0x2e, 0x6c, 0x76, 0x6c, 0x00, 0x00, 0x00, 0x00,
0x00, 0x78, 0x9c, 0x63, 0x60, 0x60, 0x60, 0x04,
0x00, 0x00, 0x05, 0x00, 0x02
};
lm->LogA(L_WARN, "mapnewsdl", arena, "can't load level file, falling back to tinymap.lvl");
data = amalloc(sizeof(*data));
data->checksum = 0x5643ef8a;
data->uncmplen = 4;
data->cmplen = sizeof(emergencymap);
data->cmpmap = amalloc(sizeof(emergencymap));
memcpy(data->cmpmap, emergencymap, sizeof(emergencymap));
astrncpy(data->filename, "tinymap.lvl", sizeof(data->filename));
}
LLAdd(dls, data);
/* now look for lvzs */
mapdata->EnumLVZFiles(arena, one_lvz_file, dls);
aman->Unhold(arena);
}
/*
* This subroutine polls the APC Smart UPS to find out
* what capabilities it has.
*/
int apcsmart_ups_get_capabilities(UPSINFO *ups)
{
char answer[1000]; /* keep this big to handle big string */
char caps[1000], *cmds, *p;
int i;
write_lock(ups);
/* Get UPS capabilities string */
astrncpy(caps, smart_poll(ups->UPS_Cmd[CI_UPS_CAPS], ups), sizeof(caps));
if (strlen(caps) && (strcmp(caps, "NA") != 0)) {
ups->UPS_Cap[CI_UPS_CAPS] = TRUE;
/* skip version */
for (p = caps; *p && *p != '.'; p++)
;
/* skip alert characters */
for (; *p && *p != '.'; p++)
;
cmds = p; /* point to commands */
if (!*cmds) { /* oops, none */
cmds = NULL;
ups->UPS_Cap[CI_UPS_CAPS] = FALSE;
}
} else {
cmds = NULL; /* No commands string */
}
/*
* Try all the possible UPS capabilities and mark the ones supported.
* If we can get the eprom caps list, use them to jump over the
* unsupported caps, if we can't get the cap list try every known
* capability.
*/
for (i = 0; i <= CI_MAX_CAPS; i++) {
if (ups->UPS_Cmd[i] == 0)
continue;
if (!cmds || strchr(cmds, ups->UPS_Cmd[i]) != NULL) {
astrncpy(answer, smart_poll(ups->UPS_Cmd[i], ups), sizeof(answer));
if (*answer && (strcmp(answer, "NA") != 0)) {
ups->UPS_Cap[i] = true;
}
}
}
/*
* If UPS did not support APC_CMD_UPSMODEL (the default comand for
* CI_UPSMODEL), maybe it supports APC_CMD_OLDFWREV which can be used to
* construct the model number.
*/
if (!ups->UPS_Cap[CI_UPSMODEL] &&
(!cmds || strchr(cmds, APC_CMD_OLDFWREV) != NULL)) {
astrncpy(answer, smart_poll(APC_CMD_OLDFWREV, ups), sizeof(answer));
if (*answer && (strcmp(answer, "NA") != 0)) {
ups->UPS_Cap[CI_UPSMODEL] = true;
ups->UPS_Cmd[CI_UPSMODEL] = APC_CMD_OLDFWREV;
}
}
/*
* If UPS does not support APC_CMD_REVNO (the default command for CI_REVNO),
* maybe it supports APC_CMD_OLDFWREV instead.
*/
if (!ups->UPS_Cap[CI_REVNO] &&
(!cmds || strchr(cmds, APC_CMD_OLDFWREV) != NULL)) {
astrncpy(answer, smart_poll(APC_CMD_OLDFWREV, ups), sizeof(answer));
if (*answer && (strcmp(answer, "NA") != 0)) {
ups->UPS_Cap[CI_REVNO] = true;
ups->UPS_Cmd[CI_REVNO] = APC_CMD_OLDFWREV;
}
}
write_unlock(ups);
return 1;
}
local void new_player(Player *p, int isnew)
{
char *group = ((pdata*)PPDATA(p, pdkey))->group;
if (isnew)
astrncpy(group, "none", MAXGROUPLEN);
}
/*********************************************************************
*
* This subroutine is called to load our shared memory with
* information that is changing inside the UPS depending
* on the state of the UPS and the mains power.
*/
int apcsmart_ups_read_volatile_data(UPSINFO *ups)
{
time_t now;
char *answer;
/*
* We need it for self-test start time.
*/
now = time(NULL);
write_lock(ups);
UPSlinkCheck(ups); /* make sure serial port is working */
ups->poll_time = time(NULL); /* save time stamp */
/* UPS_STATUS */
if (ups->UPS_Cap[CI_STATUS]) {
char status[10];
int retries = 5; /* Number of retries on status read */
again:
answer = smart_poll(ups->UPS_Cmd[CI_STATUS], ups);
Dmsg1(80, "Got CI_STATUS: %s\n", answer);
strncpy(status, answer, sizeof(status));
/*
* The Status command may return "SM" probably because firmware
* is in a state where it still didn't updated its internal status
* register. In this case retry to read the register. To be sure
* not to get stuck here, we retry only 5 times.
*
* XXX
*
* If this fails, apcupsd may not be able to detect a status
* change and will have unpredictable behavior. This will be fixed
* once we will handle correctly the own apcupsd Status word.
*/
if (status[0] == 'S' && status[1] == 'M' && (retries-- > 0))
goto again;
ups->Status &= ~0xFF; /* clear APC byte */
ups->Status |= strtoul(status, NULL, 16) & 0xFF; /* set APC byte */
}
/* ONBATT_STATUS_FLAG -- line quality */
if (ups->UPS_Cap[CI_LQUAL]) {
answer = smart_poll(ups->UPS_Cmd[CI_LQUAL], ups);
Dmsg1(80, "Got CI_LQUAL: %s\n", answer);
astrncpy(ups->linequal, answer, sizeof(ups->linequal));
}
/* Reason for last transfer to batteries */
if (ups->UPS_Cap[CI_WHY_BATT]) {
answer = smart_poll(ups->UPS_Cmd[CI_WHY_BATT], ups);
Dmsg1(80, "Got CI_WHY_BATT: %s\n", answer);
ups->lastxfer = decode_lastxfer(answer);
/*
* XXX
*
* See if this is a self test rather than power failure
* But not now !
* When we will be ready we will copy the code below inside
* the driver entry point, for performing this check inside the
* driver.
*/
}
/* Results of last self test */
if (ups->UPS_Cap[CI_ST_STAT]) {
answer = smart_poll(ups->UPS_Cmd[CI_ST_STAT], ups);
Dmsg1(80, "Got CI_ST_STAT: %s\n", answer);
ups->testresult = decode_testresult(answer);
}
/* LINE_VOLTAGE */
if (ups->UPS_Cap[CI_VLINE]) {
answer = smart_poll(ups->UPS_Cmd[CI_VLINE], ups);
Dmsg1(80, "Got CI_VLINE: %s\n", answer);
ups->LineVoltage = atof(answer);
}
/* UPS_LINE_MAX */
if (ups->UPS_Cap[CI_VMAX]) {
answer = smart_poll(ups->UPS_Cmd[CI_VMAX], ups);
Dmsg1(80, "Got CI_VMAX: %s\n", answer);
ups->LineMax = atof(answer);
}
/* UPS_LINE_MIN */
if (ups->UPS_Cap[CI_VMIN]) {
answer = smart_poll(ups->UPS_Cmd[CI_VMIN], ups);
Dmsg1(80, "Got CI_VMIN: %s\n", answer);
ups->LineMin = atof(answer);
}
/* OUTPUT_VOLTAGE */
if (ups->UPS_Cap[CI_VOUT]) {
answer = smart_poll(ups->UPS_Cmd[CI_VOUT], ups);
Dmsg1(80, "Got CI_VOUT: %s\n", answer);
ups->OutputVoltage = atof(answer);
}
/* BATT_FULL Battery level percentage */
if (ups->UPS_Cap[CI_BATTLEV]) {
answer = smart_poll(ups->UPS_Cmd[CI_BATTLEV], ups);
Dmsg1(80, "Got CI_BATTLEV: %s\n", answer);
ups->BattChg = atof(answer);
}
/* BATT_VOLTAGE */
if (ups->UPS_Cap[CI_VBATT]) {
answer = smart_poll(ups->UPS_Cmd[CI_VBATT], ups);
Dmsg1(80, "Got CI_VBATT: %s\n", answer);
ups->BattVoltage = atof(answer);
}
/* UPS_LOAD */
if (ups->UPS_Cap[CI_LOAD]) {
answer = smart_poll(ups->UPS_Cmd[CI_LOAD], ups);
Dmsg1(80, "Got CI_LOAD: %s\n", answer);
ups->UPSLoad = atof(answer);
}
/* LINE_FREQ */
if (ups->UPS_Cap[CI_FREQ]) {
answer = smart_poll(ups->UPS_Cmd[CI_FREQ], ups);
Dmsg1(80, "Got CI_FREQ: %s\n", answer);
ups->LineFreq = atof(answer);
}
/* UPS_RUNTIME_LEFT */
if (ups->UPS_Cap[CI_RUNTIM]) {
answer = smart_poll(ups->UPS_Cmd[CI_RUNTIM], ups);
Dmsg1(80, "Got CI_RUNTIM: %s\n", answer);
ups->TimeLeft = atof(answer);
}
/* UPS_TEMP */
if (ups->UPS_Cap[CI_ITEMP]) {
answer = smart_poll(ups->UPS_Cmd[CI_ITEMP], ups);
Dmsg1(80, "Got CI_ITEMP: %s\n", answer);
ups->UPSTemp = atof(answer);
}
/* DIP_SWITCH_SETTINGS */
if (ups->UPS_Cap[CI_DIPSW]) {
answer = smart_poll(ups->UPS_Cmd[CI_DIPSW], ups);
Dmsg1(80, "Got CI_DIPSW: %s\n", answer);
ups->dipsw = strtoul(answer, NULL, 16);
}
/* Register 1 */
if (ups->UPS_Cap[CI_REG1]) {
answer = smart_poll(ups->UPS_Cmd[CI_REG1], ups);
Dmsg1(80, "Got CI_REG1: %s\n", answer);
ups->reg1 = strtoul(answer, NULL, 16);
}
/* Register 2 */
if (ups->UPS_Cap[CI_REG2]) {
answer = smart_poll(ups->UPS_Cmd[CI_REG2], ups);
Dmsg1(80, "Got CI_REG2: %s\n", answer);
ups->reg2 = strtoul(answer, NULL, 16);
ups->set_battpresent(!(ups->reg2 & 0x20));
}
/* Register 3 */
if (ups->UPS_Cap[CI_REG3]) {
answer = smart_poll(ups->UPS_Cmd[CI_REG3], ups);
Dmsg1(80, "Got CI_REG3: %s\n", answer);
ups->reg3 = strtoul(answer, NULL, 16);
}
/* Humidity percentage */
if (ups->UPS_Cap[CI_HUMID]) {
answer = smart_poll(ups->UPS_Cmd[CI_HUMID], ups);
Dmsg1(80, "Got CI_HUMID: %s\n", answer);
ups->humidity = atof(answer);
}
/* Ambient temperature */
if (ups->UPS_Cap[CI_ATEMP]) {
answer = smart_poll(ups->UPS_Cmd[CI_ATEMP], ups);
Dmsg1(80, "Got CI_ATEMP: %s\n", answer);
ups->ambtemp = atof(answer);
}
/* Hours since self test */
if (ups->UPS_Cap[CI_ST_TIME]) {
answer = smart_poll(ups->UPS_Cmd[CI_ST_TIME], ups);
Dmsg1(80, "Got CI_ST_TIME: %s\n", answer);
ups->LastSTTime = atof(answer);
}
apc_enable(ups); /* reenable APC serial UPS */
write_unlock(ups);
return SUCCESS;
}
/*********************************************************************
*
* This subroutine is called to load our shared memory with
* information that is static inside the UPS. Hence it
* normally would only be called once when starting up the
* UPS.
*/
int apcsmart_ups_read_static_data(UPSINFO *ups)
{
char *answer;
/* Everything from here on down is non-volitile, that is
* we do not expect it to change while the UPS is running
* unless we explicitly change it.
*/
/* SENSITIVITY */
if (ups->UPS_Cap[CI_SENS]) {
answer = smart_poll(ups->UPS_Cmd[CI_SENS], ups);
Dmsg1(80, "Got CI_SENS: %s\n", answer);
astrncpy(ups->sensitivity, answer, sizeof(ups->sensitivity));
}
/* WAKEUP_DELAY */
if (ups->UPS_Cap[CI_DWAKE]) {
answer = smart_poll(ups->UPS_Cmd[CI_DWAKE], ups);
Dmsg1(80, "Got CI_DWAKE: %s\n", answer);
ups->dwake = (int)atof(answer);
}
/* SLEEP_DELAY */
if (ups->UPS_Cap[CI_DSHUTD]) {
answer = smart_poll(ups->UPS_Cmd[CI_DSHUTD], ups);
Dmsg1(80, "Got CI_DSHUTD: %s\n", answer);
ups->dshutd = (int)atof(answer);
}
/* LOW_TRANSFER_LEVEL */
if (ups->UPS_Cap[CI_LTRANS]) {
answer = smart_poll(ups->UPS_Cmd[CI_LTRANS], ups);
Dmsg1(80, "Got CI_LTRANS: %s\n", answer);
ups->lotrans = (int)atof(answer);
}
/* HIGH_TRANSFER_LEVEL */
if (ups->UPS_Cap[CI_HTRANS]) {
answer = smart_poll(ups->UPS_Cmd[CI_HTRANS], ups);
Dmsg1(80, "Got CI_HTRANS: %s\n", answer);
ups->hitrans = (int)atof(answer);
}
/* UPS_BATT_CAP_RETURN */
if (ups->UPS_Cap[CI_RETPCT]) {
answer = smart_poll(ups->UPS_Cmd[CI_RETPCT], ups);
Dmsg1(80, "Got CI_RETPCT: %s\n", answer);
ups->rtnpct = (int)atof(answer);
}
/* ALARM_STATUS */
if (ups->UPS_Cap[CI_DALARM]) {
answer = smart_poll(ups->UPS_Cmd[CI_DALARM], ups);
Dmsg1(80, "Got CI_DALARM: %s\n", answer);
astrncpy(ups->beepstate, answer, sizeof(ups->beepstate));
}
/* LOWBATT_SHUTDOWN_LEVEL */
if (ups->UPS_Cap[CI_DLBATT]) {
answer = smart_poll(ups->UPS_Cmd[CI_DLBATT], ups);
Dmsg1(80, "Got CI_DLBATT: %s\n", answer);
ups->dlowbatt = (int)atof(answer);
}
/* UPS_NAME */
if (ups->upsname[0] == 0 && ups->UPS_Cap[CI_IDEN]) {
answer = smart_poll(ups->UPS_Cmd[CI_IDEN], ups);
Dmsg1(80, "Got CI_IDEN: %s\n", answer);
astrncpy(ups->upsname, answer, sizeof(ups->upsname));
}
/* UPS_SELFTEST */
if (ups->UPS_Cap[CI_STESTI]) {
answer = smart_poll(ups->UPS_Cmd[CI_STESTI], ups);
Dmsg1(80, "Got CI_STESTI: %s\n", answer);
astrncpy(ups->selftest, answer, sizeof(ups->selftest));
}
/* UPS_MANUFACTURE_DATE */
if (ups->UPS_Cap[CI_MANDAT]) {
answer = smart_poll(ups->UPS_Cmd[CI_MANDAT], ups);
Dmsg1(80, "Got CI_MANDAT: %s\n", answer);
astrncpy(ups->birth, answer, sizeof(ups->birth));
}
/* UPS_SERIAL_NUMBER */
if (ups->UPS_Cap[CI_SERNO]) {
answer = smart_poll(ups->UPS_Cmd[CI_SERNO], ups);
Dmsg1(80, "Got CI_SERNO: %s\n", answer);
astrncpy(ups->serial, answer, sizeof(ups->serial));
}
/* UPS_BATTERY_REPLACE */
if (ups->UPS_Cap[CI_BATTDAT]) {
answer = smart_poll(ups->UPS_Cmd[CI_BATTDAT], ups);
Dmsg1(80, "Got CI_BATTDAT: %s\n", answer);
astrncpy(ups->battdat, answer, sizeof(ups->battdat));
}
/* Nominal output voltage when on batteries */
if (ups->UPS_Cap[CI_NOMOUTV]) {
answer = smart_poll(ups->UPS_Cmd[CI_NOMOUTV], ups);
Dmsg1(80, "Got CI_NOMOUTV: %s\n", answer);
ups->NomOutputVoltage = (int)atof(answer);
}
/* Nominal battery voltage */
if (ups->UPS_Cap[CI_NOMBATTV]) {
answer = smart_poll(ups->UPS_Cmd[CI_NOMBATTV], ups);
Dmsg1(80, "Got CI_NOMBATTV: %s\n", answer);
ups->nombattv = atof(answer);
}
/* Firmware revision */
if (ups->UPS_Cap[CI_REVNO]) {
answer = smart_poll(ups->UPS_Cmd[CI_REVNO], ups);
Dmsg1(80, "Got CI_REVNO: %s\n", answer);
astrncpy(ups->firmrev, answer, sizeof(ups->firmrev));
}
/* Number of external batteries installed */
if (ups->UPS_Cap[CI_EXTBATTS]) {
answer = smart_poll(ups->UPS_Cmd[CI_EXTBATTS], ups);
Dmsg1(80, "Got CI_EXTBATTS: %s\n", answer);
ups->extbatts = (int)atof(answer);
}
/* Number of bad batteries installed */
if (ups->UPS_Cap[CI_BADBATTS]) {
answer = smart_poll(ups->UPS_Cmd[CI_BADBATTS], ups);
Dmsg1(80, "Got CI_BADBATTS: %s\n", answer);
ups->badbatts = (int)atof(answer);
}
/* UPS model */
if (ups->UPS_Cap[CI_UPSMODEL]) {
answer = smart_poll(ups->UPS_Cmd[CI_UPSMODEL], ups);
if (ups->UPS_Cmd[CI_UPSMODEL] == APC_CMD_OLDFWREV) {
/* Derive UPS model from old fw rev */
astrncpy(ups->upsmodel, get_model_from_oldfwrev(answer),
sizeof(ups->upsmodel));
} else {
astrncpy(ups->upsmodel, answer, sizeof(ups->upsmodel));
}
Dmsg1(80, "Got CI_UPSMODEL: %s\n", ups->upsmodel);
}
/* EPROM Capabilities */
if (ups->UPS_Cap[CI_EPROM]) {
answer = smart_poll(ups->UPS_Cmd[CI_EPROM], ups);
Dmsg1(80, "Got CI_EPROM: %s\n", answer);
astrncpy(ups->eprom, answer, sizeof(ups->eprom));
}
return SUCCESS;
}
int powernet_snmp_ups_read_static_data(UPSINFO *ups)
{
struct snmp_ups_internal_data *Sid =
(struct snmp_ups_internal_data *)ups->driver_internal_data;
struct snmp_session *s = &Sid->session;
powernet_mib_t *data = (powernet_mib_t *)Sid->MIB;
if (powernet_check_comm_lost(ups) == 0)
return 0;
data->upsBasicIdent = NULL;
powernet_mib_mgr_get_upsBasicIdent(s, &(data->upsBasicIdent));
if (data->upsBasicIdent) {
SNMP_STRING(upsBasicIdent, Model, upsmodel);
SNMP_STRING(upsBasicIdent, Name, upsname);
free(data->upsBasicIdent);
}
data->upsAdvIdent = NULL;
powernet_mib_mgr_get_upsAdvIdent(s, &(data->upsAdvIdent));
if (data->upsAdvIdent) {
SNMP_STRING(upsAdvIdent, FirmwareRevision, firmrev);
SNMP_STRING(upsAdvIdent, DateOfManufacture, birth);
SNMP_STRING(upsAdvIdent, SerialNumber, serial);
free(data->upsAdvIdent);
}
data->upsBasicBattery = NULL;
powernet_mib_mgr_get_upsBasicBattery(s, &(data->upsBasicBattery));
if (data->upsBasicBattery) {
SNMP_STRING(upsBasicBattery, LastReplaceDate, battdat);
free(data->upsBasicBattery);
}
data->upsAdvBattery = NULL;
powernet_mib_mgr_get_upsAdvBattery(s, &(data->upsAdvBattery));
if (data->upsAdvBattery) {
ups->extbatts = data->upsAdvBattery->__upsAdvBatteryNumOfBattPacks;
ups->badbatts = data->upsAdvBattery->__upsAdvBatteryNumOfBadBattPacks;
free(data->upsAdvBattery);
}
data->upsAdvConfig = NULL;
powernet_mib_mgr_get_upsAdvConfig(s, &(data->upsAdvConfig));
if (data->upsAdvConfig) {
ups->NomOutputVoltage = data->upsAdvConfig->__upsAdvConfigRatedOutputVoltage;
ups->hitrans = data->upsAdvConfig->__upsAdvConfigHighTransferVolt;
ups->lotrans = data->upsAdvConfig->__upsAdvConfigLowTransferVolt;
switch (data->upsAdvConfig->__upsAdvConfigAlarm) {
case 1:
if (data->upsAdvConfig->__upsAdvConfigAlarmTimer / 100 < 30)
astrncpy(ups->beepstate, "0 Seconds", sizeof(ups->beepstate));
else
astrncpy(ups->beepstate, "Timed", sizeof(ups->beepstate));
break;
case 2:
astrncpy(ups->beepstate, "LowBatt", sizeof(ups->beepstate));
break;
case 3:
astrncpy(ups->beepstate, "NoAlarm", sizeof(ups->beepstate));
break;
default:
astrncpy(ups->beepstate, "Timed", sizeof(ups->beepstate));
break;
}
ups->rtnpct = data->upsAdvConfig->__upsAdvConfigMinReturnCapacity;
switch (data->upsAdvConfig->__upsAdvConfigSensitivity) {
case 1:
astrncpy(ups->sensitivity, "Auto", sizeof(ups->sensitivity));
break;
case 2:
astrncpy(ups->sensitivity, "Low", sizeof(ups->sensitivity));
break;
case 3:
astrncpy(ups->sensitivity, "Medium", sizeof(ups->sensitivity));
break;
case 4:
astrncpy(ups->sensitivity, "High", sizeof(ups->sensitivity));
break;
default:
astrncpy(ups->sensitivity, "Unknown", sizeof(ups->sensitivity));
break;
}
/* Data in Timeticks (1/100th sec). */
ups->dlowbatt = data->upsAdvConfig->__upsAdvConfigLowBatteryRunTime / 6000;
ups->dwake = data->upsAdvConfig->__upsAdvConfigReturnDelay / 100;
ups->dshutd = data->upsAdvConfig->__upsAdvConfigShutoffDelay / 100;
free(data->upsAdvConfig);
}
data->upsAdvTest = NULL;
powernet_mib_mgr_get_upsAdvTest(s, &(data->upsAdvTest));
if (data->upsAdvTest) {
switch (data->upsAdvTest->__upsAdvTestDiagnosticSchedule) {
case 1:
astrncpy(ups->selftest, "unknown", sizeof(ups->selftest));
break;
case 2:
astrncpy(ups->selftest, "biweekly", sizeof(ups->selftest));
break;
case 3:
astrncpy(ups->selftest, "weekly", sizeof(ups->selftest));
break;
case 4:
astrncpy(ups->selftest, "atTurnOn", sizeof(ups->selftest));
break;
case 5:
astrncpy(ups->selftest, "never", sizeof(ups->selftest));
break;
default:
astrncpy(ups->selftest, "unknown", sizeof(ups->selftest));
break;
}
switch (data->upsAdvTest->__upsAdvTestDiagnosticsResults) {
case 1: /* Passed */
ups->testresult = TEST_PASSED;
break;
case 2: /* Failed */
case 3: /* Invalid test */
ups->testresult = TEST_FAILED;
break;
case 4: /* Test in progress */
ups->testresult = TEST_INPROGRESS;
break;
default:
ups->testresult = TEST_UNKNOWN;
break;
}
free(data->upsAdvTest);
}
return 1;
}
local void GetInfo(BWLimit *bw, char *buf, int buflen)
{
astrncpy(buf, "(no limit)", buflen);
}
local struct MapDownloadData * compress_map(const char *fname, int docomp)
{
byte *cmap;
uLong csize;
const char *mapname;
struct MapDownloadData *data;
MMapData *mmd;
data = amalloc(sizeof(*data));
/* get basename */
mapname = strrchr(fname, '/');
if (!mapname)
mapname = fname;
else
mapname++;
astrncpy(data->filename, mapname, 20);
mmd = MapFile(fname, FALSE);
if (!mmd)
goto fail1;
/* calculate crc on mmap'd map */
data->checksum = crc32(crc32(0, Z_NULL, 0), mmd->data, mmd->len);
data->uncmplen = mmd->len;
/* allocate space for compressed version */
if (docomp)
csize = (uLong)(1.0011 * mmd->len + 35);
else
csize = mmd->len + 17;
cmap = malloc(csize);
if (!cmap)
{
lm->Log(L_ERROR, "<mapnewsdl> malloc failed in compress_map for %s", fname);
goto fail2;
}
/* set up packet header */
cmap[0] = S2C_MAPDATA;
strncpy((char*)(cmap+1), mapname, 16);
if (docomp)
{
/* compress the stuff! */
compress(cmap+17, &csize, mmd->data, mmd->len);
csize += 17;
/* shrink the allocated memory */
data->cmpmap = realloc(cmap, csize);
if (data->cmpmap == NULL)
{
lm->Log(L_ERROR, "<mapnewsdl> realloc failed in compress_map for %s", fname);
goto fail3;
}
}
else
{
/* just copy */
memcpy(cmap+17, mmd->data, mmd->len);
data->cmpmap = cmap;
}
data->cmplen = csize;
if (csize > 256*1024)
lm->Log(L_WARN, "<mapnewsdl> compressed map/lvz is bigger than 256k: %s", fname);
UnmapFile(mmd);
return data;
fail3:
free(cmap);
fail2:
UnmapFile(mmd);
fail1:
afree(data);
return NULL;
}
local void Cmark(const char *tc, const char *params, Player *p, const Target *target)
{
kothmark *md;
md = (kothmark*)PPDATA(p, markey);
if (*params || (target->type == T_PLAYER))
{
marklistednode *node;
const char *name;
Player *pp;
if (*params)
{
pp = 0;
name = params;
}
else
{
pp = target->u.p;
name = pp->name;
}
#ifdef MARK_SELF_MESSAGE
if (strcasecmp(p->name, name) == 0) {
chat->SendMessage(p,MARK_SELF_MESSAGE);
return;
}
#endif
if (strlen(name) >= MARK_NAME_LENGTH_MAX) {
chat->SendMessage(p,"Mark names must be under %i characters",MARK_NAME_LENGTH_MAX);
return;
}
if (md->listCount >= MARK_MAX_LISTED) {
chat->SendMessage(p,"You may not mark more than %i players",MARK_MAX_LISTED);
return;
}
if (markExists(md,name)) {
#ifdef ACK_MARK_COMMANDS
chat->SendMessage(p,"You have already marked %s", name);
#endif
return;
}
node = amalloc(sizeof(marklistednode));
RETURN_IF(!node)
astrncpy(node->name, name, MARK_NAME_LENGTH_MAX);
LLAdd(&md->listed,node);
++md->listCount;
#ifdef ACK_MARK_COMMANDS
chat->SendMessage(p,"Marked %s",name);
#endif
if (!pp) {
pp = pd->FindPlayer(name);
RETURN_IF(!pp)
}
