/*
* Run a File daemon Job -- File daemon already authorized
* Director sends us this command.
*
* Basic task here is:
* - Read a command from the File daemon
* - Execute it
*
*/
void run_job(JCR *jcr)
{
BSOCK *dir = jcr->dir_bsock;
char ec1[30];
dir->set_jcr(jcr);
Dmsg1(120, "Start run Job=%s\n", jcr->Job);
dir->fsend(Job_start, jcr->Job);
jcr->start_time = time(NULL);
jcr->run_time = jcr->start_time;
jcr->sendJobStatus(JS_Running);
do_fd_commands(jcr);
jcr->end_time = time(NULL);
dequeue_messages(jcr); /* send any queued messages */
jcr->setJobStatus(JS_Terminated);
generate_plugin_event(jcr, bsdEventJobEnd);
dir->fsend(Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles,
edit_uint64(jcr->JobBytes, ec1), jcr->JobErrors);
dir->signal(BNET_EOD); /* send EOD to Director daemon */
free_plugins(jcr); /* release instantiated plugins */
}
bool finish_cmd(JCR *jcr)
{
BSOCK *dir = jcr->dir_bsock;
char ec1[30];
/*
* See if the Job has a certain protocol. Some protocols allow the
* finish cmd some do not (Native backup for example does NOT)
*/
switch (jcr->getJobProtocol()) {
case PT_NDMP:
Dmsg1(200, "Finish_cmd: %s", jcr->dir_bsock->msg);
jcr->end_time = time(NULL);
dequeue_messages(jcr); /* send any queued messages */
jcr->setJobStatus(JS_Terminated);
switch (jcr->getJobType()) {
case JT_BACKUP:
end_of_ndmp_backup(jcr);
break;
case JT_RESTORE:
end_of_ndmp_restore(jcr);
break;
default:
break;
}
generate_plugin_event(jcr, bsdEventJobEnd);
dir->fsend(Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles,
edit_uint64(jcr->JobBytes, ec1), jcr->JobErrors);
dir->signal(BNET_EOD); /* send EOD to Director daemon */
free_plugins(jcr); /* release instantiated plugins */
Dmsg2(800, "Done jid=%d %p\n", jcr->JobId, jcr);
return false; /* Continue DIR session ? */
default:
Dmsg1(200, "Finish_cmd: %s", jcr->dir_bsock->msg);
Jmsg2(jcr, M_FATAL, 0, _("Hey!!!! JobId %u Job %s tries to use finish cmd while not part of protocol.\n"),
(uint32_t)jcr->JobId, jcr->Job);
return false; /* Continue DIR session ? */
}
}
extern "C" __declspec(dllexport) int Load()
{
mir_getLP(&pluginInfo);
srand((unsigned)time(0));
bayesdb = NULL;
if (_getOptB("BayesEnabled", defaultBayesEnabled)) {
if (CheckBayes()) {
OpenBayes();
if (_getOptB("BayesAutolearnNotApproved", defaultBayesAutolearnNotApproved)) {
dequeue_messages();
last_queue_check = time(NULL);
}
}
}
hModulesLoaded = HookEvent(ME_SYSTEM_MODULESLOADED, OnModulesLoaded);
hDBContactAdded = HookEvent(ME_DB_CONTACT_ADDED, OnDBContactAdded);
hDBEventAdded = HookEvent(ME_DB_EVENT_ADDED, OnDBEventAdded);
hDBEventFilterAdd = HookEvent(ME_DB_EVENT_FILTER_ADD, OnDBEventFilterAdd);
return 0;
}
/*
* Run a File daemon Job -- File daemon already authorized
* Director sends us this command.
*
* Basic task here is:
* - Read a command from the File daemon
* - Execute it
*
*/
void run_job(JCR *jcr)
{
BSOCK *dir = jcr->dir_bsock;
char ec1[30];
dir->set_jcr(jcr);
Dmsg1(120, "Start run Job=%s\n", jcr->Job);
dir->fsend(Job_start, jcr->Job);
jcr->start_time = time(NULL);
jcr->run_time = jcr->start_time;
set_jcr_job_status(jcr, JS_Running);
dir_send_job_status(jcr); /* update director */
do_fd_commands(jcr);
jcr->end_time = time(NULL);
dequeue_messages(jcr); /* send any queued messages */
set_jcr_job_status(jcr, JS_Terminated);
generate_daemon_event(jcr, "JobEnd");
dir->fsend(Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles,
edit_uint64(jcr->JobBytes, ec1), jcr->JobErrors);
dir->signal(BNET_EOD); /* send EOD to Director daemon */
return;
}
/*
* Handle Director User Agent commands
*/
static void *handle_UA_client_request(void *arg)
{
int status;
UAContext *ua;
JCR *jcr;
BSOCK *user = (BSOCK *)arg;
pthread_detach(pthread_self());
jcr = new_control_jcr("-Console-", JT_CONSOLE);
ua = new_ua_context(jcr);
ua->UA_sock = user;
set_jcr_in_tsd(INVALID_JCR);
user->recv(); /* Get first message */
if (!authenticate_user_agent(ua)) {
goto getout;
}
while (!ua->quit) {
if (ua->api) {
user->signal(BNET_MAIN_PROMPT);
}
status = user->recv();
if (status >= 0) {
pm_strcpy(ua->cmd, ua->UA_sock->msg);
parse_ua_args(ua);
if (ua->argc > 0 && ua->argk[0][0] == '.') {
do_a_dot_command(ua);
} else {
do_a_command(ua);
}
dequeue_messages(ua->jcr);
if (!ua->quit) {
if (console_msg_pending && acl_access_ok(ua, Command_ACL, "messages")) {
if (ua->auto_display_messages) {
pm_strcpy(ua->cmd, "messages");
qmessages_cmd(ua, ua->cmd);
ua->user_notified_msg_pending = false;
} else if (!ua->gui && !ua->user_notified_msg_pending && console_msg_pending) {
if (ua->api) {
user->signal(BNET_MSGS_PENDING);
} else {
bsendmsg(ua, _("You have messages.\n"));
}
ua->user_notified_msg_pending = true;
}
}
if (!ua->api) {
user->signal(BNET_EOD); /* send end of command */
}
}
} else if (is_bnet_stop(user)) {
ua->quit = true;
} else { /* signal */
user->signal(BNET_POLL);
}
}
getout:
close_db(ua);
free_ua_context(ua);
free_jcr(jcr);
user->close();
delete user;
return NULL;
}
int OnDBEventFilterAdd(WPARAM wParam, LPARAM lParam)
{
HANDLE hContact = (HANDLE)wParam;
DBEVENTINFO *dbei = (DBEVENTINFO *)lParam;
char *msgblob;
POPUPDATA ppdp = {0};
DBTIMETOSTRING tts = {0};
char protoOption[256] = {0};
char *response, *tmp, *challenge;
int buflen = MAX_BUFFER_LENGTH;
TCHAR buf[MAX_BUFFER_LENGTH];
TCHAR *message = NULL, *challengeW = NULL, *tmpW = NULL;
TCHAR *whitelist = NULL, *ptok;
TCHAR mexpr[64];
int maxmsglen = 0, a, b, i;
BOOL bayesEnabled = _getOptB("BayesEnabled", defaultBayesEnabled);
BOOL bCorrectResponse = FALSE;
// get hContact from DBEVENTINFO as icq_proto.c doesn't pass hContact the usual way for some reason.
if (dbei->eventType == EVENTTYPE_AUTHREQUEST)
hContact = *((PHANDLE)(dbei->pBlob+sizeof(DWORD)));
// get maximum length of the message a protocol supports
maxmsglen = CallProtoService(dbei->szModule, PS_GETCAPS, PFLAG_MAXLENOFMESSAGE, (LPARAM)hContact);
/*** Dequeue and learn messages ***/
if (bayesEnabled && _getOptB("BayesAutolearnNotApproved", defaultBayesAutolearnNotApproved))
if (time(NULL) - last_queue_check > 4*3600) { // dequeue every 4 hours
dequeue_messages();
last_queue_check = time(NULL);
}
/*** Check for conditional and unconditional approval ***/
// Pass-through if protocol is not enabled
strcat(protoOption, "proto_");
strcat(protoOption, dbei->szModule);
if (_getOptB(protoOption, 0) == 0) // Protocol is not handled by Spam-o-tron
return 0;
// Pass-through if the event is not of type EVENTTYPE_MESSAGE or EVENTTYPE_AUTHREQUEST
if (dbei->eventType != EVENTTYPE_MESSAGE && dbei->eventType != EVENTTYPE_AUTHREQUEST)
return 0;
// Pass-through if contact is already verified.
if (_getCOptB(hContact, "Verified", 0) == 1)
return 0;
// Pass-through if the event is already read.
if (dbei->flags & DBEF_READ)
return 0;
// Pass-through if event is from a contact that is already in the list.
if (db_get_b(hContact, "CList", "NotOnList", 1) == 0) // Already in the list
return 0;
// Pass-through if event is from a contact that is already in the server-side contact list
if (db_get_w(hContact, dbei->szModule, "ServerId", 0))
return 0;
// Pass-through if contact is a MetaContact
if (db_get_dw(hContact, "MetaContacts", "NumContacts", 0))
return 0;
// Pass-through and approve if outgoing event.
if (dbei->flags & DBEF_SENT) {
if (_getOptB("ApproveOnMsgOut", 0)) {
_setCOptB(hContact, "Verified", 1);
if (_getOptB("AddPermanently", defaultAddPermanently))
db_unset(hContact, "CList", "NotOnList");
db_unset(hContact, "CList", "Delete");
}
return 0;
}
// Hide the contact until verified if option set.
if (_getOptB("HideUnverified", defaultHideUnverified))
db_set_b(hContact, "CList", "Hidden", 1);
// Fetch the incoming message body
if (dbei->eventType == EVENTTYPE_MESSAGE) {
msgblob = (char *)dbei->pBlob;
} else if (dbei->eventType == EVENTTYPE_AUTHREQUEST) {
msgblob = (char *)(dbei->pBlob + sizeof(DWORD) + sizeof(HANDLE));
for(a=4;a>0;a--)
msgblob += strlen(msgblob)+1;
}
if (dbei->flags & DBEF_UTF)
message = mir_utf8decodeW(msgblob);
else
message = mir_a2u(msgblob);
/*** Check for words in white-list ***/
if (_getOptB("ApproveOnMsgIn", defaultApproveOnMsgIn)) {
whitelist = (TCHAR*)malloc(2048 * sizeof(TCHAR));
if (whitelist != NULL) {
_getOptS(whitelist, 2048, "ApproveOnMsgInWordlist", defaultApproveOnMsgInWordlist);
if (_isregex(whitelist)) {
if (_regmatch(message, whitelist))
bCorrectResponse = TRUE;
} else {
ptok = _tcstok(whitelist, L" ");
while (ptok != NULL) {
if (_tcsstr(message, ptok)) {
bCorrectResponse = TRUE;
break;
}
ptok = _tcstok(NULL, L" ");
}
}
free(whitelist);
if (bCorrectResponse) {
_setCOptB(hContact, "Verified", 1);
if (_getOptB("HideUnverified", defaultHideUnverified))
db_unset(hContact, "CList", "Hidden");
if (_getOptB("AddPermanently", defaultAddPermanently))
db_unset(hContact, "CList", "NotOnList");
db_unset(hContact, "CList", "Delete");
if (_getOptB("ReplyOnSuccess", defaultReplyOnSuccess) && (_getCOptB(hContact, "MsgSent", 0))) {
tmp = mir_u2a(_getOptS(buf, buflen, "SuccessResponse", defaultSuccessResponse));
response = mir_utf8encode(tmp);
mir_free(tmp);
CallContactService(hContact, PSS_MESSAGE, PREF_UTF, (LPARAM)response);
mir_free(response);
}
return 0;
}
}
}
/*** Check for correct answer ***/
switch (_getOptB("Mode", defaultMode))
{
case SPAMOTRON_MODE_ROTATE:
case SPAMOTRON_MODE_RANDOM:
get_response(buf, buflen, _getCOptD(hContact, "ResponseNum", 0));
if (_isregex(buf)) {
if (_regmatch(message, buf))
bCorrectResponse = TRUE;
} else {
if (_tcsstr_cc(message, buf, _getOptB("ResponseCC", defaultResponseCC)) &&
(_tcslen(message) == _tcslen(buf)))
bCorrectResponse = TRUE;
}
break;
case SPAMOTRON_MODE_PLAIN:
_getOptS(buf, buflen, "Response", defaultResponse);
i = get_response_num(buf);
while (i-- > 0) {
get_response(buf, buflen, i-1);
if (_isregex(buf)) {
if (_regmatch(message, buf)) {
bCorrectResponse = TRUE;
break;
}
} else {
if (_tcsstr_cc(message, buf, _getOptB("ResponseCC", defaultResponseCC)) &&
(_tcslen(message) == _tcslen(buf))) {
bCorrectResponse = TRUE;
break;
}
}
}
break;
case SPAMOTRON_MODE_MATH:
if (message == NULL)
break;
_itot(_getCOptD(hContact, "ResponseMath", -1), buf, 10);
if (_tcsstr(message, buf) && (_tcslen(buf) == _tcslen(message))) {
bCorrectResponse = TRUE;
}
break;
}
if (bCorrectResponse)
{
_setCOptB(hContact, "Verified", 1);
if (_getOptB("HideUnverified", defaultHideUnverified))
db_unset(hContact, "CList", "Hidden");
if (_getOptB("AddPermanently", defaultAddPermanently))
db_unset(hContact, "CList", "NotOnList");
db_unset(hContact, "CList", "Delete");
db_unset(hContact, "CList", "ResponseNum");
if (_getOptB("ReplyOnSuccess", defaultReplyOnSuccess)) {
tmp = mir_u2a(_getOptS(buf, buflen, "SuccessResponse", defaultSuccessResponse));
response = mir_utf8encode(tmp);
mir_free(tmp);
CallContactService(hContact, PSS_MESSAGE, PREF_UTF, (LPARAM)response);
mir_free(response);
}
_notify(hContact, POPUP_APPROVED, TranslateT("Contact %s approved."), NULL);
// Resubmit pending authorization request
if (_getCOptB(hContact, "AuthEventPending", FALSE)) {
DBVARIANT _dbv;
TCHAR AuthEventModule[100];
char* szAuthEventModule;
if (db_get(hContact, PLUGIN_NAME, "AuthEvent", &_dbv) == 0) {
DBEVENTINFO *_dbei = (DBEVENTINFO *)malloc(sizeof(DBEVENTINFO));
if (_dbei != NULL) {
memcpy(&_dbei->cbBlob, _dbv.pbVal, sizeof(DWORD));
_dbei->eventType = EVENTTYPE_AUTHREQUEST;
_getCOptS(AuthEventModule, 100, hContact, "AuthEventModule", _T("ICQ"));
szAuthEventModule = mir_u2a(AuthEventModule);
_dbei->szModule = szAuthEventModule;
_dbei->timestamp = dbei->timestamp;
_dbei->flags = 0;
_dbei->cbSize = sizeof(DBEVENTINFO);
_dbei->pBlob = _dbv.pbVal + sizeof(DWORD);
db_event_add(hContact,_dbei);
db_unset(hContact, PLUGIN_NAME, "AuthEvent");
db_unset(hContact, PLUGIN_NAME, "AuthEventPending");
db_unset(hContact, PLUGIN_NAME, "AuthEventModule");
mir_free(szAuthEventModule);
free(_dbei);
}
db_free(&_dbv);
}
}
// User approved, learn from previous messages
if (bayesEnabled && _getOptB("BayesAutolearnApproved", defaultBayesAutolearnApproved))
bayes_approve_contact(hContact);
// Mark previous messages unread if option set
if (_getOptB("KeepBlockedMsg", defaultKeepBlockedMsg) &&
_getOptB("MarkMsgUnreadOnApproval", defaultMarkMsgUnreadOnApproval) &&
hContact != NULL) {
// We will mark unread all blocked messages for the most recent day
MarkUnread(hContact);
}
return 1;
}
/*** Check for rejection ***/
// Completely reject if challenge was already sent today for MaxMsgContactCountPerDay times
// and the option is turned on.
if (isOneDay(dbei->timestamp, _getCOptD(hContact, "MsgSentTime", 0)) &&
_getOptD("MaxMsgContactCountPerDay", defaultMaxMsgContactCountPerDay) > 0 &&
_getCOptD(hContact, "MsgSent", 0) >= _getOptD("MaxMsgContactCountPerDay", defaultMaxMsgContactCountPerDay)) {
_notify(hContact, POPUP_BLOCKED, TranslateT("Message from %s rejected because it reached a maximum for challenge requests per day."), message);
if (bayesEnabled)
queue_message(hContact, dbei->timestamp, message);
return 1;
}
// Completely reject if duplicate incoming message found
if (_getOptD("MaxSameMsgCountPerDay", defaultMaxSameMsgCountPerDay) > 0 &&
_getCOptD(hContact, "SameMsgCount", 0) >= _getOptD("MaxSameMsgCountPerDay", defaultMaxSameMsgCountPerDay) &&
_tcscmp(message, _getCOptS(buf, buflen, hContact, "LastInMsg", _T(""))) == 0) {
_notify(hContact, POPUP_BLOCKED, TranslateT("Message from %s rejected because it reached a maximum for same responses per day."), message);
if (bayesEnabled)
queue_message(hContact, dbei->timestamp, message);
return 1;
}
// Completely reject if incoming message contains any word from DontReplyMsgWordlist option
if (_getOptB("DontReplyMsg", defaultDontReplyMsg) &&
Contains(message, _getOptS(buf, buflen, "DontReplyMsgWordlist", defaultDontReplyMsgWordlist))) {
_notify(hContact, POPUP_BLOCKED, TranslateT("Message from %s dropped because it has a word from black list."), message);
return 1;
}
/*** Bayes checks ***/
// Drop if score > spam score
if (bayesEnabled && _getOptB("BayesBlockMsg", defaultBayesBlockMsg))
if (get_msg_score(message) >= (double)_getOptD("BayesSpamScore", defaultBayesSpamScore) * SCORE_C) {
_notify(hContact, POPUP_BLOCKED, TranslateT("Message from %s dropped because of high spam score."), message);
if (bayesEnabled && _getOptB("BayesAutolearnNotApproved", defaultBayesAutolearnNotApproved))
queue_message(hContact, dbei->timestamp, message);
return 1;
}
// Accept if score < ham score
if (bayesEnabled && _getOptB("BayesAutoApprove", defaultBayesAutoApprove))
if (get_msg_score(message) <= (double)_getOptD("BayesHamScore", defaultBayesHamScore) * SCORE_C) {
_notify(hContact, POPUP_APPROVED, TranslateT("Contact %s approved."), message);
_setCOptB(hContact, "Verified", 1);
if (_getOptB("HideUnverified", defaultHideUnverified))
db_unset(hContact, "CList", "Hidden");
if (_getOptB("AddPermanently", defaultAddPermanently))
db_unset(hContact, "CList", "NotOnList");
db_unset(hContact, "CList", "Delete");
if (bayesEnabled &&
_getOptB("BayesAutolearnApproved", defaultBayesAutolearnApproved) &&
_getOptB("BayesAutolearnAutoApproved", defaultBayesAutolearnAutoApproved)) {
queue_message(hContact, dbei->timestamp, message);
bayes_approve_contact(hContact);
}
return 0;
}
// Accept if event is EVENTTYPE_AUTHREQUEST and ReplyOnAuth is NOT set
if (dbei->eventType == EVENTTYPE_AUTHREQUEST && !_getOptB("ReplyOnAuth", defaultReplyOnAuth))
return 0;
// Accept if event is EVENTTYPE_MESSAGE and ReplyOnMsg is NOT set
if (dbei->eventType == EVENTTYPE_MESSAGE && !_getOptB("ReplyOnMsg", defaultReplyOnMsg))
return 0;
/*** Send Challenge ***/
challengeW = (TCHAR *)malloc(maxmsglen*sizeof(TCHAR));
tmpW = (TCHAR *)malloc(maxmsglen*sizeof(TCHAR));
switch (_getOptB("Mode", defaultMode))
{
case SPAMOTRON_MODE_PLAIN:
if (dbei->eventType == EVENTTYPE_AUTHREQUEST)
_getOptS(challengeW, maxmsglen, "AuthChallenge", defaultAuthChallenge);
else
_getOptS(challengeW, maxmsglen, "Challenge", defaultChallenge);
ReplaceVars(challengeW, maxmsglen);
tmp = mir_u2a(challengeW);
challenge = mir_utf8encode(tmp);
mir_free(tmp);
CallContactService(hContact, PSS_MESSAGE, PREF_UTF, (LPARAM)challenge);
mir_free(challenge);
_notify(hContact, POPUP_CHALLENGE, TranslateT("Sending plain challenge to %s."), message);
break;
case SPAMOTRON_MODE_ROTATE:
if (dbei->eventType == EVENTTYPE_AUTHREQUEST)
_getOptS(challengeW, maxmsglen, "AuthChallenge", defaultAuthChallenge);
else
_getOptS(challengeW, maxmsglen, "Challenge", defaultChallenge);
_getOptS(buf, buflen, "Response", defaultResponse);
if (_getCOptD(hContact, "ResponseNum", 0) >= (unsigned int)(get_response_num(buf)-1)) {
_setCOptD(hContact, "ResponseNum", -1);
}
_setCOptD(hContact, "ResponseNum", _getCOptD(hContact, "ResponseNum", -1) + 1);
ReplaceVarsNum(challengeW, maxmsglen, _getCOptD(hContact, "ResponseNum", 0));
tmp = mir_u2a(challengeW);
challenge = mir_utf8encode(tmp);
mir_free(tmp);
CallContactService(hContact, PSS_MESSAGE, PREF_UTF, (LPARAM)challenge);
mir_free(challenge);
_notify(hContact, POPUP_CHALLENGE, TranslateT("Sending round-robin challenge to %s."), message);
break;
case SPAMOTRON_MODE_RANDOM:
if (dbei->eventType == EVENTTYPE_AUTHREQUEST)
_getOptS(challengeW, maxmsglen, "AuthChallenge", defaultAuthChallenge);
else
_getOptS(challengeW, maxmsglen, "Challenge", defaultChallenge);
_getOptS(buf, buflen, "Response", defaultResponse);
srand(time(NULL));
_setCOptD(hContact, "ResponseNum", rand() % get_response_num(buf));
ReplaceVarsNum(challengeW, maxmsglen, _getCOptD(hContact, "ResponseNum", 0));
tmp = mir_u2a(challengeW);
challenge = mir_utf8encode(tmp);
mir_free(tmp);
CallContactService(hContact, PSS_MESSAGE, PREF_UTF, (LPARAM)challenge);
mir_free(challenge);
_notify(hContact, POPUP_CHALLENGE, TranslateT("Sending random challenge to %s."), message);
break;
case SPAMOTRON_MODE_MATH:
a = (rand() % 10) + 1;
b = (rand() % 10) + 1;
mir_sntprintf(mexpr, sizeof(mexpr), _T("%d + %d"), a, b);
if (dbei->eventType == EVENTTYPE_AUTHREQUEST)
_getOptS(challengeW, maxmsglen, "AuthChallengeMath", defaultAuthChallengeMath);
else
_getOptS(challengeW, maxmsglen, "ChallengeMath", defaultChallengeMath);
ReplaceVar(challengeW, maxmsglen, _T("%mathexpr%"), mexpr);
_setCOptD(hContact, "ResponseMath", a + b);
tmp = mir_u2a(challengeW);
challenge = mir_utf8encode(tmp);
mir_free(tmp);
CallContactService(hContact, PSS_MESSAGE, PREF_UTF, (LPARAM)challenge);
mir_free(challenge);
_notify(hContact, POPUP_CHALLENGE, TranslateT("Sending math expression challenge to %s."), message);
break;
}
free(challengeW);
free(tmpW);
// As a workaround for temporary NotOnList contact not being deleted from server-side list
// (which was added by the ICQ server itself upon first outgoing challenge request message)
// we need to set Delete setting, so that contacts gets deleted on next restart/connect.
db_set_b(hContact, "CList", "Delete", 1);
// Queue user message in Bayes db
if (bayesEnabled && message != NULL)
queue_message(hContact, dbei->timestamp, message);
/*** Do any post-send procedures we need to do ***/
// Increment MsgSent if it was sent the same day. Otherwise set it to 1.
if (isOneDay(dbei->timestamp, _getCOptD(hContact, "MsgSentTime",0)))
_setCOptD(hContact, "MsgSent", _getCOptD(hContact, "MsgSent", 0)+1);
else
_setCOptD(hContact, "MsgSent", 1);
_setCOptD(hContact, "MsgSentTime", dbei->timestamp);
// Save Last Msg and update SameMsgCount
if (message != NULL) {
if (_tcscmp(_getCOptS(buf, buflen, hContact, "LastInMsg", _T("")), message) == 0)
_setCOptD(hContact, "SameMsgCount", 1+_getCOptD(hContact, "SameMsgCount", 0));
else
_setCOptD(hContact, "SameMsgCount", 1);
_setCOptTS(hContact, "LastInMsg", message);
}
if (message != NULL)
mir_free(message);
// Finally silently save the message to contact history if corresponding option is set
if (_getOptB("KeepBlockedMsg", defaultKeepBlockedMsg)) {
if (dbei->eventType == EVENTTYPE_AUTHREQUEST) {
// Save the request to database so that it can be automatically submitted on user approval
PBYTE eventdata = (PBYTE)malloc(sizeof(DWORD) + dbei->cbBlob);
if (eventdata != NULL && dbei->cbBlob > 0) {
memcpy(eventdata, &dbei->cbBlob, sizeof(DWORD));
memcpy(eventdata + sizeof(DWORD), dbei->pBlob, dbei->cbBlob);
db_set_blob(hContact, PLUGIN_NAME, "AuthEvent", eventdata, sizeof(DWORD) + dbei->cbBlob);
_setCOptS(hContact, "AuthEventModule", dbei->szModule);
_setCOptB(hContact, "AuthEventPending", TRUE);
free(eventdata);
}
} else {
if (_getOptB("MarkMsgUnreadOnApproval", defaultMarkMsgUnreadOnApproval)) {
DBVARIANT _dbv;
DWORD dbei_size = 3*sizeof(DWORD) + sizeof(WORD) + dbei->cbBlob + (DWORD)strlen(dbei->szModule)+1;
PBYTE eventdata = (PBYTE)malloc(dbei_size);
PBYTE pos = eventdata;
if (eventdata != NULL && dbei->cbBlob > 0) {
if (db_get(hContact, PLUGIN_NAME, "LastMsgEvents", &_dbv) == 0) {
eventdata = (PBYTE)realloc(eventdata, dbei_size + _dbv.cpbVal);
pos = eventdata;
memcpy(eventdata, _dbv.pbVal, _dbv.cpbVal);
pos += _dbv.cpbVal;
db_free(&_dbv);
}
memcpy(pos, &dbei->eventType, sizeof(WORD));
memcpy(pos+sizeof(WORD), &dbei->flags, sizeof(DWORD));
memcpy(pos+sizeof(WORD)+sizeof(DWORD), &dbei->timestamp, sizeof(DWORD));
memcpy(pos+sizeof(WORD)+sizeof(DWORD)*2, dbei->szModule, strlen(dbei->szModule)+1);
memcpy(pos+sizeof(WORD)+sizeof(DWORD)*2+strlen(dbei->szModule)+1, &dbei->cbBlob, sizeof(DWORD));
memcpy(pos+sizeof(WORD)+sizeof(DWORD)*3+strlen(dbei->szModule)+1, dbei->pBlob, dbei->cbBlob);
db_set_blob(hContact, PLUGIN_NAME, "LastMsgEvents", eventdata, (pos - eventdata) + dbei_size);
free(eventdata);
}
} else {
dbei->flags |= DBEF_READ;
db_event_add(hContact, dbei);
}
}
}
return 1;
}
void b_free_jcr(const char *file, int line, JCR *jcr)
{
struct s_last_job *je;
Dmsg3(dbglvl, "Enter free_jcr jid=%u from %s:%d\n", jcr->JobId, file, line);
#else
void free_jcr(JCR *jcr)
{
struct s_last_job *je;
Dmsg3(dbglvl, "Enter free_jcr jid=%u use_count=%d Job=%s\n",
jcr->JobId, jcr->use_count(), jcr->Job);
#endif
lock_jcr_chain();
jcr->dec_use_count(); /* decrement use count */
if (jcr->use_count() < 0) {
Jmsg2(jcr, M_ERROR, 0, _("JCR use_count=%d JobId=%d\n"),
jcr->use_count(), jcr->JobId);
}
if (jcr->JobId > 0) {
Dmsg3(dbglvl, "Dec free_jcr jid=%u use_count=%d Job=%s\n",
jcr->JobId, jcr->use_count(), jcr->Job);
}
if (jcr->use_count() > 0) { /* if in use */
unlock_jcr_chain();
return;
}
if (jcr->JobId > 0) {
Dmsg3(dbglvl, "remove jcr jid=%u use_count=%d Job=%s\n",
jcr->JobId, jcr->use_count(), jcr->Job);
}
remove_jcr(jcr); /* remove Jcr from chain */
unlock_jcr_chain();
dequeue_messages(jcr);
job_end_pop(jcr); /* pop and call hooked routines */
Dmsg1(dbglvl, "End job=%d\n", jcr->JobId);
/*
* Keep some statistics
*/
switch (jcr->getJobType()) {
case JT_BACKUP:
case JT_VERIFY:
case JT_RESTORE:
case JT_MIGRATE:
case JT_COPY:
case JT_ADMIN:
/*
* Keep list of last jobs, but not Console where JobId==0
*/
if (jcr->JobId > 0) {
lock_last_jobs_list();
num_jobs_run++;
je = (struct s_last_job *)malloc(sizeof(struct s_last_job));
memset(je, 0, sizeof(struct s_last_job)); /* zero in case unset fields */
je->Errors = jcr->JobErrors;
je->JobType = jcr->getJobType();
je->JobId = jcr->JobId;
je->VolSessionId = jcr->VolSessionId;
je->VolSessionTime = jcr->VolSessionTime;
bstrncpy(je->Job, jcr->Job, sizeof(je->Job));
je->JobFiles = jcr->JobFiles;
je->JobBytes = jcr->JobBytes;
je->JobStatus = jcr->JobStatus;
je->JobLevel = jcr->getJobLevel();
je->start_time = jcr->start_time;
je->end_time = time(NULL);
if (!last_jobs) {
init_last_jobs_list();
}
last_jobs->append(je);
if (last_jobs->size() > max_last_jobs) {
je = (struct s_last_job *)last_jobs->first();
last_jobs->remove(je);
free(je);
}
unlock_last_jobs_list();
}
break;
default:
break;
}
close_msg(jcr); /* close messages for this job */
if (jcr->daemon_free_jcr) {
jcr->daemon_free_jcr(jcr); /* call daemon free routine */
}
free_common_jcr(jcr);
close_msg(NULL); /* flush any daemon messages */
Dmsg0(dbglvl, "Exit free_jcr\n");
}
/*
* Remove jcr from thread specific data, but
* but make sure it is us who are attached.
*/
void remove_jcr_from_tsd(JCR *jcr)
{
JCR *tjcr = get_jcr_from_tsd();
if (tjcr == jcr) {
set_jcr_in_tsd(INVALID_JCR);
}
}
/*
* This is the engine called by jobq.c:jobq_add() when we were pulled
* from the work queue.
* At this point, we are running in our own thread and all
* necessary resources are allocated -- see jobq.c
*/
static void *job_thread(void *arg)
{
JCR *jcr = (JCR *)arg;
pthread_detach(pthread_self());
Dsm_check(100);
Dmsg0(200, "=====Start Job=========\n");
jcr->setJobStatus(JS_Running); /* this will be set only if no error */
jcr->start_time = time(NULL); /* set the real start time */
jcr->jr.StartTime = jcr->start_time;
if (jcr->res.job->MaxStartDelay != 0 && jcr->res.job->MaxStartDelay <
(utime_t)(jcr->start_time - jcr->sched_time)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
}
if (job_check_maxrunschedtime(jcr)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max run sched time exceeded.\n"));
}
/* TODO : check if it is used somewhere */
if (jcr->res.job->RunScripts == NULL) {
Dmsg0(200, "Warning, job->RunScripts is empty\n");
jcr->res.job->RunScripts = New(alist(10, not_owned_by_alist));
}
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
/* Run any script BeforeJob on dird */
run_scripts(jcr, jcr->res.job->RunScripts, "BeforeJob");
/*
* We re-update the job start record so that the start
* time is set after the run before job. This avoids
* that any files created by the run before job will
* be saved twice. They will be backed up in the current
* job, but not in the next one unless they are changed.
* Without this, they will be backed up in this job and
* in the next job run because in that case, their date
* is after the start of this run.
*/
jcr->start_time = time(NULL);
jcr->jr.StartTime = jcr->start_time;
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
generate_plugin_event(jcr, bDirEventJobRun);
switch (jcr->getJobType()) {
case JT_BACKUP:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_backup(jcr)) {
do_autoprune(jcr);
} else {
ndmp_backup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_backup_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
if (do_native_vbackup(jcr)) {
do_autoprune(jcr);
} else {
native_vbackup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
if (do_native_backup(jcr)) {
do_autoprune(jcr);
} else {
native_backup_cleanup(jcr, JS_ErrorTerminated);
}
}
} else {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
native_vbackup_cleanup(jcr, JS_Canceled);
} else {
native_backup_cleanup(jcr, JS_Canceled);
}
}
break;
}
break;
case JT_VERIFY:
if (!job_canceled(jcr)) {
if (do_verify(jcr)) {
do_autoprune(jcr);
} else {
verify_cleanup(jcr, JS_ErrorTerminated);
}
} else {
verify_cleanup(jcr, JS_Canceled);
}
break;
case JT_RESTORE:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_restore(jcr)) {
do_autoprune(jcr);
} else {
ndmp_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_restore_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (do_native_restore(jcr)) {
do_autoprune(jcr);
} else {
native_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
native_restore_cleanup(jcr, JS_Canceled);
}
break;
}
break;
case JT_ADMIN:
if (!job_canceled(jcr)) {
if (do_admin(jcr)) {
do_autoprune(jcr);
} else {
admin_cleanup(jcr, JS_ErrorTerminated);
}
} else {
admin_cleanup(jcr, JS_Canceled);
}
break;
case JT_COPY:
case JT_MIGRATE:
if (!job_canceled(jcr)) {
if (do_migration(jcr)) {
do_autoprune(jcr);
} else {
migration_cleanup(jcr, JS_ErrorTerminated);
}
} else {
migration_cleanup(jcr, JS_Canceled);
}
break;
default:
Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType());
break;
}
run_scripts(jcr, jcr->res.job->RunScripts, "AfterJob");
/* Send off any queued messages */
if (jcr->msg_queue && jcr->msg_queue->size() > 0) {
dequeue_messages(jcr);
}
generate_plugin_event(jcr, bDirEventJobEnd);
Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus);
Dsm_check(100);
return NULL;
}
void update_job_end(JCR *jcr, int TermCode)
{
dequeue_messages(jcr); /* display any queued messages */
jcr->setJobStatus(TermCode);
update_job_end_record(jcr);
}
/*
* Read Data and commit to new job.
*/
bool do_mac_run(JCR *jcr)
{
DEVICE *dev;
char ec1[50];
const char *Type;
bool ok = true;
BSOCK *dir = jcr->dir_bsock;
switch(jcr->getJobType()) {
case JT_MIGRATE:
Type = "Migration";
break;
case JT_ARCHIVE:
Type = "Archive";
break;
case JT_COPY:
Type = "Copy";
break;
case JT_BACKUP:
Type = "Virtual Backup";
break;
default:
Type = "Unknown";
break;
}
Dmsg0(20, "Start read data.\n");
if (jcr->NumReadVolumes == 0) {
Jmsg(jcr, M_FATAL, 0, _("No Volume names found for %s.\n"), Type);
goto bail_out;
}
/*
* Check autoinflation/autodeflation settings.
*/
check_auto_xflation(jcr);
/*
* See if we perform both read and write or read only.
*/
if (jcr->remote_replicate) {
BSOCK *sd;
if (!jcr->read_dcr) {
Jmsg(jcr, M_FATAL, 0, _("Read device not properly initialized.\n"));
goto bail_out;
}
Dmsg1(100, "read_dcr=%p\n", jcr->read_dcr);
Dmsg3(200, "Found %d volumes names for %s. First=%s\n",
jcr->NumReadVolumes, Type, jcr->VolList->VolumeName);
/*
* Ready devices for reading.
*/
if (!acquire_device_for_read(jcr->read_dcr)) {
ok = false;
goto bail_out;
}
Dmsg2(200, "===== After acquire pos %u:%u\n", jcr->read_dcr->dev->file, jcr->read_dcr->dev->block_num);
jcr->sendJobStatus(JS_Running);
/*
* Set network buffering.
*/
sd = jcr->store_bsock;
if (!sd->set_buffer_size(me->max_network_buffer_size, BNET_SETBUF_WRITE)) {
Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size SD->SD.\n"));
ok = false;
goto bail_out;
}
/*
* Let the remote SD know we are about to start the replication.
*/
sd->fsend(start_replicate);
Dmsg1(110, ">stored: %s", sd->msg);
/*
* Expect to receive back the Ticket number.
*/
if (bget_msg(sd) >= 0) {
Dmsg1(110, "<stored: %s", sd->msg);
if (sscanf(sd->msg, OK_start_replicate, &jcr->Ticket) != 1) {
Jmsg(jcr, M_FATAL, 0, _("Bad response to start replicate: %s\n"), sd->msg);
goto bail_out;
}
Dmsg1(110, "Got Ticket=%d\n", jcr->Ticket);
} else {
Jmsg(jcr, M_FATAL, 0, _("Bad response from stored to start replicate command\n"));
goto bail_out;
}
/*
* Let the remote SD know we are now really going to send the data.
*/
sd->fsend(replicate_data, jcr->Ticket);
Dmsg1(110, ">stored: %s", sd->msg);
/*
* Expect to get response to the replicate data cmd from Storage daemon
*/
if (!response(jcr, sd, OK_data, "replicate data")) {
ok = false;
goto bail_out;
}
/*
* Read all data and send it to remote SD.
*/
ok = read_records(jcr->read_dcr, clone_record_to_remote_sd, mount_next_read_volume);
/*
* Send the last EOD to close the last data transfer and a next EOD to
* signal the remote we are done.
*/
if (!sd->signal(BNET_EOD) || !sd->signal(BNET_EOD)) {
if (!jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
sd->bstrerror());
}
goto bail_out;
}
/*
* Expect to get response that the replicate data succeeded.
*/
if (!response(jcr, sd, OK_replicate, "replicate data")) {
ok = false;
goto bail_out;
}
/*
* End replicate session.
*/
sd->fsend(end_replicate);
Dmsg1(110, ">stored: %s", sd->msg);
/*
* Expect to get response to the end replicate cmd from Storage daemon
*/
if (!response(jcr, sd, OK_end_replicate, "end replicate")) {
ok = false;
goto bail_out;
}
/* Inform Storage daemon that we are done */
sd->signal(BNET_TERMINATE);
} else {
if (!jcr->read_dcr || !jcr->dcr) {
Jmsg(jcr, M_FATAL, 0, _("Read and write devices not properly initialized.\n"));
goto bail_out;
}
Dmsg2(100, "read_dcr=%p write_dcr=%p\n", jcr->read_dcr, jcr->dcr);
Dmsg3(200, "Found %d volumes names for %s. First=%s\n",
jcr->NumReadVolumes, Type, jcr->VolList->VolumeName);
/*
* Ready devices for reading and writing.
*/
if (!acquire_device_for_read(jcr->read_dcr) ||
!acquire_device_for_append(jcr->dcr)) {
ok = false;
goto bail_out;
}
Dmsg2(200, "===== After acquire pos %u:%u\n", jcr->dcr->dev->file, jcr->dcr->dev->block_num);
jcr->sendJobStatus(JS_Running);
if (!begin_data_spool(jcr->dcr) ) {
ok = false;
goto bail_out;
}
if (!begin_attribute_spool(jcr)) {
ok = false;
goto bail_out;
}
jcr->dcr->VolFirstIndex = jcr->dcr->VolLastIndex = 0;
jcr->run_time = time(NULL);
set_start_vol_position(jcr->dcr);
jcr->JobFiles = 0;
/*
* Read all data and make a local clone of it.
*/
ok = read_records(jcr->read_dcr, clone_record_internally, mount_next_read_volume);
}
bail_out:
if (!ok) {
jcr->setJobStatus(JS_ErrorTerminated);
}
if (!jcr->remote_replicate && jcr->dcr) {
/*
* Don't use time_t for job_elapsed as time_t can be 32 or 64 bits,
* and the subsequent Jmsg() editing will break
*/
int32_t job_elapsed;
dev = jcr->dcr->dev;
Dmsg1(100, "ok=%d\n", ok);
if (ok || dev->can_write()) {
/*
* Flush out final partial block of this session
*/
if (!jcr->dcr->write_block_to_device()) {
Jmsg2(jcr, M_FATAL, 0, _("Fatal append error on device %s: ERR=%s\n"),
dev->print_name(), dev->bstrerror());
Dmsg0(100, _("Set ok=FALSE after write_block_to_device.\n"));
ok = false;
}
Dmsg2(200, "Flush block to device pos %u:%u\n", dev->file, dev->block_num);
}
if (!ok) {
discard_data_spool(jcr->dcr);
} else {
/*
* Note: if commit is OK, the device will remain blocked
*/
commit_data_spool(jcr->dcr);
}
job_elapsed = time(NULL) - jcr->run_time;
if (job_elapsed <= 0) {
job_elapsed = 1;
}
Jmsg(jcr, M_INFO, 0, _("Elapsed time=%02d:%02d:%02d, Transfer rate=%s Bytes/second\n"),
job_elapsed / 3600, job_elapsed % 3600 / 60, job_elapsed % 60,
edit_uint64_with_suffix(jcr->JobBytes / job_elapsed, ec1));
/*
* Release the device -- and send final Vol info to DIR
*/
release_device(jcr->dcr);
if (!ok || job_canceled(jcr)) {
discard_attribute_spool(jcr);
} else {
commit_attribute_spool(jcr);
}
}
if (jcr->read_dcr) {
if (!release_device(jcr->read_dcr)) {
ok = false;
}
}
jcr->sendJobStatus(); /* update director */
Dmsg0(30, "Done reading.\n");
jcr->end_time = time(NULL);
dequeue_messages(jcr); /* send any queued messages */
if (ok) {
jcr->setJobStatus(JS_Terminated);
}
generate_plugin_event(jcr, bsdEventJobEnd);
dir->fsend(Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles,
edit_uint64(jcr->JobBytes, ec1), jcr->JobErrors);
Dmsg4(100, Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles, ec1);
dir->signal(BNET_EOD); /* send EOD to Director daemon */
free_plugins(jcr); /* release instantiated plugins */
return false; /* Continue DIR session ? */
}
/*
* Run a Storage daemon replicate Job -- Wait for remote Storage daemon
* to connect and authenticate it we then will get a wakeup sign using
* the job_start_wait conditional
*
* Director sends us this command.
*
* Basic task here is:
* - Read a command from the Storage daemon
* - Execute it
*/
bool do_listen_run(JCR *jcr)
{
char ec1[30];
int errstat = 0;
struct timeval tv;
struct timezone tz;
struct timespec timeout;
BSOCK *dir = jcr->dir_bsock;
jcr->sendJobStatus(JS_WaitSD); /* wait for SD to connect */
gettimeofday(&tv, &tz);
timeout.tv_nsec = tv.tv_usec * 1000;
timeout.tv_sec = tv.tv_sec + me->client_wait;
Dmsg3(50, "%s waiting %d sec for SD to contact SD key=%s\n",
jcr->Job, (int)(timeout.tv_sec-time(NULL)), jcr->sd_auth_key);
Dmsg2(800, "Wait SD for jid=%d %p\n", jcr->JobId, jcr);
/*
* Wait for the Storage daemon to contact us to start the Job,
* when he does, we will be released, unless the 30 minutes expires.
*/
P(mutex);
while (!jcr->authenticated && !job_canceled(jcr)) {
errstat = pthread_cond_timedwait(&jcr->job_start_wait, &mutex, &timeout);
if (errstat == ETIMEDOUT || errstat == EINVAL || errstat == EPERM) {
break;
}
Dmsg1(800, "=== Auth cond errstat=%d\n", errstat);
}
Dmsg3(50, "Auth=%d canceled=%d errstat=%d\n", jcr->authenticated,
job_canceled(jcr), errstat);
V(mutex);
Dmsg2(800, "Auth fail or cancel for jid=%d %p\n", jcr->JobId, jcr);
Dmsg1(120, "Start run Job=%s\n", jcr->Job);
dir->fsend(Job_start, jcr->Job);
jcr->start_time = time(NULL);
jcr->run_time = jcr->start_time;
jcr->sendJobStatus(JS_Running);
/*
* See if we need to limit the inbound bandwidth.
*/
if (me->max_bandwidth_per_job && jcr->store_bsock) {
jcr->store_bsock->set_bwlimit(me->max_bandwidth_per_job);
if (me->allow_bw_bursting) {
jcr->store_bsock->set_bwlimit_bursting();
}
}
do_sd_commands(jcr);
jcr->end_time = time(NULL);
dequeue_messages(jcr); /* send any queued messages */
jcr->setJobStatus(JS_Terminated);
generate_plugin_event(jcr, bsdEventJobEnd);
dir->fsend(Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles,
edit_uint64(jcr->JobBytes, ec1), jcr->JobErrors);
dir->signal(BNET_EOD); /* send EOD to Director daemon */
free_plugins(jcr); /* release instantiated plugins */
/*
* After a listen cmd we are done e.g. return false.
*/
return false;
}
