Top |
Functions
SoupAddress * | soup_address_new () |
SoupAddress * | soup_address_new_from_sockaddr () |
SoupAddress * | soup_address_new_any () |
void | (*SoupAddressCallback) () |
void | soup_address_resolve_async () |
guint | soup_address_resolve_sync () |
gboolean | soup_address_is_resolved () |
const char * | soup_address_get_name () |
struct sockaddr * | soup_address_get_sockaddr () |
GSocketAddress * | soup_address_get_gsockaddr () |
const char * | soup_address_get_physical () |
guint | soup_address_get_port () |
gboolean | soup_address_equal_by_name () |
guint | soup_address_hash_by_name () |
gboolean | soup_address_equal_by_ip () |
guint | soup_address_hash_by_ip () |
Types and Values
SoupAddress | |
enum | SoupAddressFamily |
#define | SOUP_ADDRESS_ANY_PORT |
#define | SOUP_ADDRESS_FAMILY |
#define | SOUP_ADDRESS_NAME |
#define | SOUP_ADDRESS_PHYSICAL |
#define | SOUP_ADDRESS_PORT |
#define | SOUP_ADDRESS_SOCKADDR |
#define | SOUP_ADDRESS_PROTOCOL |
Description
SoupAddress represents the address of a TCP connection endpoint: both the IP address and the port. (It is somewhat like an object-oriented version of struct sockaddr.)
Although SoupAddress is still used in some libsoup API's, it should not be used in new code; use GLib's GNetworkAddress or GSocketAddress instead.
Functions
soup_address_new ()
SoupAddress * soup_address_new (const char *name
,guint port
);
Creates a SoupAddress from name
and port
. The SoupAddress's IP
address may not be available right away; the caller can call
soup_address_resolve_async()
or soup_address_resolve_sync()
to
force a DNS resolution.
soup_address_new_from_sockaddr ()
SoupAddress * soup_address_new_from_sockaddr (struct sockaddr *sa
,int len
);
Returns a SoupAddress equivalent to sa
(or NULL
if sa
's
address family isn't supported)
soup_address_new_any ()
SoupAddress * soup_address_new_any (SoupAddressFamily family
,guint port
);
Returns a SoupAddress corresponding to the "any" address
for family
(or NULL
if family
isn't supported), suitable for
using as a listening SoupSocket.
SoupAddressCallback ()
void (*SoupAddressCallback) (SoupAddress *addr
,guint status
,gpointer user_data
);
The callback function passed to soup_address_resolve_async()
.
Parameters
addr |
the SoupAddress that was resolved |
|
status |
|
|
user_data |
the user data that was passed to
|
soup_address_resolve_async ()
void soup_address_resolve_async (SoupAddress *addr
,GMainContext *async_context
,GCancellable *cancellable
,SoupAddressCallback callback
,gpointer user_data
);
Asynchronously resolves the missing half of addr
(its IP address
if it was created with soup_address_new()
, or its hostname if it
was created with soup_address_new_from_sockaddr()
or
soup_address_new_any()
.)
If cancellable
is non-NULL
, it can be used to cancel the
resolution. callback
will still be invoked in this case, with a
status of SOUP_STATUS_CANCELLED
.
It is safe to call this more than once on a given address, from the
same thread, with the same async_context
(and doing so will not
result in redundant DNS queries being made). But it is not safe to
call from multiple threads, or with different async_contexts
, or
mixed with calls to soup_address_resolve_sync()
.
Parameters
addr |
||
async_context |
the GMainContext to call |
[allow-none] |
cancellable |
a GCancellable object, or |
|
callback |
callback to call with the result. |
[scope async] |
user_data |
data for |
soup_address_resolve_sync ()
guint soup_address_resolve_sync (SoupAddress *addr
,GCancellable *cancellable
);
Synchronously resolves the missing half of addr
, as with
soup_address_resolve_async()
.
If cancellable
is non-NULL
, it can be used to cancel the
resolution. soup_address_resolve_sync()
will then return a status
of SOUP_STATUS_CANCELLED
.
It is safe to call this more than once, even from different
threads, but it is not safe to mix calls to
soup_address_resolve_sync()
with calls to
soup_address_resolve_async()
on the same address.
soup_address_is_resolved ()
gboolean
soup_address_is_resolved (SoupAddress *addr
);
Tests if addr
has already been resolved. Unlike the other
SoupAddress "get" methods, this is safe to call when addr
might
be being resolved in another thread.
soup_address_get_name ()
const char *
soup_address_get_name (SoupAddress *addr
);
Returns the hostname associated with addr
.
This method is not thread-safe; if you call it while addr
is being
resolved in another thread, it may return garbage. You can use
soup_address_is_resolved()
to safely test whether or not an address
is resolved before fetching its name or address.
soup_address_get_sockaddr ()
struct sockaddr * soup_address_get_sockaddr (SoupAddress *addr
,int *len
);
Returns the sockaddr associated with addr
, with its length in
*len
. If the sockaddr is not yet known, returns NULL
.
This method is not thread-safe; if you call it while addr
is being
resolved in another thread, it may return garbage. You can use
soup_address_is_resolved()
to safely test whether or not an address
is resolved before fetching its name or address.
soup_address_get_gsockaddr ()
GSocketAddress *
soup_address_get_gsockaddr (SoupAddress *addr
);
Creates a new GSocketAddress corresponding to addr
(which is assumed
to only have one socket address associated with it).
Since 2.32
soup_address_get_physical ()
const char *
soup_address_get_physical (SoupAddress *addr
);
Returns the physical address associated with addr
as a string.
(Eg, "127.0.0.1"). If the address is not yet known, returns NULL
.
This method is not thread-safe; if you call it while addr
is being
resolved in another thread, it may return garbage. You can use
soup_address_is_resolved()
to safely test whether or not an address
is resolved before fetching its name or address.
soup_address_get_port ()
guint
soup_address_get_port (SoupAddress *addr
);
Returns the port associated with addr
.
soup_address_equal_by_name ()
gboolean soup_address_equal_by_name (gconstpointer addr1
,gconstpointer addr2
);
Tests if addr1
and addr2
have the same "name". This method can be
used with soup_address_hash_by_name()
to create a GHashTable that
hashes on address "names".
Comparing by name normally means comparing the addresses by their hostnames. But if the address was originally created using an IP address literal, then it will be compared by that instead.
In particular, if "www.example.com" has the IP address 10.0.0.1,
and addr1
was created with the name "www.example.com" and addr2
was created with the name "10.0.0.1", then they will compare as
unequal for purposes of soup_address_equal_by_name()
.
This would be used to distinguish hosts in situations where different virtual hosts on the same IP address should be considered different. Eg, for purposes of HTTP authentication or cookies, two hosts with the same IP address but different names are considered to be different hosts.
See also soup_address_equal_by_ip()
, which compares by IP address
rather than by name.
Parameters
addr1 |
a SoupAddress with a resolved name. |
[type Soup.Address] |
addr2 |
another SoupAddress with a resolved name. |
[type Soup.Address] |
Since 2.26
soup_address_hash_by_name ()
guint
soup_address_hash_by_name (gconstpointer addr
);
A hash function (for GHashTable) that corresponds to
soup_address_equal_by_name()
, qv
Since 2.26
soup_address_equal_by_ip ()
gboolean soup_address_equal_by_ip (gconstpointer addr1
,gconstpointer addr2
);
Tests if addr1
and addr2
have the same IP address. This method
can be used with soup_address_hash_by_ip()
to create a
GHashTable that hashes on IP address.
This would be used to distinguish hosts in situations where different virtual hosts on the same IP address should be considered the same. Eg, if "www.example.com" and "www.example.net" have the same IP address, then a single connection can be used to talk to either of them.
See also soup_address_equal_by_name()
, which compares by name
rather than by IP address.
Parameters
addr1 |
a SoupAddress with a resolved IP address. |
[type Soup.Address] |
addr2 |
another SoupAddress with a resolved IP address. |
[type Soup.Address] |
Since 2.26
soup_address_hash_by_ip ()
guint
soup_address_hash_by_ip (gconstpointer addr
);
A hash function (for GHashTable) that corresponds to
soup_address_equal_by_ip()
, qv
Since 2.26
Types and Values
enum SoupAddressFamily
The supported address families.
SOUP_ADDRESS_ANY_PORT
#define SOUP_ADDRESS_ANY_PORT 0
This can be passed to any SoupAddress method that expects a port, to indicate that you don't care what port is used.
SOUP_ADDRESS_FAMILY
#define SOUP_ADDRESS_FAMILY "family"
Alias for the “family” property. (The SoupAddressFamily for this address.)
SOUP_ADDRESS_NAME
#define SOUP_ADDRESS_NAME "name"
Alias for the “name” property. (The hostname for this address.)
SOUP_ADDRESS_PHYSICAL
#define SOUP_ADDRESS_PHYSICAL "physical"
An alias for the “physical” property. (The stringified IP address for this address.)
SOUP_ADDRESS_PORT
#define SOUP_ADDRESS_PORT "port"
An alias for the “port” property. (The port for this address.)
SOUP_ADDRESS_SOCKADDR
#define SOUP_ADDRESS_SOCKADDR "sockaddr"
An alias for the “sockaddr” property. (A pointer to the struct sockaddr for this address.)
SOUP_ADDRESS_PROTOCOL
#define SOUP_ADDRESS_PROTOCOL "protocol"
Alias for the “protocol” property. (The URI scheme used with this address.)
Property Details
The “family”
property
“family” SoupAddressFamily
Address family for this address.
Flags: Read / Write / Construct Only
Default value: SOUP_ADDRESS_FAMILY_INVALID
The “name”
property
“name” gchar *
Hostname for this address.
Flags: Read / Write / Construct Only
Default value: NULL
The “physical”
property
“physical” gchar *
IP address for this address.
Flags: Read
Default value: NULL
The “port”
property
“port” gint
Port for this address.
Flags: Read / Write / Construct Only
Allowed values: [-1,65535]
Default value: -1
The “protocol”
property
“protocol” gchar *
URI scheme for this address.
Flags: Read / Write / Construct Only
Default value: NULL
The “sockaddr”
property
“sockaddr” gpointer
struct sockaddr for this address.
Flags: Read / Write / Construct Only