/* Sends a message to the server */
int send_msg(int agentid, char *msg)
{
int msg_size;
char crypt_msg[OS_MAXSTR +1];
msg_size = CreateSecMSG(&keys, msg, crypt_msg, agentid);
if(msg_size == 0)
{
merror(SEC_ERROR,ARGV0);
return(-1);
}
/* Send msg_size of crypt_msg */
if(OS_SendUDPbySize(agt->sock, msg_size, crypt_msg) < 0)
{
merror(SEND_ERROR,ARGV0, "server");
sleep(1);
return(-1);
}
return(0);
}
/* Send win32 info to server */
void send_win32_info(time_t curr_time)
{
int msg_size;
char tmp_msg[OS_MAXSTR +2];
char crypt_msg[OS_MAXSTR +2];
tmp_msg[OS_MAXSTR +1] = '\0';
crypt_msg[OS_MAXSTR +1] = '\0';
debug1("%s: DEBUG: Sending keep alive message.", ARGV0);
verbose("%s Sending keep alive message....", ARGV0);
/* fixing time */
__win32_curr_time = curr_time;
/* Getting uname. */
if(!__win32_uname)
{
__win32_uname = getuname();
if(!__win32_uname)
{
merror("%s: Error generating system information.", ARGV0);
os_strdup("Microsoft Windows - Unknown (unable to get system info)", __win32_uname);
}
}
/* Getting shared files list -- every 30 seconds only. */
if((__win32_curr_time - __win32_shared_time) > 30)
{
if(__win32_shared)
{
free(__win32_shared);
__win32_shared = NULL;
}
__win32_shared_time = __win32_curr_time;
}
/* get shared files */
if(!__win32_shared)
{
__win32_shared = getsharedfiles();
if(!__win32_shared)
{
__win32_shared = strdup("\0");
if(!__win32_shared)
{
merror(MEM_ERROR, ARGV0);
return;
}
}
}
/* creating message */
if(File_DateofChange(AGENTCONFIGINT) > 0)
{
os_md5 md5sum;
if(OS_MD5_File(AGENTCONFIGINT, md5sum) != 0)
{
snprintf(tmp_msg, OS_SIZE_1024, "#!-%s\n%s", __win32_uname, __win32_shared);
}
else
{
snprintf(tmp_msg, OS_SIZE_1024, "#!-%s / %s\n%s", __win32_uname, md5sum, __win32_shared);
}
}
else
{
snprintf(tmp_msg, OS_SIZE_1024, "#!-%s\n%s", __win32_uname, __win32_shared);
}
/* creating message */
debug1("%s: DEBUG: Sending keep alive: %s", ARGV0, tmp_msg);
msg_size = CreateSecMSG(&keys, tmp_msg, crypt_msg, 0);
if(msg_size == 0)
{
merror(SEC_ERROR, ARGV0);
return;
}
/* Sending UDP message */
if(OS_SendUDPbySize(logr->sock, msg_size, crypt_msg) < 0)
{
merror(SEND_ERROR, ARGV0, "server");
sleep(1);
}
return;
}
/* SendMSG for windows */
int SendMSG(int queue, char *message, char *locmsg, char loc)
{
int _ssize;
time_t cu_time;
char *pl;
char tmpstr[OS_MAXSTR+2];
char crypt_msg[OS_MAXSTR +2];
DWORD dwWaitResult;
tmpstr[OS_MAXSTR +1] = '\0';
crypt_msg[OS_MAXSTR +1] = '\0';
debug2("%s: DEBUG: Attempting to send message to server.", ARGV0);
/* Using a mutex to synchronize the writes */
while(1)
{
dwWaitResult = WaitForSingleObject(hMutex, 1000000L);
if(dwWaitResult != WAIT_OBJECT_0)
{
switch(dwWaitResult)
{
case WAIT_TIMEOUT:
merror("%s: Error waiting mutex (timeout).", ARGV0);
sleep(5);
continue;
case WAIT_ABANDONED:
merror("%s: Error waiting mutex (abandoned).", ARGV0);
return(0);
default:
merror("%s: Error waiting mutex.", ARGV0);
return(0);
}
}
else
{
/* Lock acquired */
break;
}
} /*end - while for mutex...*/
cu_time = time(0);
#ifndef ONEWAY
/* Check if the server has responded */
if((cu_time - available_server) > logr->notify_time)
{
debug1("%s: DEBUG: Sending info to server (c1)...", ARGV0);
verbose("%s More than %d seconds without server response...sending win32info", ARGV0,logr->notify_time);
send_win32_info(cu_time);
/* Attempting to send message again. */
if((cu_time - available_server) > logr->notify_time)
{
/* Try again... */
sleep(1);
send_win32_info(cu_time);
sleep(1);
if((cu_time - available_server) > logr->notify_time)
{
send_win32_info(cu_time);
}
}
/* If we reached here, the server is unavailable for a while. */
if((cu_time - available_server) > logr->max_time_reconnect_try)
{
int wi = 1;
verbose("%s More than %d seconds without server response...is server alive? and Is there connection?", ARGV0,logr->max_time_reconnect_try);
/* Last attempt before going into reconnect mode. */
debug1("%s: DEBUG: Sending info to server (c3)...", ARGV0);
sleep(1);
send_win32_info(cu_time);
if((cu_time - available_server) > logr->max_time_reconnect_try)
{
sleep(1);
send_win32_info(cu_time);
sleep(1);
}
/* Checking and generating log if unavailable. */
cu_time = time(0);
if((cu_time - available_server) > logr->max_time_reconnect_try)
{
int global_sleep = 1;
int mod_sleep = 12;
/* If response is not available, set lock and
* wait for it.
*/
verbose(SERVER_UNAV, ARGV0);
/* Going into reconnect mode. */
while((cu_time - available_server) > logr->max_time_reconnect_try)
{
/* Sending information to see if server replies */
if(logr->sock != -1)
{
send_win32_info(cu_time);
}
sleep(wi);
cu_time = time(0);
if(wi < 20)
{
wi++;
}
else
{
global_sleep++;
}
/* If we have more than one server, try all. */
if(wi > 12 && logr->rip[1])
{
int curr_rip = logr->rip_id;
merror("%s: INFO: Trying next server ip in "
"line: '%s'.",
ARGV0,
logr->rip[logr->rip_id + 1] != NULL?
logr->rip[logr->rip_id + 1]:
logr->rip[0]);
connect_server(logr->rip_id +1);
if(logr->rip_id != curr_rip)
{
wi = 1;
}
}
else if(global_sleep == 2 || ((global_sleep % mod_sleep) == 0) ||
(logr->sock == -1))
{
connect_server(logr->rip_id +1);
if(logr->sock == -1)
{
sleep(wi + global_sleep);
}
else
{
sleep(global_sleep);
}
if(global_sleep > 30)
{
mod_sleep = 50;
}
}
}
verbose(AG_CONNECTED, ARGV0, logr->rip[logr->rip_id],
logr->port);
verbose(SERVER_UP, ARGV0);
}
}
}
#else
if(0)
{
}
#endif
/* Send notification */
else if((cu_time - __win32_curr_time) > (NOTIFY_TIME - 200))
{
debug1("%s: DEBUG: Sending info to server (ctime2)...", ARGV0);
send_win32_info(cu_time);
}
/* locmsg cannot have the C:, as we use it as delimiter */
pl = strchr(locmsg, ':');
if(pl)
{
/* Setting pl after the ":" if it exists. */
pl++;
}
else
{
pl = locmsg;
}
debug2("%s: DEBUG: Sending message to server: '%s'", ARGV0, message);
snprintf(tmpstr,OS_MAXSTR,"%c:%s:%s", loc, pl, message);
_ssize = CreateSecMSG(&keys, tmpstr, crypt_msg, 0);
/* Returns NULL if can't create encrypted message */
if(_ssize == 0)
{
merror(SEC_ERROR,ARGV0);
if(!ReleaseMutex(hMutex))
{
merror("%s: Error releasing mutex.", ARGV0);
}
return(-1);
}
/* Send _ssize of crypt_msg */
if(OS_SendUDPbySize(logr->sock, _ssize, crypt_msg) < 0)
{
merror(SEND_ERROR,ARGV0, "server");
sleep(1);
}
if(!ReleaseMutex(hMutex))
{
merror("%s: Error releasing mutex.", ARGV0);
}
return(0);
}
