int main( int argc, char **argv )
{
Analysis *scmanal = new Analysis( 3, 2, 0, "", argc, argv );
char output_comment[ 256 ];
snprintf( output_comment, 256, "(%s) + (%s)", scmanal->get_comment( 0 ),
scmanal->get_comment( 1 ) );
scmanal->set_comment( 2, output_comment );
if ( scmanal->get_type( 0 ) != scmanal->get_type( 1 ) ) {
fprintf( stderr, "%s: Input file types differ.\n", argv[ 0 ] );
exit( 1 );
}
if ( scmanal->get_length( 0 ) != scmanal->get_length( 1 ) ) {
fprintf( stderr, "%s: Input file sizes differ.\n", argv[ 0 ] );
if ( scmanal->get_type( 0 ) != TIME_DOMAIN ) {
exit( 1 );
}
}
size_t length = MINVAL( scmanal->get_length( 0 ), scmanal->get_length( 1 ) );
if ( (scmanal->get_begin( 0 ) != scmanal->get_begin( 1 ))
|| (scmanal->get_compl_begin( 0 ) != scmanal->get_compl_begin( 1 ))
|| (scmanal->get_compl_end( 0 ) != scmanal->get_compl_end( 1 ))) {
fprintf( stderr, "%s: Input file spans differ.\n", argv[ 0 ] );
exit( 1 );
}
if ( ( scmanal->get_end( 0 ) != scmanal->get_end( 1 ) )
&& ( scmanal->get_type( 0 ) != TIME_DOMAIN ) ) {
fprintf( stderr, "%s: Input file ends differ.\n", argv[ 0 ] );
exit( 1 );
}
double min_end = MINVAL( scmanal->get_end( 0 ), scmanal->get_end( 1 ) );
scmanal->set_type( 2, scmanal->get_type( 0 ) );
scmanal->set_begin( 2, scmanal->get_begin( 0 ) );
scmanal->set_end( 2, min_end );
scmanal->set_compl_begin( 2, scmanal->get_compl_begin( 0 ) );
scmanal->set_compl_end( 2, scmanal->get_compl_end( 0 ) );
scmanal->make_outputs( length );
double
*input_1 = scmanal->get_file( 0 ),
*input_2 = scmanal->get_file( 1 ),
*output = scmanal->get_file( 2 );
for ( uint i = 0; i < length; i++ ) {
output[ i ] = input_1[ i ] + input_2[ i ];
}
delete scmanal;
}
Atom atom_init_integer(DeviceIntPtr dev, char* name, int nvalues, int* values, int size) {
Atom atom;
int i;
uint8_t uvals8[MAX_INT_VALUES];
uint16_t uvals16[MAX_INT_VALUES];
uint32_t uvals32[MAX_INT_VALUES];
pointer uvals;
nvalues = MINVAL(MAX_INT_VALUES, nvalues);
switch(size) {
case 8:
for (i = 0; i < nvalues; i++) {
uvals8[i] = values[i];
}
uvals = uvals8;
break;
case 16:
for (i = 0; i < nvalues; i++) {
uvals16[i] = values[i];
}
uvals = uvals16;
break;
default:
for (i = 0; i < nvalues; i++) {
uvals32[i] = values[i];
}
uvals = uvals32;
break;
}
atom = MakeAtom(name, strlen(name), TRUE);
XIChangeDeviceProperty(dev, atom, XA_INTEGER, size, PropModeReplace, nvalues, uvals, FALSE);
XISetDevicePropertyDeletable(dev, atom, FALSE);
return atom;
}
/*
* Return value:
* ERROR: -1
* NOT FOUND: 0
* FOUND: matching line number
*/
int search_file(struct filter_settings *current_settings, char *search_filename, char *target_string, int strlen_target_string, char start_wildcard, char *start_wildcard_matches, char end_wildcard, char *end_wildcard_matches)
{
int return_value;
FILE *tmp_file;
char tmp_buf[MAX_FILE_BUF + 1];
int line_num;
int i;
int strlen_buf;
char lower_start_wildcard;
char lower_end_wildcard;
char lower_target_string[MAX_BUF + 1];
int strlen_lower_target_string;
return_value = 0;
if ((target_string != NULL) &&
(strlen_target_string > 0))
{
if ((tmp_file = fopen(search_filename, "r")) != NULL)
{
line_num = 0;
lower_start_wildcard = (start_wildcard != '\0') ? tolower((int)start_wildcard) : start_wildcard;
lower_end_wildcard = (end_wildcard != '\0') ? tolower((int)end_wildcard) : end_wildcard;
strlen_lower_target_string = MINVAL(MAX_BUF, strlen_target_string);
for (i = 0; i < strlen_lower_target_string; i++)
lower_target_string[i] = tolower((int)target_string[i]);
while (!feof(tmp_file) &&
(line_num < MAX_FILE_LINES))
{
if ((fscanf(tmp_file, "%" STRINGIFY(MAX_FILE_BUF) "[^\r\n]", tmp_buf) == 1) &&
(tmp_buf[0] != COMMENT_DELIMITER) &&
((strlen_buf = strlen(tmp_buf)) > 0) &&
examine_entry(lower_target_string, strlen_lower_target_string, tmp_buf, strlen_buf, lower_start_wildcard, start_wildcard_matches, lower_end_wildcard, end_wildcard_matches))
{
return_value = line_num + 1;
break;
}
fscanf(tmp_file, "%*1[\r\n]");
line_num++;
}
if (line_num == MAX_FILE_LINES)
SPAMDYKE_LOG_VERBOSE(current_settings, LOG_VERBOSE_FILE_TOO_LONG "%s", MAX_FILE_LINES, search_filename);
fclose(tmp_file);
}
else
{
SPAMDYKE_LOG_ERROR(current_settings, LOG_ERROR_OPEN_SEARCH "%s: %s", search_filename, strerror(errno));
return_value = -1;
}
}
return(return_value);
}
/* Flush RBUF's buffer to WHERE. Flush MAXSIZE bytes at most.
Returns the number of bytes actually copied. If the buffer is
empty, 0 is returned. */
int
rbuf_flush (struct rbuf *rbuf, char *where, int maxsize)
{
if (!rbuf->buffer_left)
return 0;
else
{
int howmuch = MINVAL (rbuf->buffer_left, maxsize);
if (where)
memcpy (where, rbuf->buffer_pos, howmuch);
rbuf->buffer_left -= howmuch;
rbuf->buffer_pos += howmuch;
return howmuch;
}
}
/*
* Return value:
* NOT FOUND: 0
* FOUND: 1
*/
int find_path(struct filter_settings *current_settings, char *filename, char *envp[], char *return_filename, int size_return_filename)
{
int return_value;
int strlen_filename;
char *path;
char *tmp_start;
char *tmp_end;
char new_filename[MAX_BUF + 1];
struct stat tmp_stat;
return_value = 0;
if ((filename != NULL) &&
(return_filename != NULL) &&
(size_return_filename > 0))
{
if (stat(filename, &tmp_stat) == 0)
{
strlen_filename = MINVAL(size_return_filename, strlen(filename));
memcpy(return_filename, filename, sizeof(char) * strlen_filename);
return_filename[strlen_filename] = '\0';
return_value = 1;
}
else if (strchr(filename, DIR_DELIMITER) == NULL)
{
if (((path = find_environment_variable(current_settings, envp, ENVIRONMENT_PATH, STRLEN(ENVIRONMENT_PATH), NULL)) == NULL) ||
(path[0] == '\0'))
{
SPAMDYKE_LOG_EXCESSIVE(current_settings, LOG_DEBUGX_PATH_DEFAULT, DEFAULT_PATH);
path = DEFAULT_PATH;
}
tmp_start = path;
tmp_end = NULL;
while (tmp_start != NULL)
{
if ((tmp_end = strchr(tmp_start, ':')) != NULL)
{
strlen_filename = snprintf(new_filename, MAX_BUF, "%.*s" DIR_DELIMITER_STR "%s", (int)(tmp_end - tmp_start), tmp_start, filename);
tmp_start = tmp_end + 1;
}
else
{
strlen_filename = snprintf(new_filename, MAX_BUF, "%s" DIR_DELIMITER_STR "%s", tmp_start, filename);
tmp_start = NULL;
}
if (stat(new_filename, &tmp_stat) == 0)
{
if (strlen_filename > size_return_filename)
strlen_filename = size_return_filename;
memcpy(return_filename, new_filename, sizeof(char) * strlen_filename);
return_filename[strlen_filename] = '\0';
return_value = 1;
break;
}
}
}
}
return(return_value);
}
int Process_new_client_connection (const int socket_fd, const char* client_host_name, const char* client_IP, const uint16_t client_port,
const char* password, const char* executable)
{
bool auxres;
char* line_buffer = NULL;
size_t line_buffer_len = 0;
size_t line_len = 0;
FILE *input_lines, *output_lines;
char cookie[5];
char* password_latin;
char hash[HASH_LEN + 1];
bool eof_found;
bool close_requested;
TEventType event_type;
char* event;
char** payload;
size_t payload_len, payload_buffer_len;
bool isTCPEvents;
size_t auxlen;
errno = 0;
/* ************************************************************************************** */
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Promoting socket to FILE...");
errno = 0;
/* Promote socket. */
if ( ( (input_lines = fdopen (socket_fd, "r")) == NULL) ||
( (output_lines = fdopen (socket_fd, "w")) == NULL))
return ERROR_PROMOTING_SOCKET_TO_FILE;
/* Set the buffering to lines for the output file. */
setlinebuf (output_lines);
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Success promoting socket to FILE.");
/* ************************************************************************************** */
/* ************************************************************************************** */
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
return ERROR_INTERRUPTED;
/* ************************************************************************************** */
/* ************************************************************************************** */
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Trying to read the \"Magic word\".");
errno = 0;
if (!Read_line (input_lines, &line_buffer, &line_buffer_len,
&line_len, &eof_found, true, false))
return ERROR_READING_MAGIC_WORD;
errno = 0;
auxres =
( (line_len == strlen (MAGIC_WORD)) &&
(strncmp (line_buffer, MAGIC_WORD, line_len) == 0));
Free_string (&line_buffer);
if (!auxres)
return ERROR_BAD_MAGIC_WORD;
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Success reading the \"Magic word\".");
/* ************************************************************************************** */
/* ************************************************************************************** */
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
return ERROR_INTERRUPTED;
/* ************************************************************************************** */
/* ************************************************************************************** */
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Generating and sending cookie for password...");
errno = 0;
if (!Generate_cookie (cookie, sizeof (cookie)))
return ERROR_GENERATING_PASSWORD_COOKIE;
if (!Write_line (output_lines, cookie))
return ERROR_WRITING_COOKIE;
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Success generating and sending cookie for password.");
/* ************************************************************************************** */
/* ************************************************************************************** */
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
return ERROR_INTERRUPTED;
/* ************************************************************************************** */
/* ************************************************************************************** */
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Calculating hash...");
errno = 0;
if (!Convert_between_latin15_and_current_locale (password, &password_latin, false))
return ERROR_CALCULATING_HASH;
errno = 0;
auxres = Hash_cookied_password (password_latin, cookie, hash, sizeof (hash));
Free_string (&password_latin);
if (!auxres)
return ERROR_CALCULATING_HASH;
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Success calculating hash.");
/* ************************************************************************************** */
/* ************************************************************************************** */
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
return ERROR_INTERRUPTED;
/* ************************************************************************************** */
/* ************************************************************************************** */
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Trying to read and match hash from client...");
if (!Read_line (input_lines, &line_buffer, &line_buffer_len,
&line_len, &eof_found, false, false))
return ERROR_READING_HASH;
errno = 0;
auxres = ( (line_len >= HASH_LEN) &&
(strncasecmp (line_buffer + line_len - HASH_LEN, hash, HASH_LEN) == 0));
isTCPEvents = (auxres && (line_len >= (HASH_LEN + strlen (TCP_EVENTS_MSG))) &&
(strncasecmp (line_buffer, TCP_EVENTS_MSG, strlen (TCP_EVENTS_MSG)) == 0));
Free_string (&line_buffer);
if (!auxres)
return ERROR_HASH_DOES_NOT_MATCH;
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Success reading and matching hash from client.");
/* ************************************************************************************** */
/* ************************************************************************************** */
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
return ERROR_INTERRUPTED;
/* ************************************************************************************** */
/* ************************************************************************************** */
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Sending \"accept\" message...");
errno = 0;
if (!Write_line (output_lines, ACCEPT_MSG))
return ERROR_WRITING_ACCEPT_MSG;
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Success sending \"accept\" message.");
/* ************************************************************************************** */
/* ************************************************************************************** */
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
return ERROR_INTERRUPTED;
/* ************************************************************************************** */
/* ************************************************************************************** */
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Processing events...");
close_requested = false;
event_type = tet_unknown;
event = NULL;
payload = NULL;
payload_len = 0;
payload_buffer_len = 0;
line_buffer = NULL;
do
{
if ( (!Read_line (input_lines, &line_buffer, &line_buffer_len,
&line_len, &eof_found, false, true)) && (!eof_found))
{
Free_string_array (&payload, &payload_len, &payload_buffer_len);
Free_string (&line_buffer);
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
return ERROR_INTERRUPTED;
return ERROR_READING_EVENT;
}
else if (eof_found)
{
Free_string_array (&payload, &payload_len, &payload_buffer_len);
Free_string (&line_buffer);
break;
}
else if (line_buffer_len > MAX_EVENT_LINE_LEN)
{
Free_string_array (&payload, &payload_len, &payload_buffer_len);
Free_string (&line_buffer);
return ERROR_EVENT_LINE_TOO_LONG;
}
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
break;
if (strncasecmp (line_buffer, CLOSE_MSG,
MINVAL (line_len, strlen (CLOSE_MSG))) == 0)
{
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Received: <Close>");
/* Close requested. */
Free_string_array (&payload, &payload_len, &payload_buffer_len);
Free_string (&line_buffer);
close_requested = true;
}
else if (strncasecmp (line_buffer, PAYLOAD_MSG,
MINVAL (line_len, strlen (PAYLOAD_MSG))) == 0)
{
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Received: <Payload>");
/* Add to payload. */
if (!Add_string_to_string_array (&payload, &payload_len, &payload_buffer_len,
line_buffer + strlen (PAYLOAD_MSG) + 1))
{
Free_string_array (&payload, &payload_len, &payload_buffer_len);
Free_string (&line_buffer);
return ERROR_ALLOCATING_MEMORY;
}
}
else if ( (payload_len > 0) && (strncasecmp (payload[payload_len - 1], BUTTON_RELEASED_MSG,
MINVAL (strlen (payload[payload_len - 1]), strlen (BUTTON_RELEASED_MSG))) == 0))
{
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Received: <Enduring Event - Stop>");
/* End enduring event. */
event = line_buffer;
event_type = tet_end_event;
}
else if ( (payload_len > 0) && (strncasecmp (payload[payload_len - 1], WITHOUT_RELEASE_MSG,
MINVAL (strlen (payload[payload_len - 1]), strlen (WITHOUT_RELEASE_MSG))) == 0))
{
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Received: <Enduring Event - Start>");
/* Trigger enduring event. */
event = line_buffer;
event_type = tet_enduring_event;
}
else
{
Vlogit (tll_debug,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_debug),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Received: <Event>");
/* Trigger event. */
event = line_buffer;
event_type = tet_event;
}
errno = 0;
if ( (!Is_signaled_to_terminate()) && (!close_requested) && (event_type != tet_unknown) &&
(executable != NULL) && (strlen (executable) > 0))
{
Vlogit (tll_info,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_info),
PROCESS_P_C (g_daemonized, g_processor),
getpid(),
"Executing command...");
Ignore_or_restore_SIGPIPE_signal (true);
auxres = Execute_and_report_output (executable, client_host_name, client_IP, client_port,
(event != NULL) ? event : EMPTY_STRING,
event_type, payload_len, (const char**) payload,
&socket_fd, 1);
Ignore_or_restore_SIGPIPE_signal (false);
if (!auxres)
{
Free_string_array (&payload, &payload_len, &payload_buffer_len);
Free_string (&line_buffer);
return ERROR_EXECUTING_COMMAND;
}
Vlogit (tll_info,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_info),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Success executing command.");
}
else if ( (!close_requested) && (event_type != tet_unknown))
{
Vlogit (tll_info,
LOG_EVENT_NO_COMMAND,
LOGLEVELNAME (tll_info),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), event);
}
Free_string (&line_buffer);
if (event_type != tet_unknown)
{
Free_string_array (&payload, &payload_len, &payload_buffer_len);
close_requested = false;
event_type = tet_unknown;
event = NULL;
}
}
while (!Is_signaled_to_terminate() && !close_requested);
Free_string_array (&payload, &payload_len, &payload_buffer_len);
Free_string (&line_buffer);
/* ************************************************************************************** */
/* ************************************************************************************** */
/* If the program is signaled to terminate. */
if (Is_signaled_to_terminate())
return ERROR_INTERRUPTED;
else if (close_requested)
{
Vlogit (tll_info,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_info),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Client requested close.");
}
else
{
Vlogit (tll_info,
LOG_MESSAGE_PREAMBLE,
LOGLEVELNAME (tll_info),
PROCESS_P_C (g_daemonized, g_processor),
getpid(), "Client closed the conection.");
}
/* ************************************************************************************** */
errno = 0;
return ERROR_SUCESS;
}
int dns_get(char *target_name, int type, unsigned char *return_answer, int return_answer_length, int verbose)
{
static int query_id = 0;
int return_value;
int i;
int dns_socket;
unsigned char question[PACKETSZ];
unsigned char answer[PACKETSZ];
int question_length;
unsigned short tmp_id;
int sendto_result;
int select_result;
int response_length;
fd_set read_fds;
struct timeval tmp_timeval;
time_t start_time;
int num_queries;
return_value = 0;
if ((dns_socket = dns_initialize(0)) != -1)
{
if ((question_length = res_mkquery(QUERY, target_name, C_IN, type, NULL, 0, NULL, question, PACKETSZ)) >= 0)
{
tmp_id = htons(query_id);
query_id++;
question[0] = ((char *)&tmp_id)[0];
question[1] = ((char *)&tmp_id)[1];
start_time = time(NULL);
num_queries = 0;
do
{
sendto_result = 0;
if (num_queries < MAX_DNS_QUERIES_PREFERRED)
{
if (verbose)
printf(MSG_SENDING, num_queries, inet_ntoa(_res.nsaddr_list[0].sin_addr), ntohs(_res.nsaddr_list[0].sin_port));
sendto_result = sendto(dns_socket, question, question_length, 0, (struct sockaddr *)&_res.nsaddr_list[0], sizeof(struct sockaddr));
}
else
for (i = 0; i < _res.nscount; i++)
{
if (verbose)
printf(MSG_SENDING, num_queries, inet_ntoa(_res.nsaddr_list[i].sin_addr), ntohs(_res.nsaddr_list[i].sin_port));
sendto_result = sendto(dns_socket, question, question_length, 0, (struct sockaddr *)&_res.nsaddr_list[i], sizeof(struct sockaddr));
}
num_queries++;
if (sendto_result == question_length)
{
FD_ZERO(&read_fds);
FD_SET(dns_socket, &read_fds);
tmp_timeval.tv_sec = MINVAL((TIMEOUT_DNS_QUERY_SECS * MAX_DNS_QUERIES) - (time(NULL) - start_time), TIMEOUT_DNS_QUERY_SECS);
tmp_timeval.tv_usec = 0;
while ((tmp_timeval.tv_sec > 0) &&
((select_result = select(dns_socket + 1, &read_fds, NULL, NULL, &tmp_timeval)) > 0))
{
if (((response_length = recvfrom(dns_socket, answer, PACKETSZ, 0, NULL, NULL)) > 0) &&
(answer[0] == question[0]) &&
(answer[1] == question[1]))
{
if (verbose)
printf(MSG_RECEIVING, response_length);
memcpy(return_answer, answer, MINVAL(response_length, return_answer_length));
return_value = MINVAL(response_length, return_answer_length);
break;
}
else if (verbose)
printf(MSG_MISMATCH);
}
if (return_value > 0)
break;
}
else if (sendto_result >= 0)
printf(ERROR_SENDTO_INCOMPLETE, question_length, sendto_result);
else
{
printf(ERROR_SENDTO, strerror(errno));
break;
}
}
while (num_queries < MAX_DNS_QUERIES);
}
else
printf(ERROR_MKQUERY, strerror(errno));
}
return(return_value);
}
