modules/awaystore.cpp
Rama master · réplica de lectura del repositorio original.
/*
* Copyright (C) 2004-2026 ZNC, see the NOTICE file for details.
* Author: imaginos <imaginos@imaginos.net>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Quiet Away and message logger
*
* I originally wrote this module for when I had multiple clients connected to
*ZNC. I would leave work and forget to close my client, arriving at home
* and re-attaching there someone may have messaged me in commute and I wouldn't
*know it until I would arrive back at work the next day. I wrote it such that
* my xchat client would monitor desktop activity and ping the module to let it
*know I was active. Within a few minutes of inactivity the pinging stops and
* the away module sets the user as away and logging commences.
*/
#define REQUIRESSL
#include <znc/main.h>
#include <znc/User.h>
#include <znc/IRCNetwork.h>
#include <znc/FileUtils.h>
#include <znc/Modules.h>
#include <znc/Chan.h>
using std::vector;
using std::map;
#define CRYPT_VERIFICATION_TOKEN "::__:AWAY:__::"
class CAway;
class CAwayJob : public CTimer {
public:
CAwayJob(CModule* pModule, unsigned int uInterval, unsigned int uCycles,
const CString& sLabel, const CString& sDescription)
: CTimer(pModule, uInterval, uCycles, sLabel, sDescription) {}
~CAwayJob() override {}
protected:
void RunJob() override;
};
class CAway : public CModule {
void AwayCommand(const CString& sCommand) {
CString sReason;
timeval curtime;
gettimeofday(&curtime, nullptr);
if (sCommand.Token(1) != "-quiet") {
sReason = CUtils::FormatTime(curtime, sCommand.Token(1, true),
GetUser()->GetTimezone());
PutModNotice(t_s("You have been marked as away"));
} else {
sReason = CUtils::FormatTime(curtime, sCommand.Token(2, true),
GetUser()->GetTimezone());
}
// Update with new message if already away.
Away(true, sReason);
}
void BackCommand(const CString& sCommand) {
if ((m_vMessages.empty()) && (sCommand.Token(1) != "-quiet"))
PutModNotice(t_s("Welcome back!"));
Ping();
Back();
}
void MessagesCommand(const CString& sCommand) {
for (u_int a = 0; a < m_vMessages.size(); a++)
PutModule(m_vMessages[a]);
}
void ReplayCommand(const CString& sCommand) {
CString nick = GetClient()->GetNick();
for (u_int a = 0; a < m_vMessages.size(); a++) {
CString sWhom = m_vMessages[a].Token(1, false, " ");
CString sMessage = m_vMessages[a].Token(2, true, " ");
PutUser(":" + sWhom + " PRIVMSG " + nick + " :" + sMessage);
}
}
void DeleteCommand(const CString& sCommand) {
CString sWhich = sCommand.Token(1);
if (sWhich == "all") {
PutModNotice(t_f("Deleted {1} messages")(m_vMessages.size()));
for (u_int a = 0; a < m_vMessages.size(); a++)
m_vMessages.erase(m_vMessages.begin() + a--);
} else if (sWhich.empty()) {
PutModNotice(t_s("USAGE: delete <num|all>"));
return;
} else {
u_int iNum = sWhich.ToUInt();
if (iNum >= m_vMessages.size()) {
PutModNotice(t_s("Illegal message # requested"));
return;
} else {
m_vMessages.erase(m_vMessages.begin() + iNum);
PutModNotice(t_s("Message erased"));
}
SaveBufferToDisk();
}
}
void SaveCommand(const CString& sCommand) {
if (m_saveMessages) {
SaveBufferToDisk();
PutModNotice(t_s("Messages saved to disk"));
} else {
PutModNotice(t_s("There are no messages to save"));
}
}
void PingCommand(const CString& sCommand) {
Ping();
if (m_bIsAway) Back();
}
void PassCommand(const CString& sCommand) {
CString sNewPass = sCommand.Token(1);
m_sPassword = CBlowfish::MD5(sNewPass);
SaveBufferToDisk();
PutModNotice(t_f("Password updated to [{1}]")(sNewPass));
}
void ShowCommand(const CString& sCommand) {
map<CString, vector<CString>> msvOutput;
for (u_int a = 0; a < m_vMessages.size(); a++) {
CString sTime = m_vMessages[a].Token(0, false);
CString sWhom = m_vMessages[a].Token(1, false);
CString sMessage = m_vMessages[a].Token(2, true);
if ((sTime.empty()) || (sWhom.empty()) || (sMessage.empty())) {
// illegal format
PutModule(t_f("Corrupt message! [{1}]")(m_vMessages[a]));
m_vMessages.erase(m_vMessages.begin() + a--);
continue;
}
time_t iTime = sTime.ToULong();
char szFormat[64];
struct tm t;
localtime_r(&iTime, &t);
size_t iCount = strftime(szFormat, 64, "%F %T", &t);
if (iCount <= 0) {
PutModule(t_f("Corrupt time stamp! [{1}]")(m_vMessages[a]));
m_vMessages.erase(m_vMessages.begin() + a--);
continue;
}
CString sTmp = " " + CString(a) + ") [";
sTmp.append(szFormat, iCount);
sTmp += "] ";
sTmp += sMessage;
msvOutput[sWhom].push_back(sTmp);
}
for (map<CString, vector<CString>>::iterator it = msvOutput.begin();
it != msvOutput.end(); ++it) {
PutModule(it->first);
for (u_int a = 0; a < it->second.size(); a++)
PutModule(it->second[a]);
}
PutModule(t_s("#--- End of messages"));
}
void EnableTimerCommand(const CString& sCommand) {
SetAwayTime(300);
PutModule(t_s("Timer set to 300 seconds"));
}
void DisableTimerCommand(const CString& sCommand) {
SetAwayTime(0);
PutModule(t_s("Timer disabled"));
}
void SetTimerCommand(const CString& sCommand) {
int iSetting = sCommand.Token(1).ToInt();
SetAwayTime(iSetting);
if (iSetting == 0)
PutModule(t_s("Timer disabled"));
else
PutModule(t_f("Timer set to {1} seconds")(iSetting));
}
void TimerCommand(const CString& sCommand) {
PutModule(t_f("Current timer setting: {1} seconds")(GetAwayTime()));
}
public:
MODCONSTRUCTOR(CAway) {
Ping();
m_bIsAway = false;
m_bBootError = false;
m_saveMessages = true;
m_chanMessages = false;
SetAwayTime(300);
AddTimer(
new CAwayJob(this, 60, 0, "AwayJob",
"Checks for idle and saves messages every 1 minute"));
AddHelpCommand();
AddCommand("Away",
static_cast<CModCommand::ModCmdFunc>(&CAway::AwayCommand),
"[-quiet]");
AddCommand("Back",
static_cast<CModCommand::ModCmdFunc>(&CAway::BackCommand),
"[-quiet]");
AddCommand("Messages",
static_cast<CModCommand::ModCmdFunc>(&CAway::MessagesCommand));
AddCommand("Delete",
static_cast<CModCommand::ModCmdFunc>(&CAway::DeleteCommand),
"delete <num|all>");
AddCommand("Save",
static_cast<CModCommand::ModCmdFunc>(&CAway::SaveCommand));
AddCommand("Ping",
static_cast<CModCommand::ModCmdFunc>(&CAway::PingCommand));
AddCommand("Pass",
static_cast<CModCommand::ModCmdFunc>(&CAway::PassCommand));
AddCommand("Show",
static_cast<CModCommand::ModCmdFunc>(&CAway::ShowCommand));
AddCommand("Replay",
static_cast<CModCommand::ModCmdFunc>(&CAway::ReplayCommand));
AddCommand("EnableTimer", static_cast<CModCommand::ModCmdFunc>(
&CAway::EnableTimerCommand));
AddCommand("DisableTimer", static_cast<CModCommand::ModCmdFunc>(
&CAway::DisableTimerCommand));
AddCommand("SetTimer", static_cast<CModCommand::ModCmdFunc>(
&CAway::SetTimerCommand),
"<secs>");
AddCommand("Timer",
static_cast<CModCommand::ModCmdFunc>(&CAway::TimerCommand));
}
~CAway() override {
if (!m_bBootError) SaveBufferToDisk();
}
bool OnLoad(const CString& sArgs, CString& sMessage) override {
CString sMyArgs = sArgs;
size_t uIndex = 0;
if (sMyArgs.Token(0) == "-nostore") {
uIndex++;
m_saveMessages = false;
}
if (sMyArgs.Token(uIndex) == "-chans") {
uIndex++;
m_chanMessages = true;
}
if (sMyArgs.Token(uIndex) == "-notimer") {
SetAwayTime(0);
sMyArgs = sMyArgs.Token(uIndex + 1, true);
} else if (sMyArgs.Token(uIndex) == "-timer") {
SetAwayTime(sMyArgs.Token(uIndex + 1).ToInt());
sMyArgs = sMyArgs.Token(uIndex + 2, true);
}
if (m_saveMessages) {
if (!sMyArgs.empty()) {
m_sPassword = CBlowfish::MD5(sMyArgs);
} else {
sMessage =
t_s("This module needs as an argument a keyphrase used for "
"encryption");
return false;
}
if (!BootStrap()) {
sMessage = t_s(
"Failed to decrypt your saved messages - "
"Did you give the right encryption key as an argument to "
"this module?");
m_bBootError = true;
return false;
}
}
return true;
}
void OnIRCConnected() override {
if (m_bIsAway) {
Away(true); // reset away if we are reconnected
} else {
// ircd seems to remember your away if you killed the client and
// came back
Back();
}
}
bool BootStrap() {
CString sFile;
if (DecryptMessages(sFile)) {
VCString vsLines;
VCString::iterator it;
sFile.Split("\n", vsLines);
for (it = vsLines.begin(); it != vsLines.end(); ++it) {
CString sLine(*it);
sLine.Trim();
AddMessage(sLine);
}
} else {
m_sPassword = "";
CUtils::PrintError("[" + GetModName() +
".so] Failed to Decrypt Messages");
return (false);
}
return (true);
}
void SaveBufferToDisk() {
if (!m_sPassword.empty()) {
CString sFile = CRYPT_VERIFICATION_TOKEN;
for (u_int b = 0; b < m_vMessages.size(); b++)
sFile += m_vMessages[b] + "\n";
CBlowfish c(m_sPassword, BF_ENCRYPT);
sFile = c.Crypt(sFile);
CString sPath = GetPath();
if (!sPath.empty()) {
CFile File(sPath);
if (File.Open(O_WRONLY | O_CREAT | O_TRUNC, 0600)) {
File.Chmod(0600);
File.Write(sFile);
}
File.Close();
}
}
}
void OnClientLogin() override { Back(true); }
void OnClientDisconnect() override { Away(); }
CString GetPath() {
CString sBuffer = GetUser()->GetUsername();
CString sRet = GetSavePath();
sRet += "/.znc-away-" + CBlowfish::MD5(sBuffer, true);
return (sRet);
}
void Away(bool bForce = false, const CString& sReason = "") {
if ((!m_bIsAway) || (bForce)) {
if (!bForce)
m_sReason = sReason;
else if (!sReason.empty())
m_sReason = sReason;
time_t iTime = time(nullptr);
char* pTime = ctime(&iTime);
CString sTime;
if (pTime) {
sTime = pTime;
sTime.Trim();
}
if (m_sReason.empty()) m_sReason = "Auto Away at " + sTime;
PutIRC("AWAY :" + m_sReason);
m_bIsAway = true;
}
}
void Back(bool bUsePrivMessage = false) {
PutIRC("away");
m_bIsAway = false;
if (!m_vMessages.empty()) {
if (bUsePrivMessage) {
PutModule(t_s("Welcome back!"));
PutModule(t_f("You have {1} messages!")(m_vMessages.size()));
} else {
PutModNotice(t_s("Welcome back!"));
PutModNotice(t_f("You have {1} messages!")(m_vMessages.size()));
}
}
m_sReason = "";
}
EModRet OnPrivTextMessage(CTextMessage& Message) override {
if (m_bIsAway) {
const CNick& Nick = Message.GetNick();
CString sMessage = Message.GetText();
AddMessage(time(nullptr), Nick, sMessage);
}
return CONTINUE;
}
EModRet OnChanTextMessage(CTextMessage& Message) override {
if (m_bIsAway && m_chanMessages) {
const CNick& nick = Message.GetNick();
CChan& channel = *Message.GetChan();
CString sMessage = Message.GetText();
if (sMessage.AsLower().find(m_pNetwork->GetCurNick().AsLower()) != CString::npos) {
AddMessage(time(nullptr), nick, channel.GetName() + " " + sMessage);
}
}
return CONTINUE;
}
EModRet OnPrivActionMessage(CActionMessage& Message) override {
if (m_bIsAway) {
const CNick& Nick = Message.GetNick();
CString sMessage = Message.GetText();
AddMessage(time(nullptr), Nick, "* " + sMessage);
}
return CONTINUE;
}
EModRet OnUserTextMessage(CTextMessage& Message) override {
Ping();
if (m_bIsAway) Back();
return CONTINUE;
}
EModRet OnUserNoticeMessage(CNoticeMessage& Message) override {
Ping();
if (m_bIsAway) Back();
return CONTINUE;
}
EModRet OnUserActionMessage(CActionMessage& Message) override {
Ping();
if (m_bIsAway) Back();
return CONTINUE;
}
time_t GetTimeStamp() const { return (m_iLastSentData); }
void Ping() { m_iLastSentData = time(nullptr); }
time_t GetAwayTime() { return m_iAutoAway; }
void SetAwayTime(time_t u) { m_iAutoAway = u; }
bool IsAway() { return (m_bIsAway); }
private:
CString m_sPassword;
bool m_bBootError;
bool DecryptMessages(CString& sBuffer) {
CString sMessages = GetPath();
CString sFile;
sBuffer = "";
CFile File(sMessages);
if (sMessages.empty() || !File.Open() || !File.ReadFile(sFile)) {
PutModule(t_s("Unable to find buffer"));
return (true); // gonna be successful here
}
File.Close();
if (!sFile.empty()) {
CBlowfish c(m_sPassword, BF_DECRYPT);
sBuffer = c.Crypt(sFile);
if (sBuffer.Left(strlen(CRYPT_VERIFICATION_TOKEN)) !=
CRYPT_VERIFICATION_TOKEN) {
// failed to decode :(
PutModule(t_s("Unable to decode encrypted messages"));
return (false);
}
sBuffer.erase(0, strlen(CRYPT_VERIFICATION_TOKEN));
}
return (true);
}
void AddMessage(time_t iTime, const CNick& Nick, const CString& sMessage) {
if (Nick.GetNick() == GetNetwork()->GetIRCNick().GetNick())
return; // ignore messages from self
AddMessage(CString(iTime) + " " + Nick.GetNickMask() + " " + sMessage);
}
void AddMessage(const CString& sText) {
if (m_saveMessages) {
m_vMessages.push_back(sText);
}
}
time_t m_iLastSentData;
bool m_bIsAway;
time_t m_iAutoAway;
vector<CString> m_vMessages;
CString m_sReason;
bool m_saveMessages;
bool m_chanMessages;
};
void CAwayJob::RunJob() {
CAway* p = (CAway*)GetModule();
p->SaveBufferToDisk();
if (!p->IsAway()) {
time_t iNow = time(nullptr);
if ((iNow - p->GetTimeStamp()) > p->GetAwayTime() &&
p->GetAwayTime() != 0)
p->Away();
}
}
template <>
void TModInfo<CAway>(CModInfo& Info) {
Info.SetWikiPage("awaystore");
Info.SetHasArgs(true);
Info.SetArgsHelpText(Info.t_s(
"[ -notimer | -timer N ] [-chans] passw0rd . N is number of seconds, "
"300 by default."));
}
NETWORKMODULEDEFS(
CAway, t_s("Adds auto-away with logging, useful when you use ZNC from "
"different locations"))