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 |
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 |
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 |
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, |
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.
|
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, |
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, |
|
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, |
Set the port number.
|
Check if the domain name is canonical. For IPv4, a canonical name is a dotted decimal name (eg, 141.213.8.59).
|
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.
|
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)
|
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)
|
Check if the address is a loopback address. Loopback addresses have the prefix 127.0.0.1/16.
|
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).
|
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.
|
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.)
|
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. |
|
Hash the address. This is useful for glib containers.
p : | Pointer to an GInetAddr. |
Returns : | hash value. |
|
Compare two GInetAddr's.
|
Compare two GInetAddr's, but does not compare the port numbers.