static sw_result HOWL_API
query_record_reply(
sw_discovery session,
sw_discovery_oid oid,
sw_discovery_query_record_status status,
sw_uint32 interface_index,
sw_const_string fullname,
sw_uint16 rrtype,
sw_uint16 rrclass,
sw_uint16 rrdatalen,
sw_const_octets rrdata,
sw_uint32 ttl,
sw_opaque extra)
{
sw_ipv4_address address;
fprintf(stderr, "interface index = 0x%x, fullname is %s\n", interface_index, fullname);
if ((rrtype == 1) && (rrclass == 1))
{
sw_ipv4_address address;
sw_char name[16];
sw_ipv4_address_init_from_saddr(&address, *(sw_saddr*) rrdata);
fprintf(stderr, "address is %s\n", sw_ipv4_address_name(address, name, sizeof(name)));
}
return SW_OKAY;
}
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char *argv[]) {
sw_ipv4_address a;
char t[256];
uint8_t a1, a2, a3, a4;
ASSERT_SW_OKAY(sw_ipv4_address_init_from_name(&a, "heise.de"));
ASSERT_NOT_NULL(sw_ipv4_address_name(a, t, sizeof(t)));
printf("%s\n", t);
ASSERT_SW_OKAY(sw_ipv4_address_init_from_this_host(&a));
ASSERT_NOT_NULL(sw_ipv4_address_name(a, t, sizeof(t)));
printf("%s\n", t);
ASSERT_SW_OKAY(sw_ipv4_address_decompose(a, &a1, &a2, &a3, &a4));
printf("%i.%i.%i.%i\n", a1, a2, a3, a4);
return 0;
}
/*
TCP implementation
*/
static sw_result
sw_socket_tcp_connect(
sw_socket self,
sw_ipv4_address address,
sw_port port)
{
sw_int8 host[16];
sw_socklen_t len;
int nodelay = 1;
struct linger l;
int res;
sw_result err;
sw_debug(SW_LOG_VERBOSE, "sw_socket_tcp_connect() : host = %s, port = %d\n", sw_ipv4_address_name(address, host, 16), port);
sw_memset(&self->m_dest_addr, 0, sizeof(self->m_dest_addr));
self->m_dest_addr.sin_family = AF_INET;
self->m_dest_addr.sin_addr.s_addr = sw_ipv4_address_saddr(address);
self->m_dest_addr.sin_port = htons(port);
res = connect(self->m_desc, (struct sockaddr*) &self->m_dest_addr, sizeof(self->m_dest_addr));
err = sw_translate_error(res == 0, sw_socket_errno());
sw_check_okay_log(err, exit);
len = sizeof(self->m_addr);
res = getsockname(self->m_desc, (struct sockaddr*) &self->m_addr, &len);
err = sw_translate_error(res == 0, sw_socket_errno());
sw_check_okay_log(err, exit);
self->m_connected = SW_TRUE;
res = setsockopt(self->m_desc, IPPROTO_TCP, TCP_NODELAY, (char*) &nodelay, sizeof(nodelay));
err = sw_translate_error(res == 0, sw_socket_errno());
sw_check_okay_log(err, exit);
l.l_onoff = 0;
l.l_linger = 0;
res = setsockopt(self->m_desc, SOL_SOCKET, SO_LINGER, (char*) &l, sizeof(l));
err = sw_translate_error(res == 0, sw_socket_errno());
sw_check_okay_log(err, exit);
exit:
return err;
}
sw_result
sw_socket_bind(
sw_socket self,
sw_ipv4_address address,
sw_port port)
{
sw_int8 host[16];
sw_socklen_t len;
int res;
sw_result err = SW_OKAY;
sw_debug(SW_LOG_VERBOSE, "sw_socket_bind() : fd = %d, addr = %s, port = %d\n", self->m_desc, sw_ipv4_address_name(address, host, 16), port);
/*
now bind
*/
sw_memset(&self->m_addr, 0, sizeof(self->m_addr));
self->m_addr.sin_family = AF_INET;
/*
if they haven't chosen a network interface, choose one for them
*/
self->m_addr.sin_addr.s_addr = sw_ipv4_address_saddr(address);
self->m_addr.sin_port = htons(port);
len = sizeof(self->m_addr);
res = bind(self->m_desc, (struct sockaddr*) &self->m_addr, len);
err = sw_translate_error(res == 0, sw_socket_errno());
sw_check_okay_log(err, exit);
/*
now get our port
*/
res = getsockname(self->m_desc, (struct sockaddr*) &self->m_addr, &len);
err = sw_translate_error(res == 0, sw_socket_errno());
sw_check_okay_log(err, exit);
exit:
return err;
}
static sw_result HOWL_API
my_resolver(
sw_discovery discovery,
sw_discovery_oid oid,
sw_uint32 interface_index,
sw_const_string name,
sw_const_string type,
sw_const_string domain,
sw_ipv4_address address,
sw_port port,
sw_octets text_record,
sw_uint32 text_record_len,
sw_opaque_t extra)
{
sw_text_record_iterator it;
sw_int8 name_buf[16];
sw_int8 key[SW_TEXT_RECORD_MAX_LEN];
sw_int8 sval[SW_TEXT_RECORD_MAX_LEN];
sw_uint8 oval[SW_TEXT_RECORD_MAX_LEN];
sw_uint32 oval_len;
sw_result err = SW_OKAY;
sw_discovery_cancel(discovery, oid);
fprintf(stderr, "resolve reply: 0x%x %s %s %s %s %d\n", interface_index, name, type, domain, sw_ipv4_address_name(address, name_buf, 16), port);
if ((text_record_len > 0) && (text_record) && (*text_record != '\0'))
{
err = sw_text_record_iterator_init(&it, text_record, text_record_len);
sw_check_okay(err, exit);
while (sw_text_record_iterator_next(it, key, oval, &oval_len) == SW_OKAY)
{
fprintf(stderr, "Txt: [%s]=[%s] - (%d bytes)\n", key, oval, oval_len);
}
err = sw_text_record_iterator_fina(it);
sw_check_okay(err, exit);
}
exit:
return err;
}
sw_result
sw_corby_channel_init_with_profile(
sw_corby_channel * self,
struct _sw_corby_orb * orb,
sw_const_corby_profile profile,
sw_socket_options options,
sw_size_t bufsize)
{
sw_corby_channel channel;
sw_socket socket;
sw_result err;
/*
* initialize
*/
socket = NULL;
*self = NULL;
err = SW_OKAY;
/*
* let's try and see if we already have a connection to this guy
*/
for (channel = orb->m_channel_cache; channel; channel = channel->m_nextc)
{
if ((channel->m_to_tag == profile->m_tag) && sw_ipv4_address_equals(channel->m_to, profile->m_address) && (channel->m_to_port == profile->m_port))
{
sw_int8 name_buf[16];
sw_debug(SW_LOG_NOTICE, "sharing connection to %s, %d\n", sw_ipv4_address_name(profile->m_address, name_buf, 16), profile->m_port);
/*
* found it
*/
channel->m_cache_refs++;
channel->m_refs++;
*self = channel;
goto exit;
}
}
/*
* couldn't find it, so make a new one
*/
switch (profile->m_tag)
{
case SW_TAG_INTERNET_IOP:
err = sw_tcp_socket_init(&socket);
sw_check_okay(err, exit);
break;
case SW_TAG_UIOP:
err = sw_udp_socket_init(&socket);
sw_check_okay(err, exit);
err = sw_socket_bind(socket, sw_ipv4_address_any(), 0);
sw_check_okay(err, exit);
break;
case SW_TAG_MIOP:
err = sw_multicast_socket_init(&socket);
sw_check_okay(err, exit);
err = sw_socket_bind(socket, sw_ipv4_address_any(), profile->m_port);
sw_check_okay(err, exit);
break;
default:
err = SW_E_INIT;
goto exit;
}
/*
* now let's try to connect...for connectionless protocols it just stashes this info to be used later
*/
err = sw_socket_connect(socket, profile->m_address, profile->m_port);
sw_check_okay(err, exit);
err = sw_corby_channel_init(self, orb, socket, options, bufsize);
sw_check_okay(err, exit);
/*
* if we connected okay, then add to list of extant channels
*/
err = sw_ipv4_address_init_from_address(&(*self)->m_to, profile->m_address);
sw_check_okay(err, exit);
(*self)->m_to_tag = profile->m_tag;
(*self)->m_to_port = profile->m_port;
(*self)->m_send_queue_head = NULL;
(*self)->m_send_queue_tail = NULL;
(*self)->m_nextc = g_channel_cache;
(*self)->m_prevc = NULL;
if (orb->m_channel_cache)
{
orb->m_channel_cache->m_prevc = (*self);
}
orb->m_channel_cache = (*self);
(*self)->m_cache_refs++;
exit:
if (err != SW_OKAY)
{
if (*self != NULL)
{
sw_corby_channel_fina(*self);
}
else if (socket != NULL)
{
sw_socket_fina(socket);
}
}
return err;
}
