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).
typedef enum { GINETADDR_ASYNC_STATUS_OK, GINETADDR_ASYNC_STATUS_ERROR } GInetAddrAsyncStatus; |
Status of a asynchronous lookup (from gnet_inetaddr_new_async() or gnet_inetaddr_get_name_async()), passed by GInetAddrNewAsyncFunc or GInetAddrGetNameAsyncFunc. More errors may be added in the future, so it's best to compare against GINETADDR_ASYNC_STATUS_OK.
ID of an asynchronous InetAddr creation started with gnet_inetaddr_new_async(). The creation can be canceled by calling gnet_inetaddr_new_async_cancel() with the ID.
void (*GInetAddrNewAsyncFunc) (GInetAddr *inetaddr, GInetAddrAsyncStatus status, |
Caller owns the address; the callee should copy it if necessary. FIX: In next major version, make inetaddr callee owned. GInetAddrGetNameAsyncFunc and GTcpSocketConnectAsyncFunc both pass callee owned data.
Callback for gnet_inetaddr_new_async().
ID of an asynchronous InetAddr name lookup started with gnet_inetaddr_get_name_async(). The lookup can be canceled by calling gnet_inetaddr_get_name_async_cancel() with the ID.
void (*GInetAddrGetNameAsyncFunc) (GInetAddr *inetaddr, GInetAddrAsyncStatus status, |
Callback for gnet_inetaddr_get_name_async(). Delete the name when you're done with it. The GInetAddr is the GInetAddr passed to gnet_inetaddr_get_name_async() -- the address is not copied. (FIX: In 1.2.0, don't pass the InetAddr.)
GInetAddr* gnet_inetaddr_new (const |
Create an internet address from a name and port. This function may block.
GInetAddrNewAsyncID gnet_inetaddr_new_async (const |
Create a GInetAddr from a name and port asynchronously. The callback is called once the structure is created or an error occurs during lookup. The callback will not be called during the call to gnet_inetaddr_new_async().
The Unix version creates a pthread thread which does the lookup. If pthreads aren't available, it forks and does the lookup. Forking will be slow or even fail when using operating systems that copy the entire process when forking.
If you need to lookup hundreds of addresses, we recommend calling g_main_iteration(FALSE) between calls. This will help prevent an explosion of threads or 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. This library does not use threads or processes.
The Windows version should work fine. Windows has an asynchronous DNS lookup function.
void gnet_inetaddr_new_async_cancel (GInetAddrNewAsyncID id); |
Cancel an asynchronous GInetAddr creation that was started with gnet_inetaddr_new_async().
GInetAddr* gnet_inetaddr_new_nonblock (const |
Create an internet address from a name and port, but don't block and fail if it would require blocking. This is, if the name is a canonical name or "localhost", it returns the address. Otherwise, it returns NULL.
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"). The "nice name" is the domain name if it has one or the canonical name if it does not. Be warned that this call may block since it may need to do a reverse DNS lookup.
|
Get the nice name of the address, but don't block and fail if it would require blocking.
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. The callback will not be called during the call to gnet_inetaddr_new_async().
The Unix uses either pthreads or
FIX: In the next big version, this should copy ia.
void gnet_inetaddr_get_name_async_cancel (GInetAddrGetNameAsyncID id); |
Cancel an asynchronous nice name lookup that was started with gnet_inetaddr_get_name_async().
|
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.)
|
Hash the address. This is useful for glib containers.
|
Compare two GInetAddr's.
|
Compare two GInetAddr's, but does not compare the port numbers.
GInetAddr* gnet_inetaddr_gethostaddr (void); |
Get the primary host's GInetAddr.
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>".
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.