struct SoupAddress

struct SoupAddress;

enum SoupAddressFamily

typedef enum {
	SOUP_ADDRESS_FAMILY_IPV4 = AF_INET,
	SOUP_ADDRESS_FAMILY_IPV6 = AF_INET6
} SoupAddressFamily;

The supported address families. Note that the SOUP_ADDRESS_FAMILY_IPV6 constant is available even if libsoup was built without IPv6 support, but attempting to create an IPv6 address will fail in that case.

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_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 passing to soup_socket_server_new().

SoupAddressCallback ()

void                (*SoupAddressCallback)              (SoupAddress *addr,
                                                         guint status,
                                                         gpointer data);

The callback function passed to soup_address_resolve_async().

soup_address_resolve_async ()

void                soup_address_resolve_async          (SoupAddress *addr,
                                                         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().) callback will be called when the resolution finishes (successfully or not).

soup_address_resolve_async_full ()

void                soup_address_resolve_async_full     (SoupAddress *addr,
                                                         GMainContext *async_context,
                                                         SoupAddressCallback callback,
                                                         gpointer user_data);

Like soup_address_resolve_async(), but calls callback from the given async_context.

soup_address_resolve_sync ()

guint               soup_address_resolve_sync           (SoupAddress *addr);

Synchronously resolves the missing half of addr, as with soup_address_resolve_async().

soup_address_get_name ()

const char*         soup_address_get_name               (SoupAddress *addr);

Returns the hostname associated with addr.

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.

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.

soup_address_get_port ()

guint               soup_address_get_port               (SoupAddress *addr);

Returns the port associated with addr.

The "dns-result" signal

void                user_function                      (SoupAddress *addr,
                                                        gint         status,
                                                        gpointer     user_data)      : Run First

Emitted when an address resolution completes. (This is used internally by soup_address_resolve_async() itself.)