mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-14 13:26:16 +01:00
00bfb3ab44
This was mostly machine generated with the following command:
```
codespell \
--builtin clear,rare,usage \
--skip './po/*' --skip './.git/*' --skip './NEWS*' \
--write-changes .
```
using the latest git version of `codespell` as per [these
instructions](https://github.com/codespell-project/codespell#user-content-updating).
Then I manually checked each change using `git add -p`, made a few
manual fixups and dropped a load of incorrect changes.
There are still some outdated or loaded terms used in GLib, mostly to do
with git branch terminology. They will need to be changed later as part
of a wider migration of git terminology.
If I’ve missed anything, please file an issue!
Signed-off-by: Philip Withnall <withnall@endlessm.com>
454 lines
11 KiB
C
454 lines
11 KiB
C
/* GIO - GLib Input, Output and Streaming Library
|
||
*
|
||
* Copyright (C) 2010 Collabora, Ltd.
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation; either
|
||
* version 2.1 of the License, or (at your option) any later version.
|
||
*
|
||
* This library is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General
|
||
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||
*
|
||
* Authors: Nicolas Dufresne <nicolas.dufresne@collabora.co.uk>
|
||
*/
|
||
|
||
#include <config.h>
|
||
#include <glib.h>
|
||
#include <string.h>
|
||
|
||
#include <gio/gsocketaddress.h>
|
||
|
||
#include "gproxyaddress.h"
|
||
#include "glibintl.h"
|
||
|
||
/**
|
||
* SECTION:gproxyaddress
|
||
* @short_description: An internet address with proxy information
|
||
* @include: gio/gio.h
|
||
*
|
||
* Support for proxied #GInetSocketAddress.
|
||
*/
|
||
|
||
/**
|
||
* GProxyAddress:
|
||
*
|
||
* A #GInetSocketAddress representing a connection via a proxy server
|
||
*
|
||
* Since: 2.26
|
||
**/
|
||
|
||
/**
|
||
* GProxyAddressClass:
|
||
*
|
||
* Class structure for #GProxyAddress.
|
||
*
|
||
* Since: 2.26
|
||
**/
|
||
|
||
enum
|
||
{
|
||
PROP_0,
|
||
PROP_PROTOCOL,
|
||
PROP_DESTINATION_PROTOCOL,
|
||
PROP_DESTINATION_HOSTNAME,
|
||
PROP_DESTINATION_PORT,
|
||
PROP_USERNAME,
|
||
PROP_PASSWORD,
|
||
PROP_URI
|
||
};
|
||
|
||
struct _GProxyAddressPrivate
|
||
{
|
||
gchar *uri;
|
||
gchar *protocol;
|
||
gchar *username;
|
||
gchar *password;
|
||
gchar *dest_protocol;
|
||
gchar *dest_hostname;
|
||
guint16 dest_port;
|
||
};
|
||
|
||
G_DEFINE_TYPE_WITH_PRIVATE (GProxyAddress, g_proxy_address, G_TYPE_INET_SOCKET_ADDRESS)
|
||
|
||
static void
|
||
g_proxy_address_finalize (GObject *object)
|
||
{
|
||
GProxyAddress *proxy = G_PROXY_ADDRESS (object);
|
||
|
||
g_free (proxy->priv->uri);
|
||
g_free (proxy->priv->protocol);
|
||
g_free (proxy->priv->username);
|
||
g_free (proxy->priv->password);
|
||
g_free (proxy->priv->dest_hostname);
|
||
g_free (proxy->priv->dest_protocol);
|
||
|
||
G_OBJECT_CLASS (g_proxy_address_parent_class)->finalize (object);
|
||
}
|
||
|
||
static void
|
||
g_proxy_address_set_property (GObject *object,
|
||
guint prop_id,
|
||
const GValue *value,
|
||
GParamSpec *pspec)
|
||
{
|
||
GProxyAddress *proxy = G_PROXY_ADDRESS (object);
|
||
|
||
switch (prop_id)
|
||
{
|
||
case PROP_PROTOCOL:
|
||
g_free (proxy->priv->protocol);
|
||
proxy->priv->protocol = g_value_dup_string (value);
|
||
break;
|
||
|
||
case PROP_DESTINATION_PROTOCOL:
|
||
g_free (proxy->priv->dest_protocol);
|
||
proxy->priv->dest_protocol = g_value_dup_string (value);
|
||
break;
|
||
|
||
case PROP_DESTINATION_HOSTNAME:
|
||
g_free (proxy->priv->dest_hostname);
|
||
proxy->priv->dest_hostname = g_value_dup_string (value);
|
||
break;
|
||
|
||
case PROP_DESTINATION_PORT:
|
||
proxy->priv->dest_port = g_value_get_uint (value);
|
||
break;
|
||
|
||
case PROP_USERNAME:
|
||
g_free (proxy->priv->username);
|
||
proxy->priv->username = g_value_dup_string (value);
|
||
break;
|
||
|
||
case PROP_PASSWORD:
|
||
g_free (proxy->priv->password);
|
||
proxy->priv->password = g_value_dup_string (value);
|
||
break;
|
||
|
||
case PROP_URI:
|
||
g_free (proxy->priv->uri);
|
||
proxy->priv->uri = g_value_dup_string (value);
|
||
break;
|
||
|
||
default:
|
||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
||
}
|
||
}
|
||
|
||
static void
|
||
g_proxy_address_get_property (GObject *object,
|
||
guint prop_id,
|
||
GValue *value,
|
||
GParamSpec *pspec)
|
||
{
|
||
GProxyAddress *proxy = G_PROXY_ADDRESS (object);
|
||
|
||
switch (prop_id)
|
||
{
|
||
case PROP_PROTOCOL:
|
||
g_value_set_string (value, proxy->priv->protocol);
|
||
break;
|
||
|
||
case PROP_DESTINATION_PROTOCOL:
|
||
g_value_set_string (value, proxy->priv->dest_protocol);
|
||
break;
|
||
|
||
case PROP_DESTINATION_HOSTNAME:
|
||
g_value_set_string (value, proxy->priv->dest_hostname);
|
||
break;
|
||
|
||
case PROP_DESTINATION_PORT:
|
||
g_value_set_uint (value, proxy->priv->dest_port);
|
||
break;
|
||
|
||
case PROP_USERNAME:
|
||
g_value_set_string (value, proxy->priv->username);
|
||
break;
|
||
|
||
case PROP_PASSWORD:
|
||
g_value_set_string (value, proxy->priv->password);
|
||
break;
|
||
|
||
case PROP_URI:
|
||
g_value_set_string (value, proxy->priv->uri);
|
||
break;
|
||
|
||
default:
|
||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
||
}
|
||
}
|
||
|
||
static void
|
||
g_proxy_address_class_init (GProxyAddressClass *klass)
|
||
{
|
||
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
||
|
||
gobject_class->finalize = g_proxy_address_finalize;
|
||
gobject_class->set_property = g_proxy_address_set_property;
|
||
gobject_class->get_property = g_proxy_address_get_property;
|
||
|
||
g_object_class_install_property (gobject_class,
|
||
PROP_PROTOCOL,
|
||
g_param_spec_string ("protocol",
|
||
P_("Protocol"),
|
||
P_("The proxy protocol"),
|
||
NULL,
|
||
G_PARAM_READWRITE |
|
||
G_PARAM_CONSTRUCT_ONLY |
|
||
G_PARAM_STATIC_STRINGS));
|
||
|
||
g_object_class_install_property (gobject_class,
|
||
PROP_USERNAME,
|
||
g_param_spec_string ("username",
|
||
P_("Username"),
|
||
P_("The proxy username"),
|
||
NULL,
|
||
G_PARAM_READWRITE |
|
||
G_PARAM_CONSTRUCT_ONLY |
|
||
G_PARAM_STATIC_STRINGS));
|
||
|
||
g_object_class_install_property (gobject_class,
|
||
PROP_PASSWORD,
|
||
g_param_spec_string ("password",
|
||
P_("Password"),
|
||
P_("The proxy password"),
|
||
NULL,
|
||
G_PARAM_READWRITE |
|
||
G_PARAM_CONSTRUCT_ONLY |
|
||
G_PARAM_STATIC_STRINGS));
|
||
|
||
/**
|
||
* GProxyAddress:destination-protocol:
|
||
*
|
||
* The protocol being spoke to the destination host, or %NULL if
|
||
* the #GProxyAddress doesn't know.
|
||
*
|
||
* Since: 2.34
|
||
*/
|
||
g_object_class_install_property (gobject_class,
|
||
PROP_DESTINATION_PROTOCOL,
|
||
g_param_spec_string ("destination-protocol",
|
||
P_("Destination Protocol"),
|
||
P_("The proxy destination protocol"),
|
||
NULL,
|
||
G_PARAM_READWRITE |
|
||
G_PARAM_CONSTRUCT_ONLY |
|
||
G_PARAM_STATIC_STRINGS));
|
||
|
||
g_object_class_install_property (gobject_class,
|
||
PROP_DESTINATION_HOSTNAME,
|
||
g_param_spec_string ("destination-hostname",
|
||
P_("Destination Hostname"),
|
||
P_("The proxy destination hostname"),
|
||
NULL,
|
||
G_PARAM_READWRITE |
|
||
G_PARAM_CONSTRUCT_ONLY |
|
||
G_PARAM_STATIC_STRINGS));
|
||
|
||
g_object_class_install_property (gobject_class,
|
||
PROP_DESTINATION_PORT,
|
||
g_param_spec_uint ("destination-port",
|
||
P_("Destination Port"),
|
||
P_("The proxy destination port"),
|
||
0, 65535, 0,
|
||
G_PARAM_READWRITE |
|
||
G_PARAM_CONSTRUCT_ONLY |
|
||
G_PARAM_STATIC_STRINGS));
|
||
|
||
/**
|
||
* GProxyAddress:uri:
|
||
*
|
||
* The URI string that the proxy was constructed from (or %NULL
|
||
* if the creator didn't specify this).
|
||
*
|
||
* Since: 2.34
|
||
*/
|
||
g_object_class_install_property (gobject_class,
|
||
PROP_URI,
|
||
g_param_spec_string ("uri",
|
||
P_("URI"),
|
||
P_("The proxy’s URI"),
|
||
NULL,
|
||
G_PARAM_READWRITE |
|
||
G_PARAM_CONSTRUCT_ONLY |
|
||
G_PARAM_STATIC_STRINGS));
|
||
}
|
||
|
||
static void
|
||
g_proxy_address_init (GProxyAddress *proxy)
|
||
{
|
||
proxy->priv = g_proxy_address_get_instance_private (proxy);
|
||
proxy->priv->protocol = NULL;
|
||
proxy->priv->username = NULL;
|
||
proxy->priv->password = NULL;
|
||
proxy->priv->dest_hostname = NULL;
|
||
proxy->priv->dest_port = 0;
|
||
}
|
||
|
||
/**
|
||
* g_proxy_address_new:
|
||
* @inetaddr: The proxy server #GInetAddress.
|
||
* @port: The proxy server port.
|
||
* @protocol: The proxy protocol to support, in lower case (e.g. socks, http).
|
||
* @dest_hostname: The destination hostname the proxy should tunnel to.
|
||
* @dest_port: The destination port to tunnel to.
|
||
* @username: (nullable): The username to authenticate to the proxy server
|
||
* (or %NULL).
|
||
* @password: (nullable): The password to authenticate to the proxy server
|
||
* (or %NULL).
|
||
*
|
||
* Creates a new #GProxyAddress for @inetaddr with @protocol that should
|
||
* tunnel through @dest_hostname and @dest_port.
|
||
*
|
||
* (Note that this method doesn't set the #GProxyAddress:uri or
|
||
* #GProxyAddress:destination-protocol fields; use g_object_new()
|
||
* directly if you want to set those.)
|
||
*
|
||
* Returns: a new #GProxyAddress
|
||
*
|
||
* Since: 2.26
|
||
*/
|
||
GSocketAddress *
|
||
g_proxy_address_new (GInetAddress *inetaddr,
|
||
guint16 port,
|
||
const gchar *protocol,
|
||
const gchar *dest_hostname,
|
||
guint16 dest_port,
|
||
const gchar *username,
|
||
const gchar *password)
|
||
{
|
||
return g_object_new (G_TYPE_PROXY_ADDRESS,
|
||
"address", inetaddr,
|
||
"port", port,
|
||
"protocol", protocol,
|
||
"destination-hostname", dest_hostname,
|
||
"destination-port", dest_port,
|
||
"username", username,
|
||
"password", password,
|
||
NULL);
|
||
}
|
||
|
||
|
||
/**
|
||
* g_proxy_address_get_protocol:
|
||
* @proxy: a #GProxyAddress
|
||
*
|
||
* Gets @proxy's protocol. eg, "socks" or "http"
|
||
*
|
||
* Returns: the @proxy's protocol
|
||
*
|
||
* Since: 2.26
|
||
*/
|
||
const gchar *
|
||
g_proxy_address_get_protocol (GProxyAddress *proxy)
|
||
{
|
||
return proxy->priv->protocol;
|
||
}
|
||
|
||
/**
|
||
* g_proxy_address_get_destination_protocol:
|
||
* @proxy: a #GProxyAddress
|
||
*
|
||
* Gets the protocol that is being spoken to the destination
|
||
* server; eg, "http" or "ftp".
|
||
*
|
||
* Returns: the @proxy's destination protocol
|
||
*
|
||
* Since: 2.34
|
||
*/
|
||
const gchar *
|
||
g_proxy_address_get_destination_protocol (GProxyAddress *proxy)
|
||
{
|
||
return proxy->priv->dest_protocol;
|
||
}
|
||
|
||
/**
|
||
* g_proxy_address_get_destination_hostname:
|
||
* @proxy: a #GProxyAddress
|
||
*
|
||
* Gets @proxy's destination hostname; that is, the name of the host
|
||
* that will be connected to via the proxy, not the name of the proxy
|
||
* itself.
|
||
*
|
||
* Returns: the @proxy's destination hostname
|
||
*
|
||
* Since: 2.26
|
||
*/
|
||
const gchar *
|
||
g_proxy_address_get_destination_hostname (GProxyAddress *proxy)
|
||
{
|
||
return proxy->priv->dest_hostname;
|
||
}
|
||
|
||
/**
|
||
* g_proxy_address_get_destination_port:
|
||
* @proxy: a #GProxyAddress
|
||
*
|
||
* Gets @proxy's destination port; that is, the port on the
|
||
* destination host that will be connected to via the proxy, not the
|
||
* port number of the proxy itself.
|
||
*
|
||
* Returns: the @proxy's destination port
|
||
*
|
||
* Since: 2.26
|
||
*/
|
||
guint16
|
||
g_proxy_address_get_destination_port (GProxyAddress *proxy)
|
||
{
|
||
return proxy->priv->dest_port;
|
||
}
|
||
|
||
/**
|
||
* g_proxy_address_get_username:
|
||
* @proxy: a #GProxyAddress
|
||
*
|
||
* Gets @proxy's username.
|
||
*
|
||
* Returns: the @proxy's username
|
||
*
|
||
* Since: 2.26
|
||
*/
|
||
const gchar *
|
||
g_proxy_address_get_username (GProxyAddress *proxy)
|
||
{
|
||
return proxy->priv->username;
|
||
}
|
||
|
||
/**
|
||
* g_proxy_address_get_password:
|
||
* @proxy: a #GProxyAddress
|
||
*
|
||
* Gets @proxy's password.
|
||
*
|
||
* Returns: the @proxy's password
|
||
*
|
||
* Since: 2.26
|
||
*/
|
||
const gchar *
|
||
g_proxy_address_get_password (GProxyAddress *proxy)
|
||
{
|
||
return proxy->priv->password;
|
||
}
|
||
|
||
|
||
/**
|
||
* g_proxy_address_get_uri:
|
||
* @proxy: a #GProxyAddress
|
||
*
|
||
* Gets the proxy URI that @proxy was constructed from.
|
||
*
|
||
* Returns: the @proxy's URI, or %NULL if unknown
|
||
*
|
||
* Since: 2.34
|
||
*/
|
||
const gchar *
|
||
g_proxy_address_get_uri (GProxyAddress *proxy)
|
||
{
|
||
return proxy->priv->uri;
|
||
}
|