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); } }