static void
_handle_caps(xmpp_stanza_t *const stanza)
{
char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if (from) {
char *hash = stanza_caps_get_hash(stanza);
// hash supported xep-0115
if (g_strcmp0(hash, "sha-1") == 0) {
log_info("Hash %s supported");
char *ver = stanza_get_caps_ver(stanza);
if (ver) {
if (caps_contains(ver)) {
log_info("Capabilities cached: %s", ver);
caps_map(from, ver);
} else {
log_info("Capabilities not cached: %s, sending service discovery request", ver);
char *node = stanza_caps_get_node(stanza);
char *id = create_unique_id("caps");
iq_send_caps_request(from, id, node, ver);
free(id);
}
}
// no hash, or not supported
} else {
if (hash) {
log_info("Hash %s not supported, not sending service discovery request");
// send service discovery request, cache against from full jid
} else {
log_info("No hash specified, not sending service discovery request");
// do legacy
}
}
}
}
void keyboard_handler(registers_t *r)
{
unsigned char scancode = inportb(0x60);
//printf("r->int_no=%d,scancode=0x%x,caps=%d,shift=%d,control=%d,capacity=%d\n",
// r->int_no, scancode, caps, shift, control, capacity(q));
if (scancode & 0x80)
{
switch (scancode)
{
case SCANCODE_LEFT_SHIFT | 0x80:
case SCANCODE_RIGHT_SHIFT | 0x80:
flags.shift = 0;
return;
case SCANCODE_LEFT_CTRL | 0x80:
flags.control = 0;
return;
case SCANCODE_LEFT_ALT | 0x80:
flags.alt = 0;
return;
case 0xE0:
flags.extended = 1;
return;
default:
flags.extended = 0;
return;
}
}
switch (scancode)
{
case SCANCODE_LEFT_SHIFT:
case SCANCODE_RIGHT_SHIFT:
flags.shift = 1;
return;
case SCANCODE_LEFT_CTRL:
flags.control = 1;
return;
case SCANCODE_LEFT_ALT:
flags.alt = 1;
return;
case SCANCODE_CAPSLOCK:
flags.capslock = ~flags.capslock;
return;
}
char c;
if (flags.shift && !flags.capslock)
{
c = shift_map(kbd_map, scancode);
}
else if (flags.shift && flags.capslock)
{
c = normal_map(kbd_map, scancode);
}
else if (flags.capslock)
{
c = caps_map(kbd_map, scancode);
}
else
{
c = normal_map(kbd_map, scancode);
}
input_t input = { .flags = flags, .scancode = scancode, .keycode = c };
_putch(input);
flags.extended = 0;
}
static int
_caps_response_handler(xmpp_conn_t *const conn, xmpp_stanza_t * const stanza,
void * const userdata)
{
const char *id = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_ID);
xmpp_stanza_t *query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
if (id) {
log_info("Capabilities response handler fired for id %s", id);
} else {
log_info("Capabilities response handler fired");
}
const char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if (!from) {
log_info("No from attribute");
return 0;
}
char *type = xmpp_stanza_get_type(stanza);
// handle error responses
if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
char *error_message = stanza_get_error_message(stanza);
log_warning("Error received for capabilities response from %s: ", from, error_message);
free(error_message);
return 0;
}
if (query == NULL) {
log_warning("No query element found.");
return 0;
}
char *node = xmpp_stanza_get_attribute(query, STANZA_ATTR_NODE);
if (node == NULL) {
log_warning("No node attribute found");
return 0;
}
// validate sha1
gchar **split = g_strsplit(node, "#", -1);
char *given_sha1 = split[1];
char *generated_sha1 = caps_create_sha1_str(query);
if (g_strcmp0(given_sha1, generated_sha1) != 0) {
log_warning("Generated sha-1 does not match given:");
log_warning("Generated : %s", generated_sha1);
log_warning("Given : %s", given_sha1);
} else {
log_info("Valid SHA-1 hash found: %s", given_sha1);
if (caps_contains(given_sha1)) {
log_info("Capabilties cached: %s", given_sha1);
} else {
log_info("Capabilities not cached: %s, storing", given_sha1);
Capabilities *capabilities = caps_create(query);
caps_add(given_sha1, capabilities);
caps_destroy(capabilities);
}
caps_map(from, given_sha1);
}
g_free(generated_sha1);
g_strfreev(split);
return 0;
}
