struct hub_probe* probe_create(struct hub_info* hub, int sd, struct ip_addr_encap* addr)
{
struct hub_probe* probe = (struct hub_probe*) hub_malloc_zero(sizeof(struct hub_probe));
if (probe == NULL)
return NULL; /* OOM */
LOG_TRACE("probe_create(): %p", probe);
probe->hub = hub;
probe->connection = net_con_create();
net_con_initialize(probe->connection, sd, probe_net_event, probe, NET_EVENT_READ);
net_con_set_timeout(probe->connection, TIMEOUT_CONNECTED);
memcpy(&probe->addr, addr, sizeof(struct ip_addr_encap));
return probe;
}
static int net_connect_job_process(struct net_connect_job* job)
{
int sd;
if (!job->con)
{
sd = net_socket_create(job->addr.ss_family, SOCK_STREAM, IPPROTO_TCP);
if (sd == -1)
{
LOG_DEBUG("net_connect_job_process: Unable to create socket!");
net_connect_callback(job->handle, net_connect_status_socket_error, NULL);
return -1; // FIXME
}
job->con = net_con_create();
net_con_initialize(job->con, sd, net_connect_job_internal_cb, job, NET_EVENT_WRITE);
net_con_set_timeout(job->con, TIMEOUT_CONNECTED); // FIXME: Use a proper timeout value!
}
return net_connect_job_check(job);
}
int hub_handle_support(struct hub_info* hub, struct hub_user* u, struct adc_message* cmd)
{
int ret = 0;
int index = 0;
int ok = 1;
char* arg = adc_msg_get_argument(cmd, index);
if (hub->status == hub_status_disabled && u->state == state_protocol)
{
on_login_failure(hub, u, status_msg_hub_disabled);
hub_free(arg);
return -1;
}
while (arg)
{
if (strlen(arg) == 6)
{
fourcc_t fourcc = FOURCC(arg[2], arg[3], arg[4], arg[5]);
if (strncmp(arg, ADC_SUP_FLAG_ADD, 2) == 0)
{
user_support_add(u, fourcc);
}
else if (strncmp(arg, ADC_SUP_FLAG_REMOVE, 2) == 0)
{
user_support_remove(u, fourcc);
}
else
{
ok = 0;
}
}
else
{
ok = 0;
}
index++;
hub_free(arg);
arg = adc_msg_get_argument(cmd, index);
}
if (u->state == state_protocol)
{
if (index == 0) ok = 0; /* Need to support *SOMETHING*, at least BASE */
if (!ok)
{
/* disconnect user. Do not send crap during initial handshake! */
hub_disconnect_user(hub, u, quit_logon_error);
return -1;
}
if (user_flag_get(u, feature_base))
{
/* User supports ADC/1.0 and a hash we know */
if (user_flag_get(u, feature_tiger))
{
hub_send_handshake(hub, u);
/* TODO: timeouts for mux users */
if (u->connection)
net_con_set_timeout(u->connection, TIMEOUT_HANDSHAKE);
}
else
{
// no common hash algorithm.
hub_send_status(hub, u, status_msg_proto_no_common_hash, status_level_fatal);
hub_disconnect_user(hub, u, quit_protocol_error);
}
}
else if (user_flag_get(u, feature_bas0))
{
if (hub->config->obsolete_clients)
{
hub_send_handshake(hub, u);
/* TODO: timeouts for mux users */
if (u->connection)
net_con_set_timeout(u->connection, TIMEOUT_HANDSHAKE);
}
else
{
/* disconnect user for using an obsolete client. */
char* tmp = adc_msg_escape(hub->config->msg_proto_obsolete_adc0);
struct adc_message* message = adc_msg_construct(ADC_CMD_IMSG, 6 + strlen(tmp));
adc_msg_add_argument(message, tmp);
hub_free(tmp);
route_to_user(hub, u, message);
adc_msg_free(message);
hub_disconnect_user(hub, u, quit_protocol_error);
}
}
else
{
/* Not speaking a compatible protocol - just disconnect. */
hub_disconnect_user(hub, u, quit_logon_error);
}
}
return ret;
}