static gboolean
validate_address (const gchar *key,
const gchar *value,
gboolean suffix,
GError **error)
{
if (suffix && g_strrstr (value, "/"))
{
gs_strfreev gchar **tokens = NULL;
gs_unref_object GInetAddress *address = NULL;
tokens = g_strsplit (value, "/", 2);
address = g_inet_address_new_from_string (tokens[0]);
if (address == NULL)
{
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'%s' entry must contain a valid IPv4 address"),
key);
return FALSE;
}
GRegex *regex = g_regex_new ("^[0-9]{1,2}$", 0, 0, NULL);
if (!g_regex_match_full (regex, tokens[1], -1, 0, 0, NULL, NULL))
{
g_regex_unref (regex);
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'%s' entry must contain a valid IPv4 suffix"),
key);
return FALSE;
}
g_regex_unref (regex);
if (g_ascii_strtoull (tokens[1], NULL, 0) > 32)
{
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'%s' entry must contain a valid IPv4 suffix"),
key);
return FALSE;
}
}
else
{
gs_unref_object GInetAddress *address = NULL;
address = g_inet_address_new_from_string (value);
if (address == NULL)
{
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'%s' entry must be a valid IPv4 address"),
key);
return FALSE;
}
}
return TRUE;
}
static GstBuffer *
create_rtcp_app (guint32 ssrc, guint count)
{
GInetAddress *inet_addr_0;
guint16 port = 5678 + count;
GSocketAddress *socket_addr_0;
GstBuffer *rtcp_buffer;
GstRTCPPacket *rtcp_packet = NULL;
GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT;
inet_addr_0 = g_inet_address_new_from_string ("192.168.1.1");
socket_addr_0 = g_inet_socket_address_new (inet_addr_0, port);
g_object_unref (inet_addr_0);
rtcp_buffer = gst_rtcp_buffer_new (1400);
gst_buffer_add_net_address_meta (rtcp_buffer, socket_addr_0);
g_object_unref (socket_addr_0);
/* need to begin with rr */
gst_rtcp_buffer_map (rtcp_buffer, GST_MAP_READWRITE, &rtcp);
rtcp_packet = g_slice_new0 (GstRTCPPacket);
gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_RR, rtcp_packet);
gst_rtcp_packet_rr_set_ssrc (rtcp_packet, ssrc);
g_slice_free (GstRTCPPacket, rtcp_packet);
/* useful to make the rtcp buffer valid */
rtcp_packet = g_slice_new0 (GstRTCPPacket);
gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_APP, rtcp_packet);
g_slice_free (GstRTCPPacket, rtcp_packet);
gst_rtcp_buffer_unmap (&rtcp);
return rtcp_buffer;
}
static VsxServer *
create_server (GError **error)
{
GInetAddress *inet_address;
VsxServer *server = NULL;
inet_address = g_inet_address_new_from_string (option_listen_address);
if (inet_address == NULL)
g_set_error (error, G_IO_ERROR, G_IO_ERROR_UNKNOWN,
"Failed to parse address '%s'",
option_listen_address);
else
{
GSocketAddress *address = g_inet_socket_address_new (inet_address,
option_listen_port);
server = vsx_server_new (address, error);
g_object_unref (address);
g_object_unref (inet_address);
}
return server;
}
static gboolean
is_multicast_address (const gchar * host_name)
{
GInetAddress *addr;
GResolver *resolver = NULL;
gboolean ret = FALSE;
addr = g_inet_address_new_from_string (host_name);
if (!addr) {
GList *results;
resolver = g_resolver_get_default ();
results = g_resolver_lookup_by_name (resolver, host_name, NULL, NULL);
if (!results)
goto out;
addr = G_INET_ADDRESS (g_object_ref (results->data));
g_resolver_free_addresses (results);
}
g_assert (addr != NULL);
ret = g_inet_address_get_is_multicast (addr);
out:
if (resolver)
g_object_unref (resolver);
if (addr)
g_object_unref (addr);
return ret;
}
static void
arv_gv_discover_socket_list_send_discover_packet (ArvGvDiscoverSocketList *socket_list)
{
GInetAddress *broadcast_address;
GSocketAddress *broadcast_socket_address;
ArvGvcpPacket *packet;
GSList *iter;
size_t size;
packet = arv_gvcp_packet_new_discovery_cmd (&size);
broadcast_address = g_inet_address_new_from_string ("255.255.255.255");
broadcast_socket_address = g_inet_socket_address_new (broadcast_address, ARV_GVCP_PORT);
g_object_unref (broadcast_address);
for (iter = socket_list->sockets; iter != NULL; iter = iter->next) {
ArvGvDiscoverSocket *discover_socket = iter->data;
GError *error = NULL;
arv_gv_discover_socket_set_broadcast (discover_socket, TRUE);
g_socket_send_to (discover_socket->socket,
broadcast_socket_address,
(const char *) packet, size,
NULL, &error);
if (error != NULL) {
arv_warning_interface ("[ArvGVInterface::send_discover_packet] Error: %s", error->message);
g_error_free (error);
}
arv_gv_discover_socket_set_broadcast (discover_socket, FALSE);
}
g_object_unref (broadcast_socket_address);
arv_gvcp_packet_free (packet);
}
void owr_image_server_add_image_renderer(OwrImageServer *image_server,
OwrImageRenderer *image_renderer, const gchar *tag)
{
OwrImageServerPrivate *priv;
g_return_if_fail(OWR_IS_IMAGE_SERVER(image_server));
g_return_if_fail(OWR_IS_IMAGE_RENDERER(image_renderer));
g_return_if_fail(tag && tag[0]);
priv = image_server->priv;
g_mutex_lock(&priv->image_renderers_mutex);
if (!g_hash_table_contains(priv->image_renderers, tag)) {
g_hash_table_insert(priv->image_renderers, g_strdup(tag), image_renderer);
g_object_ref(image_renderer);
} else
g_warning("Image renderer not added, an image renderer is already added for this tag");
g_mutex_unlock(&priv->image_renderers_mutex);
if (!priv->socket_service_is_started) {
g_socket_listener_add_address(G_SOCKET_LISTENER(priv->socket_service),
g_inet_socket_address_new(g_inet_address_new_from_string("127.0.0.1"),
(guint16)priv->port), G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP,
NULL, NULL, NULL);
g_socket_service_start(priv->socket_service);
priv->socket_service_is_started = TRUE;
}
}
static char *p_ip(const char *val, GError **err) {
GInetAddress *a = g_inet_address_new_from_string(val);
if(!a) {
g_set_error_literal(err, 1, 0, "Invalid IP.");
return NULL;
}
g_object_unref(a);
return g_strdup(val);
}
gint net_init(gchar* interface, gchar* baseaddress, gchar *multicastbase)
{
GError * e = NULL;
interface = NULL; //prevent warning
net_base = g_inet_address_new_from_string(baseaddress);
if( net_base == NULL ){
syslog(LOG_ERR, "net_init: Could not parse base address");
return -1;
}
struct node n;
n.netadr = net_base;
n.ubnetd = NULL;
syslog(LOG_DEBUG,"creating base address...\n");
interface_createAddress(&n);
usleep(3000*1000);
syslog(LOG_DEBUG,"done\n");
net_multicastbase = g_inet_address_new_from_string(multicastbase);
if( net_multicastbase == NULL ){
syslog(LOG_ERR, "net_init: Could not parse multicast base address");
return -1;
}
address6_init(net_base, net_multicastbase);
tcp_init();
GSocketAddress * sa = g_inet_socket_address_new(net_base,2323);
//set up data tcp listener
syslog(LOG_DEBUG,"net_init: Creating tcp socket on port 2323\n");
GSocketService *gss = g_socket_service_new();
//TODO: save a reference to the gss somewhere
if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), sa,
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &e)
== FALSE ){
syslog(LOG_WARNING, "net_init: error while creating socket listener: %s\n",
e->message);
g_error_free(e);
}
g_signal_connect(gss, "incoming", G_CALLBACK(tcp_listener),NULL);
g_socket_service_start(gss);
g_object_unref(sa);
return 0;
}
static void
kms_rtp_endpoint_set_addr (KmsRtpEndpoint * self)
{
GList *ips, *l;
gboolean done = FALSE;
ips = nice_interfaces_get_local_ips (FALSE);
for (l = ips; l != NULL && !done; l = l->next) {
GInetAddress *addr;
gboolean is_ipv6 = FALSE;
addr = g_inet_address_new_from_string (l->data);
if (G_IS_INET_ADDRESS (addr)) {
switch (g_inet_address_get_family (addr)) {
case G_SOCKET_FAMILY_INVALID:
case G_SOCKET_FAMILY_UNIX:
/* Ignore this addresses */
break;
case G_SOCKET_FAMILY_IPV6:
is_ipv6 = TRUE;
case G_SOCKET_FAMILY_IPV4:
{
gchar *addr_str;
gboolean use_ipv6;
g_object_get (self, "use-ipv6", &use_ipv6, NULL);
if (is_ipv6 != use_ipv6) {
GST_DEBUG_OBJECT (self, "No valid address type: %d", is_ipv6);
break;
}
addr_str = g_inet_address_to_string (addr);
if (addr_str != NULL) {
KmsBaseSdpEndpoint *base_sdp = KMS_BASE_SDP_ENDPOINT (self);
KmsSdpAgent *agent = kms_base_sdp_endpoint_get_sdp_agent (base_sdp);
g_object_set (agent, "addr", addr_str, NULL);
g_free (addr_str);
done = TRUE;
}
break;
}
}
}
if (G_IS_OBJECT (addr)) {
g_object_unref (addr);
}
}
g_list_free_full (ips, g_free);
if (!done) {
GST_WARNING_OBJECT (self, "Addr not set");
}
}
FChatBuddy *fchat_buddy_new(const gchar *host, const gchar *alias) {
FChatBuddy *buddy = g_new0(FChatBuddy, 1);
buddy->host = g_strdup(host);
buddy->addr = g_inet_address_new_from_string(host);
if (!buddy->addr) {
purple_debug_error("fchat", "Incorrect address %s\n", host);
}
buddy->alias = alias ? g_strdup(alias) : NULL;
return buddy;
}
//Bfoadcast ivy msgs to clients
void broadcast_to_clients () {
int i;
if (uTCP) {
//broadcast using tcp connection
GError *error = NULL;
for (i = 0; i < MAXCLIENT; i++) {
if (ConnectedClients[i].used > 0) {
GOutputStream * ostream = g_io_stream_get_output_stream (ConnectedClients[i].ClientTcpData);
g_output_stream_write(ostream, ivybuffer, strlen(ivybuffer), NULL, &error);
}
}
return;
}
i=0;
for (i = 0; i < MAXCLIENT; i++) {
if (ConnectedClients[i].used > 0) {
//Send data
GInetAddress *udpAddress;
GSocketAddress *udpSocketAddress;
GSocket *udpSocket;
udpAddress = g_inet_address_new_from_string(ConnectedClients[i].client_ip);
udpSocketAddress = g_inet_socket_address_new(udpAddress, udp_port);
udpSocket = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, 17, NULL);
if (g_socket_connect(udpSocket, udpSocketAddress, NULL, NULL) == FALSE) {
printf("App Server: stg wrong with socket connect\n");
fflush(stdout);
}
if (g_socket_send(udpSocket, ivybuffer, strlen(ivybuffer) , NULL, NULL) < 0) {
printf("App Server: stg wrong with send func\n");
fflush(stdout);
}
if (g_socket_close(udpSocket, NULL) == FALSE) {
printf("App Server: stg wrong with socket close\n");
fflush(stdout);
}
//Unref objects
g_object_unref(udpAddress);
g_object_unref(udpSocketAddress);
g_object_unref(udpSocket);
}
}
}
GSocketAddress *
g_inet_socket_address_new_from_string (const char *address,
guint port)
{
GSocketAddress *ret;
GInetAddress *addr = g_inet_address_new_from_string(address);
ret = g_inet_socket_address_new(addr, port);
g_object_unref (addr);
return ret;
}
static int
_SSL_check_common_name (X509 *cert, const char *host)
{
X509_NAME *name;
char *common_name = NULL;
int common_name_len;
int rv = -1;
GInetAddress *addr;
name = X509_get_subject_name (cert);
if (name == NULL)
return -1;
common_name_len = X509_NAME_get_text_by_NID (name, NID_commonName, NULL, 0);
if (common_name_len < 0)
return -1;
common_name = calloc (common_name_len + 1, 1);
if (common_name == NULL)
return -1;
X509_NAME_get_text_by_NID (name, NID_commonName, common_name, common_name_len + 1);
/* NUL bytes in CN? */
if (common_name_len != (int)strlen(common_name))
{
g_warning ("NUL byte in Common Name field, probably a malicious certificate.\n");
rv = -2;
goto out;
}
if ((addr = g_inet_address_new_from_string (host)) != NULL)
{
/*
* We don't want to attempt wildcard matching against IP
* addresses, so perform a simple comparison here.
*/
if (g_strcmp0 (common_name, host) == 0)
rv = 0;
else
rv = -1;
g_object_unref (addr);
}
else if (_SSL_match_hostname (common_name, host) == 0)
rv = 0;
out:
free(common_name);
return rv;
}
static void
do_connectable (const char *arg, gboolean synchronous)
{
char **parts;
GSocketConnectable *connectable;
GSocketAddressEnumerator *enumerator;
if (strchr (arg, '/'))
{
/* service/protocol/domain */
parts = g_strsplit (arg, "/", 3);
if (!parts || !parts[2])
usage ();
connectable = g_network_service_new (parts[0], parts[1], parts[2]);
}
else
{
guint16 port;
parts = g_strsplit (arg, ":", 2);
if (parts && parts[1])
{
arg = parts[0];
port = strtoul (parts[1], NULL, 10);
}
else
port = 0;
if (g_hostname_is_ip_address (arg))
{
GInetAddress *addr = g_inet_address_new_from_string (arg);
GSocketAddress *sockaddr = g_inet_socket_address_new (addr, port);
g_object_unref (addr);
connectable = G_SOCKET_CONNECTABLE (sockaddr);
}
else
connectable = g_network_address_new (arg, port);
}
enumerator = g_socket_connectable_enumerate (connectable);
g_object_unref (connectable);
if (synchronous)
do_sync_connectable (enumerator);
else
do_async_connectable (enumerator);
}
static gboolean
kms_sctp_connection_create_socket (KmsSCTPConnection * conn, gchar * host,
gint port, GCancellable * cancellable, GError ** err)
{
GInetAddress *addr;
/* look up name if we need to */
addr = g_inet_address_new_from_string (host);
if (addr == NULL) {
GResolver *resolver;
GList *results;
resolver = g_resolver_get_default ();
results = g_resolver_lookup_by_name (resolver, host, cancellable, err);
if (results == NULL) {
g_object_unref (resolver);
return FALSE;
}
addr = G_INET_ADDRESS (g_object_ref (results->data));
g_resolver_free_addresses (results);
g_object_unref (resolver);
}
if (G_UNLIKELY (GST_LEVEL_DEBUG <= _gst_debug_min)) {
gchar *ip = g_inet_address_to_string (addr);
GST_DEBUG ("IP address for host %s is %s", host, ip);
g_free (ip);
}
conn->saddr = g_inet_socket_address_new (addr, port);
g_object_unref (addr);
conn->socket = g_socket_new (g_socket_address_get_family (conn->saddr),
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_SCTP, err);
if (conn->socket == NULL) {
g_clear_object (&conn->saddr);
return FALSE;
}
/* create socket */
GST_DEBUG ("created SCTP socket for %s", host);
return TRUE;
}
int setRTPConnectionToServer(GstRTSPsink *sink)
{
GError *error;
// gchar *host = sink->host; // "www.ynet.co.il";// "192.168.2.108";
// gint port = sink->server_rtp_port;
//
if (!sink->socket) {
sink->socket = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL);
gchar *s;
GInetAddress *ia;
ia = g_inet_address_new_from_string(sink->host);
// Try to get hostby name
if (!ia) {
GResolver *resolver;
resolver = g_resolver_get_default();
GList *results;
results = g_resolver_lookup_by_name(resolver, sink->host, FALSE, &error);
if (results){
ia = G_INET_ADDRESS(g_object_ref(results->data));
}
gchar *ip = g_inet_address_to_string(ia);
g_print("IP address for host %s is %s", sink->host, ip);
g_free(ip);
g_resolver_free_addresses(results);
g_object_unref(resolver);
}
s = g_inet_address_to_string(ia);
sink->sa = g_inet_socket_address_new(ia, sink->server_rtp_port);
}
if (sink->socket != NULL && sink->sa != NULL)
return GST_RTSP_OK;
return GST_RTSP_ERROR;
}
static GstUDPClient *
create_client (GstMultiUDPSink * sink, const gchar * host, gint port)
{
GstUDPClient *client;
GInetAddress *addr;
GResolver *resolver;
GError *err = NULL;
addr = g_inet_address_new_from_string (host);
if (!addr) {
GList *results;
resolver = g_resolver_get_default ();
results =
g_resolver_lookup_by_name (resolver, host, sink->cancellable, &err);
if (!results)
goto name_resolve;
addr = G_INET_ADDRESS (g_object_ref (results->data));
g_resolver_free_addresses (results);
g_object_unref (resolver);
}
#ifndef GST_DISABLE_GST_DEBUG
{
gchar *ip = g_inet_address_to_string (addr);
GST_DEBUG_OBJECT (sink, "IP address for host %s is %s", host, ip);
g_free (ip);
}
#endif
client = g_slice_new0 (GstUDPClient);
client->refcount = 1;
client->host = g_strdup (host);
client->port = port;
client->addr = g_inet_socket_address_new (addr, port);
g_object_unref (addr);
return client;
name_resolve:
{
g_object_unref (resolver);
return NULL;
}
}
GInetAddress*
detect_internet_address ()
{
int sockfd;
gchar ip [100];
struct sockaddr_in serv_add;
struct sockaddr_storage myaddr;
socklen_t len;
/*
TODO This is to be adapted to work also over IPv6
*/
memset (&serv_add, 0, sizeof (serv_add));
serv_add.sin_family = AF_INET;
serv_add.sin_port = htons (80);
/*
This is the IP for slashdot.com
*/
if ((inet_pton (AF_INET, "216.34.181.45", &serv_add.sin_addr)) <= 0)
return NULL;
sockfd = socket (AF_INET, SOCK_DGRAM, 0);
if (!sockfd)
return NULL;
if (connect (sockfd, (struct sockaddr*) &serv_add, sizeof (serv_add)) == -1) {
close (sockfd);
return NULL;
}
len = sizeof (myaddr);
if (getsockname (sockfd, (struct sockaddr*) &myaddr, &len) != 0) {
close (sockfd);
return NULL;
}
close (sockfd);
memset (ip, 0, sizeof (char) * 100);
if (inet_ntop (AF_INET, &(((struct sockaddr_in*) &myaddr)->sin_addr), ip, 100) == NULL)
return NULL;
return g_inet_address_new_from_string (ip);
}
void dirserver_init(gchar* baseaddress)
{
syslog(LOG_DEBUG,"dirserver_init: starting directory server");
services = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
dirserversocket = multicast_createSocket("directoryserver", 2323, &sa);
if( socket != NULL){
syslog(LOG_DEBUG,"dirserver_init: socket open");
GSource *source = g_socket_create_source(dirserversocket,
G_IO_IN, NULL);
ub_assert(source != NULL);
g_source_set_callback(source, (GSourceFunc)dirserver_read,
NULL, NULL);
g_source_attach(source, g_main_context_default());
}else{
syslog(LOG_WARNING,
"directory-server.c: warning: could not create socket");
}
GError * e = NULL;
GInetAddress *net_base = g_inet_address_new_from_string(baseaddress);
if( net_base == NULL ){
syslog(LOG_ERR, "dirserver_init: Could not parse base address");
return;
}
//set up http tcp listener
GSocketAddress *httpsa = g_inet_socket_address_new(net_base,8080);
syslog(LOG_DEBUG,"dirserver_init: Creating tcp socket on port 8080\n");
GSocketService *gss = g_socket_service_new();
//TODO: save a reference to the gss somewhere
if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), httpsa,
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &e)
== FALSE ){
syslog(LOG_WARNING,
"dirserver_init: error while creating socket listener: %s\n",e->message);
g_error_free(e);
}
g_signal_connect(gss, "incoming", G_CALLBACK(dirserver_tcp_listener),NULL);
g_socket_service_start(gss);
g_timeout_add_seconds(1,dirserver_tick,NULL);
}
gboolean xr_server_bind(xr_server* server, const char* bind_addr, GError** err)
{
GError* local_err = NULL;
char* addr = NULL;
int port = 0;
xr_trace(XR_DEBUG_SERVER_TRACE, "(server=%p, bind_addr=%s, err=%p)", server, bind_addr, err);
g_return_val_if_fail(server != NULL, FALSE);
g_return_val_if_fail(bind_addr != NULL, FALSE);
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
g_return_val_if_fail(_parse_addr(bind_addr, &addr, &port), FALSE);
if (addr[0] == '*')
{
g_socket_listener_add_inet_port(G_SOCKET_LISTENER(server->service), (guint16)port, NULL, &local_err);
}
else
{
// build address
GInetAddress* iaddr = g_inet_address_new_from_string(addr);
if (!iaddr)
{
g_error_new(XR_SERVER_ERROR, XR_SERVER_ERROR_FAILED, "Invalid address: %s", bind_addr);
g_free(addr);
xr_server_stop(server);
return FALSE;
}
GSocketAddress* isaddr = g_inet_socket_address_new(iaddr, (guint16)port);
g_socket_listener_add_address(G_SOCKET_LISTENER(server->service), isaddr, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &local_err);
}
g_free(addr);
if (local_err)
{
g_propagate_prefixed_error(err, local_err, "Port listen failed: ");
xr_server_stop(server);
return FALSE;
}
return TRUE;
}
GSocket *multicast_createSocket(gchar *interface, gchar *groupaddress, guint port,
GSocketAddress **sa)
{
GError *err = NULL;
GInetAddress *addr =
g_inet_address_new_from_string(groupaddress);
*sa = g_inet_socket_address_new(addr,port);
GSocket *socket = g_socket_new(G_SOCKET_FAMILY_IPV6,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP,
NULL);
ub_assert(socket != NULL);
int on = 1;
setsockopt(g_socket_get_fd(socket), SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if( g_socket_bind(socket, *sa, TRUE, &err) == FALSE ){
syslog(LOG_ERR, "net_createSockets: Error while binding udp socket: %s\n", err->message);
g_error_free(err);
g_object_unref(*sa);
g_object_unref(socket);
return NULL;
}
struct addrinfo *resmulti;
struct ipv6_mreq mreq;
mreq.ipv6mr_interface = if_nametoindex(interface);
gchar *tmp = g_inet_address_to_string(addr);
syslog(LOG_DEBUG,"using address: %s\n",tmp);
int ret = getaddrinfo(tmp, NULL, NULL, &resmulti);
g_free(tmp);
if( ret ){
syslog(LOG_ERR,"net_multicast.c: %s", gai_strerror(ret));
g_object_unref(*sa);
g_object_unref(socket);
return NULL;
}
mreq.ipv6mr_multiaddr = ((struct sockaddr_in6 *)resmulti->ai_addr)->sin6_addr;
setsockopt(g_socket_get_fd(socket), IPPROTO_IPV6,
IPV6_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq));
return socket;
}
static void
use_inet_address (gboolean synchronous)
{
GSocketAddressEnumerator *enumerator;
GSocketAddress *sockaddr;
GInetAddress *addr = NULL;
guint port = 0;
gchar **ip_and_port;
ip_and_port = g_strsplit (info, ":", 2);
if (ip_and_port[0])
{
addr = g_inet_address_new_from_string (ip_and_port[0]);
if (ip_and_port [1])
port = strtoul (ip_and_port [1], NULL, 10);
}
g_strfreev (ip_and_port);
if (addr == NULL || port <= 0 || port >= 65535)
{
fprintf (stderr, "Bad 'ip:port' parameter '%s'\n", info);
if (addr)
g_object_unref (addr);
return_value = 1;
return;
}
sockaddr = g_inet_socket_address_new (addr, port);
g_object_unref (addr);
enumerator =
g_socket_connectable_proxy_enumerate (G_SOCKET_CONNECTABLE (sockaddr));
g_object_unref (sockaddr);
printf ("Proxies for ip and port '%s' are:\n", info);
run_with_enumerator (synchronous, enumerator);
g_object_unref (enumerator);
}
static GInetAddress *
gst_udpsrc_resolve (GstUDPSrc * src, const gchar * address)
{
GInetAddress *addr;
GError *err = NULL;
GResolver *resolver;
addr = g_inet_address_new_from_string (address);
if (!addr) {
GList *results;
GST_DEBUG_OBJECT (src, "resolving IP address for host %s", address);
resolver = g_resolver_get_default ();
results =
g_resolver_lookup_by_name (resolver, address, src->cancellable, &err);
if (!results)
goto name_resolve;
addr = G_INET_ADDRESS (g_object_ref (results->data));
g_resolver_free_addresses (results);
g_object_unref (resolver);
}
#ifndef GST_DISABLE_GST_DEBUG
{
gchar *ip = g_inet_address_to_string (addr);
GST_DEBUG_OBJECT (src, "IP address for host %s is %s", address, ip);
g_free (ip);
}
#endif
return addr;
name_resolve:
{
GST_WARNING_OBJECT (src, "Failed to resolve %s: %s", address, err->message);
g_clear_error (&err);
g_object_unref (resolver);
return NULL;
}
}
/**
* Register the flare service port
*/
void create_service(gchar *address, uint16_t port, GCallback *callback, gulong *handler_id)
{
GSocketService *service = g_socket_service_new();
GInetAddress *inet_address = g_inet_address_new_from_string(address);
GSocketAddress *socket_address = g_inet_socket_address_new(inet_address, port);
g_socket_listener_add_address(
G_SOCKET_LISTENER(service),
socket_address,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP,
NULL, NULL, NULL);
g_object_unref(socket_address);
g_object_unref(inet_address);
*handler_id = g_signal_connect(service, "incoming", G_CALLBACK(callback), NULL);
g_socket_service_start(service);
g_assert(g_socket_service_is_active(service));
}
static gboolean
fill_address (const gchar * address, guint16 port, Addr * addr,
gboolean is_multicast)
{
GInetAddress *inet;
inet = g_inet_address_new_from_string (address);
if (inet == NULL)
return FALSE;
if (is_multicast != g_inet_address_get_is_multicast (inet)) {
g_object_unref (inet);
return FALSE;
}
addr->size = g_inet_address_get_native_size (inet);
memcpy (addr->bytes, g_inet_address_to_bytes (inet), addr->size);
g_object_unref (inet);
addr->port = port;
return TRUE;
}
static void
start_async_lookups (char **argv, int argc)
{
int i;
for (i = 0; i < argc; i++)
{
if (strchr (argv[i], '/'))
{
/* service/protocol/domain */
char **parts = g_strsplit (argv[i], "/", 3);
if (!parts || !parts[2])
usage ();
g_resolver_lookup_service_async (resolver,
parts[0], parts[1], parts[2],
cancellable,
lookup_service_callback, argv[i]);
}
else if (g_hostname_is_ip_address (argv[i]))
{
GInetAddress *addr = g_inet_address_new_from_string (argv[i]);
g_resolver_lookup_by_address_async (resolver, addr, cancellable,
lookup_by_addr_callback, argv[i]);
g_object_unref (addr);
}
else
{
g_resolver_lookup_by_name_async (resolver, argv[i], cancellable,
lookup_by_name_callback,
argv[i]);
}
/* Stress-test the reloading code */
g_signal_emit_by_name (resolver, "reload");
}
}
void
do_dns (session *sess, char *nick, char *host,
const message_tags_data *tags_data)
{
GResolver *res = g_resolver_get_default ();
GInetAddress *addr;
char *po;
po = strrchr (host, '@');
if (po)
host = po + 1;
if (nick)
EMIT_SIGNAL_TIMESTAMP (XP_TE_RESOLVINGUSER, sess, tags_data->timestamp, nick, host);
PrintTextf (sess, _("Looking up %s..."), host);
addr = g_inet_address_new_from_string (host);
if (addr)
g_resolver_lookup_by_address_async (res, addr, NULL, dns_addr_callback, sess);
else
g_resolver_lookup_by_name_async (res, host, NULL, dns_name_callback, sess);
}
void cortrol_service_init()
{
GError * error = NULL;
control_service_data.cmd_buf = NULL;
/* create the new socketservice */
control_service_data.service = g_socket_service_new ();
GInetAddress *address = g_inet_address_new_from_string(inet_ntoa(local_ip));
GSocketAddress *socket_address = g_inet_socket_address_new(address, CONTROL_PORT);
g_socket_listener_add_address(G_SOCKET_LISTENER(control_service_data.service), socket_address, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL);
/* connect to the port */
/*g_socket_listener_add_inet_port ((GSocketListener*)control_service_data.service,
CONTROL_PORT,
NULL,
&error);*/
/* don't forget to check for errors */
if (error != NULL)
{
g_error ("%s", error->message);
}
/* listen to the 'incoming' signal */
g_signal_connect (control_service_data.service,
"incoming",
G_CALLBACK (incoming_callback),
NULL);
/* start the socket service */
g_socket_service_start (control_service_data.service);
/* enter mainloop */
g_print ("Waiting for client! %s\n", inet_ntoa(local_ip));
}
static void
BP_TCPService_BindListener (BPTCPService *filter)
{
// Don't bind if we're sink-only
g_return_if_fail (filter->ready && !filter->init && filter->mode != BP_MODE_SINK_ONLY);
filter->service = g_socket_service_new();
filter->inetAddress = g_inet_address_new_from_string(filter->address->str);
filter->socketAddress = g_inet_socket_address_new(filter->inetAddress, filter->port);
// add server socket to service and attach listener
g_socket_listener_add_address(G_SOCKET_LISTENER(filter->service),
filter->socketAddress,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP,
NULL, NULL, NULL);
g_message ("Starting IO service...");
// Connect socket to IO service
g_socket_service_start(filter->service);
g_message ("IO service is up");
g_message ("Attaching signals ...");
// Pass proxy instance as user data
g_signal_connect(filter->service, "incoming", G_CALLBACK(BP_TCPService_IncomingConnection), filter);
g_message ("Attached!");
BP_TCPService_ValidateBind (filter);
g_message ("Local IP/Port: %s:%u", filter->address->str, filter->port);
filter->init = TRUE;
}
static void
lookup_one_sync (const char *arg)
{
GError *error = NULL;
if (strchr (arg, '/'))
{
GList *targets;
/* service/protocol/domain */
char **parts = g_strsplit (arg, "/", 3);
if (!parts || !parts[2])
usage ();
targets = g_resolver_lookup_service (resolver,
parts[0], parts[1], parts[2],
cancellable, &error);
print_resolved_service (arg, targets, error);
}
else if (g_hostname_is_ip_address (arg))
{
GInetAddress *addr = g_inet_address_new_from_string (arg);
char *name;
name = g_resolver_lookup_by_address (resolver, addr, cancellable, &error);
print_resolved_name (arg, name, error);
g_object_unref (addr);
}
else
{
GList *addresses;
addresses = g_resolver_lookup_by_name (resolver, arg, cancellable, &error);
print_resolved_addresses (arg, addresses, error);
}
}
