GNet Network Library Reference Manual | |||
---|---|---|---|
<<< Previous Page | Home | Up | Next Page >>> |
InetAddr represents an internet address. Currently, only IP version 4 addresses are used (eg, addresses in the form 141.213.8.59).
GInetAddr* gnet_inetaddr_new (const gchar *name, gint port); |
Create an internet address from a name and port.
name : | a nice name (eg, mofo.eecs.umich.edu) or a dotted decimal name (eg, 141.213.8.59). You can delete the after the function is called. |
port : | port number (0 if the port doesn't matter) |
Returns : | a new GInetAddr, or NULL if there was a failure. |
GInetAddr* gnet_inetaddr_new_any (void); |
Create a GInetAddr with the address INADDR_ANY and port 0. This is useful for creating default addresses for binding. The address's name will be "<INADDR_ANY>".
Returns : | INADDR_ANY GInetAddr. |
GInetAddr* gnet_inetaddr_new_nonblock (const gchar *name, gint port); |
Create an internet address from a name and port, but don't block and fail if success would require blocking. This is, if the name is a canonical name or "localhost", it returns the address. Otherwise, it returns NULL.
name : | a nice name (eg, mofo.eecs.umich.edu) or a dotted decimal name (eg, 141.213.8.59). You can delete the after the function is called. |
port : | port number (0 if the port doesn't matter) |
Returns : | a new GInetAddr, or NULL if there was a failure. |
GInetAddrNewAsyncID gnet_inetaddr_new_async (const gchar *name, gint port, GInetAddrNewAsyncFunc func, gpointer data); |
Create a GInetAddr from a name and port asynchronously. Once the structure is created, it will call the callback. It may call the callback before the function returns. It will call the callback if there is a failure.
The Unix version forks and does the lookup, which can cause some problems. In general, this will work ok for most programs most of the time. It will be slow or even fail when using operating systems that copy the entire process when forking.
If you need to lookup a lot of addresses, we recommend calling g_main_iteration(FALSE) between calls. This will help prevent an explosion of processes.
If you need a more robust library for Unix, look at <ulink url="http://www.gnu.org/software/adns/adns.html">GNU ADNS</ulink>. GNU ADNS is under the GNU GPL.
The Windows version should work fine. Windows has an asynchronous DNS lookup function.
name : | a nice name (eg, mofo.eecs.umich.edu) or a dotted decimal name (eg, 141.213.8.59). You can delete the after the function is called. |
port : | port number (0 if the port doesn't matter) |
func : | Callback function. |
data : | User data passed when callback function is called. |
Returns : | ID of the lookup which can be used with gnet_inetaddr_new_async_cancel() to cancel it; NULL on immediate success or failure. |
void gnet_inetaddr_new_async_cancel (GInetAddrNewAsyncID id); |
Cancel an asynchronous GInetAddr creation that was started with gnet_inetaddr_new_async().
void (*GInetAddrNewAsyncFunc) (GInetAddr *inetaddr, GInetAddrAsyncStatus status, gpointer data); |
typedef enum { GINETADDR_ASYNC_STATUS_OK, GINETADDR_ASYNC_STATUS_ERROR } GInetAddrAsyncStatus; |
GInetAddr* gnet_inetaddr_clone (const GInetAddr *ia); |
Create an internet address from another one.
void gnet_inetaddr_ref (GInetAddr *ia); |
Increment the reference counter of the GInetAddr.
void gnet_inetaddr_unref (GInetAddr *ia); |
Remove a reference from the GInetAddr. When reference count reaches 0, the address is deleted.
gchar* gnet_inetaddr_get_name (GInetAddr *ia); |
Get the nice name of the address (eg, "mofo.eecs.umich.edu"). Be warned that this call may block since it may need to do a reverse DNS lookup.
GInetAddrGetNameAsyncID gnet_inetaddr_get_name_async (GInetAddr *ia, GInetAddrGetNameAsyncFunc func, gpointer data); |
Get the nice name of the address (eg, "mofo.eecs.umich.edu"). This function will use the callback once it knows the nice name. It may even call the callback before it returns. The callback will be called if there is an error.
The Unix version forks and does the reverse lookup. This has problems. See the notes for gnet_inetaddr_new_async(). The Windows version should work fine.
void gnet_inetaddr_get_name_async_cancel (GInetAddrGetNameAsyncID id); |
Cancel an asynchronous nice name lookup that was started with gnet_inetaddr_get_name_async().
void (*GInetAddrGetNameAsyncFunc) (GInetAddr *inetaddr, GInetAddrAsyncStatus status, gchar *name, gpointer data); |
gchar* gnet_inetaddr_get_canonical_name (const GInetAddr *ia); |
Get the "canonical" name of an address (eg, for IP4 the dotted decimal name 141.213.8.59).
void gnet_inetaddr_set_port (const GInetAddr *ia, guint port); |
Set the port number.
gboolean gnet_inetaddr_is_canonical (const gchar *name); |
Check if the domain name is canonical. For IPv4, a canonical name is a dotted decimal name (eg, 141.213.8.59).
gboolean gnet_inetaddr_is_internet (const GInetAddr *inetaddr); |
Check if the address is a sensible internet address. This mean it is not private, reserved, loopback, multicast, or broadcast.
Note that private and loopback address are often valid addresses, so this should only be used to check for general Internet connectivity. That is, if the address passes, it is reachable on the Internet.
gboolean gnet_inetaddr_is_private (const GInetAddr *inetaddr); |
Check if the address is an address reserved for private networks or something else. This includes:
10.0.0.0 - 10.255.255.255 (10/8 prefix) 172.16.0.0 - 172.31.255.255 (172.16/12 prefix) 192.168.0.0 - 192.168.255.255 (192.168/16 prefix)
(from RFC 1918. See also draft-manning-dsua-02.txt)
gboolean gnet_inetaddr_is_reserved (const GInetAddr *inetaddr); |
Check if the address is reserved for 'something'. This excludes address reserved for private networks.
We check for: 0.0.0.0/16 (top 16 bits are 0's) Class E (top 5 bits are 11110)
gboolean gnet_inetaddr_is_loopback (const GInetAddr *inetaddr); |
Check if the address is a loopback address. Loopback addresses have the prefix 127.0.0.1/16.
gboolean gnet_inetaddr_is_multicast (const GInetAddr *inetaddr); |
Check if the address is a multicast address. Multicast address are in the range 224.0.0.1 - 239.255.255.255 (ie, the top four bits are 1110).
gboolean gnet_inetaddr_is_broadcast (const GInetAddr *inetaddr); |
Check if the address is a broadcast address. The broadcast address is 255.255.255.255. (Network broadcast address are network dependent.)
GInetAddr* gnet_inetaddr_gethostaddr (void); |
Get the primary host's GInetAddr.
GInetAddr* gnet_inetaddr_autodetect_internet_interface (void); |
Find an Internet interface. Usually, this interface routes packets to and from the Internet. It can be used to automatically configure simple servers that must advertise their address. This sometimes doesn't work correctly when the user is behind a NAT.
GInetAddr* gnet_inetaddr_get_interface_to (const GInetAddr *addr); |
Figure out which local interface would be used to send a packet to addr. This works on some systems, but not others. We recommend using gnet_inetaddr_autodetect_internet_interface() to find an Internet interface since it's more likely to work.
GInetAddr* gnet_inetaddr_get_internet_interface (void); |
Find an Internet interface. This just calls gnet_inetaddr_list_interfaces() and returns the first one that passes gnet_inetaddr_is_internet(). This works well on some systems, but not so well on others. We recommend using gnet_inetaddr_autodetect_internet_interface() to find an Internet interface since it's more likely to work.
gboolean gnet_inetaddr_is_internet_domainname (const gchar *name); |
Check if the domain name is a sensible Internet domain name. This function uses heuristics and does not use DNS (or even block). For example, "localhost" and "10.10.23.42" are not sensible Internet domain names. (10.10.23.42 is a network address, but not accessible to the Internet at large.)
GList* gnet_inetaddr_list_interfaces (void); |
Get a list of GInetAddr interfaces's on this host. This list includes all "up" Internet interfaces and the loopback interface, if it exists.
Note that the Windows version supports a maximum of 10 interfaces. In Windows NT, Service Pack 4 (or higher) is required.
Returns : | A list of GInetAddr's representing available interfaces. The caller should delete the list and the addresses. |
guint gnet_inetaddr_hash (gconstpointer p); |
Hash the address. This is useful for glib containers.
p : | Pointer to an GInetAddr. |
Returns : | hash value. |
gint gnet_inetaddr_equal (gconstpointer p1, gconstpointer p2); |
Compare two GInetAddr's.
gint gnet_inetaddr_noport_equal (gconstpointer p1, gconstpointer p2); |
Compare two GInetAddr's, but does not compare the port numbers.