static void
tls_print_session_info(const host_addr_t addr, uint16 port,
gnutls_session session, bool incoming)
{
const char *proto, *cert, *kx, *ciph, *mac, *comp;
g_return_if_fail(session);
proto = gnutls_protocol_get_name(gnutls_protocol_get_version(session));
cert = gnutls_certificate_type_get_name(
gnutls_certificate_type_get(session));
kx = gnutls_kx_get_name(gnutls_kx_get(session));
comp = gnutls_compression_get_name(gnutls_compression_get(session));
ciph = gnutls_cipher_get_name(gnutls_cipher_get(session));
mac = gnutls_mac_get_name(gnutls_mac_get (session));
g_debug(
"TLS session info (%s):\n"
" Host: %s\n"
" Protocol: %s\n"
" Certificate: %s\n"
" Key Exchange: %s\n"
" Cipher: %s\n"
" MAC: %s\n"
" Compression: %s",
incoming ? "incoming" : "outgoing",
host_addr_port_to_string(addr, port),
NULL_STRING(proto),
NULL_STRING(cert),
NULL_STRING(kx),
NULL_STRING(ciph),
NULL_STRING(mac),
NULL_STRING(comp)
);
}
void
bitzi_gui_update(const bitzi_data_t *bitzi_data)
{
guint32 bitzi_debug;
g_assert(bitzi_data != NULL);
gnet_prop_get_guint32_val(PROP_BITZI_DEBUG, &bitzi_debug);
if (bitzi_debug > 10)
g_debug("bitzi_gui_update: data %p, size %s, "
"goodness %f, judgment %d, type %s, details %s",
cast_to_gconstpointer(bitzi_data),
uint64_to_string(bitzi_data->size),
bitzi_data->goodness,
bitzi_data->judgment,
NULL_STRING(bitzi_data->mime_type),
NULL_STRING(bitzi_data->mime_desc));
/* Update the various GUI elements */
search_gui_metadata_update(bitzi_data);
}
/*
* Read a switch configuration
*/
SWITCH *
switch_conf()
{
char *keyword;
char *argument;
int token;
SWITCH *sw;
char *name;
struct switch_attributes *attributes;
sw = (SWITCH *) malloc(sizeof(SWITCH));
if (sw == NULL) {
config_error("malloc() failed.\n");
exit(1);
}
name = read_option(); /* Read name */
argument = read_option(); /* Read type */
if ((name == NULL) || (argument == NULL)) {
config_error("Name and type required for switch. Skipping.\n");
next_keyword();
return NULL;
}
sw->sw_type = parse_token(argument, switch_keywords);
if (sw->sw_type == TOKEN_NOT_FOUND) {
config_error("Switch type \"%s\" unknown. Assuming PS32.\n", argument);
sw->sw_type = HIPPISW_PS32;
}
/*
* Fill in defaults
*/
strncpy(sw->sw_name, name, SWNAMELEN);
sw->sw_version = 1;
/* Set a bunch of stuff here in one wave of the hand */
attributes = get_sw_attributes(sw->sw_type);
bcopy(attributes, &(sw->sw_attributes), sizeof(sw->sw_attributes));
sw->sw_ports = NULL;
NULL_STRING(sw->sw_hostname);
sw->sw_tport = TELNET_PORT;
sw->sw_linenum = parsed_linenumber();
NULL_STRING(sw->sw_comment);
sw->sw_virt_attached = NULL;
NULL_STRING(sw->sw_password);
/*
* Read rest of options
*/
while ((keyword = read_option()) != NULL) {
if ((token = parse_token(keyword, keywords)) == TOKEN_NOT_FOUND) {
config_error("\"%s\" is not recognized. Skipping.\n", keyword);
continue;
}
/* Currently all options take arguments
*/
argument = read_option();
if (argument == NULL) {
config_error("Argument required for %s option.\n", keyword);
continue;
}
switch(token) {
case KEYWD_SIZE:
if (is_numeric(argument) == FALSE) {
config_error("\"%s\" is not a legal numeric argument. Skipping.\n",
argument);
continue;
}
sw->sw_num_ports = str_to_int(argument);
break;
case KEYWD_ADDRESS:
if (hostname_to_netaddr(argument) == NETADDR_NULL)
config_error("Warning: can't resolve net address for \"%s\".\n",
argument);
strncpy(sw->sw_hostname, argument, HNAMELEN);
break;
case KEYWD_PORT:
if (is_numeric(argument) == FALSE) {
config_error("\"%s\" is not a legal numeric argument. Skipping.\n",
argument);
continue;
}
sw->sw_tport = str_to_int(argument);
break;
case KEYWD_PROMPT:
config_error("\"prompt\" no longer supported. Skipping.\n");
break;
case KEYWD_SMS:
if (is_numeric(argument) == FALSE) {
config_error("\"%s\" is not a legal numeric argument. Skipping.\n",
argument);
continue;
}
sw->sw_version = str_to_int(argument);
break;
case KEYWD_COMMENT:
strncpy(sw->sw_comment, argument, COMMENTLEN);
break;
case KEYWD_START_LOG:
config_error("\"start_log\" no longer supported.\n");
continue;
}
}
if ((sw->sw_num = add_switch(sw)) == ERROR) {
config_error("Error adding switch to list.\n");
exit(1);
}
return sw;
}
static void
magnet_handle_key(struct magnet_resource *res,
const char *name, const char *value)
{
char *to_free = NULL;
g_return_if_fail(res);
g_return_if_fail(name);
g_return_if_fail(value);
if (!utf8_is_valid_string(value)) {
const char *encoding;
char *result;
g_message("MAGNET URI key \"%s\" is not UTF-8 encoded", name);
if (MAGNET_KEY_DISPLAY_NAME != magnet_key_get(name))
return;
result = unknown_to_utf8(value, &encoding);
if (result != value) {
to_free = result;
}
value = result;
g_message("assuming MAGNET URI key \"%s\" is %s encoded",
name, encoding);
}
switch (magnet_key_get(name)) {
case MAGNET_KEY_DISPLAY_NAME:
if (!res->display_name) {
magnet_set_display_name(res, value);
}
break;
case MAGNET_KEY_ALTERNATE_SOURCE:
case MAGNET_KEY_EXACT_SOURCE:
{
struct magnet_source *ms;
const char *error;
ms = magnet_parse_exact_source(value, &error);
if (ms) {
if (!res->sha1 && ms->sha1) {
res->sha1 = atom_sha1_get(ms->sha1);
}
if (!ms->sha1 || sha1_eq(res->sha1, ms->sha1)) {
res->sources = g_slist_prepend(res->sources, ms);
} else {
magnet_source_free(&ms);
}
} else {
g_message("could not parse source \"%s\" in MAGNET URI: %s",
value, NULL_STRING(error));
}
}
break;
case MAGNET_KEY_EXACT_TOPIC:
if (!magnet_set_exact_topic(res, value)) {
g_message("MAGNET URI contained unsupported exact topic \"%s\"",
value);
}
break;
case MAGNET_KEY_KEYWORD_TOPIC:
magnet_add_search(res, value);
break;
case MAGNET_KEY_EXACT_LENGTH:
{
int error;
uint64 u;
u = parse_uint64(value, NULL, 10, &error);
if (!error) {
magnet_set_filesize(res, u);
}
}
break;
case MAGNET_KEY_PARQ_ID:
magnet_set_parq_id(res, value);
break;
case MAGNET_KEY_VENDOR:
magnet_set_vendor(res, value);
break;
case MAGNET_KEY_GUID:
magnet_set_guid(res, value);
break;
case MAGNET_KEY_DHT:
{
int error;
uint8 u;
u = parse_uint8(value, NULL, 10, &error);
if (!error) {
magnet_set_dht(res, u);
}
}
break;
case MAGNET_KEY_NONE:
g_message("unhandled parameter in MAGNET URI: \"%s\"", name);
break;
case NUM_MAGNET_KEYS:
g_assert_not_reached();
}
G_FREE_NULL(to_free);
}
