/**
* mds — A micro-display server
* Copyright © 2014, 2015, 2016 Mattias Andrée (maandree@member.fsf.org)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "interceptors.h"
#include "globals.h"
#include "interception-condition.h"
#include "client.h"
#include "queued-interception.h"
#include <libmdsserver/macros.h>
#include <libmdsserver/hash-help.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
/**
* Remove interception condition by index
*
* @param client The intercepting client
* @param index The index of the condition
*/
static void __attribute__((nonnull))
remove_intercept_condition(client_t *client, size_t index)
{
interception_condition_t *conds = client->interception_conditions;
size_t n = client->interception_conditions_count;
/* Remove the condition from the list. */
free(conds[index].condition);
memmove(conds + index, conds + index + 1, --n - index);
client->interception_conditions_count--;
/* Shrink the list. */
if (!client->interception_conditions_count) {
free(conds);
client->interception_conditions = NULL;
} else if (xrealloc(conds, n, interception_condition_t)) {
xperror(*argv);
} else {
client->interception_conditions = conds;
}
}
/**
* Add an interception condition for a client
*
* @param client The client
* @param condition The header, optionally with value, to look for, or empty (not NULL) for all messages
* @param priority Interception priority
* @param modifying Whether the client may modify the messages
* @param stop Whether the condition should be removed rather than added
*/
void
add_intercept_condition(client_t *client, char *condition, int64_t priority, int modifying, int stop)
{
size_t n = client->interception_conditions_count;
interception_condition_t *conds = client->interception_conditions;
ssize_t nonmodifying = -1;
char *header = condition;
char *colon = NULL;
char *value;
size_t hash, i;
interception_condition_t temp;
/* Split header and value apart. */
if ((value = strchr(header, ':'))) {
*value = '\0'; /* NUL-terminate header. */
colon = value; /* End of header. */
value += 2; /* Skip over delimiter. */
}
/* Calcuate header hash (comparison optimisation) */
hash = string_hash(header);
/* Undo header–value splitting. */
if (colon)
*colon = ':';
/* Remove of update condition of already registered,
also look for non-modifying condition to swap position
with for optimisation. */
for (i = 0; i < n; i++) {
if ((conds[i].header_hash != hash) || !strequals(conds[i].condition, condition)) {
/* Look for the first non-modifying, this is a part of the
optimisation where we put all modifying conditions at the
beginning. */
if (nonmodifying < 0 && conds[i].modifying)
nonmodifying = (ssize_t)i;
continue;
}
if (stop) {
remove_intercept_condition(client, i);
} else {
/* Update parameters. */
conds[i].priority = priority;
conds[i].modifying = modifying;
if (modifying && nonmodifying >= 0) {
/* Optimisation: put conditions that are modifying
at the beginning. When a client is intercepting
we most know if any satisfying condition is
modifying. With this optimisation the first
satisfying condition will tell us if there is
any satisfying condition that is modifying. */
temp = conds[nonmodifying];
conds[nonmodifying] = conds[i];
conds[i] = temp;
}
}
return;
}
if (stop) {
eprint("client tried to stop intercepting messages that it does not intercept.");
} else {
/* Duplicate condition string. */
fail_if (xstrdup_nn(condition, condition));
/* Grow the interception condition list. */
fail_if (xrealloc(conds, n + 1, interception_condition_t));
client->interception_conditions = conds;
/* Store condition. */
client->interception_conditions_count++;
conds[n].condition = condition;
conds[n].header_hash = hash;
conds[n].priority = priority;
conds[n].modifying = modifying;
if (modifying && nonmodifying >= 0) {
/* Optimisation: put conditions that are modifying
at the beginning. When a client is intercepting
we most know if any satisfying condition is
modifying. With this optimisation the first
satisfying condition will tell us if there is
any satisfying condition that is modifying. */
temp = conds[nonmodifying];
conds[nonmodifying] = conds[n];
conds[n] = temp;
}
}
return;
fail:
xperror(*argv);
free(condition);
return;
}
/**
* Check if a condition matches any of a set of accepted patterns
*
* @param cond The condition
* @param hashes The hashes of the accepted header names
* @param keys The header names
* @param headers The header name–value pairs
* @param count The number of accepted patterns
* @return Evaluates to true if and only if a matching pattern was found
*/
int
is_condition_matching(interception_condition_t *cond, size_t *hashes,
char **keys, char **headers, size_t count)
{
size_t i;
for (i = 0; i < count; i++) {
if (*cond->condition == '\0')
return 1;
else if ((cond->header_hash == hashes[i]) &&
(strequals(cond->condition, keys[i]) ||
strequals(cond->condition, headers[i])))
return 1;
}
return 0;
}
/**
* Find a matching condition to any of a set of acceptable conditions
*
* @param client The intercepting client
* @param hashes The hashes of the accepted header names
* @param keys The header names
* @param headers The header name–value pairs
* @param count The number of accepted patterns
* @param interception_out Storage slot for found interception
* @return -1 on error, otherwise: evalutes to true iff a matching condition was found
*/
int
find_matching_condition(client_t *client, size_t *hashes, char **keys, char **headers,
size_t count, queued_interception_t *interception_out)
{
pthread_mutex_t mutex = client->mutex;
interception_condition_t *conds = client->interception_conditions;
size_t n = 0, i;
fail_if ((errno = pthread_mutex_lock(&(mutex))));
/* Look for a matching condition. */
if (client->open)
n = client->interception_conditions_count;
for (i = 0; i < n; i++) {
if (is_condition_matching(conds + i, hashes, keys, headers, count)) {
/* Report matching condition. */
interception_out->client = client;
interception_out->priority = conds[i].priority;
interception_out->modifying = conds[i].modifying;
break;
}
}
pthread_mutex_unlock(&mutex);
return i < n;
fail:
return -1;
}
/**
* Get all interceptors who have at least one condition matching any of a set of acceptable patterns
*
* @param sender The original sender of the message
* @param hashes The hashes of the accepted header names
* @param keys The header names
* @param headers The header name–value pairs
* @param count The number of accepted patterns
* @param interceptions_count_out Slot at where to store the number of found interceptors
* @return The found interceptors, `NULL` on error
*/
queued_interception_t *
get_interceptors(client_t *sender, size_t *hashes, char **keys, char **headers,
size_t count, size_t *interceptions_count_out)
{
queued_interception_t *interceptions = NULL;
size_t interceptions_count = 0, n = 0;
ssize_t node;
int saved_errno, r;
client_t *client;
/* Count clients. */
foreach_linked_list_node (client_list, node)
n++;
/* Allocate interceptor list. */
fail_if (xmalloc(interceptions, n, queued_interception_t));
/* Search clients. */
foreach_linked_list_node (client_list, node) {
client = (void *)(client_list.values[node]);
/* Look for and list a matching condition. */
if (client->open && (client != sender)) {
r = find_matching_condition(client, hashes, keys, headers, count,
interceptions + interceptions_count);
fail_if (r == -1);
if (r)
/* List client of there was a matching condition. */
interceptions_count++;
}
}
*interceptions_count_out = interceptions_count;
return interceptions;
fail:
saved_errno = errno;
free(interceptions);
return errno = saved_errno, NULL;
}
