diff options
Diffstat (limited to 'src/libnm-core-public')
67 files changed, 9596 insertions, 0 deletions
diff --git a/src/libnm-core-public/README.md b/src/libnm-core-public/README.md new file mode 100644 index 0000000000..0737269d1c --- /dev/null +++ b/src/libnm-core-public/README.md @@ -0,0 +1,24 @@ +libnm-core-public +================= + +This contains (mostly) header files only, which are also part of +the public API of [`libnm`](../../libnm). + +Also, this API is implemented by the static library [`libnm-core-impl`](../libnm-core-impl), +which in turn is statically linked into NetworkManager core and [`libnm`](../../libnm). + +These headers can be used by anybody who either: + +- links (statically) against [`libnm-core-impl`](../libnm-core-impl). +- links dynamically against [`libnm`](../../libnm). + +Note that there is also one source file: `nm-core-enum-types.c`. +This source file really belongs to [`libnm-core-impl`](../libnm-core-impl) but it is here +because it's a generated file and so far I couldn't figure out how +to generate `nm-core-enum-types.h` here while moving `nm-core-enum-types.c` +to [`libnm-core-impl`](../libnm-core-impl). + +Aside `nm-core-enum-types.c`, this directory only provides header files. +Users should add this directory (both srcdir and builddir) to the include +search path, because libnm users are used to include these headers unqualified +(like `#include "nm-setting.h`). diff --git a/src/libnm-core-public/meson.build b/src/libnm-core-public/meson.build new file mode 100644 index 0000000000..6b8dad0f28 --- /dev/null +++ b/src/libnm-core-public/meson.build @@ -0,0 +1,128 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later + +libnm_core_public_inc = include_directories('.') + +libnm_core_headers = files( + 'nm-connection.h', + 'nm-core-types.h', + 'nm-dbus-interface.h', + 'nm-errors.h', + 'nm-keyfile.h', + 'nm-setting-6lowpan.h', + 'nm-setting-8021x.h', + 'nm-setting-adsl.h', + 'nm-setting-bluetooth.h', + 'nm-setting-bond.h', + 'nm-setting-bridge-port.h', + 'nm-setting-bridge.h', + 'nm-setting-cdma.h', + 'nm-setting-connection.h', + 'nm-setting-dcb.h', + 'nm-setting-dummy.h', + 'nm-setting-ethtool.h', + 'nm-setting-generic.h', + 'nm-setting-gsm.h', + 'nm-setting-hostname.h', + 'nm-setting-infiniband.h', + 'nm-setting-ip-config.h', + 'nm-setting-ip-tunnel.h', + 'nm-setting-ip4-config.h', + 'nm-setting-ip6-config.h', + 'nm-setting-macsec.h', + 'nm-setting-macvlan.h', + 'nm-setting-match.h', + 'nm-setting-olpc-mesh.h', + 'nm-setting-ovs-bridge.h', + 'nm-setting-ovs-dpdk.h', + 'nm-setting-ovs-external-ids.h', + 'nm-setting-ovs-interface.h', + 'nm-setting-ovs-patch.h', + 'nm-setting-ovs-port.h', + 'nm-setting-ppp.h', + 'nm-setting-pppoe.h', + 'nm-setting-proxy.h', + 'nm-setting-serial.h', + 'nm-setting-sriov.h', + 'nm-setting-tc-config.h', + 'nm-setting-team-port.h', + 'nm-setting-team.h', + 'nm-setting-tun.h', + 'nm-setting-user.h', + 'nm-setting-veth.h', + 'nm-setting-vlan.h', + 'nm-setting-vpn.h', + 'nm-setting-vrf.h', + 'nm-setting-vxlan.h', + 'nm-setting-wifi-p2p.h', + 'nm-setting-wimax.h', + 'nm-setting-wired.h', + 'nm-setting-wireguard.h', + 'nm-setting-wireless-security.h', + 'nm-setting-wireless.h', + 'nm-setting-wpan.h', + 'nm-setting.h', + 'nm-simple-connection.h', + 'nm-utils.h', + 'nm-version.h', + 'nm-vpn-dbus-interface.h', + 'nm-vpn-editor-plugin.h', + 'nm-vpn-plugin-info.h', +) + +nm_version_macro_header = configure_file( + input: 'nm-version-macros.h.in', + output: '@BASENAME@', + configuration: data_conf, +) + +libnm_core_public_enum_sources = gnome.mkenums_simple( + 'nm-core-enum-types', + sources: libnm_core_headers + [nm_version_macro_header], + identifier_prefix: nm_id_prefix, + body_prefix: '#include "libnm-core-impl/nm-default-libnm-core.h"', + install_header: true, + install_dir: libnm_pkgincludedir, +) + +libnm_core_public_dep = declare_dependency( + sources: libnm_core_headers + [ + libnm_core_public_enum_sources[1], + nm_version_macro_header, + ], + include_directories: [ + libnm_core_public_inc, + src_inc, + top_inc, + ], + dependencies: [ + glib_dep, + ], +) + +docbooks = [ + ['nm-dbus-types', 'nm-dbus-interface.h', 'NetworkManager D-Bus API Types'], + ['nm-vpn-dbus-types', 'nm-vpn-dbus-interface.h', 'VPN Plugin D-Bus API Types'], +] + +foreach docbook: docbooks + output = docbook[0] + '.xml' + + xml = custom_target( + output, + input: docbook[1], + output: output, + capture: true, + command: [ + perl, + join_paths(source_root, 'tools', 'enums-to-docbook.pl'), + docbook[0], + docbook[2], + '@INPUT@', + ], + # FIXME: gtkdoc does not depend directly on this. + # https://github.com/mesonbuild/meson/pull/2806 + build_by_default: true, + ) + + content_files += xml.full_path() +endforeach diff --git a/src/libnm-core-public/nm-connection.h b/src/libnm-core-public/nm-connection.h new file mode 100644 index 0000000000..19034e790a --- /dev/null +++ b/src/libnm-core-public/nm-connection.h @@ -0,0 +1,224 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2018 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_CONNECTION_H__ +#define __NM_CONNECTION_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-core-types.h" +#include "nm-setting.h" +#include "nm-errors.h" + +G_BEGIN_DECLS + +#define NM_TYPE_CONNECTION (nm_connection_get_type()) +#define NM_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_CONNECTION, NMConnection)) +#define NM_IS_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_CONNECTION)) +#define NM_CONNECTION_GET_INTERFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE((obj), NM_TYPE_CONNECTION, NMConnectionClass)) + +/* Signals */ +#define NM_CONNECTION_SECRETS_UPDATED "secrets-updated" +#define NM_CONNECTION_SECRETS_CLEARED "secrets-cleared" +#define NM_CONNECTION_CHANGED "changed" + +/* + * NM_CONNECTION_NORMALIZE_PARAM_IP6_CONFIG_METHOD: overwrite the ip6 method + * when normalizing ip6 configuration. If omitted, this defaults to + * @NM_SETTING_IP6_CONFIG_METHOD_AUTO. + */ +#define NM_CONNECTION_NORMALIZE_PARAM_IP6_CONFIG_METHOD "ip6-config-method" + +/** + * NMConnection: + * + * NMConnection is the interface implemented by #NMRemoteConnection on the + * client side, and #NMSettingsConnection on the daemon side. + */ + +/** + * NMConnectionInterface: + * @parent: the parent interface struct + * @secrets_updated: emitted when the connection's secrets are updated + * @secrets_cleared: emitted when the connection's secrets are cleared + * @changed: emitted when any change to the connection's settings occurs + */ +typedef struct { + GTypeInterface parent; + + /* Signals */ + void (*secrets_updated)(NMConnection *connection, const char *setting); + void (*secrets_cleared)(NMConnection *connection); + void (*changed)(NMConnection *connection); + +} NMConnectionInterface; + +GType nm_connection_get_type(void); + +void nm_connection_add_setting(NMConnection *connection, NMSetting *setting); + +void nm_connection_remove_setting(NMConnection *connection, GType setting_type); + +NMSetting *nm_connection_get_setting(NMConnection *connection, GType setting_type); + +NMSetting *nm_connection_get_setting_by_name(NMConnection *connection, const char *name); + +/** + * NM_VARIANT_TYPE_CONNECTION: + * + * #GVariantType for a dictionary mapping from setting names to + * %NM_VARIANT_TYPE_SETTING variants. This is used to represent an + * #NMConnection, and is the type taken by nm_simple_connection_new_from_dbus() + * and returned from nm_connection_to_dbus(). + */ +#define NM_VARIANT_TYPE_CONNECTION (G_VARIANT_TYPE("a{sa{sv}}")) + +/** + * NM_VARIANT_TYPE_SETTING: + * + * #GVariantType for a dictionary mapping from property names to values. This is + * an alias for %G_VARIANT_TYPE_VARDICT, and is the type of each element of + * an %NM_VARIANT_TYPE_CONNECTION dictionary. + */ +#define NM_VARIANT_TYPE_SETTING G_VARIANT_TYPE_VARDICT + +/** + * NMConnectionSerializationFlags: + * @NM_CONNECTION_SERIALIZE_ALL: serialize all properties (including secrets) + * @NM_CONNECTION_SERIALIZE_NO_SECRETS: do not include secrets + * @NM_CONNECTION_SERIALIZE_ONLY_SECRETS: only serialize secrets + * @NM_CONNECTION_SERIALIZE_WITH_SECRETS_AGENT_OWNED: if set, only secrets that + * are agent owned will be serialized. Since: 1.20. + * + * These flags determine which properties are serialized when calling when + * calling nm_connection_to_dbus(). + **/ +typedef enum { /*< flags >*/ + NM_CONNECTION_SERIALIZE_ALL = 0x00000000, + NM_CONNECTION_SERIALIZE_NO_SECRETS = 0x00000001, + NM_CONNECTION_SERIALIZE_ONLY_SECRETS = 0x00000002, + NM_CONNECTION_SERIALIZE_WITH_SECRETS_AGENT_OWNED = 0x00000004, +} NMConnectionSerializationFlags; + +GVariant *nm_connection_to_dbus(NMConnection *connection, NMConnectionSerializationFlags flags); + +gboolean +nm_connection_replace_settings(NMConnection *connection, GVariant *new_settings, GError **error); + +void nm_connection_replace_settings_from_connection(NMConnection *connection, + NMConnection *new_connection); + +void nm_connection_clear_settings(NMConnection *connection); + +gboolean nm_connection_compare(NMConnection *a, NMConnection *b, NMSettingCompareFlags flags); + +gboolean nm_connection_diff(NMConnection * a, + NMConnection * b, + NMSettingCompareFlags flags, + GHashTable ** out_settings); + +gboolean nm_connection_verify(NMConnection *connection, GError **error); +NM_AVAILABLE_IN_1_2 +gboolean nm_connection_verify_secrets(NMConnection *connection, GError **error); +gboolean nm_connection_normalize(NMConnection *connection, + GHashTable * parameters, + gboolean * modified, + GError ** error); + +const char *nm_connection_need_secrets(NMConnection *connection, GPtrArray **hints); + +void nm_connection_clear_secrets(NMConnection *connection); + +void nm_connection_clear_secrets_with_flags(NMConnection * connection, + NMSettingClearSecretsWithFlagsFn func, + gpointer user_data); + +gboolean nm_connection_update_secrets(NMConnection *connection, + const char * setting_name, + GVariant * secrets, + GError ** error); + +void nm_connection_set_path(NMConnection *connection, const char *path); + +const char *nm_connection_get_path(NMConnection *connection); + +const char *nm_connection_get_interface_name(NMConnection *connection); + +gboolean nm_connection_is_type(NMConnection *connection, const char *type); + +void nm_connection_for_each_setting_value(NMConnection * connection, + NMSettingValueIterFn func, + gpointer user_data); + +NM_AVAILABLE_IN_1_10 +NMSetting **nm_connection_get_settings(NMConnection *connection, guint *out_length); + +void nm_connection_dump(NMConnection *connection); + +/* Helpers */ +const char *nm_connection_get_uuid(NMConnection *connection); +const char *nm_connection_get_id(NMConnection *connection); +const char *nm_connection_get_connection_type(NMConnection *connection); + +gboolean nm_connection_is_virtual(NMConnection *connection); +char * nm_connection_get_virtual_device_description(NMConnection *connection); + +NMSetting8021x * nm_connection_get_setting_802_1x(NMConnection *connection); +NMSettingBluetooth * nm_connection_get_setting_bluetooth(NMConnection *connection); +NMSettingBond * nm_connection_get_setting_bond(NMConnection *connection); +NMSettingTeam * nm_connection_get_setting_team(NMConnection *connection); +NMSettingTeamPort * nm_connection_get_setting_team_port(NMConnection *connection); +NMSettingBridge * nm_connection_get_setting_bridge(NMConnection *connection); +NMSettingBridgePort *nm_connection_get_setting_bridge_port(NMConnection *connection); +NMSettingCdma * nm_connection_get_setting_cdma(NMConnection *connection); +NMSettingConnection *nm_connection_get_setting_connection(NMConnection *connection); +NMSettingDcb * nm_connection_get_setting_dcb(NMConnection *connection); +NM_AVAILABLE_IN_1_8 +NMSettingDummy * nm_connection_get_setting_dummy(NMConnection *connection); +NMSettingGeneric * nm_connection_get_setting_generic(NMConnection *connection); +NMSettingGsm * nm_connection_get_setting_gsm(NMConnection *connection); +NMSettingInfiniband *nm_connection_get_setting_infiniband(NMConnection *connection); +NM_AVAILABLE_IN_1_2 +NMSettingIPTunnel *nm_connection_get_setting_ip_tunnel(NMConnection *connection); +NMSettingIPConfig *nm_connection_get_setting_ip4_config(NMConnection *connection); +NMSettingIPConfig *nm_connection_get_setting_ip6_config(NMConnection *connection); +NM_AVAILABLE_IN_1_6 +NMSettingMacsec *nm_connection_get_setting_macsec(NMConnection *connection); +NM_AVAILABLE_IN_1_2 +NMSettingMacvlan * nm_connection_get_setting_macvlan(NMConnection *connection); +NMSettingOlpcMesh *nm_connection_get_setting_olpc_mesh(NMConnection *connection); +NM_AVAILABLE_IN_1_10 +NMSettingOvsBridge *nm_connection_get_setting_ovs_bridge(NMConnection *connection); +NM_AVAILABLE_IN_1_10 +NMSettingOvsInterface *nm_connection_get_setting_ovs_interface(NMConnection *connection); +NMSettingOvsPatch * nm_connection_get_setting_ovs_patch(NMConnection *connection); +NM_AVAILABLE_IN_1_10 +NMSettingOvsPort *nm_connection_get_setting_ovs_port(NMConnection *connection); +NMSettingPpp * nm_connection_get_setting_ppp(NMConnection *connection); +NMSettingPppoe * nm_connection_get_setting_pppoe(NMConnection *connection); +NM_AVAILABLE_IN_1_6 +NMSettingProxy * nm_connection_get_setting_proxy(NMConnection *connection); +NMSettingSerial *nm_connection_get_setting_serial(NMConnection *connection); +NM_AVAILABLE_IN_1_12 +NMSettingTCConfig *nm_connection_get_setting_tc_config(NMConnection *connection); +NM_AVAILABLE_IN_1_2 +NMSettingTun * nm_connection_get_setting_tun(NMConnection *connection); +NMSettingVpn * nm_connection_get_setting_vpn(NMConnection *connection); +NMSettingWimax * nm_connection_get_setting_wimax(NMConnection *connection); +NMSettingAdsl * nm_connection_get_setting_adsl(NMConnection *connection); +NMSettingWired * nm_connection_get_setting_wired(NMConnection *connection); +NMSettingWireless * nm_connection_get_setting_wireless(NMConnection *connection); +NMSettingWirelessSecurity *nm_connection_get_setting_wireless_security(NMConnection *connection); +NMSettingVlan * nm_connection_get_setting_vlan(NMConnection *connection); +NM_AVAILABLE_IN_1_2 +NMSettingVxlan *nm_connection_get_setting_vxlan(NMConnection *connection); + +G_END_DECLS + +#endif /* __NM_CONNECTION_H__ */ diff --git a/src/libnm-core-public/nm-core-types.h b/src/libnm-core-public/nm-core-types.h new file mode 100644 index 0000000000..bf0c2a9966 --- /dev/null +++ b/src/libnm-core-public/nm-core-types.h @@ -0,0 +1,73 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2014 - 2018 Red Hat, Inc. + */ + +#ifndef __NM_CORE_TYPES_H__ +#define __NM_CORE_TYPES_H__ + +#include <glib-object.h> + +#include "nm-version.h" +#include "nm-dbus-interface.h" +#include "nm-core-enum-types.h" + +typedef struct _NMConnection NMConnection; +typedef struct _NMSetting NMSetting; +typedef struct _NMSetting6Lowpan NMSetting6Lowpan; +typedef struct _NMSetting8021x NMSetting8021x; +typedef struct _NMSettingAdsl NMSettingAdsl; +typedef struct _NMSettingBluetooth NMSettingBluetooth; +typedef struct _NMSettingBond NMSettingBond; +typedef struct _NMSettingBridge NMSettingBridge; +typedef struct _NMSettingBridgePort NMSettingBridgePort; +typedef struct _NMSettingCdma NMSettingCdma; +typedef struct _NMSettingConnection NMSettingConnection; +typedef struct _NMSettingDcb NMSettingDcb; +typedef struct _NMSettingDummy NMSettingDummy; +typedef struct _NMSettingEthtool NMSettingEthtool; +typedef struct _NMSettingGeneric NMSettingGeneric; +typedef struct _NMSettingGsm NMSettingGsm; +typedef struct _NMSettingHostname NMSettingHostname; +typedef struct _NMSettingIP4Config NMSettingIP4Config; +typedef struct _NMSettingIP6Config NMSettingIP6Config; +typedef struct _NMSettingIPConfig NMSettingIPConfig; +typedef struct _NMSettingIPTunnel NMSettingIPTunnel; +typedef struct _NMSettingInfiniband NMSettingInfiniband; +typedef struct _NMSettingMacsec NMSettingMacsec; +typedef struct _NMSettingMacvlan NMSettingMacvlan; +typedef struct _NMSettingMatch NMSettingMatch; +typedef struct _NMSettingOlpcMesh NMSettingOlpcMesh; +typedef struct _NMSettingOvsBridge NMSettingOvsBridge; +typedef struct _NMSettingOvsDpdk NMSettingOvsDpdk; +typedef struct _NMSettingOvsExternalIDs NMSettingOvsExternalIDs; +typedef struct _NMSettingOvsInterface NMSettingOvsInterface; +typedef struct _NMSettingOvsPatch NMSettingOvsPatch; +typedef struct _NMSettingOvsPort NMSettingOvsPort; +typedef struct _NMSettingPpp NMSettingPpp; +typedef struct _NMSettingPppoe NMSettingPppoe; +typedef struct _NMSettingProxy NMSettingProxy; +typedef struct _NMSettingSerial NMSettingSerial; +typedef struct _NMSettingSriov NMSettingSriov; +typedef struct _NMSettingTCConfig NMSettingTCConfig; +typedef struct _NMSettingTeam NMSettingTeam; +typedef struct _NMSettingTeamPort NMSettingTeamPort; +typedef struct _NMSettingTun NMSettingTun; +typedef struct _NMSettingUser NMSettingUser; +typedef struct _NMSettingVeth NMSettingVeth; +typedef struct _NMSettingVlan NMSettingVlan; +typedef struct _NMSettingVpn NMSettingVpn; +typedef struct _NMSettingVrf NMSettingVrf; +typedef struct _NMSettingVxlan NMSettingVxlan; +typedef struct _NMSettingWifiP2P NMSettingWifiP2P; +typedef struct _NMSettingWimax NMSettingWimax; +typedef struct _NMSettingWired NMSettingWired; +typedef struct _NMSettingWireGuard NMSettingWireGuard; +typedef struct _NMSettingWireless NMSettingWireless; +typedef struct _NMSettingWirelessSecurity NMSettingWirelessSecurity; +typedef struct _NMSettingWpan NMSettingWpan; +typedef struct _NMSimpleConnection NMSimpleConnection; + +typedef gboolean (*NMUtilsPredicateStr)(const char *str); + +#endif /* __NM_CORE_TYPES_H__ */ diff --git a/src/libnm-core-public/nm-dbus-interface.h b/src/libnm-core-public/nm-dbus-interface.h new file mode 100644 index 0000000000..295a22a177 --- /dev/null +++ b/src/libnm-core-public/nm-dbus-interface.h @@ -0,0 +1,1284 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2004 - 2018 Red Hat, Inc. + */ + +/* Definitions related to NetworkManager's D-Bus interfaces. + * + * Note that although this header is installed as part of libnm, it is also + * used by some external code that does not link to libnm. + */ + +#ifndef __NM_DBUS_INTERFACE_H__ +#define __NM_DBUS_INTERFACE_H__ + +/* This header must not include glib or libnm. */ + +#ifndef NM_VERSION_H + #define NM_AVAILABLE_IN_1_2 + #define NM_AVAILABLE_IN_1_8 +#endif + +/* + * dbus services details + */ +#define NM_DBUS_SERVICE "org.freedesktop.NetworkManager" + +#define NM_DBUS_INTERFACE "org.freedesktop.NetworkManager" +#define NM_DBUS_INTERFACE_ACCESS_POINT NM_DBUS_INTERFACE ".AccessPoint" +#define NM_DBUS_INTERFACE_ACTIVE_CONNECTION NM_DBUS_INTERFACE ".Connection.Active" +#define NM_DBUS_INTERFACE_CHECKPOINT NM_DBUS_INTERFACE ".Checkpoint" +#define NM_DBUS_INTERFACE_DEVICE NM_DBUS_INTERFACE ".Device" +#define NM_DBUS_INTERFACE_DEVICE_6LOWPAN NM_DBUS_INTERFACE_DEVICE ".Lowpan" +#define NM_DBUS_INTERFACE_DEVICE_ADSL NM_DBUS_INTERFACE_DEVICE ".Adsl" +#define NM_DBUS_INTERFACE_DEVICE_BLUETOOTH NM_DBUS_INTERFACE_DEVICE ".Bluetooth" +#define NM_DBUS_INTERFACE_DEVICE_BOND NM_DBUS_INTERFACE_DEVICE ".Bond" +#define NM_DBUS_INTERFACE_DEVICE_BRIDGE NM_DBUS_INTERFACE_DEVICE ".Bridge" +#define NM_DBUS_INTERFACE_DEVICE_DUMMY NM_DBUS_INTERFACE_DEVICE ".Dummy" +#define NM_DBUS_INTERFACE_DEVICE_GENERIC NM_DBUS_INTERFACE_DEVICE ".Generic" +#define NM_DBUS_INTERFACE_DEVICE_GRE NM_DBUS_INTERFACE_DEVICE ".Gre" +#define NM_DBUS_INTERFACE_DEVICE_INFINIBAND NM_DBUS_INTERFACE_DEVICE ".Infiniband" +#define NM_DBUS_INTERFACE_DEVICE_IP_TUNNEL NM_DBUS_INTERFACE_DEVICE ".IPTunnel" +#define NM_DBUS_INTERFACE_DEVICE_MACSEC NM_DBUS_INTERFACE_DEVICE ".Macsec" +#define NM_DBUS_INTERFACE_DEVICE_MACVLAN NM_DBUS_INTERFACE_DEVICE ".Macvlan" +#define NM_DBUS_INTERFACE_DEVICE_MODEM NM_DBUS_INTERFACE_DEVICE ".Modem" +#define NM_DBUS_INTERFACE_DEVICE_OLPC_MESH NM_DBUS_INTERFACE_DEVICE ".OlpcMesh" +#define NM_DBUS_INTERFACE_DEVICE_OVS_BRIDGE NM_DBUS_INTERFACE_DEVICE ".OvsBridge" +#define NM_DBUS_INTERFACE_DEVICE_OVS_INTERFACE NM_DBUS_INTERFACE_DEVICE ".OvsInterface" +#define NM_DBUS_INTERFACE_DEVICE_OVS_PORT NM_DBUS_INTERFACE_DEVICE ".OvsPort" +#define NM_DBUS_INTERFACE_DEVICE_PPP NM_DBUS_INTERFACE_DEVICE ".Ppp" +#define NM_DBUS_INTERFACE_DEVICE_STATISTICS NM_DBUS_INTERFACE_DEVICE ".Statistics" +#define NM_DBUS_INTERFACE_DEVICE_TEAM NM_DBUS_INTERFACE_DEVICE ".Team" +#define NM_DBUS_INTERFACE_DEVICE_TUN NM_DBUS_INTERFACE_DEVICE ".Tun" +#define NM_DBUS_INTERFACE_DEVICE_VETH NM_DBUS_INTERFACE_DEVICE ".Veth" +#define NM_DBUS_INTERFACE_DEVICE_VLAN NM_DBUS_INTERFACE_DEVICE ".Vlan" +#define NM_DBUS_INTERFACE_DEVICE_VRF NM_DBUS_INTERFACE_DEVICE ".Vrf" +#define NM_DBUS_INTERFACE_DEVICE_VXLAN NM_DBUS_INTERFACE_DEVICE ".Vxlan" +#define NM_DBUS_INTERFACE_DEVICE_WIFI_P2P NM_DBUS_INTERFACE_DEVICE ".WifiP2P" +#define NM_DBUS_INTERFACE_DEVICE_WIMAX NM_DBUS_INTERFACE_DEVICE ".WiMax" +#define NM_DBUS_INTERFACE_DEVICE_WIRED NM_DBUS_INTERFACE_DEVICE ".Wired" +#define NM_DBUS_INTERFACE_DEVICE_WIREGUARD NM_DBUS_INTERFACE_DEVICE ".WireGuard" +#define NM_DBUS_INTERFACE_DEVICE_WIRELESS NM_DBUS_INTERFACE_DEVICE ".Wireless" +#define NM_DBUS_INTERFACE_DEVICE_WPAN NM_DBUS_INTERFACE_DEVICE ".Wpan" +#define NM_DBUS_INTERFACE_DHCP4_CONFIG NM_DBUS_INTERFACE ".DHCP4Config" +#define NM_DBUS_INTERFACE_DHCP6_CONFIG NM_DBUS_INTERFACE ".DHCP6Config" +#define NM_DBUS_INTERFACE_IP4_CONFIG NM_DBUS_INTERFACE ".IP4Config" +#define NM_DBUS_INTERFACE_IP6_CONFIG NM_DBUS_INTERFACE ".IP6Config" +#define NM_DBUS_INTERFACE_WIFI_P2P_PEER NM_DBUS_INTERFACE ".WifiP2PPeer" +#define NM_DBUS_INTERFACE_WIMAX_NSP NM_DBUS_INTERFACE ".WiMax.Nsp" + +#define NM_DBUS_PATH "/org/freedesktop/NetworkManager" +#define NM_DBUS_PATH_ACCESS_POINT NM_DBUS_PATH "/AccessPoint" +#define NM_DBUS_PATH_WIFI_P2P_PEER NM_DBUS_PATH "/WifiP2PPeer" +#define NM_DBUS_PATH_WIMAX_NSP NM_DBUS_PATH "/Nsp" + +#define NM_DBUS_INTERFACE_SETTINGS "org.freedesktop.NetworkManager.Settings" +#define NM_DBUS_PATH_SETTINGS "/org/freedesktop/NetworkManager/Settings" + +#define NM_DBUS_INTERFACE_SETTINGS_CONNECTION "org.freedesktop.NetworkManager.Settings.Connection" +#define NM_DBUS_PATH_SETTINGS_CONNECTION "/org/freedesktop/NetworkManager/Settings/Connection" +#define NM_DBUS_INTERFACE_SETTINGS_CONNECTION_SECRETS \ + "org.freedesktop.NetworkManager.Settings.Connection.Secrets" + +#define NM_DBUS_INTERFACE_AGENT_MANAGER NM_DBUS_INTERFACE ".AgentManager" +#define NM_DBUS_PATH_AGENT_MANAGER "/org/freedesktop/NetworkManager/AgentManager" + +#define NM_DBUS_INTERFACE_SECRET_AGENT NM_DBUS_INTERFACE ".SecretAgent" +#define NM_DBUS_PATH_SECRET_AGENT "/org/freedesktop/NetworkManager/SecretAgent" + +#define NM_DBUS_INTERFACE_DNS_MANAGER "org.freedesktop.NetworkManager.DnsManager" +#define NM_DBUS_PATH_DNS_MANAGER "/org/freedesktop/NetworkManager/DnsManager" + +/** + * NMCapability: + * @NM_CAPABILITY_TEAM: Teams can be managed. This means the team device plugin + * is loaded. + * @NM_CAPABILITY_OVS: OpenVSwitch can be managed. This means the OVS device plugin + * is loaded. Since: 1.24. + * + * #NMCapability names the numbers in the Capabilities property. + * Capabilities are positive numbers. They are part of stable API + * and a certain capability number is guaranteed not to change. + * + * The range 0x7000 - 0x7FFF of capabilities is guaranteed not to be + * used by upstream NetworkManager. It could thus be used for downstream + * extensions. + */ +typedef enum { + NM_CAPABILITY_TEAM = 1, + NM_CAPABILITY_OVS = 2, +} NMCapability; + +/** + * NMState: + * @NM_STATE_UNKNOWN: Networking state is unknown. This indicates a daemon error + * that makes it unable to reasonably assess the state. In such event the + * applications are expected to assume Internet connectivity might be present + * and not disable controls that require network access. + * The graphical shells may hide the network accessibility indicator altogether + * since no meaningful status indication can be provided. + * @NM_STATE_ASLEEP: Networking is not enabled, the system is being suspended or + * resumed from suspend. + * @NM_STATE_DISCONNECTED: There is no active network connection. + * The graphical shell should indicate no network connectivity and the + * applications should not attempt to access the network. + * @NM_STATE_DISCONNECTING: Network connections are being cleaned up. + * The applications should tear down their network sessions. + * @NM_STATE_CONNECTING: A network connection is being started + * The graphical shell should indicate the network is being connected while + * the applications should still make no attempts to connect the network. + * @NM_STATE_CONNECTED_LOCAL: There is only local IPv4 and/or IPv6 connectivity, + * but no default route to access the Internet. The graphical shell should + * indicate no network connectivity. + * @NM_STATE_CONNECTED_SITE: There is only site-wide IPv4 and/or IPv6 connectivity. + * This means a default route is available, but the Internet connectivity check + * (see "Connectivity" property) did not succeed. The graphical shell should + * indicate limited network connectivity. + * @NM_STATE_CONNECTED_GLOBAL: There is global IPv4 and/or IPv6 Internet connectivity + * This means the Internet connectivity check succeeded, the graphical shell should + * indicate full network connectivity. + * + * #NMState values indicate the current overall networking state. + **/ +typedef enum { + NM_STATE_UNKNOWN = 0, + NM_STATE_ASLEEP = 10, + NM_STATE_DISCONNECTED = 20, + NM_STATE_DISCONNECTING = 30, + NM_STATE_CONNECTING = 40, + NM_STATE_CONNECTED_LOCAL = 50, + NM_STATE_CONNECTED_SITE = 60, + NM_STATE_CONNECTED_GLOBAL = 70, +} NMState; + +/** + * NMConnectivityState: + * @NM_CONNECTIVITY_UNKNOWN: Network connectivity is unknown. This means the + * connectivity checks are disabled (e.g. on server installations) or has + * not run yet. The graphical shell should assume the Internet connection + * might be available and not present a captive portal window. + * @NM_CONNECTIVITY_NONE: The host is not connected to any network. There's + * no active connection that contains a default route to the internet and + * thus it makes no sense to even attempt a connectivity check. The graphical + * shell should use this state to indicate the network connection is unavailable. + * @NM_CONNECTIVITY_PORTAL: The Internet connection is hijacked by a captive + * portal gateway. The graphical shell may open a sandboxed web browser window + * (because the captive portals typically attempt a man-in-the-middle attacks + * against the https connections) for the purpose of authenticating to a gateway + * and retrigger the connectivity check with CheckConnectivity() when the + * browser window is dismissed. + * @NM_CONNECTIVITY_LIMITED: The host is connected to a network, does not appear + * to be able to reach the full Internet, but a captive portal has not been + * detected. + * @NM_CONNECTIVITY_FULL: The host is connected to a network, and + * appears to be able to reach the full Internet. + */ +typedef enum { + NM_CONNECTIVITY_UNKNOWN = 0, + NM_CONNECTIVITY_NONE = 1, + NM_CONNECTIVITY_PORTAL = 2, + NM_CONNECTIVITY_LIMITED = 3, + NM_CONNECTIVITY_FULL = 4, +} NMConnectivityState; + +/** + * NMDeviceType: + * @NM_DEVICE_TYPE_UNKNOWN: unknown device + * @NM_DEVICE_TYPE_GENERIC: generic support for unrecognized device types + * @NM_DEVICE_TYPE_ETHERNET: a wired ethernet device + * @NM_DEVICE_TYPE_WIFI: an 802.11 Wi-Fi device + * @NM_DEVICE_TYPE_UNUSED1: not used + * @NM_DEVICE_TYPE_UNUSED2: not used + * @NM_DEVICE_TYPE_BT: a Bluetooth device supporting PAN or DUN access protocols + * @NM_DEVICE_TYPE_OLPC_MESH: an OLPC XO mesh networking device + * @NM_DEVICE_TYPE_WIMAX: an 802.16e Mobile WiMAX broadband device + * @NM_DEVICE_TYPE_MODEM: a modem supporting analog telephone, CDMA/EVDO, + * GSM/UMTS, or LTE network access protocols + * @NM_DEVICE_TYPE_INFINIBAND: an IP-over-InfiniBand device + * @NM_DEVICE_TYPE_BOND: a bond master interface + * @NM_DEVICE_TYPE_VLAN: an 802.1Q VLAN interface + * @NM_DEVICE_TYPE_ADSL: ADSL modem + * @NM_DEVICE_TYPE_BRIDGE: a bridge master interface + * @NM_DEVICE_TYPE_TEAM: a team master interface + * @NM_DEVICE_TYPE_TUN: a TUN or TAP interface + * @NM_DEVICE_TYPE_IP_TUNNEL: a IP tunnel interface + * @NM_DEVICE_TYPE_MACVLAN: a MACVLAN interface + * @NM_DEVICE_TYPE_VXLAN: a VXLAN interface + * @NM_DEVICE_TYPE_VETH: a VETH interface + * @NM_DEVICE_TYPE_MACSEC: a MACsec interface + * @NM_DEVICE_TYPE_DUMMY: a dummy interface + * @NM_DEVICE_TYPE_PPP: a PPP interface + * @NM_DEVICE_TYPE_OVS_INTERFACE: a Open vSwitch interface + * @NM_DEVICE_TYPE_OVS_PORT: a Open vSwitch port + * @NM_DEVICE_TYPE_OVS_BRIDGE: a Open vSwitch bridge + * @NM_DEVICE_TYPE_WPAN: a IEEE 802.15.4 (WPAN) MAC Layer Device + * @NM_DEVICE_TYPE_6LOWPAN: 6LoWPAN interface + * @NM_DEVICE_TYPE_WIREGUARD: a WireGuard interface + * @NM_DEVICE_TYPE_WIFI_P2P: an 802.11 Wi-Fi P2P device. Since: 1.16. + * @NM_DEVICE_TYPE_VRF: A VRF (Virtual Routing and Forwarding) interface. Since: 1.24. + * + * #NMDeviceType values indicate the type of hardware represented by a + * device object. + **/ +typedef enum { + NM_DEVICE_TYPE_UNKNOWN = 0, + NM_DEVICE_TYPE_ETHERNET = 1, + NM_DEVICE_TYPE_WIFI = 2, + NM_DEVICE_TYPE_UNUSED1 = 3, + NM_DEVICE_TYPE_UNUSED2 = 4, + NM_DEVICE_TYPE_BT = 5, /* Bluetooth */ + NM_DEVICE_TYPE_OLPC_MESH = 6, + NM_DEVICE_TYPE_WIMAX = 7, + NM_DEVICE_TYPE_MODEM = 8, + NM_DEVICE_TYPE_INFINIBAND = 9, + NM_DEVICE_TYPE_BOND = 10, + NM_DEVICE_TYPE_VLAN = 11, + NM_DEVICE_TYPE_ADSL = 12, + NM_DEVICE_TYPE_BRIDGE = 13, + NM_DEVICE_TYPE_GENERIC = 14, + NM_DEVICE_TYPE_TEAM = 15, + NM_DEVICE_TYPE_TUN = 16, + NM_DEVICE_TYPE_IP_TUNNEL = 17, + NM_DEVICE_TYPE_MACVLAN = 18, + NM_DEVICE_TYPE_VXLAN = 19, + NM_DEVICE_TYPE_VETH = 20, + NM_DEVICE_TYPE_MACSEC = 21, + NM_DEVICE_TYPE_DUMMY = 22, + NM_DEVICE_TYPE_PPP = 23, + NM_DEVICE_TYPE_OVS_INTERFACE = 24, + NM_DEVICE_TYPE_OVS_PORT = 25, + NM_DEVICE_TYPE_OVS_BRIDGE = 26, + NM_DEVICE_TYPE_WPAN = 27, + NM_DEVICE_TYPE_6LOWPAN = 28, + NM_DEVICE_TYPE_WIREGUARD = 29, + NM_DEVICE_TYPE_WIFI_P2P = 30, + NM_DEVICE_TYPE_VRF = 31, +} NMDeviceType; + +/** + * NMDeviceCapabilities: + * @NM_DEVICE_CAP_NONE: device has no special capabilities + * @NM_DEVICE_CAP_NM_SUPPORTED: NetworkManager supports this device + * @NM_DEVICE_CAP_CARRIER_DETECT: this device can indicate carrier status + * @NM_DEVICE_CAP_IS_SOFTWARE: this device is a software device + * @NM_DEVICE_CAP_SRIOV: this device supports single-root I/O virtualization + * + * General device capability flags. + **/ +typedef enum { /*< flags >*/ + NM_DEVICE_CAP_NONE = 0x00000000, + NM_DEVICE_CAP_NM_SUPPORTED = 0x00000001, + NM_DEVICE_CAP_CARRIER_DETECT = 0x00000002, + NM_DEVICE_CAP_IS_SOFTWARE = 0x00000004, + NM_DEVICE_CAP_SRIOV = 0x00000008, +} NMDeviceCapabilities; + +/** + * NMDeviceWifiCapabilities: + * @NM_WIFI_DEVICE_CAP_NONE: device has no encryption/authentication capabilities + * @NM_WIFI_DEVICE_CAP_CIPHER_WEP40: device supports 40/64-bit WEP encryption + * @NM_WIFI_DEVICE_CAP_CIPHER_WEP104: device supports 104/128-bit WEP encryption + * @NM_WIFI_DEVICE_CAP_CIPHER_TKIP: device supports TKIP encryption + * @NM_WIFI_DEVICE_CAP_CIPHER_CCMP: device supports AES/CCMP encryption + * @NM_WIFI_DEVICE_CAP_WPA: device supports WPA1 authentication + * @NM_WIFI_DEVICE_CAP_RSN: device supports WPA2/RSN authentication + * @NM_WIFI_DEVICE_CAP_AP: device supports Access Point mode + * @NM_WIFI_DEVICE_CAP_ADHOC: device supports Ad-Hoc mode + * @NM_WIFI_DEVICE_CAP_FREQ_VALID: device reports frequency capabilities + * @NM_WIFI_DEVICE_CAP_FREQ_2GHZ: device supports 2.4GHz frequencies + * @NM_WIFI_DEVICE_CAP_FREQ_5GHZ: device supports 5GHz frequencies + * @NM_WIFI_DEVICE_CAP_MESH: device supports acting as a mesh point. Since: 1.20. + * @NM_WIFI_DEVICE_CAP_IBSS_RSN: device supports WPA2/RSN in an IBSS network. Since: 1.22. + * + * 802.11 specific device encryption and authentication capabilities. + **/ +typedef enum { /*< flags >*/ + NM_WIFI_DEVICE_CAP_NONE = 0x00000000, + NM_WIFI_DEVICE_CAP_CIPHER_WEP40 = 0x00000001, + NM_WIFI_DEVICE_CAP_CIPHER_WEP104 = 0x00000002, + NM_WIFI_DEVICE_CAP_CIPHER_TKIP = 0x00000004, + NM_WIFI_DEVICE_CAP_CIPHER_CCMP = 0x00000008, + NM_WIFI_DEVICE_CAP_WPA = 0x00000010, + NM_WIFI_DEVICE_CAP_RSN = 0x00000020, + NM_WIFI_DEVICE_CAP_AP = 0x00000040, + NM_WIFI_DEVICE_CAP_ADHOC = 0x00000080, + NM_WIFI_DEVICE_CAP_FREQ_VALID = 0x00000100, + NM_WIFI_DEVICE_CAP_FREQ_2GHZ = 0x00000200, + NM_WIFI_DEVICE_CAP_FREQ_5GHZ = 0x00000400, + NM_WIFI_DEVICE_CAP_MESH = 0x00001000, + NM_WIFI_DEVICE_CAP_IBSS_RSN = 0x00002000, +} NMDeviceWifiCapabilities; + +/** + * NM80211ApFlags: + * @NM_802_11_AP_FLAGS_NONE: access point has no special capabilities + * @NM_802_11_AP_FLAGS_PRIVACY: access point requires authentication and + * encryption (usually means WEP) + * @NM_802_11_AP_FLAGS_WPS: access point supports some WPS method + * @NM_802_11_AP_FLAGS_WPS_PBC: access point supports push-button WPS + * @NM_802_11_AP_FLAGS_WPS_PIN: access point supports PIN-based WPS + * + * 802.11 access point flags. + **/ +typedef enum { /*< underscore_name=nm_802_11_ap_flags, flags >*/ + NM_802_11_AP_FLAGS_NONE = 0x00000000, + NM_802_11_AP_FLAGS_PRIVACY = 0x00000001, + NM_802_11_AP_FLAGS_WPS = 0x00000002, + NM_802_11_AP_FLAGS_WPS_PBC = 0x00000004, + NM_802_11_AP_FLAGS_WPS_PIN = 0x00000008, +} NM80211ApFlags; + +/** + * NM80211ApSecurityFlags: + * @NM_802_11_AP_SEC_NONE: the access point has no special security requirements + * @NM_802_11_AP_SEC_PAIR_WEP40: 40/64-bit WEP is supported for + * pairwise/unicast encryption + * @NM_802_11_AP_SEC_PAIR_WEP104: 104/128-bit WEP is supported for + * pairwise/unicast encryption + * @NM_802_11_AP_SEC_PAIR_TKIP: TKIP is supported for pairwise/unicast encryption + * @NM_802_11_AP_SEC_PAIR_CCMP: AES/CCMP is supported for pairwise/unicast encryption + * @NM_802_11_AP_SEC_GROUP_WEP40: 40/64-bit WEP is supported for group/broadcast + * encryption + * @NM_802_11_AP_SEC_GROUP_WEP104: 104/128-bit WEP is supported for + * group/broadcast encryption + * @NM_802_11_AP_SEC_GROUP_TKIP: TKIP is supported for group/broadcast encryption + * @NM_802_11_AP_SEC_GROUP_CCMP: AES/CCMP is supported for group/broadcast + * encryption + * @NM_802_11_AP_SEC_KEY_MGMT_PSK: WPA/RSN Pre-Shared Key encryption is + * supported + * @NM_802_11_AP_SEC_KEY_MGMT_802_1X: 802.1x authentication and key management + * is supported + * @NM_802_11_AP_SEC_KEY_MGMT_SAE: WPA/RSN Simultaneous Authentication of Equals is + * supported + * @NM_802_11_AP_SEC_KEY_MGMT_OWE: WPA/RSN Opportunistic Wireless Encryption is + * supported + * @NM_802_11_AP_SEC_KEY_MGMT_OWE_TM: WPA/RSN Opportunistic Wireless Encryption + * transition mode is supported. Since: 1.26. + * @NM_802_11_AP_SEC_KEY_MGMT_EAP_SUITE_B_192: WPA3 Enterprise Suite-B 192 bit mode + * is supported. Since: 1.30. + * + * 802.11 access point security and authentication flags. These flags describe + * the current security requirements of an access point as determined from the + * access point's beacon. + **/ +typedef enum { /*< underscore_name=nm_802_11_ap_security_flags, flags >*/ + NM_802_11_AP_SEC_NONE = 0x00000000, + NM_802_11_AP_SEC_PAIR_WEP40 = 0x00000001, + NM_802_11_AP_SEC_PAIR_WEP104 = 0x00000002, + NM_802_11_AP_SEC_PAIR_TKIP = 0x00000004, + NM_802_11_AP_SEC_PAIR_CCMP = 0x00000008, + NM_802_11_AP_SEC_GROUP_WEP40 = 0x00000010, + NM_802_11_AP_SEC_GROUP_WEP104 = 0x00000020, + NM_802_11_AP_SEC_GROUP_TKIP = 0x00000040, + NM_802_11_AP_SEC_GROUP_CCMP = 0x00000080, + NM_802_11_AP_SEC_KEY_MGMT_PSK = 0x00000100, + NM_802_11_AP_SEC_KEY_MGMT_802_1X = 0x00000200, + NM_802_11_AP_SEC_KEY_MGMT_SAE = 0x00000400, + NM_802_11_AP_SEC_KEY_MGMT_OWE = 0x00000800, + NM_802_11_AP_SEC_KEY_MGMT_OWE_TM = 0x00001000, + NM_802_11_AP_SEC_KEY_MGMT_EAP_SUITE_B_192 = 0x00002000, +} NM80211ApSecurityFlags; + +/** + * NM80211Mode: + * @NM_802_11_MODE_UNKNOWN: the device or access point mode is unknown + * @NM_802_11_MODE_ADHOC: for both devices and access point objects, indicates + * the object is part of an Ad-Hoc 802.11 network without a central + * coordinating access point. + * @NM_802_11_MODE_INFRA: the device or access point is in infrastructure mode. + * For devices, this indicates the device is an 802.11 client/station. For + * access point objects, this indicates the object is an access point that + * provides connectivity to clients. + * @NM_802_11_MODE_AP: the device is an access point/hotspot. Not valid for + * access point objects; used only for hotspot mode on the local machine. + * @NM_802_11_MODE_MESH: the device is a 802.11s mesh point. Since: 1.20. + * + * Indicates the 802.11 mode an access point or device is currently in. + **/ +typedef enum { /*< underscore_name=nm_802_11_mode >*/ + NM_802_11_MODE_UNKNOWN = 0, + NM_802_11_MODE_ADHOC = 1, + NM_802_11_MODE_INFRA = 2, + NM_802_11_MODE_AP = 3, + NM_802_11_MODE_MESH = 4, +} NM80211Mode; + +/** + * NMBluetoothCapabilities: + * @NM_BT_CAPABILITY_NONE: device has no usable capabilities + * @NM_BT_CAPABILITY_DUN: device provides Dial-Up Networking capability + * @NM_BT_CAPABILITY_NAP: device provides Network Access Point capability + * + * #NMBluetoothCapabilities values indicate the usable capabilities of a + * Bluetooth device. + **/ +typedef enum { /*< flags >*/ + NM_BT_CAPABILITY_NONE = 0x00000000, + NM_BT_CAPABILITY_DUN = 0x00000001, + NM_BT_CAPABILITY_NAP = 0x00000002, +} NMBluetoothCapabilities; + +/** + * NMDeviceModemCapabilities: + * @NM_DEVICE_MODEM_CAPABILITY_NONE: modem has no usable capabilities + * @NM_DEVICE_MODEM_CAPABILITY_POTS: modem uses the analog wired telephone + * network and is not a wireless/cellular device + * @NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO: modem supports at least one of CDMA + * 1xRTT, EVDO revision 0, EVDO revision A, or EVDO revision B + * @NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS: modem supports at least one of GSM, + * GPRS, EDGE, UMTS, HSDPA, HSUPA, or HSPA+ packet switched data capability + * @NM_DEVICE_MODEM_CAPABILITY_LTE: modem has LTE data capability + * + * #NMDeviceModemCapabilities values indicate the generic radio access + * technology families a modem device supports. For more information on the + * specific access technologies the device supports use the ModemManager D-Bus + * API. + **/ +typedef enum { /*< flags >*/ + NM_DEVICE_MODEM_CAPABILITY_NONE = 0x00000000, + NM_DEVICE_MODEM_CAPABILITY_POTS = 0x00000001, + NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO = 0x00000002, + NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS = 0x00000004, + NM_DEVICE_MODEM_CAPABILITY_LTE = 0x00000008, +} NMDeviceModemCapabilities; + +/** + * NMWimaxNspNetworkType: + * @NM_WIMAX_NSP_NETWORK_TYPE_UNKNOWN: unknown network type + * @NM_WIMAX_NSP_NETWORK_TYPE_HOME: home network + * @NM_WIMAX_NSP_NETWORK_TYPE_PARTNER: partner network + * @NM_WIMAX_NSP_NETWORK_TYPE_ROAMING_PARTNER: roaming partner network + * + * WiMAX network type. + */ +typedef enum { + NM_WIMAX_NSP_NETWORK_TYPE_UNKNOWN = 0, + NM_WIMAX_NSP_NETWORK_TYPE_HOME = 1, + NM_WIMAX_NSP_NETWORK_TYPE_PARTNER = 2, + NM_WIMAX_NSP_NETWORK_TYPE_ROAMING_PARTNER = 3, +} NMWimaxNspNetworkType; + +/** + * NMDeviceState: + * @NM_DEVICE_STATE_UNKNOWN: the device's state is unknown + * @NM_DEVICE_STATE_UNMANAGED: the device is recognized, but not managed by + * NetworkManager + * @NM_DEVICE_STATE_UNAVAILABLE: the device is managed by NetworkManager, but + * is not available for use. Reasons may include the wireless switched off, + * missing firmware, no ethernet carrier, missing supplicant or modem manager, + * etc. + * @NM_DEVICE_STATE_DISCONNECTED: the device can be activated, but is currently + * idle and not connected to a network. + * @NM_DEVICE_STATE_PREPARE: the device is preparing the connection to the + * network. This may include operations like changing the MAC address, + * setting physical link properties, and anything else required to connect + * to the requested network. + * @NM_DEVICE_STATE_CONFIG: the device is connecting to the requested network. + * This may include operations like associating with the Wi-Fi AP, dialing + * the modem, connecting to the remote Bluetooth device, etc. + * @NM_DEVICE_STATE_NEED_AUTH: the device requires more information to continue + * connecting to the requested network. This includes secrets like WiFi + * passphrases, login passwords, PIN codes, etc. + * @NM_DEVICE_STATE_IP_CONFIG: the device is requesting IPv4 and/or IPv6 + * addresses and routing information from the network. + * @NM_DEVICE_STATE_IP_CHECK: the device is checking whether further action is + * required for the requested network connection. This may include checking + * whether only local network access is available, whether a captive portal + * is blocking access to the Internet, etc. + * @NM_DEVICE_STATE_SECONDARIES: the device is waiting for a secondary + * connection (like a VPN) which must activated before the device can be + * activated + * @NM_DEVICE_STATE_ACTIVATED: the device has a network connection, either local + * or global. + * @NM_DEVICE_STATE_DEACTIVATING: a disconnection from the current network + * connection was requested, and the device is cleaning up resources used for + * that connection. The network connection may still be valid. + * @NM_DEVICE_STATE_FAILED: the device failed to connect to the requested + * network and is cleaning up the connection request + **/ +typedef enum { + NM_DEVICE_STATE_UNKNOWN = 0, + NM_DEVICE_STATE_UNMANAGED = 10, + NM_DEVICE_STATE_UNAVAILABLE = 20, + NM_DEVICE_STATE_DISCONNECTED = 30, + NM_DEVICE_STATE_PREPARE = 40, + NM_DEVICE_STATE_CONFIG = 50, + NM_DEVICE_STATE_NEED_AUTH = 60, + NM_DEVICE_STATE_IP_CONFIG = 70, + NM_DEVICE_STATE_IP_CHECK = 80, + NM_DEVICE_STATE_SECONDARIES = 90, + NM_DEVICE_STATE_ACTIVATED = 100, + NM_DEVICE_STATE_DEACTIVATING = 110, + NM_DEVICE_STATE_FAILED = 120, +} NMDeviceState; + +/** + * NMDeviceStateReason: + * @NM_DEVICE_STATE_REASON_NONE: No reason given + * @NM_DEVICE_STATE_REASON_UNKNOWN: Unknown error + * @NM_DEVICE_STATE_REASON_NOW_MANAGED: Device is now managed + * @NM_DEVICE_STATE_REASON_NOW_UNMANAGED: Device is now unmanaged + * @NM_DEVICE_STATE_REASON_CONFIG_FAILED: The device could not be readied for configuration + * @NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE: IP configuration could not be reserved (no available address, timeout, etc) + * @NM_DEVICE_STATE_REASON_IP_CONFIG_EXPIRED: The IP config is no longer valid + * @NM_DEVICE_STATE_REASON_NO_SECRETS: Secrets were required, but not provided + * @NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT: 802.1x supplicant disconnected + * @NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED: 802.1x supplicant configuration failed + * @NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED: 802.1x supplicant failed + * @NM_DEVICE_STATE_REASON_SUPPLICANT_TIMEOUT: 802.1x supplicant took too long to authenticate + * @NM_DEVICE_STATE_REASON_PPP_START_FAILED: PPP service failed to start + * @NM_DEVICE_STATE_REASON_PPP_DISCONNECT: PPP service disconnected + * @NM_DEVICE_STATE_REASON_PPP_FAILED: PPP failed + * @NM_DEVICE_STATE_REASON_DHCP_START_FAILED: DHCP client failed to start + * @NM_DEVICE_STATE_REASON_DHCP_ERROR: DHCP client error + * @NM_DEVICE_STATE_REASON_DHCP_FAILED: DHCP client failed + * @NM_DEVICE_STATE_REASON_SHARED_START_FAILED: Shared connection service failed to start + * @NM_DEVICE_STATE_REASON_SHARED_FAILED: Shared connection service failed + * @NM_DEVICE_STATE_REASON_AUTOIP_START_FAILED: AutoIP service failed to start + * @NM_DEVICE_STATE_REASON_AUTOIP_ERROR: AutoIP service error + * @NM_DEVICE_STATE_REASON_AUTOIP_FAILED: AutoIP service failed + * @NM_DEVICE_STATE_REASON_MODEM_BUSY: The line is busy + * @NM_DEVICE_STATE_REASON_MODEM_NO_DIAL_TONE: No dial tone + * @NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER: No carrier could be established + * @NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT: The dialing request timed out + * @NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED: The dialing attempt failed + * @NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED: Modem initialization failed + * @NM_DEVICE_STATE_REASON_GSM_APN_FAILED: Failed to select the specified APN + * @NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING: Not searching for networks + * @NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED: Network registration denied + * @NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT: Network registration timed out + * @NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED: Failed to register with the requested network + * @NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED: PIN check failed + * @NM_DEVICE_STATE_REASON_FIRMWARE_MISSING: Necessary firmware for the device may be missing + * @NM_DEVICE_STATE_REASON_REMOVED: The device was removed + * @NM_DEVICE_STATE_REASON_SLEEPING: NetworkManager went to sleep + * @NM_DEVICE_STATE_REASON_CONNECTION_REMOVED: The device's active connection disappeared + * @NM_DEVICE_STATE_REASON_USER_REQUESTED: Device disconnected by user or client + * @NM_DEVICE_STATE_REASON_CARRIER: Carrier/link changed + * @NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED: The device's existing connection was assumed + * @NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE: The supplicant is now available + * @NM_DEVICE_STATE_REASON_MODEM_NOT_FOUND: The modem could not be found + * @NM_DEVICE_STATE_REASON_BT_FAILED: The Bluetooth connection failed or timed out + * @NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED: GSM Modem's SIM Card not inserted + * @NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED: GSM Modem's SIM Pin required + * @NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED: GSM Modem's SIM Puk required + * @NM_DEVICE_STATE_REASON_GSM_SIM_WRONG: GSM Modem's SIM wrong + * @NM_DEVICE_STATE_REASON_INFINIBAND_MODE: InfiniBand device does not support connected mode + * @NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED: A dependency of the connection failed + * @NM_DEVICE_STATE_REASON_BR2684_FAILED: Problem with the RFC 2684 Ethernet over ADSL bridge + * @NM_DEVICE_STATE_REASON_MODEM_MANAGER_UNAVAILABLE: ModemManager not running + * @NM_DEVICE_STATE_REASON_SSID_NOT_FOUND: The Wi-Fi network could not be found + * @NM_DEVICE_STATE_REASON_SECONDARY_CONNECTION_FAILED: A secondary connection of the base connection failed + * @NM_DEVICE_STATE_REASON_DCB_FCOE_FAILED: DCB or FCoE setup failed + * @NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED: teamd control failed + * @NM_DEVICE_STATE_REASON_MODEM_FAILED: Modem failed or no longer available + * @NM_DEVICE_STATE_REASON_MODEM_AVAILABLE: Modem now ready and available + * @NM_DEVICE_STATE_REASON_SIM_PIN_INCORRECT: SIM PIN was incorrect + * @NM_DEVICE_STATE_REASON_NEW_ACTIVATION: New connection activation was enqueued + * @NM_DEVICE_STATE_REASON_PARENT_CHANGED: the device's parent changed + * @NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED: the device parent's management changed + * @NM_DEVICE_STATE_REASON_OVSDB_FAILED: problem communicating with Open vSwitch database + * @NM_DEVICE_STATE_REASON_IP_ADDRESS_DUPLICATE: a duplicate IP address was detected + * @NM_DEVICE_STATE_REASON_IP_METHOD_UNSUPPORTED: The selected IP method is not supported + * @NM_DEVICE_STATE_REASON_SRIOV_CONFIGURATION_FAILED: configuration of SR-IOV parameters failed + * @NM_DEVICE_STATE_REASON_PEER_NOT_FOUND: The Wi-Fi P2P peer could not be found + * + * Device state change reason codes + */ +typedef enum { + NM_DEVICE_STATE_REASON_NONE = 0, + NM_DEVICE_STATE_REASON_UNKNOWN = 1, + NM_DEVICE_STATE_REASON_NOW_MANAGED = 2, + NM_DEVICE_STATE_REASON_NOW_UNMANAGED = 3, + NM_DEVICE_STATE_REASON_CONFIG_FAILED = 4, + NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE = 5, + NM_DEVICE_STATE_REASON_IP_CONFIG_EXPIRED = 6, + NM_DEVICE_STATE_REASON_NO_SECRETS = 7, + NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT = 8, + NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED = 9, + NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED = 10, + NM_DEVICE_STATE_REASON_SUPPLICANT_TIMEOUT = 11, + NM_DEVICE_STATE_REASON_PPP_START_FAILED = 12, + NM_DEVICE_STATE_REASON_PPP_DISCONNECT = 13, + NM_DEVICE_STATE_REASON_PPP_FAILED = 14, + NM_DEVICE_STATE_REASON_DHCP_START_FAILED = 15, + NM_DEVICE_STATE_REASON_DHCP_ERROR = 16, + NM_DEVICE_STATE_REASON_DHCP_FAILED = 17, + NM_DEVICE_STATE_REASON_SHARED_START_FAILED = 18, + NM_DEVICE_STATE_REASON_SHARED_FAILED = 19, + NM_DEVICE_STATE_REASON_AUTOIP_START_FAILED = 20, + NM_DEVICE_STATE_REASON_AUTOIP_ERROR = 21, + NM_DEVICE_STATE_REASON_AUTOIP_FAILED = 22, + NM_DEVICE_STATE_REASON_MODEM_BUSY = 23, + NM_DEVICE_STATE_REASON_MODEM_NO_DIAL_TONE = 24, + NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER = 25, + NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT = 26, + NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED = 27, + NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED = 28, + NM_DEVICE_STATE_REASON_GSM_APN_FAILED = 29, + NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING = 30, + NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED = 31, + NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT = 32, + NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED = 33, + NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED = 34, + NM_DEVICE_STATE_REASON_FIRMWARE_MISSING = 35, + NM_DEVICE_STATE_REASON_REMOVED = 36, + NM_DEVICE_STATE_REASON_SLEEPING = 37, + NM_DEVICE_STATE_REASON_CONNECTION_REMOVED = 38, + NM_DEVICE_STATE_REASON_USER_REQUESTED = 39, + NM_DEVICE_STATE_REASON_CARRIER = 40, + NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED = 41, + NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE = 42, + NM_DEVICE_STATE_REASON_MODEM_NOT_FOUND = 43, + NM_DEVICE_STATE_REASON_BT_FAILED = 44, + NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED = 45, + NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED = 46, + NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED = 47, + NM_DEVICE_STATE_REASON_GSM_SIM_WRONG = 48, + NM_DEVICE_STATE_REASON_INFINIBAND_MODE = 49, + NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED = 50, + NM_DEVICE_STATE_REASON_BR2684_FAILED = 51, + NM_DEVICE_STATE_REASON_MODEM_MANAGER_UNAVAILABLE = 52, + NM_DEVICE_STATE_REASON_SSID_NOT_FOUND = 53, + NM_DEVICE_STATE_REASON_SECONDARY_CONNECTION_FAILED = 54, + NM_DEVICE_STATE_REASON_DCB_FCOE_FAILED = 55, + NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED = 56, + NM_DEVICE_STATE_REASON_MODEM_FAILED = 57, + NM_DEVICE_STATE_REASON_MODEM_AVAILABLE = 58, + NM_DEVICE_STATE_REASON_SIM_PIN_INCORRECT = 59, + NM_DEVICE_STATE_REASON_NEW_ACTIVATION = 60, + NM_DEVICE_STATE_REASON_PARENT_CHANGED = 61, + NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED = 62, + NM_DEVICE_STATE_REASON_OVSDB_FAILED = 63, + NM_DEVICE_STATE_REASON_IP_ADDRESS_DUPLICATE = 64, + NM_DEVICE_STATE_REASON_IP_METHOD_UNSUPPORTED = 65, + NM_DEVICE_STATE_REASON_SRIOV_CONFIGURATION_FAILED = 66, + NM_DEVICE_STATE_REASON_PEER_NOT_FOUND = 67, +} NMDeviceStateReason; + +/** + * NMMetered: + * @NM_METERED_UNKNOWN: The metered status is unknown + * @NM_METERED_YES: Metered, the value was explicitly configured + * @NM_METERED_NO: Not metered, the value was explicitly configured + * @NM_METERED_GUESS_YES: Metered, the value was guessed + * @NM_METERED_GUESS_NO: Not metered, the value was guessed + * + * The NMMetered enum has two different purposes: one is to configure + * "connection.metered" setting of a connection profile in #NMSettingConnection, and + * the other is to express the actual metered state of the #NMDevice at a given moment. + * + * For the connection profile only #NM_METERED_UNKNOWN, #NM_METERED_NO + * and #NM_METERED_YES are allowed. + * + * The device's metered state at runtime is determined by the profile + * which is currently active. If the profile explicitly specifies #NM_METERED_NO + * or #NM_METERED_YES, then the device's metered state is as such. + * If the connection profile leaves it undecided at #NM_METERED_UNKNOWN (the default), + * then NetworkManager tries to guess the metered state, for example based on the + * device type or on DHCP options (like Android devices exposing a "ANDROID_METERED" + * DHCP vendor option). This then leads to either #NM_METERED_GUESS_NO or #NM_METERED_GUESS_YES. + * + * Most applications probably should treat the runtime state #NM_METERED_GUESS_YES + * like #NM_METERED_YES, and all other states as not metered. + * + * Note that the per-device metered states are then combined to a global metered + * state. This is basically the metered state of the device with the best default + * route. However, that generalization of a global metered state may not be correct + * if the default routes for IPv4 and IPv6 are on different devices, or if policy + * routing is configured. In general, the global metered state tries to express whether + * the traffic is likely metered, but since that depends on the traffic itself, + * there is not one answer in all cases. Hence, an application may want to consider + * the per-device's metered states. + * + * Since: 1.2 + **/ +NM_AVAILABLE_IN_1_2 +typedef enum { + NM_METERED_UNKNOWN = 0, + NM_METERED_YES = 1, + NM_METERED_NO = 2, + NM_METERED_GUESS_YES = 3, + NM_METERED_GUESS_NO = 4, +} NMMetered; + +/** + * NMConnectionMultiConnect: + * @NM_CONNECTION_MULTI_CONNECT_DEFAULT: indicates that the per-connection + * setting is unspecified. In this case, it will fallback to the default + * value, which is %NM_CONNECTION_MULTI_CONNECT_SINGLE. + * @NM_CONNECTION_MULTI_CONNECT_SINGLE: the connection profile can only + * be active once at each moment. Activating a profile that is already active, + * will first deactivate it. + * @NM_CONNECTION_MULTI_CONNECT_MANUAL_MULTIPLE: the profile can + * be manually activated multiple times on different devices. However, + * regarding autoconnect, the profile will autoconnect only if it is + * currently not connected otherwise. + * @NM_CONNECTION_MULTI_CONNECT_MULTIPLE: the profile can autoactivate + * and be manually activated multiple times together. + * + * Since: 1.14 + */ +typedef enum { + NM_CONNECTION_MULTI_CONNECT_DEFAULT = 0, + NM_CONNECTION_MULTI_CONNECT_SINGLE = 1, + NM_CONNECTION_MULTI_CONNECT_MANUAL_MULTIPLE = 2, + NM_CONNECTION_MULTI_CONNECT_MULTIPLE = 3, +} NMConnectionMultiConnect; + +/** + * NMActiveConnectionState: + * @NM_ACTIVE_CONNECTION_STATE_UNKNOWN: the state of the connection is unknown + * @NM_ACTIVE_CONNECTION_STATE_ACTIVATING: a network connection is being prepared + * @NM_ACTIVE_CONNECTION_STATE_ACTIVATED: there is a connection to the network + * @NM_ACTIVE_CONNECTION_STATE_DEACTIVATING: the network connection is being + * torn down and cleaned up + * @NM_ACTIVE_CONNECTION_STATE_DEACTIVATED: the network connection is disconnected + * and will be removed + * + * #NMActiveConnectionState values indicate the state of a connection to a + * specific network while it is starting, connected, or disconnecting from that + * network. + **/ +typedef enum { + NM_ACTIVE_CONNECTION_STATE_UNKNOWN = 0, + NM_ACTIVE_CONNECTION_STATE_ACTIVATING = 1, + NM_ACTIVE_CONNECTION_STATE_ACTIVATED = 2, + NM_ACTIVE_CONNECTION_STATE_DEACTIVATING = 3, + NM_ACTIVE_CONNECTION_STATE_DEACTIVATED = 4, +} NMActiveConnectionState; + +/** + * NMActiveConnectionStateReason: + * @NM_ACTIVE_CONNECTION_STATE_REASON_UNKNOWN: The reason for the active connection + * state change is unknown. + * @NM_ACTIVE_CONNECTION_STATE_REASON_NONE: No reason was given for the active + * connection state change. + * @NM_ACTIVE_CONNECTION_STATE_REASON_USER_DISCONNECTED: The active connection changed + * state because the user disconnected it. + * @NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED: The active connection + * changed state because the device it was using was disconnected. + * @NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_STOPPED: The service providing the + * VPN connection was stopped. + * @NM_ACTIVE_CONNECTION_STATE_REASON_IP_CONFIG_INVALID: The IP config of the active + * connection was invalid. + * @NM_ACTIVE_CONNECTION_STATE_REASON_CONNECT_TIMEOUT: The connection attempt to + * the VPN service timed out. + * @NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_START_TIMEOUT: A timeout occurred + * while starting the service providing the VPN connection. + * @NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_START_FAILED: Starting the service + * providing the VPN connection failed. + * @NM_ACTIVE_CONNECTION_STATE_REASON_NO_SECRETS: Necessary secrets for the + * connection were not provided. + * @NM_ACTIVE_CONNECTION_STATE_REASON_LOGIN_FAILED: Authentication to the + * server failed. + * @NM_ACTIVE_CONNECTION_STATE_REASON_CONNECTION_REMOVED: The connection was + * deleted from settings. + * @NM_ACTIVE_CONNECTION_STATE_REASON_DEPENDENCY_FAILED: Master connection of this + * connection failed to activate. + * @NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_REALIZE_FAILED: Could not create the + * software device link. + * @NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_REMOVED: The device this connection + * depended on disappeared. + * + * Active connection state reasons. + * + * Since: 1.8 + */ +NM_AVAILABLE_IN_1_8 +typedef enum { + NM_ACTIVE_CONNECTION_STATE_REASON_UNKNOWN = 0, + NM_ACTIVE_CONNECTION_STATE_REASON_NONE = 1, + NM_ACTIVE_CONNECTION_STATE_REASON_USER_DISCONNECTED = 2, + NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED = 3, + NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_STOPPED = 4, + NM_ACTIVE_CONNECTION_STATE_REASON_IP_CONFIG_INVALID = 5, + NM_ACTIVE_CONNECTION_STATE_REASON_CONNECT_TIMEOUT = 6, + NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_START_TIMEOUT = 7, + NM_ACTIVE_CONNECTION_STATE_REASON_SERVICE_START_FAILED = 8, + NM_ACTIVE_CONNECTION_STATE_REASON_NO_SECRETS = 9, + NM_ACTIVE_CONNECTION_STATE_REASON_LOGIN_FAILED = 10, + NM_ACTIVE_CONNECTION_STATE_REASON_CONNECTION_REMOVED = 11, + NM_ACTIVE_CONNECTION_STATE_REASON_DEPENDENCY_FAILED = 12, + NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_REALIZE_FAILED = 13, + NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_REMOVED = 14, +} NMActiveConnectionStateReason; + +/** + * NMSecretAgentGetSecretsFlags: + * @NM_SECRET_AGENT_GET_SECRETS_FLAG_NONE: no special behavior; by default no + * user interaction is allowed and requests for secrets are fulfilled from + * persistent storage, or if no secrets are available an error is returned. + * @NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION: allows the request to + * interact with the user, possibly prompting via UI for secrets if any are + * required, or if none are found in persistent storage. + * @NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW: explicitly prompt for new + * secrets from the user. This flag signals that NetworkManager thinks any + * existing secrets are invalid or wrong. This flag implies that interaction + * is allowed. + * @NM_SECRET_AGENT_GET_SECRETS_FLAG_USER_REQUESTED: set if the request was + * initiated by user-requested action via the D-Bus interface, as opposed to + * automatically initiated by NetworkManager in response to (for example) scan + * results or carrier changes. + * @NM_SECRET_AGENT_GET_SECRETS_FLAG_WPS_PBC_ACTIVE: indicates that WPS enrollment + * is active with PBC method. The agent may suggest that the user pushes a button + * on the router instead of supplying a PSK. + * @NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM: Internal flag, not part of + * the D-Bus API. + * @NM_SECRET_AGENT_GET_SECRETS_FLAG_NO_ERRORS: Internal flag, not part of + * the D-Bus API. + * + * #NMSecretAgentGetSecretsFlags values modify the behavior of a GetSecrets request. + */ +typedef enum { /*< flags >*/ + NM_SECRET_AGENT_GET_SECRETS_FLAG_NONE = 0x0, + NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION = 0x1, + NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW = 0x2, + NM_SECRET_AGENT_GET_SECRETS_FLAG_USER_REQUESTED = 0x4, + NM_SECRET_AGENT_GET_SECRETS_FLAG_WPS_PBC_ACTIVE = 0x8, + + /* Internal to NM; not part of the D-Bus API */ + NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM = 0x80000000, + NM_SECRET_AGENT_GET_SECRETS_FLAG_NO_ERRORS = 0x40000000, +} NMSecretAgentGetSecretsFlags; + +/** + * NMSecretAgentCapabilities: + * @NM_SECRET_AGENT_CAPABILITY_NONE: the agent supports no special capabilities + * @NM_SECRET_AGENT_CAPABILITY_VPN_HINTS: the agent supports passing hints to + * VPN plugin authentication dialogs. + * @NM_SECRET_AGENT_CAPABILITY_LAST: bounds checking value; should not be used. + * + * #NMSecretAgentCapabilities indicate various capabilities of the agent. + */ +typedef enum /*< flags >*/ { + NM_SECRET_AGENT_CAPABILITY_NONE = 0x0, + NM_SECRET_AGENT_CAPABILITY_VPN_HINTS = 0x1, + + /* boundary value */ + NM_SECRET_AGENT_CAPABILITY_LAST = NM_SECRET_AGENT_CAPABILITY_VPN_HINTS, +} NMSecretAgentCapabilities; + +#ifndef NM_VERSION_H + #undef NM_AVAILABLE_IN_1_2 + #undef NM_AVAILABLE_IN_1_8 +#endif + +#define NM_LLDP_ATTR_RAW "raw" +#define NM_LLDP_ATTR_DESTINATION "destination" +#define NM_LLDP_ATTR_CHASSIS_ID_TYPE "chassis-id-type" +#define NM_LLDP_ATTR_CHASSIS_ID "chassis-id" +#define NM_LLDP_ATTR_PORT_ID_TYPE "port-id-type" +#define NM_LLDP_ATTR_PORT_ID "port-id" +#define NM_LLDP_ATTR_PORT_DESCRIPTION "port-description" +#define NM_LLDP_ATTR_SYSTEM_NAME "system-name" +#define NM_LLDP_ATTR_SYSTEM_DESCRIPTION "system-description" +#define NM_LLDP_ATTR_SYSTEM_CAPABILITIES "system-capabilities" +#define NM_LLDP_ATTR_MANAGEMENT_ADDRESSES "management-addresses" + +#define NM_LLDP_ATTR_IEEE_802_1_PVID "ieee-802-1-pvid" +#define NM_LLDP_ATTR_IEEE_802_1_VLANS "ieee-802-1-vlans" +#define NM_LLDP_ATTR_IEEE_802_1_PPVIDS "ieee-802-1-ppvids" + +#define NM_LLDP_ATTR_IEEE_802_3_MAC_PHY_CONF "ieee-802-3-mac-phy-conf" +#define NM_LLDP_ATTR_IEEE_802_3_POWER_VIA_MDI "ieee-802-3-power-via-mdi" +#define NM_LLDP_ATTR_IEEE_802_3_MAX_FRAME_SIZE "ieee-802-3-max-frame-size" + +#define NM_LLDP_ATTR_MUD_URL "mud-url" + +/* These are deprecated in favor of NM_LLDP_ATTR_IEEE_802_1_VLANS, + * which can report multiple VLANs */ +#define NM_LLDP_ATTR_IEEE_802_1_VID "ieee-802-1-vid" +#define NM_LLDP_ATTR_IEEE_802_1_VLAN_NAME "ieee-802-1-vlan-name" + +/* These are deprecated in favor of NM_LLDP_ATTR_IEEE_802_1_PPVIDS, + * which can report multiple PPVIDs */ +#define NM_LLDP_ATTR_IEEE_802_1_PPVID "ieee-802-1-ppvid" +#define NM_LLDP_ATTR_IEEE_802_1_PPVID_FLAGS "ieee-802-1-ppvid-flags" + +#define NM_LLDP_DEST_NEAREST_BRIDGE "nearest-bridge" +#define NM_LLDP_DEST_NEAREST_NON_TPMR_BRIDGE "nearest-non-tpmr-bridge" +#define NM_LLDP_DEST_NEAREST_CUSTOMER_BRIDGE "nearest-customer-bridge" + +/** + * NMIPTunnelMode: + * @NM_IP_TUNNEL_MODE_UNKNOWN: Unknown/unset tunnel mode + * @NM_IP_TUNNEL_MODE_IPIP: IP in IP tunnel + * @NM_IP_TUNNEL_MODE_GRE: GRE tunnel + * @NM_IP_TUNNEL_MODE_SIT: SIT tunnel + * @NM_IP_TUNNEL_MODE_ISATAP: ISATAP tunnel + * @NM_IP_TUNNEL_MODE_VTI: VTI tunnel + * @NM_IP_TUNNEL_MODE_IP6IP6: IPv6 in IPv6 tunnel + * @NM_IP_TUNNEL_MODE_IPIP6: IPv4 in IPv6 tunnel + * @NM_IP_TUNNEL_MODE_IP6GRE: IPv6 GRE tunnel + * @NM_IP_TUNNEL_MODE_VTI6: IPv6 VTI tunnel + * @NM_IP_TUNNEL_MODE_GRETAP: GRETAP tunnel + * @NM_IP_TUNNEL_MODE_IP6GRETAP: IPv6 GRETAP tunnel + * + * The tunneling mode. + * + * Since: 1.2 + */ +typedef enum { + NM_IP_TUNNEL_MODE_UNKNOWN = 0, + NM_IP_TUNNEL_MODE_IPIP = 1, + NM_IP_TUNNEL_MODE_GRE = 2, + NM_IP_TUNNEL_MODE_SIT = 3, + NM_IP_TUNNEL_MODE_ISATAP = 4, + NM_IP_TUNNEL_MODE_VTI = 5, + NM_IP_TUNNEL_MODE_IP6IP6 = 6, + NM_IP_TUNNEL_MODE_IPIP6 = 7, + NM_IP_TUNNEL_MODE_IP6GRE = 8, + NM_IP_TUNNEL_MODE_VTI6 = 9, + NM_IP_TUNNEL_MODE_GRETAP = 10, + NM_IP_TUNNEL_MODE_IP6GRETAP = 11, +} NMIPTunnelMode; + +/** + * NMCheckpointCreateFlags: + * @NM_CHECKPOINT_CREATE_FLAG_NONE: no flags + * @NM_CHECKPOINT_CREATE_FLAG_DESTROY_ALL: when creating + * a new checkpoint, destroy all existing ones. + * @NM_CHECKPOINT_CREATE_FLAG_DELETE_NEW_CONNECTIONS: upon rollback, + * delete any new connection added after the checkpoint. Since: 1.6. + * @NM_CHECKPOINT_CREATE_FLAG_DISCONNECT_NEW_DEVICES: upon rollback, + * disconnect any new device appeared after the checkpoint. Since: 1.6. + * @NM_CHECKPOINT_CREATE_FLAG_ALLOW_OVERLAPPING: by default, creating + * a checkpoint fails if there are already existing checkoints that + * reference the same devices. With this flag, creation of such + * checkpoints is allowed, however, if an older checkpoint + * that references overlapping devices gets rolled back, it will + * automatically destroy this checkpoint during rollback. This + * allows to create several overlapping checkpoints in parallel, + * and rollback to them at will. With the special case that + * rolling back to an older checkpoint will invalidate all + * overlapping younger checkpoints. This opts-in that the + * checkpoint can be automatically destroyed by the rollback + * of an older checkpoint. Since: 1.12. + * + * The flags for CheckpointCreate call + * + * Since: 1.4 (gi flags generated since 1.12) + */ +typedef enum { /*< flags >*/ + NM_CHECKPOINT_CREATE_FLAG_NONE = 0, + NM_CHECKPOINT_CREATE_FLAG_DESTROY_ALL = 0x01, + NM_CHECKPOINT_CREATE_FLAG_DELETE_NEW_CONNECTIONS = 0x02, + NM_CHECKPOINT_CREATE_FLAG_DISCONNECT_NEW_DEVICES = 0x04, + NM_CHECKPOINT_CREATE_FLAG_ALLOW_OVERLAPPING = 0x08, +} NMCheckpointCreateFlags; + +/** + * NMRollbackResult: + * @NM_ROLLBACK_RESULT_OK: the rollback succeeded. + * @NM_ROLLBACK_RESULT_ERR_NO_DEVICE: the device no longer exists. + * @NM_ROLLBACK_RESULT_ERR_DEVICE_UNMANAGED: the device is now unmanaged. + * @NM_ROLLBACK_RESULT_ERR_FAILED: other errors during rollback. + * + * The result of a checkpoint Rollback() operation for a specific device. + * + * Since: 1.4 + **/ +typedef enum { /*< skip >*/ + NM_ROLLBACK_RESULT_OK = 0, + NM_ROLLBACK_RESULT_ERR_NO_DEVICE = 1, + NM_ROLLBACK_RESULT_ERR_DEVICE_UNMANAGED = 2, + NM_ROLLBACK_RESULT_ERR_FAILED = 3, +} NMRollbackResult; + +/** + * NMSettingsConnectionFlags: + * @NM_SETTINGS_CONNECTION_FLAG_NONE: an alias for numeric zero, no flags set. + * @NM_SETTINGS_CONNECTION_FLAG_UNSAVED: the connection is not saved to disk. + * That either means, that the connection is in-memory only and currently + * is not backed by a file. Or, that the connection is backed by a file, + * but has modifications in-memory that were not persisted to disk. + * @NM_SETTINGS_CONNECTION_FLAG_NM_GENERATED: A connection is "nm-generated" if + * it was generated by NetworkManger. If the connection gets modified or saved + * by the user, the flag gets cleared. A nm-generated is also unsaved + * and has no backing file as it is in-memory only. + * @NM_SETTINGS_CONNECTION_FLAG_VOLATILE: The connection will be deleted + * when it disconnects. That is for in-memory connections (unsaved), which are + * currently active but deleted on disconnect. Volatile connections are + * always unsaved, but they are also no backing file on disk and are entirely + * in-memory only. + * @NM_SETTINGS_CONNECTION_FLAG_EXTERNAL: the profile was generated to represent + * an external configuration of a networking device. Since: 1.26. + * + * Flags describing the current activation state. + * + * Since: 1.12 + **/ +typedef enum { /*< flags >*/ + NM_SETTINGS_CONNECTION_FLAG_NONE = 0, + NM_SETTINGS_CONNECTION_FLAG_UNSAVED = 0x01, + NM_SETTINGS_CONNECTION_FLAG_NM_GENERATED = 0x02, + NM_SETTINGS_CONNECTION_FLAG_VOLATILE = 0x04, + NM_SETTINGS_CONNECTION_FLAG_EXTERNAL = 0x08, +} NMSettingsConnectionFlags; + +/** + * NMActivationStateFlags: + * @NM_ACTIVATION_STATE_FLAG_NONE: an alias for numeric zero, no flags set. + * @NM_ACTIVATION_STATE_FLAG_IS_MASTER: the device is a master. + * @NM_ACTIVATION_STATE_FLAG_IS_SLAVE: the device is a slave. + * @NM_ACTIVATION_STATE_FLAG_LAYER2_READY: layer2 is activated and ready. + * @NM_ACTIVATION_STATE_FLAG_IP4_READY: IPv4 setting is completed. + * @NM_ACTIVATION_STATE_FLAG_IP6_READY: IPv6 setting is completed. + * @NM_ACTIVATION_STATE_FLAG_MASTER_HAS_SLAVES: The master has any slave devices attached. + * This only makes sense if the device is a master. + * @NM_ACTIVATION_STATE_FLAG_LIFETIME_BOUND_TO_PROFILE_VISIBILITY: the lifetime + * of the activation is bound to the visibility of the connection profile, + * which in turn depends on "connection.permissions" and whether a session + * for the user exists. Since: 1.16. + * @NM_ACTIVATION_STATE_FLAG_EXTERNAL: the active connection was generated to + * represent an external configuration of a networking device. Since: 1.26. + * + * Flags describing the current activation state. + * + * Since: 1.10 + **/ +typedef enum { /*< flags >*/ + NM_ACTIVATION_STATE_FLAG_NONE = 0, + + NM_ACTIVATION_STATE_FLAG_IS_MASTER = 0x1, + NM_ACTIVATION_STATE_FLAG_IS_SLAVE = 0x2, + NM_ACTIVATION_STATE_FLAG_LAYER2_READY = 0x4, + NM_ACTIVATION_STATE_FLAG_IP4_READY = 0x8, + NM_ACTIVATION_STATE_FLAG_IP6_READY = 0x10, + NM_ACTIVATION_STATE_FLAG_MASTER_HAS_SLAVES = 0x20, + NM_ACTIVATION_STATE_FLAG_LIFETIME_BOUND_TO_PROFILE_VISIBILITY = 0x40, + NM_ACTIVATION_STATE_FLAG_EXTERNAL = 0x80, +} NMActivationStateFlags; + +/** + * NMSettingsAddConnection2Flags: + * @NM_SETTINGS_ADD_CONNECTION2_FLAG_NONE: an alias for numeric zero, no flags set. + * @NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK: to persist the connection to disk. + * @NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY: to make the connection in-memory only. + * @NM_SETTINGS_ADD_CONNECTION2_FLAG_BLOCK_AUTOCONNECT: usually, when the connection + * has autoconnect enabled and gets added, it becomes eligible to autoconnect + * right away. Setting this flag, disables autoconnect until the connection + * is manually activated. + * + * Numeric flags for the "flags" argument of AddConnection2() D-Bus API. + * + * Since: 1.20 + */ +typedef enum { /*< flags >*/ + NM_SETTINGS_ADD_CONNECTION2_FLAG_NONE = 0, + NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK = 0x1, + NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY = 0x2, + NM_SETTINGS_ADD_CONNECTION2_FLAG_BLOCK_AUTOCONNECT = 0x20, +} NMSettingsAddConnection2Flags; + +/** + * NMSettingsUpdate2Flags: + * @NM_SETTINGS_UPDATE2_FLAG_NONE: an alias for numeric zero, no flags set. + * @NM_SETTINGS_UPDATE2_FLAG_TO_DISK: to persist the connection to disk. + * @NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY: makes the profile in-memory. + * Note that such profiles are stored in keyfile format under /run. + * If the file is already in-memory, the file in /run is updated in-place. + * Otherwise, the previous storage for the profile is left unchanged + * on disk, and the in-memory copy shadows it. + * Note that the original filename of the previous persistent storage (if any) + * is remembered. That means, when later persisting the profile again to disk, + * the file on disk will be overwritten again. + * Likewise, when finally deleting the profile, both the storage from /run + * and persistent storage are deleted (or if the persistent storage does not + * allow deletion, and nmmeta file is written to mark the UUID as deleted). + * @NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_DETACHED: this is almost the same + * as %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY, with one difference: when later deleting + * the profile, the original profile will not be deleted. Instead a nmmeta + * file is written to /run to indicate that the profile is gone. + * Note that if such a nmmeta tombstone file exists and hides a file in persistent + * storage, then when re-adding the profile with the same UUID, then the original + * storage is taken over again. + * @NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_ONLY: this is like %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY, + * but if the connection has a corresponding file on persistent storage, the file + * will be deleted right away. If the profile is later again persisted to disk, + * a new, unused filename will be chosen. + * @NM_SETTINGS_UPDATE2_FLAG_VOLATILE: This can be specified with either + * %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY, %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_DETACHED + * or %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_ONLY. + * After making the connection in-memory only, the connection is marked + * as volatile. That means, if the connection is currently not active + * it will be deleted right away. Otherwise, it is marked to for deletion + * once the connection deactivates. A volatile connection cannot autoactivate + * again (because it's about to be deleted), but a manual activation will + * clear the volatile flag. + * @NM_SETTINGS_UPDATE2_FLAG_BLOCK_AUTOCONNECT: usually, when the connection + * has autoconnect enabled and is modified, it becomes eligible to autoconnect + * right away. Setting this flag, disables autoconnect until the connection + * is manually activated. + * @NM_SETTINGS_UPDATE2_FLAG_NO_REAPPLY: when a profile gets modified that is + * currently active, then these changes don't take effect for the active + * device unless the profile gets reactivated or the configuration reapplied. + * There are two exceptions: by default "connection.zone" and "connection.metered" + * properties take effect immediately. Specify this flag to prevent these + * properties to take effect, so that the change is restricted to modify + * the profile. Since: 1.20. + * + * Since: 1.12 + */ +typedef enum { /*< flags >*/ + NM_SETTINGS_UPDATE2_FLAG_NONE = 0, + NM_SETTINGS_UPDATE2_FLAG_TO_DISK = 0x1, + NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY = 0x2, + NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_DETACHED = 0x4, + NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_ONLY = 0x8, + NM_SETTINGS_UPDATE2_FLAG_VOLATILE = 0x10, + NM_SETTINGS_UPDATE2_FLAG_BLOCK_AUTOCONNECT = 0x20, + NM_SETTINGS_UPDATE2_FLAG_NO_REAPPLY = 0x40, +} NMSettingsUpdate2Flags; + +/** + * NMTernary: + * @NM_TERNARY_DEFAULT: use the globally-configured default value. + * @NM_TERNARY_FALSE: the option is disabled. + * @NM_TERNARY_TRUE: the option is enabled. + * + * An boolean value that can be overridden by a default. + * + * Since: 1.14 + **/ +typedef enum { + NM_TERNARY_DEFAULT = -1, + NM_TERNARY_FALSE = 0, + NM_TERNARY_TRUE = 1, +} NMTernary; + +/** + * NMManagerReloadFlags: + * @NM_MANAGER_RELOAD_FLAG_NONE: an alias for numeric zero, no flags set. This + * reloads everything that is supported and is identical to a SIGHUP. + * @NM_MANAGER_RELOAD_FLAG_CONF: reload the NetworkManager.conf configuration + * from disk. Note that this does not include connections, which can be + * reloaded via Setting's ReloadConnections(). + * @NM_MANAGER_RELOAD_FLAG_DNS_RC: update DNS configuration, which usually + * involves writing /etc/resolv.conf anew. + * @NM_MANAGER_RELOAD_FLAG_DNS_FULL: means to restart the DNS plugin. This + * is for example useful when using dnsmasq plugin, which uses additional + * configuration in /etc/NetworkManager/dnsmasq.d. If you edit those files, + * you can restart the DNS plugin. This action shortly interrupts name + * resolution. + * @NM_MANAGER_RELOAD_FLAG_ALL: all flags. + * + * Flags for the manager Reload() call. + * + * Since: 1.22 + */ +typedef enum { /*< flags >*/ + NM_MANAGER_RELOAD_FLAG_NONE = 0, /*< skip >*/ + NM_MANAGER_RELOAD_FLAG_CONF = 0x1, + NM_MANAGER_RELOAD_FLAG_DNS_RC = 0x2, + NM_MANAGER_RELOAD_FLAG_DNS_FULL = 0x4, + NM_MANAGER_RELOAD_FLAG_ALL = 0x7, /*< skip >*/ +} NMManagerReloadFlags; + +/** + * NMDeviceInterfaceFlags: + * @NM_DEVICE_INTERFACE_FLAG_NONE: an alias for numeric zero, no flags set. + * @NM_DEVICE_INTERFACE_FLAG_UP: the interface is enabled from the + * administrative point of view. Corresponds to kernel IFF_UP. + * @NM_DEVICE_INTERFACE_FLAG_LOWER_UP: the physical link is up. Corresponds + * to kernel IFF_LOWER_UP. + * @NM_DEVICE_INTERFACE_FLAG_CARRIER: the interface has carrier. In most + * cases this is equal to the value of @NM_DEVICE_INTERFACE_FLAG_LOWER_UP. + * However some devices have a non-standard carrier detection mechanism. + * + * Flags for a network interface. + * + * Since: 1.22 + */ +typedef enum { /*< flags >*/ + /* kernel flags */ + NM_DEVICE_INTERFACE_FLAG_NONE = 0, /*< skip >*/ + NM_DEVICE_INTERFACE_FLAG_UP = 0x1, + NM_DEVICE_INTERFACE_FLAG_LOWER_UP = 0x2, + /* NM-specific flags */ + NM_DEVICE_INTERFACE_FLAG_CARRIER = 0x10000, +} NMDeviceInterfaceFlags; + +/** + * NMClientPermission: + * @NM_CLIENT_PERMISSION_NONE: unknown or no permission + * @NM_CLIENT_PERMISSION_ENABLE_DISABLE_NETWORK: controls whether networking + * can be globally enabled or disabled + * @NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIFI: controls whether Wi-Fi can be + * globally enabled or disabled + * @NM_CLIENT_PERMISSION_ENABLE_DISABLE_WWAN: controls whether WWAN (3G) can be + * globally enabled or disabled + * @NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIMAX: controls whether WiMAX can be + * globally enabled or disabled + * @NM_CLIENT_PERMISSION_SLEEP_WAKE: controls whether the client can ask + * NetworkManager to sleep and wake + * @NM_CLIENT_PERMISSION_NETWORK_CONTROL: controls whether networking connections + * can be started, stopped, and changed + * @NM_CLIENT_PERMISSION_WIFI_SHARE_PROTECTED: controls whether a password + * protected Wi-Fi hotspot can be created + * @NM_CLIENT_PERMISSION_WIFI_SHARE_OPEN: controls whether an open Wi-Fi hotspot + * can be created + * @NM_CLIENT_PERMISSION_SETTINGS_MODIFY_SYSTEM: controls whether connections + * that are available to all users can be modified + * @NM_CLIENT_PERMISSION_SETTINGS_MODIFY_OWN: controls whether connections + * owned by the current user can be modified + * @NM_CLIENT_PERMISSION_SETTINGS_MODIFY_HOSTNAME: controls whether the + * persistent hostname can be changed + * @NM_CLIENT_PERMISSION_SETTINGS_MODIFY_GLOBAL_DNS: modify persistent global + * DNS configuration + * @NM_CLIENT_PERMISSION_RELOAD: controls access to Reload. + * @NM_CLIENT_PERMISSION_CHECKPOINT_ROLLBACK: permission to create checkpoints. + * @NM_CLIENT_PERMISSION_ENABLE_DISABLE_STATISTICS: controls whether device + * statistics can be globally enabled or disabled + * @NM_CLIENT_PERMISSION_ENABLE_DISABLE_CONNECTIVITY_CHECK: controls whether + * connectivity check can be enabled or disabled + * @NM_CLIENT_PERMISSION_WIFI_SCAN: controls whether wifi scans can be performed + * @NM_CLIENT_PERMISSION_LAST: a reserved boundary value + * + * #NMClientPermission values indicate various permissions that NetworkManager + * clients can obtain to perform certain tasks on behalf of the current user. + **/ +typedef enum { + NM_CLIENT_PERMISSION_NONE = 0, + NM_CLIENT_PERMISSION_ENABLE_DISABLE_NETWORK = 1, + NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIFI = 2, + NM_CLIENT_PERMISSION_ENABLE_DISABLE_WWAN = 3, + NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIMAX = 4, + NM_CLIENT_PERMISSION_SLEEP_WAKE = 5, + NM_CLIENT_PERMISSION_NETWORK_CONTROL = 6, + NM_CLIENT_PERMISSION_WIFI_SHARE_PROTECTED = 7, + NM_CLIENT_PERMISSION_WIFI_SHARE_OPEN = 8, + NM_CLIENT_PERMISSION_SETTINGS_MODIFY_SYSTEM = 9, + NM_CLIENT_PERMISSION_SETTINGS_MODIFY_OWN = 10, + NM_CLIENT_PERMISSION_SETTINGS_MODIFY_HOSTNAME = 11, + NM_CLIENT_PERMISSION_SETTINGS_MODIFY_GLOBAL_DNS = 12, + NM_CLIENT_PERMISSION_RELOAD = 13, + NM_CLIENT_PERMISSION_CHECKPOINT_ROLLBACK = 14, + NM_CLIENT_PERMISSION_ENABLE_DISABLE_STATISTICS = 15, + NM_CLIENT_PERMISSION_ENABLE_DISABLE_CONNECTIVITY_CHECK = 16, + NM_CLIENT_PERMISSION_WIFI_SCAN = 17, + + NM_CLIENT_PERMISSION_LAST = 17, +} NMClientPermission; + +/** + * NMClientPermissionResult: + * @NM_CLIENT_PERMISSION_RESULT_UNKNOWN: unknown or no authorization + * @NM_CLIENT_PERMISSION_RESULT_YES: the permission is available + * @NM_CLIENT_PERMISSION_RESULT_AUTH: authorization is necessary before the + * permission is available + * @NM_CLIENT_PERMISSION_RESULT_NO: permission to perform the operation is + * denied by system policy + * + * #NMClientPermissionResult values indicate what authorizations and permissions + * the user requires to obtain a given #NMClientPermission + **/ +typedef enum { + NM_CLIENT_PERMISSION_RESULT_UNKNOWN = 0, + NM_CLIENT_PERMISSION_RESULT_YES, + NM_CLIENT_PERMISSION_RESULT_AUTH, + NM_CLIENT_PERMISSION_RESULT_NO +} NMClientPermissionResult; + +#endif /* __NM_DBUS_INTERFACE_H__ */ diff --git a/src/libnm-core-public/nm-errors.h b/src/libnm-core-public/nm-errors.h new file mode 100644 index 0000000000..639c508e3e --- /dev/null +++ b/src/libnm-core-public/nm-errors.h @@ -0,0 +1,319 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2004 - 2014 Red Hat, Inc. + */ + +#ifndef __NM_ERRORS_H__ +#define __NM_ERRORS_H__ + +/** + * NMAgentManagerError: + * @NM_AGENT_MANAGER_ERROR_FAILED: unknown or unspecified error + * @NM_AGENT_MANAGER_ERROR_PERMISSION_DENIED: The caller does not have permission + * to register a secret agent, or is trying to register the same secret agent + * twice. + * @NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER: The identifier is not a valid + * secret agent identifier. + * @NM_AGENT_MANAGER_ERROR_NOT_REGISTERED: The caller tried to unregister an agent + * that was not registered. + * @NM_AGENT_MANAGER_ERROR_NO_SECRETS: No secret agent returned secrets for this + * request + * @NM_AGENT_MANAGER_ERROR_USER_CANCELED: The user canceled the secrets request. + * + * Errors returned from the secret-agent manager. + * + * These errors may be returned from operations that could cause secrets to be + * requested (such as nm_client_activate_connection()), and correspond to D-Bus + * errors in the "org.freedesktop.NetworkManager.AgentManager" namespace. + */ +typedef enum { + NM_AGENT_MANAGER_ERROR_FAILED = 0, /*< nick=Failed >*/ + NM_AGENT_MANAGER_ERROR_PERMISSION_DENIED, /*< nick=PermissionDenied >*/ + NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER, /*< nick=InvalidIdentifier >*/ + NM_AGENT_MANAGER_ERROR_NOT_REGISTERED, /*< nick=NotRegistered >*/ + NM_AGENT_MANAGER_ERROR_NO_SECRETS, /*< nick=NoSecrets >*/ + NM_AGENT_MANAGER_ERROR_USER_CANCELED, /*< nick=UserCanceled >*/ +} NMAgentManagerError; + +GQuark nm_agent_manager_error_quark(void); +#define NM_AGENT_MANAGER_ERROR (nm_agent_manager_error_quark()) + +/** + * NMConnectionError: + * @NM_CONNECTION_ERROR_FAILED: unknown or unclassified error + * @NM_CONNECTION_ERROR_SETTING_NOT_FOUND: the #NMConnection object + * did not contain the specified #NMSetting object + * @NM_CONNECTION_ERROR_PROPERTY_NOT_FOUND: the #NMConnection did not contain the + * requested #NMSetting property + * @NM_CONNECTION_ERROR_PROPERTY_NOT_SECRET: an operation which requires a secret + * was attempted on a non-secret property + * @NM_CONNECTION_ERROR_MISSING_SETTING: the #NMConnection object is missing an + * #NMSetting which is required for its configuration. The error message will + * always be prefixed with "<setting-name>: ", where "<setting-name>" is the + * name of the setting that is missing. + * @NM_CONNECTION_ERROR_INVALID_SETTING: the #NMConnection object contains an + * invalid or inappropriate #NMSetting. The error message will always be + * prefixed with "<setting-name>: ", where "<setting-name>" is the name of the + * setting that is invalid. + * @NM_CONNECTION_ERROR_MISSING_PROPERTY: the #NMConnection object is invalid + * because it is missing a required property. The error message will always be + * prefixed with "<setting-name>.<property-name>: ", where "<setting-name>" is + * the name of the setting with the missing property, and "<property-name>" is + * the property that is missing. + * @NM_CONNECTION_ERROR_INVALID_PROPERTY: the #NMConnection object is invalid + * because a property has an invalid value. The error message will always be + * prefixed with "<setting-name>.<property-name>: ", where "<setting-name>" is + * the name of the setting with the invalid property, and "<property-name>" is + * the property that is invalid. + * + * Describes errors that may result from operations involving a #NMConnection + * or its #NMSettings. + * + * These errors may be returned directly from #NMConnection and #NMSetting + * methods, or may be returned from D-Bus operations (eg on #NMClient or + * #NMDevice), where they correspond to errors in the + * "org.freedesktop.NetworkManager.Settings.Connection" namespace. + */ +typedef enum { + NM_CONNECTION_ERROR_FAILED = 0, /*< nick=Failed >*/ + NM_CONNECTION_ERROR_SETTING_NOT_FOUND, /*< nick=SettingNotFound >*/ + NM_CONNECTION_ERROR_PROPERTY_NOT_FOUND, /*< nick=PropertyNotFound >*/ + NM_CONNECTION_ERROR_PROPERTY_NOT_SECRET, /*< nick=PropertyNotSecret >*/ + NM_CONNECTION_ERROR_MISSING_SETTING, /*< nick=MissingSetting >*/ + NM_CONNECTION_ERROR_INVALID_SETTING, /*< nick=InvalidSetting >*/ + NM_CONNECTION_ERROR_MISSING_PROPERTY, /*< nick=MissingProperty >*/ + NM_CONNECTION_ERROR_INVALID_PROPERTY, /*< nick=InvalidProperty >*/ +} NMConnectionError; + +#define NM_CONNECTION_ERROR nm_connection_error_quark() +GQuark nm_connection_error_quark(void); + +/** + * NMCryptoError: + * @NM_CRYPTO_ERROR_FAILED: generic failure + * @NM_CRYPTO_ERROR_INVALID_DATA: the certificate or key data provided + * was invalid + * @NM_CRYPTO_ERROR_INVALID_PASSWORD: the password was invalid + * @NM_CRYPTO_ERROR_UNKNOWN_CIPHER: the data uses an unknown cipher + * @NM_CRYPTO_ERROR_DECRYPTION_FAILED: decryption failed + * @NM_CRYPTO_ERROR_ENCRYPTION_FAILED: encryption failed + * + * Cryptography-related errors that can be returned from some nm-utils methods, + * and some #NMSetting8021x operations. + */ +typedef enum { + NM_CRYPTO_ERROR_FAILED = 0, + NM_CRYPTO_ERROR_INVALID_DATA, + NM_CRYPTO_ERROR_INVALID_PASSWORD, + NM_CRYPTO_ERROR_UNKNOWN_CIPHER, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + NM_CRYPTO_ERROR_ENCRYPTION_FAILED, +} NMCryptoError; + +#define NM_CRYPTO_ERROR nm_crypto_error_quark() +GQuark nm_crypto_error_quark(void); + +/** + * NMDeviceError: + * @NM_DEVICE_ERROR_FAILED: unknown or unclassified error + * @NM_DEVICE_ERROR_CREATION_FAILED: NetworkManager failed to create the device + * @NM_DEVICE_ERROR_INVALID_CONNECTION: the specified connection is not valid + * @NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION: the specified connection is not + * compatible with this device. + * @NM_DEVICE_ERROR_NOT_ACTIVE: the device does not have an active connection + * @NM_DEVICE_ERROR_NOT_SOFTWARE: the requested operation is only valid on + * software devices. + * @NM_DEVICE_ERROR_NOT_ALLOWED: the requested operation is not allowed at + * this time. + * @NM_DEVICE_ERROR_SPECIFIC_OBJECT_NOT_FOUND: the "specific object" in the + * activation request (eg, the #NMAccessPoint or #NMWimaxNsp) was not + * found. + * @NM_DEVICE_ERROR_VERSION_ID_MISMATCH: the version id did not match. + * @NM_DEVICE_ERROR_MISSING_DEPENDENCIES: the requested operation could not + * be completed due to missing dependencies. + * @NM_DEVICE_ERROR_INVALID_ARGUMENT: invalid argument. Since: 1.16. + * + * Device-related errors. + * + * These errors may be returned directly from #NMDevice methods, or may be + * returned from D-Bus operations (where they correspond to errors in the + * "org.freedesktop.NetworkManager.Device" namespace). + */ +typedef enum { + NM_DEVICE_ERROR_FAILED = 0, /*< nick=Failed >*/ + NM_DEVICE_ERROR_CREATION_FAILED, /*< nick=CreationFailed >*/ + NM_DEVICE_ERROR_INVALID_CONNECTION, /*< nick=InvalidConnection >*/ + NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, /*< nick=IncompatibleConnection >*/ + NM_DEVICE_ERROR_NOT_ACTIVE, /*< nick=NotActive >*/ + NM_DEVICE_ERROR_NOT_SOFTWARE, /*< nick=NotSoftware >*/ + NM_DEVICE_ERROR_NOT_ALLOWED, /*< nick=NotAllowed >*/ + NM_DEVICE_ERROR_SPECIFIC_OBJECT_NOT_FOUND, /*< nick=SpecificObjectNotFound >*/ + NM_DEVICE_ERROR_VERSION_ID_MISMATCH, /*< nick=VersionIdMismatch >*/ + NM_DEVICE_ERROR_MISSING_DEPENDENCIES, /*< nick=MissingDependencies >*/ + NM_DEVICE_ERROR_INVALID_ARGUMENT, /*< nick=InvalidArgument >*/ +} NMDeviceError; + +#define NM_DEVICE_ERROR nm_device_error_quark() +GQuark nm_device_error_quark(void); + +/** + * NMManagerError: + * @NM_MANAGER_ERROR_FAILED: unknown or unclassified error + * @NM_MANAGER_ERROR_PERMISSION_DENIED: Permission denied. + * @NM_MANAGER_ERROR_UNKNOWN_CONNECTION: The requested connection is not known. + * @NM_MANAGER_ERROR_UNKNOWN_DEVICE: The requested device is not known. + * @NM_MANAGER_ERROR_CONNECTION_NOT_AVAILABLE: The requested connection cannot be + * activated at this time. + * @NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE: The request could not be completed + * because a required connection is not active. + * @NM_MANAGER_ERROR_CONNECTION_ALREADY_ACTIVE: The connection to be activated was + * already active on another device. + * @NM_MANAGER_ERROR_DEPENDENCY_FAILED: An activation request failed due to a + * dependency being unavailable. + * @NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE: The manager is already in the requested + * sleep/wake state. + * @NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED: The network is already + * enabled/disabled. + * @NM_MANAGER_ERROR_UNKNOWN_LOG_LEVEL: Unknown log level in SetLogging + * @NM_MANAGER_ERROR_UNKNOWN_LOG_DOMAIN: Unknown log domain in SetLogging + * @NM_MANAGER_ERROR_INVALID_ARGUMENTS: Invalid arguments for D-Bus request + * @NM_MANAGER_ERROR_MISSING_PLUGIN: A plug-in was needed to complete the + * activation but is not available. + * + * Errors related to the main "network management" interface of NetworkManager. + * These may be returned from #NMClient methods that invoke D-Bus operations on + * the "org.freedesktop.NetworkManager" interface, and correspond to D-Bus + * errors in that namespace. + */ +typedef enum { + NM_MANAGER_ERROR_FAILED = 0, /*< nick=Failed >*/ + NM_MANAGER_ERROR_PERMISSION_DENIED, /*< nick=PermissionDenied >*/ + NM_MANAGER_ERROR_UNKNOWN_CONNECTION, /*< nick=UnknownConnection >*/ + NM_MANAGER_ERROR_UNKNOWN_DEVICE, /*< nick=UnknownDevice >*/ + NM_MANAGER_ERROR_CONNECTION_NOT_AVAILABLE, /*< nick=ConnectionNotAvailable >*/ + NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE, /*< nick=ConnectionNotActive >*/ + NM_MANAGER_ERROR_CONNECTION_ALREADY_ACTIVE, /*< nick=ConnectionAlreadyActive >*/ + NM_MANAGER_ERROR_DEPENDENCY_FAILED, /*< nick=DependencyFailed >*/ + NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE, /*< nick=AlreadyAsleepOrAwake >*/ + NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED, /*< nick=AlreadyEnabledOrDisabled >*/ + NM_MANAGER_ERROR_UNKNOWN_LOG_LEVEL, /*< nick=UnknownLogLevel >*/ + NM_MANAGER_ERROR_UNKNOWN_LOG_DOMAIN, /*< nick=UnknownLogDomain >*/ + NM_MANAGER_ERROR_INVALID_ARGUMENTS, /*< nick=InvalidArguments >*/ + NM_MANAGER_ERROR_MISSING_PLUGIN, /*< nick=MissingPlugin >*/ +} NMManagerError; + +GQuark nm_manager_error_quark(void); +#define NM_MANAGER_ERROR (nm_manager_error_quark()) + +/** + * NMSecretAgentError: + * @NM_SECRET_AGENT_ERROR_FAILED: unknown or unclassified error + * @NM_SECRET_AGENT_ERROR_PERMISSION_DENIED: the caller (ie, NetworkManager) is + * not authorized to make this request + * @NM_SECRET_AGENT_ERROR_INVALID_CONNECTION: the connection for which secrets + * were requested is invalid + * @NM_SECRET_AGENT_ERROR_USER_CANCELED: the request was canceled by the user + * @NM_SECRET_AGENT_ERROR_AGENT_CANCELED: the agent canceled the request + * because it was requested to do so by NetworkManager + * @NM_SECRET_AGENT_ERROR_NO_SECRETS: the agent cannot find any secrets for this + * connection + * + * #NMSecretAgentError values are passed by secret agents back to NetworkManager + * when they encounter problems retrieving secrets on behalf of NM. They + * correspond to errors in the "org.freedesktop.NetworkManager.SecretManager" + * namespace. + * + * Client APIs such as nm_client_activate_connection() will not see these error + * codes; instead, the secret agent manager will translate them to the + * corresponding #NMAgentManagerError codes. + */ +typedef enum { + NM_SECRET_AGENT_ERROR_FAILED = 0, /*< nick=Failed >*/ + NM_SECRET_AGENT_ERROR_PERMISSION_DENIED, /*< nick=PermissionDenied >*/ + NM_SECRET_AGENT_ERROR_INVALID_CONNECTION, /*< nick=InvalidConnection >*/ + NM_SECRET_AGENT_ERROR_USER_CANCELED, /*< nick=UserCanceled >*/ + NM_SECRET_AGENT_ERROR_AGENT_CANCELED, /*< nick=AgentCanceled >*/ + NM_SECRET_AGENT_ERROR_NO_SECRETS, /*< nick=NoSecrets >*/ +} NMSecretAgentError; + +GQuark nm_secret_agent_error_quark(void); +#define NM_SECRET_AGENT_ERROR (nm_secret_agent_error_quark()) + +/** + * NMSettingsError: + * @NM_SETTINGS_ERROR_FAILED: unknown or unclassified error + * @NM_SETTINGS_ERROR_PERMISSION_DENIED: permission denied + * @NM_SETTINGS_ERROR_NOT_SUPPORTED: the requested operation is not supported by any + * active settings backend + * @NM_SETTINGS_ERROR_INVALID_CONNECTION: the connection was invalid + * @NM_SETTINGS_ERROR_READ_ONLY_CONNECTION: attempted to modify a read-only connection + * @NM_SETTINGS_ERROR_UUID_EXISTS: a connection with that UUID already exists + * @NM_SETTINGS_ERROR_INVALID_HOSTNAME: attempted to set an invalid hostname + * @NM_SETTINGS_ERROR_INVALID_ARGUMENTS: invalid arguments + * + * Errors related to the settings/persistent configuration interface of + * NetworkManager. + * + * These may be returned from #NMClient methods that invoke D-Bus operations on + * the "org.freedesktop.NetworkManager.Settings" interface, and correspond to + * D-Bus errors in that namespace. + */ +typedef enum { + NM_SETTINGS_ERROR_FAILED = 0, /*< nick=Failed >*/ + NM_SETTINGS_ERROR_PERMISSION_DENIED, /*< nick=PermissionDenied >*/ + NM_SETTINGS_ERROR_NOT_SUPPORTED, /*< nick=NotSupported >*/ + NM_SETTINGS_ERROR_INVALID_CONNECTION, /*< nick=InvalidConnection >*/ + NM_SETTINGS_ERROR_READ_ONLY_CONNECTION, /*< nick=ReadOnlyConnection >*/ + NM_SETTINGS_ERROR_UUID_EXISTS, /*< nick=UuidExists >*/ + NM_SETTINGS_ERROR_INVALID_HOSTNAME, /*< nick=InvalidHostname >*/ + NM_SETTINGS_ERROR_INVALID_ARGUMENTS, /*< nick=InvalidArguments >*/ +} NMSettingsError; + +GQuark nm_settings_error_quark(void); +#define NM_SETTINGS_ERROR (nm_settings_error_quark()) + +/** + * NMVpnPluginError: + * @NM_VPN_PLUGIN_ERROR_FAILED: unknown or unclassified error + * @NM_VPN_PLUGIN_ERROR_STARTING_IN_PROGRESS: the plugin is already starting, + * and another connect request was received + * @NM_VPN_PLUGIN_ERROR_ALREADY_STARTED: the plugin is already connected, and + * another connect request was received + * @NM_VPN_PLUGIN_ERROR_STOPPING_IN_PROGRESS: the plugin is already stopping, + * and another stop request was received + * @NM_VPN_PLUGIN_ERROR_ALREADY_STOPPED: the plugin is already stopped, and + * another disconnect request was received + * @NM_VPN_PLUGIN_ERROR_WRONG_STATE: the operation could not be performed in + * this state + * @NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS: the operation could not be performed as + * the request contained malformed arguments, or arguments of unexpected type. + * Usually means that one of the VPN setting data items or secrets was not of + * the expected type (ie int, string, bool, etc). + * @NM_VPN_PLUGIN_ERROR_LAUNCH_FAILED: a child process failed to launch + * @NM_VPN_PLUGIN_ERROR_INVALID_CONNECTION: the operation could not be performed + * because the connection was invalid. Usually means that the connection's + * VPN setting was missing some required data item or secret. + * @NM_VPN_PLUGIN_ERROR_INTERACTIVE_NOT_SUPPORTED: the operation could not be + * performed as the plugin does not support interactive operations, such as + * ConnectInteractive() or NewSecrets() + * + * Returned by the VPN service plugin to indicate errors. These codes correspond + * to errors in the "org.freedesktop.NetworkManager.VPN.Error" namespace. + **/ +typedef enum { + NM_VPN_PLUGIN_ERROR_FAILED, /*< nick=Failed >*/ + NM_VPN_PLUGIN_ERROR_STARTING_IN_PROGRESS, /*< nick=StartingInProgress >*/ + NM_VPN_PLUGIN_ERROR_ALREADY_STARTED, /*< nick=AlreadyStarted >*/ + NM_VPN_PLUGIN_ERROR_STOPPING_IN_PROGRESS, /*< nick=StoppingInProgress >*/ + NM_VPN_PLUGIN_ERROR_ALREADY_STOPPED, /*< nick=AlreadyStopped >*/ + NM_VPN_PLUGIN_ERROR_WRONG_STATE, /*< nick=WrongState >*/ + NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS, /*< nick=BadArguments >*/ + NM_VPN_PLUGIN_ERROR_LAUNCH_FAILED, /*< nick=LaunchFailed >*/ + NM_VPN_PLUGIN_ERROR_INVALID_CONNECTION, /*< nick=InvalidConnection >*/ + NM_VPN_PLUGIN_ERROR_INTERACTIVE_NOT_SUPPORTED, /*< nick=InteractiveNotSupported >*/ +} NMVpnPluginError; + +#define NM_VPN_PLUGIN_ERROR (nm_vpn_plugin_error_quark()) +GQuark nm_vpn_plugin_error_quark(void); + +#endif /* __NM_ERRORS_H__ */ diff --git a/src/libnm-core-public/nm-keyfile.h b/src/libnm-core-public/nm-keyfile.h new file mode 100644 index 0000000000..28c052f999 --- /dev/null +++ b/src/libnm-core-public/nm-keyfile.h @@ -0,0 +1,165 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +#ifndef __NM_KEYFILE_H__ +#define __NM_KEYFILE_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-core-types.h" + +G_BEGIN_DECLS + +/** + * NMKeyfileHandlerFlags: + * @NM_KEYFILE_HANDLER_FLAGS_NONE: no flags set. + * + * Flags for customizing nm_keyfile_read() and nm_keyfile_write(). + * + * Currently no flags are implemented. + * + * Since: 1.30 + */ +typedef enum { /*< flags >*/ + NM_KEYFILE_HANDLER_FLAGS_NONE = 0, +} NMKeyfileHandlerFlags; + +/** + * NMKeyfileHandlerType: + * @NM_KEYFILE_HANDLER_TYPE_WARN: a warning. + * @NM_KEYFILE_HANDLER_TYPE_WRITE_CERT: for handling certificates while writing + * a connection to keyfile. + * + * The type of the callback for %NMKeyfileReadHandler and %NMKeyfileWriteHandler. + * Depending on the type, you can interpret %NMKeyfileHandlerData. + * + * Since: 1.30 + */ +typedef enum { + NM_KEYFILE_HANDLER_TYPE_WARN = 1, + NM_KEYFILE_HANDLER_TYPE_WRITE_CERT = 2, +} NMKeyfileHandlerType; + +/** + * NMKeyfileHandlerData: + * + * Opaque type with parameters for the callback. The actual content + * depends on the %NMKeyfileHandlerType. + * + * Since: 1.30 + */ +typedef struct _NMKeyfileHandlerData NMKeyfileHandlerData; + +/** + * NMKeyfileReadHandler: + * @keyfile: the #GKeyFile that is currently read + * @connection: the #NMConnection that is being constructed. + * @handler_type: the %NMKeyfileHandlerType that indicates which type + * the request is. + * @handler_data: the #NMKeyfileHandlerData. What you can do with it + * depends on the @handler_type. + * @user_data: the user-data argument to nm_keyfile_read(). + * + * Hook to nm_keyfile_read(). + * + * The callee may abort the reading by setting an error via nm_keyfile_handler_data_fail_with_error(). + * + * Returns: the callee should return TRUE, if the event was handled and/or recognized. + * Otherwise, a default action will be performed that depends on the @type. + * For %NM_KEYFILE_HANDLER_TYPE_WARN type, the default action is doing nothing. + * + * Since: 1.30 + */ +typedef gboolean (*NMKeyfileReadHandler)(GKeyFile * keyfile, + NMConnection * connection, + NMKeyfileHandlerType handler_type, + NMKeyfileHandlerData *handler_data, + void * user_data); + +NM_AVAILABLE_IN_1_30 +NMConnection *nm_keyfile_read(GKeyFile * keyfile, + const char * base_dir, + NMKeyfileHandlerFlags handler_flags, + NMKeyfileReadHandler handler, + void * user_data, + GError ** error); + +/** + * NMKeyfileWriteHandler: + * @connection: the #NMConnection that is currently written. + * @keyfile: the #GKeyFile that is currently constructed. + * @handler_type: the %NMKeyfileHandlerType that indicates which type + * the request is. + * @handler_data: the #NMKeyfileHandlerData. What you can do with it + * depends on the @handler_type. + * @user_data: the user-data argument to nm_keyfile_read(). + * + * This is a hook to tweak the serialization. + * + * Handler for certain properties or events that are not entirely contained + * within the keyfile or that might be serialized differently. The @type and + * @handler_data arguments tell which kind of argument we have at hand. + * + * Currently only the type %NM_KEYFILE_HANDLER_TYPE_WRITE_CERT is supported. + * + * The callee may call nm_keyfile_handler_data_fail_with_error() to abort + * the writing with error. + * + * Returns: the callee should return %TRUE if the event was handled. If the + * event was unhandled, a default action will be performed that depends on + * the @handler_type. + * + * Since: 1.30 + */ +typedef gboolean (*NMKeyfileWriteHandler)(NMConnection * connection, + GKeyFile * keyfile, + NMKeyfileHandlerType handler_type, + NMKeyfileHandlerData *handler_data, + void * user_data); + +NM_AVAILABLE_IN_1_30 +GKeyFile *nm_keyfile_write(NMConnection * connection, + NMKeyfileHandlerFlags handler_flags, + NMKeyfileWriteHandler handler, + void * user_data, + GError ** error); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_30 +void nm_keyfile_handler_data_fail_with_error(NMKeyfileHandlerData *handler_data, GError *src); + +NM_AVAILABLE_IN_1_30 +void nm_keyfile_handler_data_get_context(const NMKeyfileHandlerData *handler_data, + const char ** out_kf_group_name, + const char ** out_kf_key_name, + NMSetting ** out_cur_setting, + const char ** out_cur_property_name); + +/** + * NMKeyfileWarnSeverity: + * @NM_KEYFILE_WARN_SEVERITY_DEBUG: debug message + * @NM_KEYFILE_WARN_SEVERITY_INFO: info message + * @NM_KEYFILE_WARN_SEVERITY_INFO_MISSING_FILE: info message about a missing file + * @NM_KEYFILE_WARN_SEVERITY_WARN: a warning message + * + * The severity level of %NM_KEYFILE_HANDLER_TYPE_WARN events. + * + * Since: 1.30 + */ +typedef enum { + NM_KEYFILE_WARN_SEVERITY_DEBUG = 1000, + NM_KEYFILE_WARN_SEVERITY_INFO = 2000, + NM_KEYFILE_WARN_SEVERITY_INFO_MISSING_FILE = 2901, + NM_KEYFILE_WARN_SEVERITY_WARN = 3000, +} NMKeyfileWarnSeverity; + +NM_AVAILABLE_IN_1_30 +void nm_keyfile_handler_data_warn_get(const NMKeyfileHandlerData *handler_data, + const char ** out_message, + NMKeyfileWarnSeverity * out_severity); + +G_END_DECLS + +#endif /* __NM_KEYFILE_H__ */ diff --git a/src/libnm-core-public/nm-setting-6lowpan.h b/src/libnm-core-public/nm-setting-6lowpan.h new file mode 100644 index 0000000000..5a7c39866b --- /dev/null +++ b/src/libnm-core-public/nm-setting-6lowpan.h @@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2018 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_6LOWPAN_H__ +#define __NM_SETTING_6LOWPAN_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_6LOWPAN (nm_setting_6lowpan_get_type()) +#define NM_SETTING_6LOWPAN(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_6LOWPAN, NMSetting6Lowpan)) +#define NM_SETTING_6LOWPAN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_6LOWPANCONFIG, NMSetting6LowpanClass)) +#define NM_IS_SETTING_6LOWPAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_6LOWPAN)) +#define NM_IS_SETTING_6LOWPAN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_6LOWPAN)) +#define NM_SETTING_6LOWPAN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_6LOWPAN, NMSetting6LowpanClass)) + +#define NM_SETTING_6LOWPAN_SETTING_NAME "6lowpan" + +#define NM_SETTING_6LOWPAN_PARENT "parent" + +typedef struct _NMSetting6LowpanClass NMSetting6LowpanClass; + +NM_AVAILABLE_IN_1_14 +GType nm_setting_6lowpan_get_type(void); +NM_AVAILABLE_IN_1_14 +NMSetting *nm_setting_6lowpan_new(void); + +NM_AVAILABLE_IN_1_14 +const char *nm_setting_6lowpan_get_parent(NMSetting6Lowpan *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_6LOWPAN_H__ */ diff --git a/src/libnm-core-public/nm-setting-8021x.h b/src/libnm-core-public/nm-setting-8021x.h new file mode 100644 index 0000000000..30b725be59 --- /dev/null +++ b/src/libnm-core-public/nm-setting-8021x.h @@ -0,0 +1,366 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2014 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_8021X_H__ +#define __NM_SETTING_8021X_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_SETTING_802_1X_CERT_SCHEME_PREFIX_PATH "file://" +#define NM_SETTING_802_1X_CERT_SCHEME_PREFIX_PKCS11 "pkcs11:" + +/** + * NMSetting8021xCKFormat: + * @NM_SETTING_802_1X_CK_FORMAT_UNKNOWN: unknown file format + * @NM_SETTING_802_1X_CK_FORMAT_X509: file contains an X.509 format certificate + * @NM_SETTING_802_1X_CK_FORMAT_RAW_KEY: file contains an old-style OpenSSL PEM + * or DER private key + * @NM_SETTING_802_1X_CK_FORMAT_PKCS12: file contains a PKCS#<!-- -->12 certificate + * and private key + * + * #NMSetting8021xCKFormat values indicate the general type of a certificate + * or private key + */ +typedef enum { /*< underscore_name=nm_setting_802_1x_ck_format >*/ + NM_SETTING_802_1X_CK_FORMAT_UNKNOWN = 0, + NM_SETTING_802_1X_CK_FORMAT_X509, + NM_SETTING_802_1X_CK_FORMAT_RAW_KEY, + NM_SETTING_802_1X_CK_FORMAT_PKCS12 +} NMSetting8021xCKFormat; + +/** + * NMSetting8021xCKScheme: + * @NM_SETTING_802_1X_CK_SCHEME_UNKNOWN: unknown certificate or private key + * scheme + * @NM_SETTING_802_1X_CK_SCHEME_BLOB: certificate or key is stored as the raw + * item data + * @NM_SETTING_802_1X_CK_SCHEME_PATH: certificate or key is stored as a path + * to a file containing the certificate or key data + * @NM_SETTING_802_1X_CK_SCHEME_PKCS11: certificate or key is stored as a + * URI of an object on a PKCS#11 token + * + * #NMSetting8021xCKScheme values indicate how a certificate or private key is + * stored in the setting properties, either as a blob of the item's data, or as + * a path to a certificate or private key file on the filesystem + */ +typedef enum { /*< underscore_name=nm_setting_802_1x_ck_scheme >*/ + NM_SETTING_802_1X_CK_SCHEME_UNKNOWN = 0, + NM_SETTING_802_1X_CK_SCHEME_BLOB, + NM_SETTING_802_1X_CK_SCHEME_PATH, + NM_SETTING_802_1X_CK_SCHEME_PKCS11, +} NMSetting8021xCKScheme; + +/** + * NMSetting8021xAuthFlags: + * @NM_SETTING_802_1X_AUTH_FLAGS_NONE: No flags + * @NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_0_DISABLE: Disable TLSv1.0 + * @NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_1_DISABLE: Disable TLSv1.1 + * @NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_2_DISABLE: Disable TLSv1.2 + * @NM_SETTING_802_1X_AUTH_FLAGS_ALL: All supported flags + * + * #NMSetting8021xAuthFlags values indicate which authentication settings + * should be used. + * + * Before 1.22, this was wrongly marked as a enum and not as a flags + * type. + * + * Since: 1.8 + */ +typedef enum { /*< flags, underscore_name=nm_setting_802_1x_auth_flags >*/ + NM_SETTING_802_1X_AUTH_FLAGS_NONE = 0, + NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_0_DISABLE = 0x1, + NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_1_DISABLE = 0x2, + NM_SETTING_802_1X_AUTH_FLAGS_TLS_1_2_DISABLE = 0x4, + + NM_SETTING_802_1X_AUTH_FLAGS_ALL = 0x7, +} NMSetting8021xAuthFlags; + +#define NM_TYPE_SETTING_802_1X (nm_setting_802_1x_get_type()) +#define NM_SETTING_802_1X(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_802_1X, NMSetting8021x)) +#define NM_SETTING_802_1X_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_802_1X, NMSetting8021xClass)) +#define NM_IS_SETTING_802_1X(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_802_1X)) +#define NM_IS_SETTING_802_1X_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_802_1X)) +#define NM_SETTING_802_1X_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_802_1X, NMSetting8021xClass)) + +#define NM_SETTING_802_1X_SETTING_NAME "802-1x" + +#define NM_SETTING_802_1X_EAP "eap" +#define NM_SETTING_802_1X_IDENTITY "identity" +#define NM_SETTING_802_1X_ANONYMOUS_IDENTITY "anonymous-identity" +#define NM_SETTING_802_1X_PAC_FILE "pac-file" +#define NM_SETTING_802_1X_CA_CERT "ca-cert" +#define NM_SETTING_802_1X_CA_CERT_PASSWORD "ca-cert-password" +#define NM_SETTING_802_1X_CA_CERT_PASSWORD_FLAGS "ca-cert-password-flags" +#define NM_SETTING_802_1X_CA_PATH "ca-path" +#define NM_SETTING_802_1X_SUBJECT_MATCH "subject-match" +#define NM_SETTING_802_1X_ALTSUBJECT_MATCHES "altsubject-matches" +#define NM_SETTING_802_1X_DOMAIN_SUFFIX_MATCH "domain-suffix-match" +#define NM_SETTING_802_1X_DOMAIN_MATCH "domain-match" +#define NM_SETTING_802_1X_CLIENT_CERT "client-cert" +#define NM_SETTING_802_1X_CLIENT_CERT_PASSWORD "client-cert-password" +#define NM_SETTING_802_1X_CLIENT_CERT_PASSWORD_FLAGS "client-cert-password-flags" +#define NM_SETTING_802_1X_PHASE1_PEAPVER "phase1-peapver" +#define NM_SETTING_802_1X_PHASE1_PEAPLABEL "phase1-peaplabel" +#define NM_SETTING_802_1X_PHASE1_FAST_PROVISIONING "phase1-fast-provisioning" +#define NM_SETTING_802_1X_PHASE1_AUTH_FLAGS "phase1-auth-flags" +#define NM_SETTING_802_1X_PHASE2_AUTH "phase2-auth" +#define NM_SETTING_802_1X_PHASE2_AUTHEAP "phase2-autheap" +#define NM_SETTING_802_1X_PHASE2_CA_CERT "phase2-ca-cert" +#define NM_SETTING_802_1X_PHASE2_CA_CERT_PASSWORD "phase2-ca-cert-password" +#define NM_SETTING_802_1X_PHASE2_CA_CERT_PASSWORD_FLAGS "phase2-ca-cert-password-flags" +#define NM_SETTING_802_1X_PHASE2_CA_PATH "phase2-ca-path" +#define NM_SETTING_802_1X_PHASE2_SUBJECT_MATCH "phase2-subject-match" +#define NM_SETTING_802_1X_PHASE2_ALTSUBJECT_MATCHES "phase2-altsubject-matches" +#define NM_SETTING_802_1X_PHASE2_DOMAIN_SUFFIX_MATCH "phase2-domain-suffix-match" +#define NM_SETTING_802_1X_PHASE2_DOMAIN_MATCH "phase2-domain-match" +#define NM_SETTING_802_1X_PHASE2_CLIENT_CERT "phase2-client-cert" +#define NM_SETTING_802_1X_PHASE2_CLIENT_CERT_PASSWORD "phase2-client-cert-password" +#define NM_SETTING_802_1X_PHASE2_CLIENT_CERT_PASSWORD_FLAGS "phase2-client-cert-password-flags" +#define NM_SETTING_802_1X_PASSWORD "password" +#define NM_SETTING_802_1X_PASSWORD_FLAGS "password-flags" +#define NM_SETTING_802_1X_PASSWORD_RAW "password-raw" +#define NM_SETTING_802_1X_PASSWORD_RAW_FLAGS "password-raw-flags" +#define NM_SETTING_802_1X_PRIVATE_KEY "private-key" +#define NM_SETTING_802_1X_PRIVATE_KEY_PASSWORD "private-key-password" +#define NM_SETTING_802_1X_PRIVATE_KEY_PASSWORD_FLAGS "private-key-password-flags" +#define NM_SETTING_802_1X_PHASE2_PRIVATE_KEY "phase2-private-key" +#define NM_SETTING_802_1X_PHASE2_PRIVATE_KEY_PASSWORD "phase2-private-key-password" +#define NM_SETTING_802_1X_PHASE2_PRIVATE_KEY_PASSWORD_FLAGS "phase2-private-key-password-flags" +#define NM_SETTING_802_1X_PIN "pin" +#define NM_SETTING_802_1X_PIN_FLAGS "pin-flags" +#define NM_SETTING_802_1X_SYSTEM_CA_CERTS "system-ca-certs" +#define NM_SETTING_802_1X_AUTH_TIMEOUT "auth-timeout" +#define NM_SETTING_802_1X_OPTIONAL "optional" + +/* PRIVATE KEY NOTE: when setting PKCS#12 private keys directly via properties + * using the "blob" scheme, the data must be passed in PKCS#12 binary format. + * In this case, the appropriate "client-cert" (or "phase2-client-cert") + * property of the NMSetting8021x object must also contain the exact same + * PKCS#12 binary data that the private key does. This is because the + * PKCS#12 file contains both the private key and client certificate, so both + * properties need to be set to the same thing. When using the "path" scheme, + * just set both the private-key and client-cert properties to the same path. + * + * When setting OpenSSL-derived "traditional" format (ie S/MIME style, not + * PKCS#8) RSA and DSA keys directly via properties with the "blob" scheme, they + * should be passed to NetworkManager in PEM format with the "DEK-Info" and + * "Proc-Type" tags intact. Decrypted private keys should not be used as this + * is insecure and could allow unprivileged users to access the decrypted + * private key data. + * + * When using the "path" scheme, just set the private-key and client-cert + * properties to the paths to their respective objects. + */ + +/** + * NMSetting8021x: + * + * IEEE 802.1x Authentication Settings + */ +struct _NMSetting8021x { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSetting8021xClass; + +GType nm_setting_802_1x_get_type(void); + +NMSetting *nm_setting_802_1x_new(void); + +NM_AVAILABLE_IN_1_2 +NMSetting8021xCKScheme +nm_setting_802_1x_check_cert_scheme(gconstpointer pdata, gsize length, GError **error); + +guint32 nm_setting_802_1x_get_num_eap_methods(NMSetting8021x *setting); +const char *nm_setting_802_1x_get_eap_method(NMSetting8021x *setting, guint32 i); +gboolean nm_setting_802_1x_add_eap_method(NMSetting8021x *setting, const char *eap); +void nm_setting_802_1x_remove_eap_method(NMSetting8021x *setting, guint32 i); +gboolean nm_setting_802_1x_remove_eap_method_by_value(NMSetting8021x *setting, const char *eap); +void nm_setting_802_1x_clear_eap_methods(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_identity(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_anonymous_identity(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_pac_file(NMSetting8021x *setting); + +gboolean nm_setting_802_1x_get_system_ca_certs(NMSetting8021x *setting); +const char *nm_setting_802_1x_get_ca_path(NMSetting8021x *setting); +const char *nm_setting_802_1x_get_phase2_ca_path(NMSetting8021x *setting); + +NMSetting8021xCKScheme nm_setting_802_1x_get_ca_cert_scheme(NMSetting8021x *setting); +GBytes * nm_setting_802_1x_get_ca_cert_blob(NMSetting8021x *setting); +const char * nm_setting_802_1x_get_ca_cert_path(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_802_1x_get_ca_cert_uri(NMSetting8021x *setting); +gboolean nm_setting_802_1x_set_ca_cert(NMSetting8021x * setting, + const char * value, + NMSetting8021xCKScheme scheme, + NMSetting8021xCKFormat *out_format, + GError ** error); + +NM_AVAILABLE_IN_1_8 +const char *nm_setting_802_1x_get_ca_cert_password(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_8 +NMSettingSecretFlags nm_setting_802_1x_get_ca_cert_password_flags(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_subject_match(NMSetting8021x *setting); + +guint32 nm_setting_802_1x_get_num_altsubject_matches(NMSetting8021x *setting); +const char *nm_setting_802_1x_get_altsubject_match(NMSetting8021x *setting, guint32 i); +gboolean nm_setting_802_1x_add_altsubject_match(NMSetting8021x *setting, + const char * altsubject_match); +void nm_setting_802_1x_remove_altsubject_match(NMSetting8021x *setting, guint32 i); +gboolean nm_setting_802_1x_remove_altsubject_match_by_value(NMSetting8021x *setting, + const char * altsubject_match); +void nm_setting_802_1x_clear_altsubject_matches(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_802_1x_get_domain_suffix_match(NMSetting8021x *setting); + +NM_AVAILABLE_IN_1_24 +const char *nm_setting_802_1x_get_domain_match(NMSetting8021x *setting); + +NMSetting8021xCKScheme nm_setting_802_1x_get_client_cert_scheme(NMSetting8021x *setting); +GBytes * nm_setting_802_1x_get_client_cert_blob(NMSetting8021x *setting); +const char * nm_setting_802_1x_get_client_cert_path(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_802_1x_get_client_cert_uri(NMSetting8021x *setting); +gboolean nm_setting_802_1x_set_client_cert(NMSetting8021x * setting, + const char * value, + NMSetting8021xCKScheme scheme, + NMSetting8021xCKFormat *out_format, + GError ** error); + +NM_AVAILABLE_IN_1_8 +const char *nm_setting_802_1x_get_client_cert_password(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_8 +NMSettingSecretFlags nm_setting_802_1x_get_client_cert_password_flags(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_phase1_peapver(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_phase1_peaplabel(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_phase1_fast_provisioning(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_phase2_auth(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_phase2_autheap(NMSetting8021x *setting); + +NMSetting8021xCKScheme nm_setting_802_1x_get_phase2_ca_cert_scheme(NMSetting8021x *setting); +GBytes * nm_setting_802_1x_get_phase2_ca_cert_blob(NMSetting8021x *setting); +const char * nm_setting_802_1x_get_phase2_ca_cert_path(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_802_1x_get_phase2_ca_cert_uri(NMSetting8021x *setting); +gboolean nm_setting_802_1x_set_phase2_ca_cert(NMSetting8021x * setting, + const char * value, + NMSetting8021xCKScheme scheme, + NMSetting8021xCKFormat *out_format, + GError ** error); + +NM_AVAILABLE_IN_1_8 +const char *nm_setting_802_1x_get_phase2_ca_cert_password(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_8 +NMSettingSecretFlags nm_setting_802_1x_get_phase2_ca_cert_password_flags(NMSetting8021x *setting); + +const char *nm_setting_802_1x_get_phase2_subject_match(NMSetting8021x *setting); + +guint32 nm_setting_802_1x_get_num_phase2_altsubject_matches(NMSetting8021x *setting); +const char *nm_setting_802_1x_get_phase2_altsubject_match(NMSetting8021x *setting, guint32 i); +gboolean nm_setting_802_1x_add_phase2_altsubject_match(NMSetting8021x *setting, + const char * phase2_altsubject_match); +void nm_setting_802_1x_remove_phase2_altsubject_match(NMSetting8021x *setting, guint32 i); +gboolean + nm_setting_802_1x_remove_phase2_altsubject_match_by_value(NMSetting8021x *setting, + const char * phase2_altsubject_match); +void nm_setting_802_1x_clear_phase2_altsubject_matches(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_802_1x_get_phase2_domain_suffix_match(NMSetting8021x *setting); + +NM_AVAILABLE_IN_1_24 +const char *nm_setting_802_1x_get_phase2_domain_match(NMSetting8021x *setting); + +NMSetting8021xCKScheme nm_setting_802_1x_get_phase2_client_cert_scheme(NMSetting8021x *setting); +GBytes * nm_setting_802_1x_get_phase2_client_cert_blob(NMSetting8021x *setting); +const char * nm_setting_802_1x_get_phase2_client_cert_path(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_802_1x_get_phase2_client_cert_uri(NMSetting8021x *setting); +gboolean nm_setting_802_1x_set_phase2_client_cert(NMSetting8021x * setting, + const char * value, + NMSetting8021xCKScheme scheme, + NMSetting8021xCKFormat *out_format, + GError ** error); + +NM_AVAILABLE_IN_1_8 +const char *nm_setting_802_1x_get_phase2_client_cert_password(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_8 +NMSettingSecretFlags +nm_setting_802_1x_get_phase2_client_cert_password_flags(NMSetting8021x *setting); + +const char * nm_setting_802_1x_get_password(NMSetting8021x *setting); +NMSettingSecretFlags nm_setting_802_1x_get_password_flags(NMSetting8021x *setting); +GBytes * nm_setting_802_1x_get_password_raw(NMSetting8021x *setting); +NMSettingSecretFlags nm_setting_802_1x_get_password_raw_flags(NMSetting8021x *setting); + +const char * nm_setting_802_1x_get_pin(NMSetting8021x *setting); +NMSettingSecretFlags nm_setting_802_1x_get_pin_flags(NMSetting8021x *setting); + +NMSetting8021xCKScheme nm_setting_802_1x_get_private_key_scheme(NMSetting8021x *setting); +GBytes * nm_setting_802_1x_get_private_key_blob(NMSetting8021x *setting); +const char * nm_setting_802_1x_get_private_key_path(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_6 +const char * nm_setting_802_1x_get_private_key_uri(NMSetting8021x *setting); +gboolean nm_setting_802_1x_set_private_key(NMSetting8021x * setting, + const char * value, + const char * password, + NMSetting8021xCKScheme scheme, + NMSetting8021xCKFormat *out_format, + GError ** error); +const char * nm_setting_802_1x_get_private_key_password(NMSetting8021x *setting); +NMSettingSecretFlags nm_setting_802_1x_get_private_key_password_flags(NMSetting8021x *setting); + +NMSetting8021xCKFormat nm_setting_802_1x_get_private_key_format(NMSetting8021x *setting); + +NMSetting8021xCKScheme nm_setting_802_1x_get_phase2_private_key_scheme(NMSetting8021x *setting); +GBytes * nm_setting_802_1x_get_phase2_private_key_blob(NMSetting8021x *setting); +const char * nm_setting_802_1x_get_phase2_private_key_path(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_802_1x_get_phase2_private_key_uri(NMSetting8021x *setting); +gboolean nm_setting_802_1x_set_phase2_private_key(NMSetting8021x * setting, + const char * value, + const char * password, + NMSetting8021xCKScheme scheme, + NMSetting8021xCKFormat *out_format, + GError ** error); +const char *nm_setting_802_1x_get_phase2_private_key_password(NMSetting8021x *setting); +NMSettingSecretFlags +nm_setting_802_1x_get_phase2_private_key_password_flags(NMSetting8021x *setting); + +NMSetting8021xCKFormat nm_setting_802_1x_get_phase2_private_key_format(NMSetting8021x *setting); + +NM_AVAILABLE_IN_1_8 +NMSetting8021xAuthFlags nm_setting_802_1x_get_phase1_auth_flags(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_8 +int nm_setting_802_1x_get_auth_timeout(NMSetting8021x *setting); +NM_AVAILABLE_IN_1_22 +gboolean nm_setting_802_1x_get_optional(NMSetting8021x *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_8021X_H__ */ diff --git a/src/libnm-core-public/nm-setting-adsl.h b/src/libnm-core-public/nm-setting-adsl.h new file mode 100644 index 0000000000..3d8e99c9f1 --- /dev/null +++ b/src/libnm-core-public/nm-setting-adsl.h @@ -0,0 +1,73 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2008 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_ADSL_H__ +#define __NM_SETTING_ADSL_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_ADSL (nm_setting_adsl_get_type()) +#define NM_SETTING_ADSL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_ADSL, NMSettingAdsl)) +#define NM_SETTING_ADSL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_ADSL, NMSettingAdslClass)) +#define NM_IS_SETTING_ADSL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_ADSL)) +#define NM_IS_SETTING_ADSL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_ADSL)) +#define NM_SETTING_ADSL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_ADSL, NMSettingAdslClass)) + +#define NM_SETTING_ADSL_SETTING_NAME "adsl" + +#define NM_SETTING_ADSL_USERNAME "username" +#define NM_SETTING_ADSL_PASSWORD "password" +#define NM_SETTING_ADSL_PASSWORD_FLAGS "password-flags" +#define NM_SETTING_ADSL_PROTOCOL "protocol" +#define NM_SETTING_ADSL_ENCAPSULATION "encapsulation" +#define NM_SETTING_ADSL_VPI "vpi" +#define NM_SETTING_ADSL_VCI "vci" + +#define NM_SETTING_ADSL_PROTOCOL_PPPOA "pppoa" +#define NM_SETTING_ADSL_PROTOCOL_PPPOE "pppoe" +#define NM_SETTING_ADSL_PROTOCOL_IPOATM "ipoatm" + +#define NM_SETTING_ADSL_ENCAPSULATION_VCMUX "vcmux" +#define NM_SETTING_ADSL_ENCAPSULATION_LLC "llc" + +/** + * NMSettingAdsl: + * + * ADSL Settings + */ +struct _NMSettingAdsl { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingAdslClass; + +GType nm_setting_adsl_get_type(void); + +NMSetting * nm_setting_adsl_new(void); +const char * nm_setting_adsl_get_username(NMSettingAdsl *setting); +const char * nm_setting_adsl_get_password(NMSettingAdsl *setting); +const char * nm_setting_adsl_get_protocol(NMSettingAdsl *setting); +const char * nm_setting_adsl_get_encapsulation(NMSettingAdsl *setting); +guint32 nm_setting_adsl_get_vpi(NMSettingAdsl *setting); +guint32 nm_setting_adsl_get_vci(NMSettingAdsl *setting); +NMSettingSecretFlags nm_setting_adsl_get_password_flags(NMSettingAdsl *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_ADSL_H__ */ diff --git a/src/libnm-core-public/nm-setting-bluetooth.h b/src/libnm-core-public/nm-setting-bluetooth.h new file mode 100644 index 0000000000..4f001ef7fe --- /dev/null +++ b/src/libnm-core-public/nm-setting-bluetooth.h @@ -0,0 +1,82 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2009 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_BLUETOOTH_H__ +#define __NM_SETTING_BLUETOOTH_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_BLUETOOTH (nm_setting_bluetooth_get_type()) +#define NM_SETTING_BLUETOOTH(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_BLUETOOTH, NMSettingBluetooth)) +#define NM_SETTING_BLUETOOTH_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_BLUETOOTH, NMSettingBluetoothClass)) +#define NM_IS_SETTING_BLUETOOTH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_BLUETOOTH)) +#define NM_IS_SETTING_BLUETOOTH_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_BLUETOOTH)) +#define NM_SETTING_BLUETOOTH_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_BLUETOOTH, NMSettingBluetoothClass)) + +#define NM_SETTING_BLUETOOTH_SETTING_NAME "bluetooth" + +#define NM_SETTING_BLUETOOTH_BDADDR "bdaddr" +#define NM_SETTING_BLUETOOTH_TYPE "type" + +/** + * NM_SETTING_BLUETOOTH_TYPE_DUN: + * + * Connection type describing a connection to devices that support the Bluetooth + * DUN profile. + */ +#define NM_SETTING_BLUETOOTH_TYPE_DUN "dun" + +/** + * NM_SETTING_BLUETOOTH_TYPE_PANU: + * + * Connection type describing PANU connection to a Bluetooth NAP (Network + * Access Point). + */ +#define NM_SETTING_BLUETOOTH_TYPE_PANU "panu" + +/** + * NM_SETTING_BLUETOOTH_TYPE_NAP: + * + * Connection type describing a Bluetooth NAP (Network Access Point), + * which accepts PANU clients. + */ +#define NM_SETTING_BLUETOOTH_TYPE_NAP "nap" + +/** + * NMSettingBluetooth: + * + * Bluetooth Settings + */ +struct _NMSettingBluetooth { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingBluetoothClass; + +GType nm_setting_bluetooth_get_type(void); + +NMSetting * nm_setting_bluetooth_new(void); +const char *nm_setting_bluetooth_get_bdaddr(NMSettingBluetooth *setting); +const char *nm_setting_bluetooth_get_connection_type(NMSettingBluetooth *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_BLUETOOTH_H__ */ diff --git a/src/libnm-core-public/nm-setting-bond.h b/src/libnm-core-public/nm-setting-bond.h new file mode 100644 index 0000000000..25ae8c36e7 --- /dev/null +++ b/src/libnm-core-public/nm-setting-bond.h @@ -0,0 +1,99 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2011 - 2013 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_BOND_H__ +#define __NM_SETTING_BOND_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_BOND (nm_setting_bond_get_type()) +#define NM_SETTING_BOND(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_BOND, NMSettingBond)) +#define NM_SETTING_BOND_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_BOND, NMSettingBondClass)) +#define NM_IS_SETTING_BOND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_BOND)) +#define NM_IS_SETTING_BOND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_BOND)) +#define NM_SETTING_BOND_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_BOND, NMSettingBondClass)) + +#define NM_SETTING_BOND_SETTING_NAME "bond" + +#define NM_SETTING_BOND_OPTIONS "options" + +/* Valid options for the 'options' property */ +#define NM_SETTING_BOND_OPTION_MODE "mode" +#define NM_SETTING_BOND_OPTION_MIIMON "miimon" +#define NM_SETTING_BOND_OPTION_DOWNDELAY "downdelay" +#define NM_SETTING_BOND_OPTION_UPDELAY "updelay" +#define NM_SETTING_BOND_OPTION_ARP_INTERVAL "arp_interval" +#define NM_SETTING_BOND_OPTION_ARP_IP_TARGET "arp_ip_target" +#define NM_SETTING_BOND_OPTION_ARP_VALIDATE "arp_validate" +#define NM_SETTING_BOND_OPTION_PRIMARY "primary" +#define NM_SETTING_BOND_OPTION_PRIMARY_RESELECT "primary_reselect" +#define NM_SETTING_BOND_OPTION_FAIL_OVER_MAC "fail_over_mac" +#define NM_SETTING_BOND_OPTION_USE_CARRIER "use_carrier" +#define NM_SETTING_BOND_OPTION_AD_SELECT "ad_select" +#define NM_SETTING_BOND_OPTION_XMIT_HASH_POLICY "xmit_hash_policy" +#define NM_SETTING_BOND_OPTION_RESEND_IGMP "resend_igmp" +#define NM_SETTING_BOND_OPTION_LACP_RATE "lacp_rate" +#define NM_SETTING_BOND_OPTION_ACTIVE_SLAVE "active_slave" +#define NM_SETTING_BOND_OPTION_AD_ACTOR_SYS_PRIO "ad_actor_sys_prio" +#define NM_SETTING_BOND_OPTION_AD_ACTOR_SYSTEM "ad_actor_system" +#define NM_SETTING_BOND_OPTION_AD_USER_PORT_KEY "ad_user_port_key" +#define NM_SETTING_BOND_OPTION_ALL_SLAVES_ACTIVE "all_slaves_active" +#define NM_SETTING_BOND_OPTION_ARP_ALL_TARGETS "arp_all_targets" +#define NM_SETTING_BOND_OPTION_MIN_LINKS "min_links" +#define NM_SETTING_BOND_OPTION_NUM_GRAT_ARP "num_grat_arp" +#define NM_SETTING_BOND_OPTION_NUM_UNSOL_NA "num_unsol_na" +#define NM_SETTING_BOND_OPTION_PACKETS_PER_SLAVE "packets_per_slave" +#define NM_SETTING_BOND_OPTION_TLB_DYNAMIC_LB "tlb_dynamic_lb" +#define NM_SETTING_BOND_OPTION_LP_INTERVAL "lp_interval" + +/** + * NMSettingBond: + * + * Bonding Settings + */ +struct _NMSettingBond { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingBondClass; + +GType nm_setting_bond_get_type(void); + +NMSetting * nm_setting_bond_new(void); +guint32 nm_setting_bond_get_num_options(NMSettingBond *setting); +gboolean nm_setting_bond_get_option(NMSettingBond *setting, + guint32 idx, + const char ** out_name, + const char ** out_value); +const char *nm_setting_bond_get_option_by_name(NMSettingBond *setting, const char *name); +gboolean nm_setting_bond_add_option(NMSettingBond *setting, const char *name, const char *value); +gboolean nm_setting_bond_remove_option(NMSettingBond *setting, const char *name); + +gboolean nm_setting_bond_validate_option(const char *name, const char *value); + +const char **nm_setting_bond_get_valid_options(NMSettingBond *setting); + +const char *nm_setting_bond_get_option_default(NMSettingBond *setting, const char *name); + +NM_AVAILABLE_IN_1_24 +const char *nm_setting_bond_get_option_normalized(NMSettingBond *setting, const char *name); + +G_END_DECLS + +#endif /* __NM_SETTING_BOND_H__ */ diff --git a/src/libnm-core-public/nm-setting-bridge-port.h b/src/libnm-core-public/nm-setting-bridge-port.h new file mode 100644 index 0000000000..679131d287 --- /dev/null +++ b/src/libnm-core-public/nm-setting-bridge-port.h @@ -0,0 +1,80 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2012 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_BRIDGE_PORT_H__ +#define __NM_SETTING_BRIDGE_PORT_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" +#include "nm-setting-bridge.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_BRIDGE_PORT (nm_setting_bridge_port_get_type()) +#define NM_SETTING_BRIDGE_PORT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_BRIDGE_PORT, NMSettingBridgePort)) +#define NM_SETTING_BRIDGE_PORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_BRIDGE_PORT, NMSettingBridgePortClass)) +#define NM_IS_SETTING_BRIDGE_PORT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_BRIDGE_PORT)) +#define NM_IS_SETTING_BRIDGE_PORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_BRIDGE_PORT)) +#define NM_SETTING_BRIDGE_PORT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_BRIDGE_PORT, NMSettingBridgePortClass)) + +#define NM_SETTING_BRIDGE_PORT_SETTING_NAME "bridge-port" + +#define NM_SETTING_BRIDGE_PORT_PRIORITY "priority" +#define NM_SETTING_BRIDGE_PORT_PATH_COST "path-cost" +#define NM_SETTING_BRIDGE_PORT_HAIRPIN_MODE "hairpin-mode" +#define NM_SETTING_BRIDGE_PORT_VLANS "vlans" + +/** + * NMSettingBridgePort: + * + * Bridge Port Settings + */ +struct _NMSettingBridgePort { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingBridgePortClass; + +GType nm_setting_bridge_port_get_type(void); + +NMSetting *nm_setting_bridge_port_new(void); + +guint16 nm_setting_bridge_port_get_priority(NMSettingBridgePort *setting); + +guint16 nm_setting_bridge_port_get_path_cost(NMSettingBridgePort *setting); + +gboolean nm_setting_bridge_port_get_hairpin_mode(NMSettingBridgePort *setting); + +NM_AVAILABLE_IN_1_18 +void nm_setting_bridge_port_add_vlan(NMSettingBridgePort *setting, NMBridgeVlan *vlan); +NM_AVAILABLE_IN_1_18 +guint nm_setting_bridge_port_get_num_vlans(NMSettingBridgePort *setting); +NM_AVAILABLE_IN_1_18 +NMBridgeVlan *nm_setting_bridge_port_get_vlan(NMSettingBridgePort *setting, guint idx); +NM_AVAILABLE_IN_1_18 +void nm_setting_bridge_port_remove_vlan(NMSettingBridgePort *setting, guint idx); +NM_AVAILABLE_IN_1_18 +gboolean nm_setting_bridge_port_remove_vlan_by_vid(NMSettingBridgePort *setting, + guint16 vid_start, + guint16 vid_end); +NM_AVAILABLE_IN_1_18 +void nm_setting_bridge_port_clear_vlans(NMSettingBridgePort *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_BRIDGE_PORT_H__ */ diff --git a/src/libnm-core-public/nm-setting-bridge.h b/src/libnm-core-public/nm-setting-bridge.h new file mode 100644 index 0000000000..cda1861294 --- /dev/null +++ b/src/libnm-core-public/nm-setting-bridge.h @@ -0,0 +1,183 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2011 - 2015 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_BRIDGE_H__ +#define __NM_SETTING_BRIDGE_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_BRIDGE (nm_setting_bridge_get_type()) +#define NM_SETTING_BRIDGE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_BRIDGE, NMSettingBridge)) +#define NM_SETTING_BRIDGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_BRIDGE, NMSettingBridgeClass)) +#define NM_IS_SETTING_BRIDGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_BRIDGE)) +#define NM_IS_SETTING_BRIDGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_BRIDGE)) +#define NM_SETTING_BRIDGE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_BRIDGE, NMSettingBridgeClass)) + +#define NM_SETTING_BRIDGE_SETTING_NAME "bridge" + +#define NM_SETTING_BRIDGE_MAC_ADDRESS "mac-address" +#define NM_SETTING_BRIDGE_STP "stp" +#define NM_SETTING_BRIDGE_PRIORITY "priority" +#define NM_SETTING_BRIDGE_FORWARD_DELAY "forward-delay" +#define NM_SETTING_BRIDGE_HELLO_TIME "hello-time" +#define NM_SETTING_BRIDGE_MAX_AGE "max-age" +#define NM_SETTING_BRIDGE_AGEING_TIME "ageing-time" +#define NM_SETTING_BRIDGE_GROUP_FORWARD_MASK "group-forward-mask" +#define NM_SETTING_BRIDGE_MULTICAST_HASH_MAX "multicast-hash-max" +#define NM_SETTING_BRIDGE_MULTICAST_LAST_MEMBER_COUNT "multicast-last-member-count" +#define NM_SETTING_BRIDGE_MULTICAST_LAST_MEMBER_INTERVAL "multicast-last-member-interval" +#define NM_SETTING_BRIDGE_MULTICAST_MEMBERSHIP_INTERVAL "multicast-membership-interval" +#define NM_SETTING_BRIDGE_MULTICAST_SNOOPING "multicast-snooping" +#define NM_SETTING_BRIDGE_MULTICAST_ROUTER "multicast-router" +#define NM_SETTING_BRIDGE_MULTICAST_QUERIER "multicast-querier" +#define NM_SETTING_BRIDGE_MULTICAST_QUERIER_INTERVAL "multicast-querier-interval" +#define NM_SETTING_BRIDGE_MULTICAST_QUERY_INTERVAL "multicast-query-interval" +#define NM_SETTING_BRIDGE_MULTICAST_QUERY_RESPONSE_INTERVAL "multicast-query-response-interval" +#define NM_SETTING_BRIDGE_MULTICAST_QUERY_USE_IFADDR "multicast-query-use-ifaddr" +#define NM_SETTING_BRIDGE_MULTICAST_STARTUP_QUERY_COUNT "multicast-startup-query-count" +#define NM_SETTING_BRIDGE_MULTICAST_STARTUP_QUERY_INTERVAL "multicast-startup-query-interval" +#define NM_SETTING_BRIDGE_VLAN_FILTERING "vlan-filtering" +#define NM_SETTING_BRIDGE_VLAN_DEFAULT_PVID "vlan-default-pvid" +#define NM_SETTING_BRIDGE_VLANS "vlans" +#define NM_SETTING_BRIDGE_GROUP_ADDRESS "group-address" +#define NM_SETTING_BRIDGE_VLAN_PROTOCOL "vlan-protocol" +#define NM_SETTING_BRIDGE_VLAN_STATS_ENABLED "vlan-stats-enabled" + +#define NM_BRIDGE_VLAN_VID_MIN 1 +#define NM_BRIDGE_VLAN_VID_MAX 4094 + +typedef struct _NMSettingBridgeClass NMSettingBridgeClass; + +typedef struct _NMBridgeVlan NMBridgeVlan; + +GType nm_setting_bridge_get_type(void); + +NMSetting *nm_setting_bridge_new(void); + +const char *nm_setting_bridge_get_mac_address(NMSettingBridge *setting); + +gboolean nm_setting_bridge_get_stp(NMSettingBridge *setting); + +guint16 nm_setting_bridge_get_priority(NMSettingBridge *setting); + +guint16 nm_setting_bridge_get_forward_delay(NMSettingBridge *setting); + +guint16 nm_setting_bridge_get_hello_time(NMSettingBridge *setting); + +guint16 nm_setting_bridge_get_max_age(NMSettingBridge *setting); + +guint32 nm_setting_bridge_get_ageing_time(NMSettingBridge *setting); +NM_AVAILABLE_IN_1_10 +guint16 nm_setting_bridge_get_group_forward_mask(NMSettingBridge *setting); + +gboolean nm_setting_bridge_get_multicast_snooping(NMSettingBridge *setting); +NM_AVAILABLE_IN_1_18 +gboolean nm_setting_bridge_get_vlan_filtering(NMSettingBridge *setting); +NM_AVAILABLE_IN_1_18 +guint16 nm_setting_bridge_get_vlan_default_pvid(NMSettingBridge *setting); +NM_AVAILABLE_IN_1_18 +void nm_setting_bridge_add_vlan(NMSettingBridge *setting, NMBridgeVlan *vlan); +NM_AVAILABLE_IN_1_18 +guint nm_setting_bridge_get_num_vlans(NMSettingBridge *setting); +NM_AVAILABLE_IN_1_18 +NMBridgeVlan *nm_setting_bridge_get_vlan(NMSettingBridge *setting, guint idx); +NM_AVAILABLE_IN_1_18 +void nm_setting_bridge_remove_vlan(NMSettingBridge *setting, guint idx); +NM_AVAILABLE_IN_1_18 +gboolean +nm_setting_bridge_remove_vlan_by_vid(NMSettingBridge *setting, guint16 vid_start, guint16 vid_end); +NM_AVAILABLE_IN_1_18 +void nm_setting_bridge_clear_vlans(NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_18 +GType nm_bridge_vlan_get_type(void); +NM_AVAILABLE_IN_1_18 +NMBridgeVlan *nm_bridge_vlan_new(guint16 vid_start, guint16 vid_end); +NM_AVAILABLE_IN_1_18 +NMBridgeVlan *nm_bridge_vlan_ref(NMBridgeVlan *vlan); +NM_AVAILABLE_IN_1_18 +void nm_bridge_vlan_unref(NMBridgeVlan *vlan); +NM_AVAILABLE_IN_1_18 +NMBridgeVlan *nm_bridge_vlan_new_clone(const NMBridgeVlan *vlan); +NM_AVAILABLE_IN_1_18 +int nm_bridge_vlan_cmp(const NMBridgeVlan *a, const NMBridgeVlan *b); +NM_AVAILABLE_IN_1_18 +void nm_bridge_vlan_seal(NMBridgeVlan *vlan); +NM_AVAILABLE_IN_1_18 +gboolean nm_bridge_vlan_is_sealed(const NMBridgeVlan *vlan); +NM_AVAILABLE_IN_1_18 +void nm_bridge_vlan_set_untagged(NMBridgeVlan *vlan, gboolean value); +NM_AVAILABLE_IN_1_18 +void nm_bridge_vlan_set_pvid(NMBridgeVlan *vlan, gboolean value); +NM_AVAILABLE_IN_1_18 +gboolean +nm_bridge_vlan_get_vid_range(const NMBridgeVlan *vlan, guint16 *vid_start, guint16 *vid_end); +NM_AVAILABLE_IN_1_18 +gboolean nm_bridge_vlan_is_untagged(const NMBridgeVlan *vlan); +NM_AVAILABLE_IN_1_18 +gboolean nm_bridge_vlan_is_pvid(const NMBridgeVlan *vlan); + +NM_AVAILABLE_IN_1_18 +char *nm_bridge_vlan_to_str(const NMBridgeVlan *vlan, GError **error); +NM_AVAILABLE_IN_1_18 +NMBridgeVlan *nm_bridge_vlan_from_str(const char *str, GError **error); + +NM_AVAILABLE_IN_1_24 +const char *nm_setting_bridge_get_group_address(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_24 +const char *nm_setting_bridge_get_vlan_protocol(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_24 +gboolean nm_setting_bridge_get_vlan_stats_enabled(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_24 +const char *nm_setting_bridge_get_multicast_router(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_24 +gboolean nm_setting_bridge_get_multicast_query_use_ifaddr(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_24 +gboolean nm_setting_bridge_get_multicast_querier(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint32 nm_setting_bridge_get_multicast_hash_max(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint32 nm_setting_bridge_get_multicast_last_member_count(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint64 nm_setting_bridge_get_multicast_last_member_interval(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint64 nm_setting_bridge_get_multicast_membership_interval(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint64 nm_setting_bridge_get_multicast_querier_interval(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint64 nm_setting_bridge_get_multicast_query_interval(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint64 nm_setting_bridge_get_multicast_query_response_interval(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint32 nm_setting_bridge_get_multicast_startup_query_count(const NMSettingBridge *setting); + +NM_AVAILABLE_IN_1_26 +guint64 nm_setting_bridge_get_multicast_startup_query_interval(const NMSettingBridge *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_BRIDGE_H__ */ diff --git a/src/libnm-core-public/nm-setting-cdma.h b/src/libnm-core-public/nm-setting-cdma.h new file mode 100644 index 0000000000..67784e8963 --- /dev/null +++ b/src/libnm-core-public/nm-setting-cdma.h @@ -0,0 +1,65 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2011 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_CDMA_H__ +#define __NM_SETTING_CDMA_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_CDMA (nm_setting_cdma_get_type()) +#define NM_SETTING_CDMA(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_CDMA, NMSettingCdma)) +#define NM_SETTING_CDMA_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_CDMA, NMSettingCdmaClass)) +#define NM_IS_SETTING_CDMA(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_CDMA)) +#define NM_IS_SETTING_CDMA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_CDMA)) +#define NM_SETTING_CDMA_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_CDMA, NMSettingCdmaClass)) + +#define NM_SETTING_CDMA_SETTING_NAME "cdma" + +#define NM_SETTING_CDMA_NUMBER "number" +#define NM_SETTING_CDMA_USERNAME "username" +#define NM_SETTING_CDMA_PASSWORD "password" +#define NM_SETTING_CDMA_PASSWORD_FLAGS "password-flags" +#define NM_SETTING_CDMA_MTU "mtu" + +/** + * NMSettingCdma: + * + * CDMA-based Mobile Broadband Settings + */ +struct _NMSettingCdma { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingCdmaClass; + +GType nm_setting_cdma_get_type(void); + +NMSetting * nm_setting_cdma_new(void); +const char * nm_setting_cdma_get_number(NMSettingCdma *setting); +const char * nm_setting_cdma_get_username(NMSettingCdma *setting); +const char * nm_setting_cdma_get_password(NMSettingCdma *setting); +NMSettingSecretFlags nm_setting_cdma_get_password_flags(NMSettingCdma *setting); + +NM_AVAILABLE_IN_1_8 +guint32 nm_setting_cdma_get_mtu(NMSettingCdma *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_CDMA_H__ */ diff --git a/src/libnm-core-public/nm-setting-connection.h b/src/libnm-core-public/nm-setting-connection.h new file mode 100644 index 0000000000..34b40a4ff0 --- /dev/null +++ b/src/libnm-core-public/nm-setting-connection.h @@ -0,0 +1,219 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2014 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_CONNECTION_H__ +#define __NM_SETTING_CONNECTION_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_CONNECTION (nm_setting_connection_get_type()) +#define NM_SETTING_CONNECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_CONNECTION, NMSettingConnection)) +#define NM_SETTING_CONNECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_CONNECTION, NMSettingConnectionClass)) +#define NM_IS_SETTING_CONNECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_CONNECTION)) +#define NM_IS_SETTING_CONNECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_CONNECTION)) +#define NM_SETTING_CONNECTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_CONNECTION, NMSettingConnectionClass)) + +#define NM_SETTING_CONNECTION_SETTING_NAME "connection" + +#define NM_SETTING_CONNECTION_AUTOCONNECT_PRIORITY_MIN -999 +#define NM_SETTING_CONNECTION_AUTOCONNECT_PRIORITY_MAX 999 +#define NM_SETTING_CONNECTION_AUTOCONNECT_PRIORITY_DEFAULT 0 + +#define NM_SETTING_CONNECTION_ID "id" +#define NM_SETTING_CONNECTION_UUID "uuid" +#define NM_SETTING_CONNECTION_STABLE_ID "stable-id" +#define NM_SETTING_CONNECTION_INTERFACE_NAME "interface-name" +#define NM_SETTING_CONNECTION_TYPE "type" +#define NM_SETTING_CONNECTION_AUTOCONNECT "autoconnect" +#define NM_SETTING_CONNECTION_AUTOCONNECT_PRIORITY "autoconnect-priority" +#define NM_SETTING_CONNECTION_AUTOCONNECT_RETRIES "autoconnect-retries" +#define NM_SETTING_CONNECTION_MULTI_CONNECT "multi-connect" +#define NM_SETTING_CONNECTION_TIMESTAMP "timestamp" +#define NM_SETTING_CONNECTION_READ_ONLY "read-only" +#define NM_SETTING_CONNECTION_PERMISSIONS "permissions" +#define NM_SETTING_CONNECTION_ZONE "zone" +#define NM_SETTING_CONNECTION_MASTER "master" +#define NM_SETTING_CONNECTION_SLAVE_TYPE "slave-type" +#define NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES "autoconnect-slaves" +#define NM_SETTING_CONNECTION_SECONDARIES "secondaries" +#define NM_SETTING_CONNECTION_GATEWAY_PING_TIMEOUT "gateway-ping-timeout" +#define NM_SETTING_CONNECTION_METERED "metered" +#define NM_SETTING_CONNECTION_LLDP "lldp" +#define NM_SETTING_CONNECTION_AUTH_RETRIES "auth-retries" +#define NM_SETTING_CONNECTION_MDNS "mdns" +#define NM_SETTING_CONNECTION_LLMNR "llmnr" +#define NM_SETTING_CONNECTION_WAIT_DEVICE_TIMEOUT "wait-device-timeout" +#define NM_SETTING_CONNECTION_MUD_URL "mud-url" + +/* Types for property values */ +/** + * NMSettingConnectionAutoconnectSlaves: + * @NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_DEFAULT: default value + * @NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_NO: slaves are not brought up when + * master is activated + * @NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_YES: slaves are brought up when + * master is activated + * + * #NMSettingConnectionAutoconnectSlaves values indicate whether slave connections + * should be activated when master is activated. + */ +typedef enum { + NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_DEFAULT = -1, + NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_NO = 0, + NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_YES = 1, +} NMSettingConnectionAutoconnectSlaves; + +/** + * NMSettingConnectionLldp: + * @NM_SETTING_CONNECTION_LLDP_DEFAULT: default value + * @NM_SETTING_CONNECTION_LLDP_DISABLE: disable LLDP + * @NM_SETTING_CONNECTION_LLDP_ENABLE_RX: enable reception of LLDP frames + * + * #NMSettingConnectionLldp values indicate whether LLDP should be enabled. + */ +typedef enum { + NM_SETTING_CONNECTION_LLDP_DEFAULT = -1, + NM_SETTING_CONNECTION_LLDP_DISABLE = 0, + NM_SETTING_CONNECTION_LLDP_ENABLE_RX = 1, +} NMSettingConnectionLldp; + +/** + * NMSettingConnectionMdns: + * @NM_SETTING_CONNECTION_MDNS_DEFAULT: default value + * @NM_SETTING_CONNECTION_MDNS_NO: disable mDNS + * @NM_SETTING_CONNECTION_MDNS_RESOLVE: support only resolving, do not register hostname + * @NM_SETTING_CONNECTION_MDNS_YES: enable mDNS + * + * #NMSettingConnectionMdns values indicate whether mDNS should be enabled. + * + * Since: 1.12 + */ +typedef enum { + NM_SETTING_CONNECTION_MDNS_DEFAULT = -1, + NM_SETTING_CONNECTION_MDNS_NO = 0, + NM_SETTING_CONNECTION_MDNS_RESOLVE = 1, + NM_SETTING_CONNECTION_MDNS_YES = 2, +} NMSettingConnectionMdns; + +/** + * NMSettingConnectionLlmnr: + * @NM_SETTING_CONNECTION_LLMNR_DEFAULT: default value + * @NM_SETTING_CONNECTION_LLMNR_NO: disable LLMNR + * @NM_SETTING_CONNECTION_LLMNR_RESOLVE: support only resolving, do not register hostname + * @NM_SETTING_CONNECTION_LLMNR_YES: enable LLMNR + * + * #NMSettingConnectionLlmnr values indicate whether LLMNR should be enabled. + * + * Since: 1.14 + */ +typedef enum { + NM_SETTING_CONNECTION_LLMNR_DEFAULT = -1, + NM_SETTING_CONNECTION_LLMNR_NO = 0, + NM_SETTING_CONNECTION_LLMNR_RESOLVE = 1, + NM_SETTING_CONNECTION_LLMNR_YES = 2, +} NMSettingConnectionLlmnr; + +/** + * NMSettingConnection: + * + * General Connection Profile Settings + */ +struct _NMSettingConnection { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingConnectionClass; + +GType nm_setting_connection_get_type(void); + +NMSetting * nm_setting_connection_new(void); +const char *nm_setting_connection_get_id(NMSettingConnection *setting); +const char *nm_setting_connection_get_uuid(NMSettingConnection *setting); +NM_AVAILABLE_IN_1_4 +const char *nm_setting_connection_get_stable_id(NMSettingConnection *setting); +const char *nm_setting_connection_get_interface_name(NMSettingConnection *setting); +const char *nm_setting_connection_get_connection_type(NMSettingConnection *setting); +gboolean nm_setting_connection_get_autoconnect(NMSettingConnection *setting); +int nm_setting_connection_get_autoconnect_priority(NMSettingConnection *setting); +NM_AVAILABLE_IN_1_6 +int nm_setting_connection_get_autoconnect_retries(NMSettingConnection *setting); +NM_AVAILABLE_IN_1_14 +NMConnectionMultiConnect nm_setting_connection_get_multi_connect(NMSettingConnection *setting); +guint64 nm_setting_connection_get_timestamp(NMSettingConnection *setting); +gboolean nm_setting_connection_get_read_only(NMSettingConnection *setting); + +guint32 nm_setting_connection_get_num_permissions(NMSettingConnection *setting); +gboolean nm_setting_connection_get_permission(NMSettingConnection *setting, + guint32 idx, + const char ** out_ptype, + const char ** out_pitem, + const char ** out_detail); +const char *nm_setting_connection_get_zone(NMSettingConnection *setting); +gboolean nm_setting_connection_permissions_user_allowed(NMSettingConnection *setting, + const char * uname); +gboolean nm_setting_connection_add_permission(NMSettingConnection *setting, + const char * ptype, + const char * pitem, + const char * detail); +void nm_setting_connection_remove_permission(NMSettingConnection *setting, guint32 idx); +gboolean nm_setting_connection_remove_permission_by_value(NMSettingConnection *setting, + const char * ptype, + const char * pitem, + const char * detail); + +const char *nm_setting_connection_get_master(NMSettingConnection *setting); +gboolean nm_setting_connection_is_slave_type(NMSettingConnection *setting, const char *type); +const char *nm_setting_connection_get_slave_type(NMSettingConnection *setting); +NM_AVAILABLE_IN_1_2 +NMSettingConnectionAutoconnectSlaves +nm_setting_connection_get_autoconnect_slaves(NMSettingConnection *setting); + +guint32 nm_setting_connection_get_num_secondaries(NMSettingConnection *setting); +const char *nm_setting_connection_get_secondary(NMSettingConnection *setting, guint32 idx); +gboolean nm_setting_connection_add_secondary(NMSettingConnection *setting, const char *sec_uuid); +void nm_setting_connection_remove_secondary(NMSettingConnection *setting, guint32 idx); +gboolean nm_setting_connection_remove_secondary_by_value(NMSettingConnection *setting, + const char * sec_uuid); + +guint32 nm_setting_connection_get_gateway_ping_timeout(NMSettingConnection *setting); +NM_AVAILABLE_IN_1_2 +NMMetered nm_setting_connection_get_metered(NMSettingConnection *setting); +NM_AVAILABLE_IN_1_2 +NMSettingConnectionLldp nm_setting_connection_get_lldp(NMSettingConnection *setting); + +NM_AVAILABLE_IN_1_10 +int nm_setting_connection_get_auth_retries(NMSettingConnection *setting); + +NM_AVAILABLE_IN_1_12 +NMSettingConnectionMdns nm_setting_connection_get_mdns(NMSettingConnection *setting); +NM_AVAILABLE_IN_1_14 +NMSettingConnectionLlmnr nm_setting_connection_get_llmnr(NMSettingConnection *setting); + +NM_AVAILABLE_IN_1_20 +gint32 nm_setting_connection_get_wait_device_timeout(NMSettingConnection *setting); + +NM_AVAILABLE_IN_1_26 +const char *nm_setting_connection_get_mud_url(NMSettingConnection *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_CONNECTION_H__ */ diff --git a/src/libnm-core-public/nm-setting-dcb.h b/src/libnm-core-public/nm-setting-dcb.h new file mode 100644 index 0000000000..a33c13ad99 --- /dev/null +++ b/src/libnm-core-public/nm-setting-dcb.h @@ -0,0 +1,146 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_DCB_H__ +#define __NM_SETTING_DCB_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_DCB (nm_setting_dcb_get_type()) +#define NM_SETTING_DCB(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_DCB, NMSettingDcb)) +#define NM_SETTING_DCB_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_DCB, NMSettingDcbClass)) +#define NM_IS_SETTING_DCB(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_DCB)) +#define NM_IS_SETTING_DCB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_DCB)) +#define NM_SETTING_DCB_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_DCB, NMSettingDcbClass)) + +#define NM_SETTING_DCB_SETTING_NAME "dcb" + +/** + * NMSettingDcbFlags: + * @NM_SETTING_DCB_FLAG_NONE: no flag + * @NM_SETTING_DCB_FLAG_ENABLE: the feature is enabled + * @NM_SETTING_DCB_FLAG_ADVERTISE: the feature is advertised + * @NM_SETTING_DCB_FLAG_WILLING: the feature is willing to change based on + * peer configuration advertisements + * + * DCB feature flags. + **/ +typedef enum { /*< flags >*/ + NM_SETTING_DCB_FLAG_NONE = 0x00000000, + NM_SETTING_DCB_FLAG_ENABLE = 0x00000001, + NM_SETTING_DCB_FLAG_ADVERTISE = 0x00000002, + NM_SETTING_DCB_FLAG_WILLING = 0x00000004 +} NMSettingDcbFlags; + +/** + * NM_SETTING_DCB_FCOE_MODE_FABRIC: + * + * Indicates that the FCoE controller should use "fabric" mode (default) + */ +#define NM_SETTING_DCB_FCOE_MODE_FABRIC "fabric" + +/** + * NM_SETTING_DCB_FCOE_MODE_VN2VN: + * + * Indicates that the FCoE controller should use "VN2VN" mode. + */ +#define NM_SETTING_DCB_FCOE_MODE_VN2VN "vn2vn" + +/* Properties */ +#define NM_SETTING_DCB_APP_FCOE_FLAGS "app-fcoe-flags" +#define NM_SETTING_DCB_APP_FCOE_PRIORITY "app-fcoe-priority" +#define NM_SETTING_DCB_APP_FCOE_MODE "app-fcoe-mode" + +#define NM_SETTING_DCB_APP_ISCSI_FLAGS "app-iscsi-flags" +#define NM_SETTING_DCB_APP_ISCSI_PRIORITY "app-iscsi-priority" + +#define NM_SETTING_DCB_APP_FIP_FLAGS "app-fip-flags" +#define NM_SETTING_DCB_APP_FIP_PRIORITY "app-fip-priority" + +#define NM_SETTING_DCB_PRIORITY_FLOW_CONTROL_FLAGS "priority-flow-control-flags" +#define NM_SETTING_DCB_PRIORITY_FLOW_CONTROL "priority-flow-control" + +#define NM_SETTING_DCB_PRIORITY_GROUP_FLAGS "priority-group-flags" +#define NM_SETTING_DCB_PRIORITY_GROUP_ID "priority-group-id" +#define NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH "priority-group-bandwidth" +#define NM_SETTING_DCB_PRIORITY_BANDWIDTH "priority-bandwidth" +#define NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH "priority-strict-bandwidth" +#define NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS "priority-traffic-class" + +/** + * NMSettingDcb: + * + * Data Center Bridging Settings + */ +struct _NMSettingDcb { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingDcbClass; + +GType nm_setting_dcb_get_type(void); + +NMSetting *nm_setting_dcb_new(void); + +NMSettingDcbFlags nm_setting_dcb_get_app_fcoe_flags(NMSettingDcb *setting); +int nm_setting_dcb_get_app_fcoe_priority(NMSettingDcb *setting); +const char * nm_setting_dcb_get_app_fcoe_mode(NMSettingDcb *setting); + +NMSettingDcbFlags nm_setting_dcb_get_app_iscsi_flags(NMSettingDcb *setting); +int nm_setting_dcb_get_app_iscsi_priority(NMSettingDcb *setting); + +NMSettingDcbFlags nm_setting_dcb_get_app_fip_flags(NMSettingDcb *setting); +int nm_setting_dcb_get_app_fip_priority(NMSettingDcb *setting); + +/* Priority Flow Control */ +NMSettingDcbFlags nm_setting_dcb_get_priority_flow_control_flags(NMSettingDcb *setting); +gboolean nm_setting_dcb_get_priority_flow_control(NMSettingDcb *setting, guint user_priority); +void nm_setting_dcb_set_priority_flow_control(NMSettingDcb *setting, + guint user_priority, + gboolean enabled); + +/* Priority Groups */ +NMSettingDcbFlags nm_setting_dcb_get_priority_group_flags(NMSettingDcb *setting); + +guint nm_setting_dcb_get_priority_group_id(NMSettingDcb *setting, guint user_priority); +void +nm_setting_dcb_set_priority_group_id(NMSettingDcb *setting, guint user_priority, guint group_id); + +guint nm_setting_dcb_get_priority_group_bandwidth(NMSettingDcb *setting, guint group_id); +void nm_setting_dcb_set_priority_group_bandwidth(NMSettingDcb *setting, + guint group_id, + guint bandwidth_percent); + +guint nm_setting_dcb_get_priority_bandwidth(NMSettingDcb *setting, guint user_priority); +void nm_setting_dcb_set_priority_bandwidth(NMSettingDcb *setting, + guint user_priority, + guint bandwidth_percent); + +gboolean nm_setting_dcb_get_priority_strict_bandwidth(NMSettingDcb *setting, guint user_priority); +void nm_setting_dcb_set_priority_strict_bandwidth(NMSettingDcb *setting, + guint user_priority, + gboolean strict); + +guint nm_setting_dcb_get_priority_traffic_class(NMSettingDcb *setting, guint user_priority); +void nm_setting_dcb_set_priority_traffic_class(NMSettingDcb *setting, + guint user_priority, + guint traffic_class); + +G_END_DECLS + +#endif /* __NM_SETTING_DCB_H__ */ diff --git a/src/libnm-core-public/nm-setting-dummy.h b/src/libnm-core-public/nm-setting-dummy.h new file mode 100644 index 0000000000..504428e717 --- /dev/null +++ b/src/libnm-core-public/nm-setting-dummy.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_DUMMY_H__ +#define __NM_SETTING_DUMMY_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_DUMMY (nm_setting_dummy_get_type()) +#define NM_SETTING_DUMMY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_DUMMY, NMSettingDummy)) +#define NM_SETTING_DUMMY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_DUMMYCONFIG, NMSettingDummyClass)) +#define NM_IS_SETTING_DUMMY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_DUMMY)) +#define NM_IS_SETTING_DUMMY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_DUMMY)) +#define NM_SETTING_DUMMY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_DUMMY, NMSettingDummyClass)) + +#define NM_SETTING_DUMMY_SETTING_NAME "dummy" + +/** + * NMSettingDummy: + * + * Dummy Link Settings + */ +struct _NMSettingDummy { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingDummyClass; + +NM_AVAILABLE_IN_1_8 +GType nm_setting_dummy_get_type(void); +NM_AVAILABLE_IN_1_8 +NMSetting *nm_setting_dummy_new(void); + +G_END_DECLS + +#endif /* __NM_SETTING_DUMMY_H__ */ diff --git a/src/libnm-core-public/nm-setting-ethtool.h b/src/libnm-core-public/nm-setting-ethtool.h new file mode 100644 index 0000000000..d2310b408e --- /dev/null +++ b/src/libnm-core-public/nm-setting-ethtool.h @@ -0,0 +1,70 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2018 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_ETHTOOL_H__ +#define __NM_SETTING_ETHTOOL_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +NM_AVAILABLE_IN_1_20 +gboolean nm_ethtool_optname_is_feature(const char *optname); + +NM_AVAILABLE_IN_1_26 +gboolean nm_ethtool_optname_is_coalesce(const char *optname); + +NM_AVAILABLE_IN_1_26 +gboolean nm_ethtool_optname_is_ring(const char *optname); + +/*****************************************************************************/ + +#define NM_TYPE_SETTING_ETHTOOL (nm_setting_ethtool_get_type()) +#define NM_SETTING_ETHTOOL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_ETHTOOL, NMSettingEthtool)) +#define NM_SETTING_ETHTOOL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_ETHTOOL, NMSettingEthtoolClass)) +#define NM_IS_SETTING_ETHTOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_ETHTOOL)) +#define NM_IS_SETTING_ETHTOOL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_ETHTOOL)) +#define NM_SETTING_ETHTOOL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_ETHTOOL, NMSettingEthtoolClass)) + +#define NM_SETTING_ETHTOOL_SETTING_NAME "ethtool" + +/*****************************************************************************/ + +typedef struct _NMSettingEthtoolClass NMSettingEthtoolClass; + +NM_AVAILABLE_IN_1_14 +GType nm_setting_ethtool_get_type(void); + +NM_AVAILABLE_IN_1_14 +NMSetting *nm_setting_ethtool_new(void); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_20 +NM_DEPRECATED_IN_1_26 +const char **nm_setting_ethtool_get_optnames(NMSettingEthtool *setting, guint *out_length); + +NM_AVAILABLE_IN_1_14 +NM_DEPRECATED_IN_1_26 +NMTernary nm_setting_ethtool_get_feature(NMSettingEthtool *setting, const char *optname); +NM_AVAILABLE_IN_1_14 +NM_DEPRECATED_IN_1_26 +void +nm_setting_ethtool_set_feature(NMSettingEthtool *setting, const char *optname, NMTernary value); +NM_AVAILABLE_IN_1_14 +NM_DEPRECATED_IN_1_26 +void nm_setting_ethtool_clear_features(NMSettingEthtool *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_ETHTOOL_H__ */ diff --git a/src/libnm-core-public/nm-setting-generic.h b/src/libnm-core-public/nm-setting-generic.h new file mode 100644 index 0000000000..5c0195f2db --- /dev/null +++ b/src/libnm-core-public/nm-setting-generic.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2013 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_GENERIC_H__ +#define __NM_SETTING_GENERIC_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_GENERIC (nm_setting_generic_get_type()) +#define NM_SETTING_GENERIC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_GENERIC, NMSettingGeneric)) +#define NM_SETTING_GENERIC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_GENERIC, NMSettingGenericClass)) +#define NM_IS_SETTING_GENERIC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_GENERIC)) +#define NM_IS_SETTING_GENERIC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_GENERIC)) +#define NM_SETTING_GENERIC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_GENERIC, NMSettingGenericClass)) + +#define NM_SETTING_GENERIC_SETTING_NAME "generic" + +/** + * NMSettingGeneric: + * + * Generic Link Settings + */ +struct _NMSettingGeneric { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingGenericClass; + +GType nm_setting_generic_get_type(void); + +NMSetting *nm_setting_generic_new(void); + +G_END_DECLS + +#endif /* __NM_SETTING_GENERIC_H__ */ diff --git a/src/libnm-core-public/nm-setting-gsm.h b/src/libnm-core-public/nm-setting-gsm.h new file mode 100644 index 0000000000..ed939e7cd2 --- /dev/null +++ b/src/libnm-core-public/nm-setting-gsm.h @@ -0,0 +1,93 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2011 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_GSM_H__ +#define __NM_SETTING_GSM_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_GSM (nm_setting_gsm_get_type()) +#define NM_SETTING_GSM(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_GSM, NMSettingGsm)) +#define NM_SETTING_GSM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_GSM, NMSettingGsmClass)) +#define NM_IS_SETTING_GSM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_GSM)) +#define NM_IS_SETTING_GSM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_GSM)) +#define NM_SETTING_GSM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_GSM, NMSettingGsmClass)) + +#define NM_SETTING_GSM_SETTING_NAME "gsm" + +#define NM_SETTING_GSM_AUTO_CONFIG "auto-config" +#define NM_SETTING_GSM_USERNAME "username" +#define NM_SETTING_GSM_PASSWORD "password" +#define NM_SETTING_GSM_PASSWORD_FLAGS "password-flags" +#define NM_SETTING_GSM_APN "apn" +#define NM_SETTING_GSM_NETWORK_ID "network-id" +#define NM_SETTING_GSM_PIN "pin" +#define NM_SETTING_GSM_PIN_FLAGS "pin-flags" +#define NM_SETTING_GSM_HOME_ONLY "home-only" +#define NM_SETTING_GSM_DEVICE_ID "device-id" +#define NM_SETTING_GSM_SIM_ID "sim-id" +#define NM_SETTING_GSM_SIM_OPERATOR_ID "sim-operator-id" +#define NM_SETTING_GSM_MTU "mtu" + +/* Deprecated */ +#define NM_SETTING_GSM_NUMBER "number" + +/** + * NMSettingGsm: + * + * GSM-based Mobile Broadband Settings + */ +struct _NMSettingGsm { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingGsmClass; + +GType nm_setting_gsm_get_type(void); + +NMSetting *nm_setting_gsm_new(void); + +NM_AVAILABLE_IN_1_22 +gboolean nm_setting_gsm_get_auto_config(NMSettingGsm *setting); + +const char *nm_setting_gsm_get_username(NMSettingGsm *setting); +const char *nm_setting_gsm_get_password(NMSettingGsm *setting); +const char *nm_setting_gsm_get_apn(NMSettingGsm *setting); +const char *nm_setting_gsm_get_network_id(NMSettingGsm *setting); +const char *nm_setting_gsm_get_pin(NMSettingGsm *setting); +gboolean nm_setting_gsm_get_home_only(NMSettingGsm *setting); + +NM_AVAILABLE_IN_1_2 +const char *nm_setting_gsm_get_device_id(NMSettingGsm *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_gsm_get_sim_id(NMSettingGsm *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_gsm_get_sim_operator_id(NMSettingGsm *setting); +NM_AVAILABLE_IN_1_8 +guint32 nm_setting_gsm_get_mtu(NMSettingGsm *setting); + +NM_DEPRECATED_IN_1_16 +const char *nm_setting_gsm_get_number(NMSettingGsm *setting); + +NMSettingSecretFlags nm_setting_gsm_get_pin_flags(NMSettingGsm *setting); +NMSettingSecretFlags nm_setting_gsm_get_password_flags(NMSettingGsm *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_GSM_H__ */ diff --git a/src/libnm-core-public/nm-setting-hostname.h b/src/libnm-core-public/nm-setting-hostname.h new file mode 100644 index 0000000000..02b4e373e4 --- /dev/null +++ b/src/libnm-core-public/nm-setting-hostname.h @@ -0,0 +1,53 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2020 Red Hat, Inc. + */ + +#ifndef NM_SETTING_HOSTNAME_H +#define NM_SETTING_HOSTNAME_H + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_HOSTNAME (nm_setting_hostname_get_type()) +#define NM_SETTING_HOSTNAME(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_HOSTNAME, NMSettingHostname)) +#define NM_SETTING_HOSTNAME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_HOSTNAME, NMSettingHostnameClass)) +#define NM_IS_SETTING_HOSTNAME(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_HOSTNAME)) +#define NM_IS_SETTING_HOSTNAME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_HOSTNAME)) +#define NM_SETTING_HOSTNAME_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_HOSTNAME, NMSettingHostnameClass)) + +#define NM_SETTING_HOSTNAME_SETTING_NAME "hostname" + +#define NM_SETTING_HOSTNAME_PRIORITY "priority" +#define NM_SETTING_HOSTNAME_FROM_DHCP "from-dhcp" +#define NM_SETTING_HOSTNAME_FROM_DNS_LOOKUP "from-dns-lookup" +#define NM_SETTING_HOSTNAME_ONLY_FROM_DEFAULT "only-from-default" + +typedef struct _NMSettingHostnameClass NMSettingHostnameClass; + +NM_AVAILABLE_IN_1_30 +GType nm_setting_hostname_get_type(void); +NM_AVAILABLE_IN_1_30 +NMSetting *nm_setting_hostname_new(void); + +NM_AVAILABLE_IN_1_30 +int nm_setting_hostname_get_priority(NMSettingHostname *setting); +NM_AVAILABLE_IN_1_30 +NMTernary nm_setting_hostname_get_from_dhcp(NMSettingHostname *setting); +NM_AVAILABLE_IN_1_30 +NMTernary nm_setting_hostname_get_from_dns_lookup(NMSettingHostname *setting); +NM_AVAILABLE_IN_1_30 +NMTernary nm_setting_hostname_get_only_from_default(NMSettingHostname *setting); + +G_END_DECLS + +#endif /* NM_SETTING_HOSTNAME_H */ diff --git a/src/libnm-core-public/nm-setting-infiniband.h b/src/libnm-core-public/nm-setting-infiniband.h new file mode 100644 index 0000000000..4a771aef9e --- /dev/null +++ b/src/libnm-core-public/nm-setting-infiniband.h @@ -0,0 +1,66 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2011 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_INFINIBAND_H__ +#define __NM_SETTING_INFINIBAND_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_INFINIBAND (nm_setting_infiniband_get_type()) +#define NM_SETTING_INFINIBAND(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_INFINIBAND, NMSettingInfiniband)) +#define NM_SETTING_INFINIBAND_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_INFINIBAND, NMSettingInfinibandClass)) +#define NM_IS_SETTING_INFINIBAND(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_INFINIBAND)) +#define NM_IS_SETTING_INFINIBAND_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_INFINIBAND)) +#define NM_SETTING_INFINIBAND_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_INFINIBAND, NMSettingInfinibandClass)) + +#define NM_SETTING_INFINIBAND_SETTING_NAME "infiniband" + +#define NM_SETTING_INFINIBAND_MAC_ADDRESS "mac-address" +#define NM_SETTING_INFINIBAND_MTU "mtu" +#define NM_SETTING_INFINIBAND_TRANSPORT_MODE "transport-mode" +#define NM_SETTING_INFINIBAND_P_KEY "p-key" +#define NM_SETTING_INFINIBAND_PARENT "parent" + +/** + * NMSettingInfiniband: + * + * Infiniband Settings + */ +struct _NMSettingInfiniband { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingInfinibandClass; + +GType nm_setting_infiniband_get_type(void); + +NMSetting * nm_setting_infiniband_new(void); +const char *nm_setting_infiniband_get_mac_address(NMSettingInfiniband *setting); +guint32 nm_setting_infiniband_get_mtu(NMSettingInfiniband *setting); +const char *nm_setting_infiniband_get_transport_mode(NMSettingInfiniband *setting); +int nm_setting_infiniband_get_p_key(NMSettingInfiniband *setting); +const char *nm_setting_infiniband_get_parent(NMSettingInfiniband *setting); + +const char *nm_setting_infiniband_get_virtual_interface_name(NMSettingInfiniband *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_INFINIBAND_H__ */ diff --git a/src/libnm-core-public/nm-setting-ip-config.h b/src/libnm-core-public/nm-setting-ip-config.h new file mode 100644 index 0000000000..1cb1671714 --- /dev/null +++ b/src/libnm-core-public/nm-setting-ip-config.h @@ -0,0 +1,494 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2014 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef NM_SETTING_IP_CONFIG_H +#define NM_SETTING_IP_CONFIG_H + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" +#include "nm-utils.h" + +G_BEGIN_DECLS + +#define NM_IP_ADDRESS_ATTRIBUTE_LABEL "label" + +/** + * NMIPAddressCmpFlags: + * @NM_IP_ADDRESS_CMP_FLAGS_NONE: no flags. + * @NM_IP_ADDRESS_CMP_FLAGS_WITH_ATTRS: when comparing two addresses, + * also consider their attributes. Warning: note that attributes are GVariants + * and they don't have a total order. In other words, if the address differs only + * by their attributes, the returned compare order is not total. In that case, + * the return value merely indicates equality (zero) or inequality. + * + * Compare flags for nm_ip_address_cmp_full(). + * + * Since: 1.22 + */ +typedef enum { /*< flags >*/ + NM_IP_ADDRESS_CMP_FLAGS_NONE = 0, + NM_IP_ADDRESS_CMP_FLAGS_WITH_ATTRS = 0x1, +} NMIPAddressCmpFlags; + +typedef struct NMIPAddress NMIPAddress; + +GType nm_ip_address_get_type(void); + +NMIPAddress *nm_ip_address_new(int family, const char *addr, guint prefix, GError **error); +NMIPAddress *nm_ip_address_new_binary(int family, gconstpointer addr, guint prefix, GError **error); + +void nm_ip_address_ref(NMIPAddress *address); +void nm_ip_address_unref(NMIPAddress *address); +gboolean nm_ip_address_equal(NMIPAddress *address, NMIPAddress *other); +NM_AVAILABLE_IN_1_22 +int +nm_ip_address_cmp_full(const NMIPAddress *a, const NMIPAddress *b, NMIPAddressCmpFlags cmp_flags); +NMIPAddress *nm_ip_address_dup(NMIPAddress *address); + +int nm_ip_address_get_family(NMIPAddress *address); +const char *nm_ip_address_get_address(NMIPAddress *address); +void nm_ip_address_set_address(NMIPAddress *address, const char *addr); +void nm_ip_address_get_address_binary(NMIPAddress *address, gpointer addr); +void nm_ip_address_set_address_binary(NMIPAddress *address, gconstpointer addr); +guint nm_ip_address_get_prefix(NMIPAddress *address); +void nm_ip_address_set_prefix(NMIPAddress *address, guint prefix); + +char ** nm_ip_address_get_attribute_names(NMIPAddress *address); +GVariant *nm_ip_address_get_attribute(NMIPAddress *address, const char *name); +void nm_ip_address_set_attribute(NMIPAddress *address, const char *name, GVariant *value); + +typedef struct NMIPRoute NMIPRoute; + +GType nm_ip_route_get_type(void); + +NMIPRoute *nm_ip_route_new(int family, + const char *dest, + guint prefix, + const char *next_hop, + gint64 metric, + GError ** error); +NMIPRoute *nm_ip_route_new_binary(int family, + gconstpointer dest, + guint prefix, + gconstpointer next_hop, + gint64 metric, + GError ** error); + +void nm_ip_route_ref(NMIPRoute *route); +void nm_ip_route_unref(NMIPRoute *route); +gboolean nm_ip_route_equal(NMIPRoute *route, NMIPRoute *other); + +enum { /*< flags >*/ + NM_IP_ROUTE_EQUAL_CMP_FLAGS_NONE = 0, + NM_IP_ROUTE_EQUAL_CMP_FLAGS_WITH_ATTRS = 0x1, +}; + +NM_AVAILABLE_IN_1_10 +gboolean nm_ip_route_equal_full(NMIPRoute *route, NMIPRoute *other, guint cmp_flags); + +NMIPRoute *nm_ip_route_dup(NMIPRoute *route); + +int nm_ip_route_get_family(NMIPRoute *route); +const char *nm_ip_route_get_dest(NMIPRoute *route); +void nm_ip_route_set_dest(NMIPRoute *route, const char *dest); +void nm_ip_route_get_dest_binary(NMIPRoute *route, gpointer dest); +void nm_ip_route_set_dest_binary(NMIPRoute *route, gconstpointer dest); +guint nm_ip_route_get_prefix(NMIPRoute *route); +void nm_ip_route_set_prefix(NMIPRoute *route, guint prefix); +const char *nm_ip_route_get_next_hop(NMIPRoute *route); +void nm_ip_route_set_next_hop(NMIPRoute *route, const char *next_hop); +gboolean nm_ip_route_get_next_hop_binary(NMIPRoute *route, gpointer next_hop); +void nm_ip_route_set_next_hop_binary(NMIPRoute *route, gconstpointer next_hop); +gint64 nm_ip_route_get_metric(NMIPRoute *route); +void nm_ip_route_set_metric(NMIPRoute *route, gint64 metric); + +char ** nm_ip_route_get_attribute_names(NMIPRoute *route); +GVariant *nm_ip_route_get_attribute(NMIPRoute *route, const char *name); +void nm_ip_route_set_attribute(NMIPRoute *route, const char *name, GVariant *value); +NM_AVAILABLE_IN_1_8 +const NMVariantAttributeSpec *const *nm_ip_route_get_variant_attribute_spec(void); +NM_AVAILABLE_IN_1_8 +gboolean nm_ip_route_attribute_validate(const char *name, + GVariant * value, + int family, + gboolean * known, + GError ** error); + +#define NM_IP_ROUTE_ATTRIBUTE_CWND "cwnd" +#define NM_IP_ROUTE_ATTRIBUTE_FROM "from" +#define NM_IP_ROUTE_ATTRIBUTE_INITCWND "initcwnd" +#define NM_IP_ROUTE_ATTRIBUTE_INITRWND "initrwnd" +#define NM_IP_ROUTE_ATTRIBUTE_LOCK_CWND "lock-cwnd" +#define NM_IP_ROUTE_ATTRIBUTE_LOCK_INITCWND "lock-initcwnd" +#define NM_IP_ROUTE_ATTRIBUTE_LOCK_INITRWND "lock-initrwnd" +#define NM_IP_ROUTE_ATTRIBUTE_LOCK_MTU "lock-mtu" +#define NM_IP_ROUTE_ATTRIBUTE_LOCK_WINDOW "lock-window" +#define NM_IP_ROUTE_ATTRIBUTE_MTU "mtu" +#define NM_IP_ROUTE_ATTRIBUTE_ONLINK "onlink" +#define NM_IP_ROUTE_ATTRIBUTE_SCOPE "scope" +#define NM_IP_ROUTE_ATTRIBUTE_SRC "src" +#define NM_IP_ROUTE_ATTRIBUTE_TABLE "table" +#define NM_IP_ROUTE_ATTRIBUTE_TOS "tos" +#define NM_IP_ROUTE_ATTRIBUTE_TYPE "type" +#define NM_IP_ROUTE_ATTRIBUTE_WINDOW "window" + +/*****************************************************************************/ + +typedef struct NMIPRoutingRule NMIPRoutingRule; + +NM_AVAILABLE_IN_1_18 +GType nm_ip_routing_rule_get_type(void); + +NM_AVAILABLE_IN_1_18 +NMIPRoutingRule *nm_ip_routing_rule_new(int addr_family); + +NM_AVAILABLE_IN_1_18 +NMIPRoutingRule *nm_ip_routing_rule_new_clone(const NMIPRoutingRule *rule); + +NM_AVAILABLE_IN_1_18 +NMIPRoutingRule *nm_ip_routing_rule_ref(NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_unref(NMIPRoutingRule *self); + +NM_AVAILABLE_IN_1_18 +gboolean nm_ip_routing_rule_is_sealed(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_seal(NMIPRoutingRule *self); + +NM_AVAILABLE_IN_1_18 +int nm_ip_routing_rule_get_addr_family(const NMIPRoutingRule *self); + +NM_AVAILABLE_IN_1_18 +gboolean nm_ip_routing_rule_get_invert(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_invert(NMIPRoutingRule *self, gboolean invert); + +NM_AVAILABLE_IN_1_18 +gint64 nm_ip_routing_rule_get_priority(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_priority(NMIPRoutingRule *self, gint64 priority); + +NM_AVAILABLE_IN_1_18 +guint8 nm_ip_routing_rule_get_tos(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_tos(NMIPRoutingRule *self, guint8 tos); + +NM_AVAILABLE_IN_1_18 +guint8 nm_ip_routing_rule_get_ipproto(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_ipproto(NMIPRoutingRule *self, guint8 ipproto); + +NM_AVAILABLE_IN_1_18 +guint16 nm_ip_routing_rule_get_source_port_start(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +guint16 nm_ip_routing_rule_get_source_port_end(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_source_port(NMIPRoutingRule *self, guint16 start, guint16 end); + +NM_AVAILABLE_IN_1_18 +guint16 nm_ip_routing_rule_get_destination_port_start(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +guint16 nm_ip_routing_rule_get_destination_port_end(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_destination_port(NMIPRoutingRule *self, guint16 start, guint16 end); + +NM_AVAILABLE_IN_1_18 +guint32 nm_ip_routing_rule_get_fwmark(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +guint32 nm_ip_routing_rule_get_fwmask(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_fwmark(NMIPRoutingRule *self, guint32 fwmark, guint32 fwmask); + +NM_AVAILABLE_IN_1_18 +guint8 nm_ip_routing_rule_get_from_len(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +const char *nm_ip_routing_rule_get_from(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_from(NMIPRoutingRule *self, const char *from, guint8 len); + +NM_AVAILABLE_IN_1_18 +guint8 nm_ip_routing_rule_get_to_len(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +const char *nm_ip_routing_rule_get_to(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_to(NMIPRoutingRule *self, const char *to, guint8 len); + +NM_AVAILABLE_IN_1_18 +const char *nm_ip_routing_rule_get_iifname(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_iifname(NMIPRoutingRule *self, const char *iifname); + +NM_AVAILABLE_IN_1_18 +const char *nm_ip_routing_rule_get_oifname(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_oifname(NMIPRoutingRule *self, const char *oifname); + +NM_AVAILABLE_IN_1_18 +guint8 nm_ip_routing_rule_get_action(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_action(NMIPRoutingRule *self, guint8 action); + +NM_AVAILABLE_IN_1_18 +guint32 nm_ip_routing_rule_get_table(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_18 +void nm_ip_routing_rule_set_table(NMIPRoutingRule *self, guint32 table); + +NM_AVAILABLE_IN_1_20 +gint32 nm_ip_routing_rule_get_suppress_prefixlength(const NMIPRoutingRule *self); +NM_AVAILABLE_IN_1_20 +void nm_ip_routing_rule_set_suppress_prefixlength(NMIPRoutingRule *self, + gint32 suppress_prefixlength); + +NM_AVAILABLE_IN_1_18 +int nm_ip_routing_rule_cmp(const NMIPRoutingRule *rule, const NMIPRoutingRule *other); + +NM_AVAILABLE_IN_1_18 +gboolean nm_ip_routing_rule_validate(const NMIPRoutingRule *self, GError **error); + +/** + * NMIPRoutingRuleAsStringFlags: + * @NM_IP_ROUTING_RULE_AS_STRING_FLAGS_NONE: no flags selected. + * @NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET: whether to allow parsing + * IPv4 addresses. + * @NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET6: whether to allow parsing + * IPv6 addresses. If both @NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET and + * @NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET6 are unset, it's the same + * as setting them both. + * @NM_IP_ROUTING_RULE_AS_STRING_FLAGS_VALIDATE: if set, ensure that the + * rule verfies or fail. + * + * Since: 1.18 + */ +typedef enum { /*< flags >*/ + NM_IP_ROUTING_RULE_AS_STRING_FLAGS_NONE = 0, + + NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET = 0x1, + NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET6 = 0x2, + NM_IP_ROUTING_RULE_AS_STRING_FLAGS_VALIDATE = 0x4, +} NMIPRoutingRuleAsStringFlags; + +NM_AVAILABLE_IN_1_18 +NMIPRoutingRule *nm_ip_routing_rule_from_string(const char * str, + NMIPRoutingRuleAsStringFlags to_string_flags, + GHashTable * extra_args, + GError ** error); + +NM_AVAILABLE_IN_1_18 +char *nm_ip_routing_rule_to_string(const NMIPRoutingRule * self, + NMIPRoutingRuleAsStringFlags to_string_flags, + GHashTable * extra_args, + GError ** error); + +/*****************************************************************************/ + +#define NM_TYPE_SETTING_IP_CONFIG (nm_setting_ip_config_get_type()) +#define NM_SETTING_IP_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_IP_CONFIG, NMSettingIPConfig)) +#define NM_SETTING_IP_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_IPCONFIG, NMSettingIPConfigClass)) +#define NM_IS_SETTING_IP_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_IP_CONFIG)) +#define NM_IS_SETTING_IP_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_IP_CONFIG)) +#define NM_SETTING_IP_CONFIG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_IP_CONFIG, NMSettingIPConfigClass)) + +#define NM_SETTING_IP_CONFIG_DAD_TIMEOUT_MAX 30000 + +#define NM_SETTING_IP_CONFIG_METHOD "method" +#define NM_SETTING_IP_CONFIG_DNS "dns" +#define NM_SETTING_IP_CONFIG_DNS_SEARCH "dns-search" +#define NM_SETTING_IP_CONFIG_DNS_OPTIONS "dns-options" +#define NM_SETTING_IP_CONFIG_DNS_PRIORITY "dns-priority" +#define NM_SETTING_IP_CONFIG_ADDRESSES "addresses" +#define NM_SETTING_IP_CONFIG_GATEWAY "gateway" +#define NM_SETTING_IP_CONFIG_ROUTES "routes" +#define NM_SETTING_IP_CONFIG_ROUTE_METRIC "route-metric" +#define NM_SETTING_IP_CONFIG_ROUTE_TABLE "route-table" +#define NM_SETTING_IP_CONFIG_IGNORE_AUTO_ROUTES "ignore-auto-routes" +#define NM_SETTING_IP_CONFIG_IGNORE_AUTO_DNS "ignore-auto-dns" +#define NM_SETTING_IP_CONFIG_DHCP_HOSTNAME "dhcp-hostname" +#define NM_SETTING_IP_CONFIG_DHCP_SEND_HOSTNAME "dhcp-send-hostname" +#define NM_SETTING_IP_CONFIG_DHCP_HOSTNAME_FLAGS "dhcp-hostname-flags" +#define NM_SETTING_IP_CONFIG_NEVER_DEFAULT "never-default" +#define NM_SETTING_IP_CONFIG_MAY_FAIL "may-fail" +#define NM_SETTING_IP_CONFIG_DAD_TIMEOUT "dad-timeout" +#define NM_SETTING_IP_CONFIG_DHCP_TIMEOUT "dhcp-timeout" +#define NM_SETTING_IP_CONFIG_DHCP_IAID "dhcp-iaid" +#define NM_SETTING_IP_CONFIG_DHCP_REJECT_SERVERS "dhcp-reject-servers" + +/* these are not real GObject properties. */ +#define NM_SETTING_IP_CONFIG_ROUTING_RULES "routing-rules" + +#define NM_SETTING_DNS_OPTION_DEBUG "debug" +#define NM_SETTING_DNS_OPTION_NDOTS "ndots" +#define NM_SETTING_DNS_OPTION_TIMEOUT "timeout" +#define NM_SETTING_DNS_OPTION_ATTEMPTS "attempts" +#define NM_SETTING_DNS_OPTION_ROTATE "rotate" +#define NM_SETTING_DNS_OPTION_NO_CHECK_NAMES "no-check-names" +#define NM_SETTING_DNS_OPTION_INET6 "inet6" +#define NM_SETTING_DNS_OPTION_IP6_BYTESTRING "ip6-bytestring" +#define NM_SETTING_DNS_OPTION_IP6_DOTINT "ip6-dotint" +#define NM_SETTING_DNS_OPTION_NO_IP6_DOTINT "no-ip6-dotint" +#define NM_SETTING_DNS_OPTION_EDNS0 "edns0" +#define NM_SETTING_DNS_OPTION_SINGLE_REQUEST "single-request" +#define NM_SETTING_DNS_OPTION_SINGLE_REQUEST_REOPEN "single-request-reopen" +#define NM_SETTING_DNS_OPTION_NO_TLD_QUERY "no-tld-query" +#define NM_SETTING_DNS_OPTION_USE_VC "use-vc" +#define NM_SETTING_DNS_OPTION_NO_RELOAD "no-reload" +#define NM_SETTING_DNS_OPTION_TRUST_AD "trust-ad" + +/** + * NMSettingIPConfig: + */ +struct _NMSettingIPConfig { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /* Padding for future expansion */ + gpointer padding[8]; +} NMSettingIPConfigClass; + +/** + * NMDhcpHostnameFlags: + * @NM_DHCP_HOSTNAME_FLAG_NONE: no flag set. The default value from + * Networkmanager global configuration is used. If such value is unset + * or still zero, the DHCP request will use standard FQDN flags, i.e. + * %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE and + * %NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED for IPv4 and + * %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE for IPv6. + * @NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE: whether the server should + * do the A RR (FQDN-to-address) DNS updates. + * @NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED: if set, the FQDN is encoded + * using canonical wire format. Otherwise it uses the deprecated + * ASCII encoding. This flag is allowed only for DHCPv4. + * @NM_DHCP_HOSTNAME_FLAG_FQDN_NO_UPDATE: when not set, request the + * server to perform updates (the PTR RR and possibly the A RR + * based on the %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE flag). If + * this is set, the %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE flag + * should be cleared. + * @NM_DHCP_HOSTNAME_FLAG_FQDN_CLEAR_FLAGS: when set, no FQDN flags are + * sent in the DHCP FQDN option. When cleared and all other FQDN + * flags are zero, standard FQDN flags are sent. This flag is + * incompatible with any other FQDN flag. + * + * #NMDhcpHostnameFlags describe flags related to the DHCP hostname and + * FQDN. + * + * Since: 1.22 + */ +typedef enum { /*< flags >*/ + NM_DHCP_HOSTNAME_FLAG_NONE = 0x0, + + NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE = 0x1, + NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED = 0x2, + NM_DHCP_HOSTNAME_FLAG_FQDN_NO_UPDATE = 0x4, + + NM_DHCP_HOSTNAME_FLAG_FQDN_CLEAR_FLAGS = 0x8, + +} NMDhcpHostnameFlags; + +GType nm_setting_ip_config_get_type(void); + +const char *nm_setting_ip_config_get_method(NMSettingIPConfig *setting); + +guint nm_setting_ip_config_get_num_dns(NMSettingIPConfig *setting); +const char *nm_setting_ip_config_get_dns(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_add_dns(NMSettingIPConfig *setting, const char *dns); +void nm_setting_ip_config_remove_dns(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_remove_dns_by_value(NMSettingIPConfig *setting, const char *dns); +void nm_setting_ip_config_clear_dns(NMSettingIPConfig *setting); + +guint nm_setting_ip_config_get_num_dns_searches(NMSettingIPConfig *setting); +const char *nm_setting_ip_config_get_dns_search(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_add_dns_search(NMSettingIPConfig *setting, const char *dns_search); +void nm_setting_ip_config_remove_dns_search(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_remove_dns_search_by_value(NMSettingIPConfig *setting, + const char * dns_search); +void nm_setting_ip_config_clear_dns_searches(NMSettingIPConfig *setting); + +guint nm_setting_ip_config_get_num_dns_options(NMSettingIPConfig *setting); +gboolean nm_setting_ip_config_has_dns_options(NMSettingIPConfig *setting); +const char *nm_setting_ip_config_get_dns_option(NMSettingIPConfig *setting, guint idx); +gboolean nm_setting_ip_config_add_dns_option(NMSettingIPConfig *setting, const char *dns_option); +void nm_setting_ip_config_remove_dns_option(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_remove_dns_option_by_value(NMSettingIPConfig *setting, + const char * dns_option); +void nm_setting_ip_config_clear_dns_options(NMSettingIPConfig *setting, gboolean is_set); + +NM_AVAILABLE_IN_1_4 +int nm_setting_ip_config_get_dns_priority(NMSettingIPConfig *setting); + +guint nm_setting_ip_config_get_num_addresses(NMSettingIPConfig *setting); +NMIPAddress *nm_setting_ip_config_get_address(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_add_address(NMSettingIPConfig *setting, NMIPAddress *address); +void nm_setting_ip_config_remove_address(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_remove_address_by_value(NMSettingIPConfig *setting, + NMIPAddress * address); +void nm_setting_ip_config_clear_addresses(NMSettingIPConfig *setting); + +const char *nm_setting_ip_config_get_gateway(NMSettingIPConfig *setting); + +guint nm_setting_ip_config_get_num_routes(NMSettingIPConfig *setting); +NMIPRoute *nm_setting_ip_config_get_route(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_add_route(NMSettingIPConfig *setting, NMIPRoute *route); +void nm_setting_ip_config_remove_route(NMSettingIPConfig *setting, int idx); +gboolean nm_setting_ip_config_remove_route_by_value(NMSettingIPConfig *setting, NMIPRoute *route); +void nm_setting_ip_config_clear_routes(NMSettingIPConfig *setting); + +gint64 nm_setting_ip_config_get_route_metric(NMSettingIPConfig *setting); + +NM_AVAILABLE_IN_1_10 +guint32 nm_setting_ip_config_get_route_table(NMSettingIPConfig *setting); + +NM_AVAILABLE_IN_1_18 +guint nm_setting_ip_config_get_num_routing_rules(NMSettingIPConfig *setting); +NM_AVAILABLE_IN_1_18 +NMIPRoutingRule *nm_setting_ip_config_get_routing_rule(NMSettingIPConfig *setting, guint idx); +NM_AVAILABLE_IN_1_18 +void nm_setting_ip_config_add_routing_rule(NMSettingIPConfig *setting, + NMIPRoutingRule * routing_rule); +NM_AVAILABLE_IN_1_18 +void nm_setting_ip_config_remove_routing_rule(NMSettingIPConfig *setting, guint idx); +NM_AVAILABLE_IN_1_18 +void nm_setting_ip_config_clear_routing_rules(NMSettingIPConfig *setting); + +gboolean nm_setting_ip_config_get_ignore_auto_routes(NMSettingIPConfig *setting); +gboolean nm_setting_ip_config_get_ignore_auto_dns(NMSettingIPConfig *setting); + +const char *nm_setting_ip_config_get_dhcp_hostname(NMSettingIPConfig *setting); +gboolean nm_setting_ip_config_get_dhcp_send_hostname(NMSettingIPConfig *setting); + +gboolean nm_setting_ip_config_get_never_default(NMSettingIPConfig *setting); +gboolean nm_setting_ip_config_get_may_fail(NMSettingIPConfig *setting); +NM_AVAILABLE_IN_1_2 +int nm_setting_ip_config_get_dad_timeout(NMSettingIPConfig *setting); +NM_AVAILABLE_IN_1_2 +int nm_setting_ip_config_get_dhcp_timeout(NMSettingIPConfig *setting); +NM_AVAILABLE_IN_1_22 +const char *nm_setting_ip_config_get_dhcp_iaid(NMSettingIPConfig *setting); + +NM_AVAILABLE_IN_1_22 +NMDhcpHostnameFlags nm_setting_ip_config_get_dhcp_hostname_flags(NMSettingIPConfig *setting); + +NM_AVAILABLE_IN_1_28 +const char *const *nm_setting_ip_config_get_dhcp_reject_servers(NMSettingIPConfig *setting, + guint * out_len); +NM_AVAILABLE_IN_1_28 +void nm_setting_ip_config_add_dhcp_reject_server(NMSettingIPConfig *setting, const char *server); +NM_AVAILABLE_IN_1_28 +void nm_setting_ip_config_remove_dhcp_reject_server(NMSettingIPConfig *setting, guint idx); +NM_AVAILABLE_IN_1_28 +void nm_setting_ip_config_clear_dhcp_reject_servers(NMSettingIPConfig *setting); + +G_END_DECLS + +#endif /* NM_SETTING_IP_CONFIG_H */ diff --git a/src/libnm-core-public/nm-setting-ip-tunnel.h b/src/libnm-core-public/nm-setting-ip-tunnel.h new file mode 100644 index 0000000000..802f81e113 --- /dev/null +++ b/src/libnm-core-public/nm-setting-ip-tunnel.h @@ -0,0 +1,122 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2015 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_IP_TUNNEL_H__ +#define __NM_SETTING_IP_TUNNEL_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_IP_TUNNEL (nm_setting_ip_tunnel_get_type()) +#define NM_SETTING_IP_TUNNEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_IP_TUNNEL, NMSettingIPTunnel)) +#define NM_SETTING_IP_TUNNEL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_IP_TUNNEL, NMSettingIPTunnelClass)) +#define NM_IS_SETTING_IP_TUNNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_IP_TUNNEL)) +#define NM_IS_SETTING_IP_TUNNEL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_IP_TUNNEL)) +#define NM_SETTING_IP_TUNNEL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_IP_TUNNEL, NMSettingIPTunnelClass)) + +#define NM_SETTING_IP_TUNNEL_SETTING_NAME "ip-tunnel" + +#define NM_SETTING_IP_TUNNEL_PARENT "parent" +#define NM_SETTING_IP_TUNNEL_MODE "mode" +#define NM_SETTING_IP_TUNNEL_LOCAL "local" +#define NM_SETTING_IP_TUNNEL_REMOTE "remote" +#define NM_SETTING_IP_TUNNEL_TTL "ttl" +#define NM_SETTING_IP_TUNNEL_TOS "tos" +#define NM_SETTING_IP_TUNNEL_PATH_MTU_DISCOVERY "path-mtu-discovery" +#define NM_SETTING_IP_TUNNEL_INPUT_KEY "input-key" +#define NM_SETTING_IP_TUNNEL_OUTPUT_KEY "output-key" +#define NM_SETTING_IP_TUNNEL_ENCAPSULATION_LIMIT "encapsulation-limit" +#define NM_SETTING_IP_TUNNEL_FLOW_LABEL "flow-label" +#define NM_SETTING_IP_TUNNEL_MTU "mtu" +#define NM_SETTING_IP_TUNNEL_FLAGS "flags" + +/** + * NMSettingIPTunnel: + * + * IP Tunneling Settings + */ +struct _NMSettingIPTunnel { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingIPTunnelClass; + +/* + * NMIPTunnelFlags: + * @NM_IP_TUNNEL_FLAG_NONE: no flag + * @NM_IP_TUNNEL_FLAG_IP6_IGN_ENCAP_LIMIT: don't add encapsulation limit + * if one isn't present in inner packet + * @NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_TCLASS: copy the traffic class field + * from the inner packet + * @NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FLOWLABEL: copy the flowlabel from the + * inner packet + * @NM_IP_TUNNEL_FLAG_IP6_MIP6_DEV: used for Mobile IPv6 + * @NM_IP_TUNNEL_FLAG_IP6_RCV_DSCP_COPY: copy DSCP from the outer packet + * @NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FWMARK: copy fwmark from inner packet + * + * IP tunnel flags. + * + * Since: 1.12 + */ +typedef enum { /*< flags, prefix=NM_IP_TUNNEL_FLAG >*/ + NM_IP_TUNNEL_FLAG_NONE = 0x0, + NM_IP_TUNNEL_FLAG_IP6_IGN_ENCAP_LIMIT = 0x1, + NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_TCLASS = 0x2, + NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FLOWLABEL = 0x4, + NM_IP_TUNNEL_FLAG_IP6_MIP6_DEV = 0x8, + NM_IP_TUNNEL_FLAG_IP6_RCV_DSCP_COPY = 0x10, + NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FWMARK = 0x20, +} NMIPTunnelFlags; + +NM_AVAILABLE_IN_1_2 +GType nm_setting_ip_tunnel_get_type(void); + +NM_AVAILABLE_IN_1_2 +NMSetting *nm_setting_ip_tunnel_new(void); + +NM_AVAILABLE_IN_1_2 +const char *nm_setting_ip_tunnel_get_parent(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +NMIPTunnelMode nm_setting_ip_tunnel_get_mode(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_ip_tunnel_get_local(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_ip_tunnel_get_remote(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_ip_tunnel_get_ttl(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_ip_tunnel_get_tos(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_ip_tunnel_get_path_mtu_discovery(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_ip_tunnel_get_input_key(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_ip_tunnel_get_output_key(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_ip_tunnel_get_encapsulation_limit(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_ip_tunnel_get_flow_label(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_ip_tunnel_get_mtu(NMSettingIPTunnel *setting); +NM_AVAILABLE_IN_1_12 +NMIPTunnelFlags nm_setting_ip_tunnel_get_flags(NMSettingIPTunnel *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_IP_TUNNEL_H__ */ diff --git a/src/libnm-core-public/nm-setting-ip4-config.h b/src/libnm-core-public/nm-setting-ip4-config.h new file mode 100644 index 0000000000..b1c63a4f6e --- /dev/null +++ b/src/libnm-core-public/nm-setting-ip4-config.h @@ -0,0 +1,109 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2014 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_IP4_CONFIG_H__ +#define __NM_SETTING_IP4_CONFIG_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting-ip-config.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_IP4_CONFIG (nm_setting_ip4_config_get_type()) +#define NM_SETTING_IP4_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_IP4_CONFIG, NMSettingIP4Config)) +#define NM_SETTING_IP4_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_IP4CONFIG, NMSettingIP4ConfigClass)) +#define NM_IS_SETTING_IP4_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_IP4_CONFIG)) +#define NM_IS_SETTING_IP4_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_IP4_CONFIG)) +#define NM_SETTING_IP4_CONFIG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_IP4_CONFIG, NMSettingIP4ConfigClass)) + +#define NM_SETTING_IP4_CONFIG_SETTING_NAME "ipv4" + +#define NM_SETTING_IP4_CONFIG_DHCP_CLIENT_ID "dhcp-client-id" +#define NM_SETTING_IP4_CONFIG_DHCP_FQDN "dhcp-fqdn" +#define NM_SETTING_IP4_CONFIG_DHCP_VENDOR_CLASS_IDENTIFIER "dhcp-vendor-class-identifier" + +/** + * NM_SETTING_IP4_CONFIG_METHOD_AUTO: + * + * IPv4 configuration should be automatically determined via a method appropriate + * for the hardware interface, ie DHCP or PPP or some other device-specific + * manner. + */ +#define NM_SETTING_IP4_CONFIG_METHOD_AUTO "auto" + +/** + * NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL: + * + * IPv4 configuration should be automatically configured for link-local-only + * operation. + */ +#define NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL "link-local" + +/** + * NM_SETTING_IP4_CONFIG_METHOD_MANUAL: + * + * All necessary IPv4 configuration (addresses, prefix, DNS, etc) is specified + * in the setting's properties. + */ +#define NM_SETTING_IP4_CONFIG_METHOD_MANUAL "manual" + +/** + * NM_SETTING_IP4_CONFIG_METHOD_SHARED: + * + * This connection specifies configuration that allows other computers to + * connect through it to the default network (usually the Internet). The + * connection's interface will be assigned a private address, and a DHCP server, + * caching DNS server, and Network Address Translation (NAT) functionality will + * be started on this connection's interface to allow other devices to connect + * through that interface to the default network. + */ +#define NM_SETTING_IP4_CONFIG_METHOD_SHARED "shared" + +/** + * NM_SETTING_IP4_CONFIG_METHOD_DISABLED: + * + * This connection does not use or require IPv4 address and it should be disabled. + */ +#define NM_SETTING_IP4_CONFIG_METHOD_DISABLED "disabled" + +/** + * NMSettingIP4Config: + * + * IPv4 Settings + */ +struct _NMSettingIP4Config { + NMSettingIPConfig parent; +}; + +typedef struct { + NMSettingIPConfigClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingIP4ConfigClass; + +GType nm_setting_ip4_config_get_type(void); + +NMSetting *nm_setting_ip4_config_new(void); + +const char *nm_setting_ip4_config_get_dhcp_client_id(NMSettingIP4Config *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_ip4_config_get_dhcp_fqdn(NMSettingIP4Config *setting); + +NM_AVAILABLE_IN_1_28 +const char *nm_setting_ip4_config_get_dhcp_vendor_class_identifier(NMSettingIP4Config *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_IP4_CONFIG_H__ */ diff --git a/src/libnm-core-public/nm-setting-ip6-config.h b/src/libnm-core-public/nm-setting-ip6-config.h new file mode 100644 index 0000000000..fca6961b86 --- /dev/null +++ b/src/libnm-core-public/nm-setting-ip6-config.h @@ -0,0 +1,174 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2014 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_IP6_CONFIG_H__ +#define __NM_SETTING_IP6_CONFIG_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting-ip-config.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_IP6_CONFIG (nm_setting_ip6_config_get_type()) +#define NM_SETTING_IP6_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_IP6_CONFIG, NMSettingIP6Config)) +#define NM_SETTING_IP6_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_IP6CONFIG, NMSettingIP6ConfigClass)) +#define NM_IS_SETTING_IP6_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_IP6_CONFIG)) +#define NM_IS_SETTING_IP6_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_IP6_CONFIG)) +#define NM_SETTING_IP6_CONFIG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_IP6_CONFIG, NMSettingIP6ConfigClass)) + +#define NM_SETTING_IP6_CONFIG_SETTING_NAME "ipv6" + +#define NM_SETTING_IP6_CONFIG_IP6_PRIVACY "ip6-privacy" + +#define NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE "addr-gen-mode" + +#define NM_SETTING_IP6_CONFIG_TOKEN "token" + +#define NM_SETTING_IP6_CONFIG_DHCP_DUID "dhcp-duid" + +#define NM_SETTING_IP6_CONFIG_RA_TIMEOUT "ra-timeout" + +/** + * NM_SETTING_IP6_CONFIG_METHOD_IGNORE: + * + * IPv6 is not required or is handled by some other mechanism, and NetworkManager + * should not configure IPv6 for this connection. + */ +#define NM_SETTING_IP6_CONFIG_METHOD_IGNORE "ignore" + +/** + * NM_SETTING_IP6_CONFIG_METHOD_AUTO: + * + * IPv6 configuration should be automatically determined via a method appropriate + * for the hardware interface, ie router advertisements, DHCP, or PPP or some + * other device-specific manner. + */ +#define NM_SETTING_IP6_CONFIG_METHOD_AUTO "auto" + +/** + * NM_SETTING_IP6_CONFIG_METHOD_DHCP: + * + * IPv6 configuration should be automatically determined via DHCPv6 only and + * router advertisements should be ignored. + */ +#define NM_SETTING_IP6_CONFIG_METHOD_DHCP "dhcp" + +/** + * NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL: + * + * IPv6 configuration should be automatically configured for link-local-only + * operation. + */ +#define NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL "link-local" + +/** + * NM_SETTING_IP6_CONFIG_METHOD_MANUAL: + * + * All necessary IPv6 configuration (addresses, prefix, DNS, etc) is specified + * in the setting's properties. + */ +#define NM_SETTING_IP6_CONFIG_METHOD_MANUAL "manual" + +/** + * NM_SETTING_IP6_CONFIG_METHOD_SHARED: + * + * This connection specifies configuration that allows other computers to + * connect through it to the default network (usually the Internet). The + * connection's interface will be assigned a private address, and router + * advertisements, a caching DNS server, and Network Address Translation (NAT) + * functionality will be started on this connection's interface to allow other + * devices to connect through that interface to the default network. (not yet + * supported for IPv6) + */ +#define NM_SETTING_IP6_CONFIG_METHOD_SHARED "shared" + +/** + * NM_SETTING_IP6_CONFIG_METHOD_DISABLED: + * + * IPv6 is disabled for the connection. + * + * Since: 1.20 + */ +#define NM_SETTING_IP6_CONFIG_METHOD_DISABLED "disabled" + +/** + * NMSettingIP6ConfigPrivacy: + * @NM_SETTING_IP6_CONFIG_PRIVACY_UNKNOWN: unknown or no value specified + * @NM_SETTING_IP6_CONFIG_PRIVACY_DISABLED: IPv6 Privacy Extensions are disabled + * @NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_PUBLIC_ADDR: IPv6 Privacy Extensions + * are enabled, but public addresses are preferred over temporary addresses + * @NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR: IPv6 Privacy Extensions + * are enabled and temporary addresses are preferred over public addresses + * + * #NMSettingIP6ConfigPrivacy values indicate if and how IPv6 Privacy + * Extensions are used (RFC4941). + */ +typedef enum { + NM_SETTING_IP6_CONFIG_PRIVACY_UNKNOWN = -1, + NM_SETTING_IP6_CONFIG_PRIVACY_DISABLED = 0, + NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_PUBLIC_ADDR = 1, + NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR = 2 +} NMSettingIP6ConfigPrivacy; + +/** + * NMSettingIP6ConfigAddrGenMode: + * @NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64: The Interface Identifier is derived + * from the interface hardware address. + * @NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY: The Interface Identifier + * is created by using a cryptographically secure hash of a secret host-specific + * key along with the connection identification and the network address as + * specified by RFC7217. + * + * #NMSettingIP6ConfigAddrGenMode controls how the Interface Identifier for + * RFC4862 Stateless Address Autoconfiguration is created. + * + * Since: 1.2 + */ +typedef enum { + NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64 = 0, + NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY = 1, +} NMSettingIP6ConfigAddrGenMode; + +/** + * NMSettingIP6Config: + * + * IPv6 Settings + */ +struct _NMSettingIP6Config { + NMSettingIPConfig parent; +}; + +typedef struct { + NMSettingIPConfigClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingIP6ConfigClass; + +GType nm_setting_ip6_config_get_type(void); + +NMSetting *nm_setting_ip6_config_new(void); + +NMSettingIP6ConfigPrivacy nm_setting_ip6_config_get_ip6_privacy(NMSettingIP6Config *setting); +NM_AVAILABLE_IN_1_2 +NMSettingIP6ConfigAddrGenMode nm_setting_ip6_config_get_addr_gen_mode(NMSettingIP6Config *setting); +NM_AVAILABLE_IN_1_4 +const char *nm_setting_ip6_config_get_token(NMSettingIP6Config *setting); +NM_AVAILABLE_IN_1_12 +const char *nm_setting_ip6_config_get_dhcp_duid(NMSettingIP6Config *setting); +NM_AVAILABLE_IN_1_24 +gint32 nm_setting_ip6_config_get_ra_timeout(NMSettingIP6Config *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_IP6_CONFIG_H__ */ diff --git a/src/libnm-core-public/nm-setting-macsec.h b/src/libnm-core-public/nm-setting-macsec.h new file mode 100644 index 0000000000..bc33dd9dfb --- /dev/null +++ b/src/libnm-core-public/nm-setting-macsec.h @@ -0,0 +1,118 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_MACSEC_H__ +#define __NM_SETTING_MACSEC_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_MACSEC (nm_setting_macsec_get_type()) +#define NM_SETTING_MACSEC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_MACSEC, NMSettingMacsec)) +#define NM_SETTING_MACSEC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_MACSECCONFIG, NMSettingMacsecClass)) +#define NM_IS_SETTING_MACSEC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_MACSEC)) +#define NM_IS_SETTING_MACSEC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_MACSEC)) +#define NM_SETTING_MACSEC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_MACSEC, NMSettingMacsecClass)) + +#define NM_SETTING_MACSEC_SETTING_NAME "macsec" + +#define NM_SETTING_MACSEC_PARENT "parent" +#define NM_SETTING_MACSEC_MODE "mode" +#define NM_SETTING_MACSEC_ENCRYPT "encrypt" +#define NM_SETTING_MACSEC_MKA_CAK "mka-cak" +#define NM_SETTING_MACSEC_MKA_CAK_FLAGS "mka-cak-flags" +#define NM_SETTING_MACSEC_MKA_CKN "mka-ckn" +#define NM_SETTING_MACSEC_PORT "port" +#define NM_SETTING_MACSEC_VALIDATION "validation" +#define NM_SETTING_MACSEC_SEND_SCI "send-sci" + +/** + * NMSettingMacsec: + * + * MACSec Settings + */ +struct _NMSettingMacsec { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingMacsecClass; + +/** + * NMSettingMacsecMode: + * @NM_SETTING_MACSEC_MODE_PSK: The CAK is pre-shared + * @NM_SETTING_MACSEC_MODE_EAP: The CAK is the result of participation in EAP + * + * #NMSettingMacsecMode controls how the CAK (Connectivity Association Key) used + * in MKA (MACsec Key Agreement) is obtained. + * + * Since: 1.6 + */ +typedef enum { + NM_SETTING_MACSEC_MODE_PSK = 0, + NM_SETTING_MACSEC_MODE_EAP = 1, +} NMSettingMacsecMode; + +/** + * NMSettingMacsecValidation: + * @NM_SETTING_MACSEC_VALIDATION_DISABLE: All incoming frames are accepted if + * possible + * @NM_SETTING_MACSEC_VALIDATION_CHECK: Non protected, invalid, or impossible to + * verify frames are accepted and counted as "invalid" + * @NM_SETTING_MACSEC_VALIDATION_STRICT: Non protected, invalid, or impossible to + * verify frames are dropped + * + * #NMSettingMacsecValidation specifies a validation mode for incoming frames. + * + * Since: 1.6 + */ +typedef enum { + NM_SETTING_MACSEC_VALIDATION_DISABLE = 0, + NM_SETTING_MACSEC_VALIDATION_CHECK = 1, + NM_SETTING_MACSEC_VALIDATION_STRICT = 2, +} NMSettingMacsecValidation; + +#define NM_SETTING_MACSEC_MKA_CAK_LENGTH 32 +#define NM_SETTING_MACSEC_MKA_CKN_LENGTH 64 + +NM_AVAILABLE_IN_1_6 +GType nm_setting_macsec_get_type(void); +NM_AVAILABLE_IN_1_6 +NMSetting *nm_setting_macsec_new(void); + +NM_AVAILABLE_IN_1_6 +const char *nm_setting_macsec_get_parent(NMSettingMacsec *setting); +NM_AVAILABLE_IN_1_6 +NMSettingMacsecMode nm_setting_macsec_get_mode(NMSettingMacsec *setting); +NM_AVAILABLE_IN_1_6 +gboolean nm_setting_macsec_get_encrypt(NMSettingMacsec *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_macsec_get_mka_cak(NMSettingMacsec *setting); +NM_AVAILABLE_IN_1_6 +NMSettingSecretFlags nm_setting_macsec_get_mka_cak_flags(NMSettingMacsec *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_macsec_get_mka_ckn(NMSettingMacsec *setting); +NM_AVAILABLE_IN_1_6 +int nm_setting_macsec_get_port(NMSettingMacsec *setting); +NM_AVAILABLE_IN_1_6 +NMSettingMacsecValidation nm_setting_macsec_get_validation(NMSettingMacsec *setting); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_macsec_get_send_sci(NMSettingMacsec *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_MACSEC_H__ */ diff --git a/src/libnm-core-public/nm-setting-macvlan.h b/src/libnm-core-public/nm-setting-macvlan.h new file mode 100644 index 0000000000..05c0b36508 --- /dev/null +++ b/src/libnm-core-public/nm-setting-macvlan.h @@ -0,0 +1,87 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2015 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_MACVLAN_H__ +#define __NM_SETTING_MACVLAN_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_MACVLAN (nm_setting_macvlan_get_type()) +#define NM_SETTING_MACVLAN(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_MACVLAN, NMSettingMacvlan)) +#define NM_SETTING_MACVLAN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_MACVLANCONFIG, NMSettingMacvlanClass)) +#define NM_IS_SETTING_MACVLAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_MACVLAN)) +#define NM_IS_SETTING_MACVLAN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_MACVLAN)) +#define NM_SETTING_MACVLAN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_MACVLAN, NMSettingMacvlanClass)) + +#define NM_SETTING_MACVLAN_SETTING_NAME "macvlan" + +#define NM_SETTING_MACVLAN_PARENT "parent" +#define NM_SETTING_MACVLAN_MODE "mode" +#define NM_SETTING_MACVLAN_PROMISCUOUS "promiscuous" +#define NM_SETTING_MACVLAN_TAP "tap" + +/** + * NMSettingMacvlan: + * + * MAC VLAN Settings + */ +struct _NMSettingMacvlan { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingMacvlanClass; + +/** + * NMSettingMacvlanMode: + * @NM_SETTING_MACVLAN_MODE_UNKNOWN: unknown/unset mode + * @NM_SETTING_MACVLAN_MODE_VEPA: Virtual Ethernet Port Aggregator mode + * @NM_SETTING_MACVLAN_MODE_BRIDGE: bridge mode + * @NM_SETTING_MACVLAN_MODE_PRIVATE: private mode + * @NM_SETTING_MACVLAN_MODE_PASSTHRU: passthru mode + * @NM_SETTING_MACVLAN_MODE_SOURCE: source mode + **/ +typedef enum { + NM_SETTING_MACVLAN_MODE_UNKNOWN = 0, + NM_SETTING_MACVLAN_MODE_VEPA = 1, + NM_SETTING_MACVLAN_MODE_BRIDGE = 2, + NM_SETTING_MACVLAN_MODE_PRIVATE = 3, + NM_SETTING_MACVLAN_MODE_PASSTHRU = 4, + NM_SETTING_MACVLAN_MODE_SOURCE = 5, + _NM_SETTING_MACVLAN_MODE_NUM, /*< skip >*/ + NM_SETTING_MACVLAN_MODE_LAST = _NM_SETTING_MACVLAN_MODE_NUM - 1, /*< skip >*/ +} NMSettingMacvlanMode; + +NM_AVAILABLE_IN_1_2 +GType nm_setting_macvlan_get_type(void); +NM_AVAILABLE_IN_1_2 +NMSetting *nm_setting_macvlan_new(void); + +NM_AVAILABLE_IN_1_2 +const char *nm_setting_macvlan_get_parent(NMSettingMacvlan *setting); +NM_AVAILABLE_IN_1_2 +NMSettingMacvlanMode nm_setting_macvlan_get_mode(NMSettingMacvlan *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_macvlan_get_promiscuous(NMSettingMacvlan *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_macvlan_get_tap(NMSettingMacvlan *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_MACVLAN_H__ */ diff --git a/src/libnm-core-public/nm-setting-match.h b/src/libnm-core-public/nm-setting-match.h new file mode 100644 index 0000000000..9b3e29e7c0 --- /dev/null +++ b/src/libnm-core-public/nm-setting-match.h @@ -0,0 +1,107 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2018 Red Hat, Inc. + */ + +#ifndef NM_SETTING_MATCH_H +#define NM_SETTING_MATCH_H + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_MATCH (nm_setting_match_get_type()) +#define NM_SETTING_MATCH(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_MATCH, NMSettingMatch)) +#define NM_SETTING_MATCH_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_MATCH, NMSettingMatchClass)) +#define NM_IS_SETTING_MATCH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_MATCH)) +#define NM_IS_SETTING_MATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_MATCH)) +#define NM_SETTING_MATCH_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_MATCH, NMSettingMatchClass)) + +#define NM_SETTING_MATCH_SETTING_NAME "match" + +#define NM_SETTING_MATCH_INTERFACE_NAME "interface-name" +#define NM_SETTING_MATCH_KERNEL_COMMAND_LINE "kernel-command-line" +#define NM_SETTING_MATCH_DRIVER "driver" +#define NM_SETTING_MATCH_PATH "path" + +typedef struct _NMSettingMatchClass NMSettingMatchClass; + +NM_AVAILABLE_IN_1_14 +GType nm_setting_match_get_type(void); +NM_AVAILABLE_IN_1_14 +NMSetting *nm_setting_match_new(void); + +NM_AVAILABLE_IN_1_14 +guint nm_setting_match_get_num_interface_names(NMSettingMatch *setting); +NM_AVAILABLE_IN_1_14 +const char *nm_setting_match_get_interface_name(NMSettingMatch *setting, int idx); +NM_AVAILABLE_IN_1_14 +void nm_setting_match_remove_interface_name(NMSettingMatch *setting, int idx); +NM_AVAILABLE_IN_1_14 +gboolean nm_setting_match_remove_interface_name_by_value(NMSettingMatch *setting, + const char * interface_name); +NM_AVAILABLE_IN_1_14 +void nm_setting_match_add_interface_name(NMSettingMatch *setting, const char *interface_name); +NM_AVAILABLE_IN_1_14 +void nm_setting_match_clear_interface_names(NMSettingMatch *setting); +NM_AVAILABLE_IN_1_14 +const char *const *nm_setting_match_get_interface_names(NMSettingMatch *setting, guint *length); + +NM_AVAILABLE_IN_1_26 +guint nm_setting_match_get_num_kernel_command_lines(NMSettingMatch *setting); +NM_AVAILABLE_IN_1_26 +const char *nm_setting_match_get_kernel_command_line(NMSettingMatch *setting, guint idx); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_remove_kernel_command_line(NMSettingMatch *setting, guint idx); +NM_AVAILABLE_IN_1_26 +gboolean nm_setting_match_remove_kernel_command_line_by_value(NMSettingMatch *setting, + const char * kernel_command_line); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_add_kernel_command_line(NMSettingMatch *setting, + const char * kernel_command_line); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_clear_kernel_command_lines(NMSettingMatch *setting); +NM_AVAILABLE_IN_1_26 +const char *const *nm_setting_match_get_kernel_command_lines(NMSettingMatch *setting, + guint * length); + +NM_AVAILABLE_IN_1_26 +guint nm_setting_match_get_num_drivers(NMSettingMatch *setting); +NM_AVAILABLE_IN_1_26 +const char *nm_setting_match_get_driver(NMSettingMatch *setting, guint idx); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_remove_driver(NMSettingMatch *setting, guint idx); +NM_AVAILABLE_IN_1_26 +gboolean nm_setting_match_remove_driver_by_value(NMSettingMatch *setting, const char *driver); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_add_driver(NMSettingMatch *setting, const char *driver); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_clear_drivers(NMSettingMatch *setting); +NM_AVAILABLE_IN_1_26 +const char *const *nm_setting_match_get_drivers(NMSettingMatch *setting, guint *length); + +NM_AVAILABLE_IN_1_26 +guint nm_setting_match_get_num_paths(NMSettingMatch *setting); +NM_AVAILABLE_IN_1_26 +const char *nm_setting_match_get_path(NMSettingMatch *setting, guint idx); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_remove_path(NMSettingMatch *setting, guint idx); +NM_AVAILABLE_IN_1_26 +gboolean nm_setting_match_remove_path_by_value(NMSettingMatch *setting, const char *path); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_add_path(NMSettingMatch *setting, const char *path); +NM_AVAILABLE_IN_1_26 +void nm_setting_match_clear_paths(NMSettingMatch *setting); +NM_AVAILABLE_IN_1_26 +const char *const *nm_setting_match_get_paths(NMSettingMatch *setting, guint *length); + +G_END_DECLS + +#endif /* NM_SETTING_MATCH_H */ diff --git a/src/libnm-core-public/nm-setting-olpc-mesh.h b/src/libnm-core-public/nm-setting-olpc-mesh.h new file mode 100644 index 0000000000..fdba4a4b9a --- /dev/null +++ b/src/libnm-core-public/nm-setting-olpc-mesh.h @@ -0,0 +1,61 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2008 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + * Copyright (C) 2009 One Laptop per Child + */ + +#ifndef __NM_SETTING_OLPC_MESH_H__ +#define __NM_SETTING_OLPC_MESH_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_OLPC_MESH (nm_setting_olpc_mesh_get_type()) +#define NM_SETTING_OLPC_MESH(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_OLPC_MESH, NMSettingOlpcMesh)) +#define NM_SETTING_OLPC_MESH_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_OLPC_MESH, NMSettingOlpcMeshClass)) +#define NM_IS_SETTING_OLPC_MESH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_OLPC_MESH)) +#define NM_IS_SETTING_OLPC_MESH_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_OLPC_MESH)) +#define NM_SETTING_OLPC_MESH_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_OLPC_MESH, NMSettingOlpcMeshClass)) + +#define NM_SETTING_OLPC_MESH_SETTING_NAME "802-11-olpc-mesh" + +#define NM_SETTING_OLPC_MESH_SSID "ssid" +#define NM_SETTING_OLPC_MESH_CHANNEL "channel" +#define NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS "dhcp-anycast-address" + +/** + * NMSettingOlpcMesh: + * + * OLPC Wireless Mesh Settings + */ +struct _NMSettingOlpcMesh { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingOlpcMeshClass; + +GType nm_setting_olpc_mesh_get_type(void); + +NMSetting * nm_setting_olpc_mesh_new(void); +GBytes * nm_setting_olpc_mesh_get_ssid(NMSettingOlpcMesh *setting); +guint32 nm_setting_olpc_mesh_get_channel(NMSettingOlpcMesh *setting); +const char *nm_setting_olpc_mesh_get_dhcp_anycast_address(NMSettingOlpcMesh *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_OLPC_MESH_H__ */ diff --git a/src/libnm-core-public/nm-setting-ovs-bridge.h b/src/libnm-core-public/nm-setting-ovs-bridge.h new file mode 100644 index 0000000000..b307871503 --- /dev/null +++ b/src/libnm-core-public/nm-setting-ovs-bridge.h @@ -0,0 +1,57 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_OVS_BRIDGE_H__ +#define __NM_SETTING_OVS_BRIDGE_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_OVS_BRIDGE (nm_setting_ovs_bridge_get_type()) +#define NM_SETTING_OVS_BRIDGE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_OVS_BRIDGE, NMSettingOvsBridge)) +#define NM_SETTING_OVS_BRIDGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_OVS_BRIDGECONFIG, NMSettingOvsBridgeClass)) +#define NM_IS_SETTING_OVS_BRIDGE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_OVS_BRIDGE)) +#define NM_IS_SETTING_OVS_BRIDGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_OVS_BRIDGE)) +#define NM_SETTING_OVS_BRIDGE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_OVS_BRIDGE, NMSettingOvsBridgeClass)) + +#define NM_SETTING_OVS_BRIDGE_SETTING_NAME "ovs-bridge" + +#define NM_SETTING_OVS_BRIDGE_FAIL_MODE "fail-mode" +#define NM_SETTING_OVS_BRIDGE_MCAST_SNOOPING_ENABLE "mcast-snooping-enable" +#define NM_SETTING_OVS_BRIDGE_RSTP_ENABLE "rstp-enable" +#define NM_SETTING_OVS_BRIDGE_STP_ENABLE "stp-enable" +#define NM_SETTING_OVS_BRIDGE_DATAPATH_TYPE "datapath-type" + +typedef struct _NMSettingOvsBridgeClass NMSettingOvsBridgeClass; + +NM_AVAILABLE_IN_1_10 +GType nm_setting_ovs_bridge_get_type(void); +NM_AVAILABLE_IN_1_10 +NMSetting *nm_setting_ovs_bridge_new(void); + +NM_AVAILABLE_IN_1_10 +const char *nm_setting_ovs_bridge_get_fail_mode(NMSettingOvsBridge *self); +NM_AVAILABLE_IN_1_10 +gboolean nm_setting_ovs_bridge_get_mcast_snooping_enable(NMSettingOvsBridge *self); +NM_AVAILABLE_IN_1_10 +gboolean nm_setting_ovs_bridge_get_rstp_enable(NMSettingOvsBridge *self); +NM_AVAILABLE_IN_1_10 +gboolean nm_setting_ovs_bridge_get_stp_enable(NMSettingOvsBridge *self); +NM_AVAILABLE_IN_1_20 +const char *nm_setting_ovs_bridge_get_datapath_type(NMSettingOvsBridge *self); + +G_END_DECLS + +#endif /* __NM_SETTING_OVS_BRIDGE_H__ */ diff --git a/src/libnm-core-public/nm-setting-ovs-dpdk.h b/src/libnm-core-public/nm-setting-ovs-dpdk.h new file mode 100644 index 0000000000..72de2243c0 --- /dev/null +++ b/src/libnm-core-public/nm-setting-ovs-dpdk.h @@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2019 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_OVS_DPDK_H__ +#define __NM_SETTING_OVS_DPDK_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_OVS_DPDK (nm_setting_ovs_dpdk_get_type()) +#define NM_SETTING_OVS_DPDK(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_OVS_DPDK, NMSettingOvsDpdk)) +#define NM_SETTING_OVS_DPDK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_OVS_DPDKCONFIG, NMSettingOvsDpdkClass)) +#define NM_IS_SETTING_OVS_DPDK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_OVS_DPDK)) +#define NM_IS_SETTING_OVS_DPDK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_OVS_DPDK)) +#define NM_SETTING_OVS_DPDK_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_OVS_DPDK, NMSettingOvsDpdkClass)) + +#define NM_SETTING_OVS_DPDK_SETTING_NAME "ovs-dpdk" + +#define NM_SETTING_OVS_DPDK_DEVARGS "devargs" + +typedef struct _NMSettingOvsDpdkClass NMSettingOvsDpdkClass; + +NM_AVAILABLE_IN_1_20 +GType nm_setting_ovs_dpdk_get_type(void); +NM_AVAILABLE_IN_1_20 +NMSetting *nm_setting_ovs_dpdk_new(void); + +NM_AVAILABLE_IN_1_20 +const char *nm_setting_ovs_dpdk_get_devargs(NMSettingOvsDpdk *self); + +G_END_DECLS + +#endif /* __NM_SETTING_OVS_DPDK_H__ */ diff --git a/src/libnm-core-public/nm-setting-ovs-external-ids.h b/src/libnm-core-public/nm-setting-ovs-external-ids.h new file mode 100644 index 0000000000..906db392f1 --- /dev/null +++ b/src/libnm-core-public/nm-setting-ovs-external-ids.h @@ -0,0 +1,68 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 - 2020 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_OVS_EXTERNAL_IDS_H__ +#define __NM_SETTING_OVS_EXTERNAL_IDS_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_OVS_EXTERNAL_IDS (nm_setting_ovs_external_ids_get_type()) +#define NM_SETTING_OVS_EXTERNAL_IDS(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_OVS_EXTERNAL_IDS, NMSettingOvsExternalIDs)) +#define NM_SETTING_OVS_EXTERNAL_IDS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), \ + NM_TYPE_SETTING_OVS_EXTERNAL_IDS, \ + NMSettingOvsExternalIDsClass)) +#define NM_IS_SETTING_OVS_EXTERNAL_IDS(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_OVS_EXTERNAL_IDS)) +#define NM_IS_SETTING_OVS_EXTERNAL_IDS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_OVS_EXTERNAL_IDS)) +#define NM_SETTING_OVS_EXTERNAL_IDS_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), \ + NM_TYPE_SETTING_OVS_EXTERNAL_IDS, \ + NMSettingOvsExternalIDsClass)) + +#define NM_SETTING_OVS_EXTERNAL_IDS_SETTING_NAME "ovs-external-ids" + +#define NM_SETTING_OVS_EXTERNAL_IDS_DATA "data" + +typedef struct _NMSettingOvsExternalIDsClass NMSettingOvsExternalIDsClass; + +NM_AVAILABLE_IN_1_30 +GType nm_setting_ovs_external_ids_get_type(void); + +NM_AVAILABLE_IN_1_30 +NMSetting *nm_setting_ovs_external_ids_new(void); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_30 +const char *const *nm_setting_ovs_external_ids_get_data_keys(NMSettingOvsExternalIDs *setting, + guint * out_len); + +NM_AVAILABLE_IN_1_30 +const char *nm_setting_ovs_external_ids_get_data(NMSettingOvsExternalIDs *setting, const char *key); + +NM_AVAILABLE_IN_1_30 +void nm_setting_ovs_external_ids_set_data(NMSettingOvsExternalIDs *setting, + const char * key, + const char * val); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_30 +gboolean nm_setting_ovs_external_ids_check_key(const char *key, GError **error); +NM_AVAILABLE_IN_1_30 +gboolean nm_setting_ovs_external_ids_check_val(const char *val, GError **error); + +G_END_DECLS + +#endif /* __NM_SETTING_OVS_EXTERNAL_IDS_H__ */ diff --git a/src/libnm-core-public/nm-setting-ovs-interface.h b/src/libnm-core-public/nm-setting-ovs-interface.h new file mode 100644 index 0000000000..47ad5817cd --- /dev/null +++ b/src/libnm-core-public/nm-setting-ovs-interface.h @@ -0,0 +1,47 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_OVS_INTERFACE_H__ +#define __NM_SETTING_OVS_INTERFACE_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_OVS_INTERFACE (nm_setting_ovs_interface_get_type()) +#define NM_SETTING_OVS_INTERFACE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_OVS_INTERFACE, NMSettingOvsInterface)) +#define NM_SETTING_OVS_INTERFACE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), \ + NM_TYPE_SETTING_OVS_INTERFACECONFIG, \ + NMSettingOvsInterfaceClass)) +#define NM_IS_SETTING_OVS_INTERFACE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_OVS_INTERFACE)) +#define NM_IS_SETTING_OVS_INTERFACE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_OVS_INTERFACE)) +#define NM_SETTING_OVS_INTERFACE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_OVS_INTERFACE, NMSettingOvsInterfaceClass)) + +#define NM_SETTING_OVS_INTERFACE_SETTING_NAME "ovs-interface" + +#define NM_SETTING_OVS_INTERFACE_TYPE "type" + +typedef struct _NMSettingOvsInterfaceClass NMSettingOvsInterfaceClass; + +NM_AVAILABLE_IN_1_10 +GType nm_setting_ovs_interface_get_type(void); +NM_AVAILABLE_IN_1_10 +NMSetting *nm_setting_ovs_interface_new(void); + +NM_AVAILABLE_IN_1_10 +const char *nm_setting_ovs_interface_get_interface_type(NMSettingOvsInterface *self); + +G_END_DECLS + +#endif /* __NM_SETTING_OVS_INTERFACE_H__ */ diff --git a/src/libnm-core-public/nm-setting-ovs-patch.h b/src/libnm-core-public/nm-setting-ovs-patch.h new file mode 100644 index 0000000000..fd80d45a48 --- /dev/null +++ b/src/libnm-core-public/nm-setting-ovs-patch.h @@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_OVS_PATCH_H__ +#define __NM_SETTING_OVS_PATCH_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_OVS_PATCH (nm_setting_ovs_patch_get_type()) +#define NM_SETTING_OVS_PATCH(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_OVS_PATCH, NMSettingOvsPatch)) +#define NM_SETTING_OVS_PATCH_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_OVS_PATCHCONFIG, NMSettingOvsPatchClass)) +#define NM_IS_SETTING_OVS_PATCH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_OVS_PATCH)) +#define NM_IS_SETTING_OVS_PATCH_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_OVS_PATCH)) +#define NM_SETTING_OVS_PATCH_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_OVS_PATCH, NMSettingOvsPatchClass)) + +#define NM_SETTING_OVS_PATCH_SETTING_NAME "ovs-patch" + +#define NM_SETTING_OVS_PATCH_PEER "peer" + +typedef struct _NMSettingOvsPatchClass NMSettingOvsPatchClass; + +NM_AVAILABLE_IN_1_10 +GType nm_setting_ovs_patch_get_type(void); +NM_AVAILABLE_IN_1_10 +NMSetting *nm_setting_ovs_patch_new(void); + +NM_AVAILABLE_IN_1_10 +const char *nm_setting_ovs_patch_get_peer(NMSettingOvsPatch *self); + +G_END_DECLS + +#endif /* __NM_SETTING_OVS_PATCH_H__ */ diff --git a/src/libnm-core-public/nm-setting-ovs-port.h b/src/libnm-core-public/nm-setting-ovs-port.h new file mode 100644 index 0000000000..06d3a2aa0f --- /dev/null +++ b/src/libnm-core-public/nm-setting-ovs-port.h @@ -0,0 +1,59 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_OVS_PORT_H__ +#define __NM_SETTING_OVS_PORT_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_OVS_PORT (nm_setting_ovs_port_get_type()) +#define NM_SETTING_OVS_PORT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_OVS_PORT, NMSettingOvsPort)) +#define NM_SETTING_OVS_PORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_OVS_PORTCONFIG, NMSettingOvsPortClass)) +#define NM_IS_SETTING_OVS_PORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_OVS_PORT)) +#define NM_IS_SETTING_OVS_PORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_OVS_PORT)) +#define NM_SETTING_OVS_PORT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_OVS_PORT, NMSettingOvsPortClass)) + +#define NM_SETTING_OVS_PORT_SETTING_NAME "ovs-port" + +#define NM_SETTING_OVS_PORT_VLAN_MODE "vlan-mode" +#define NM_SETTING_OVS_PORT_TAG "tag" +#define NM_SETTING_OVS_PORT_LACP "lacp" +#define NM_SETTING_OVS_PORT_BOND_MODE "bond-mode" +#define NM_SETTING_OVS_PORT_BOND_UPDELAY "bond-updelay" +#define NM_SETTING_OVS_PORT_BOND_DOWNDELAY "bond-downdelay" + +typedef struct _NMSettingOvsPortClass NMSettingOvsPortClass; + +NM_AVAILABLE_IN_1_10 +GType nm_setting_ovs_port_get_type(void); +NM_AVAILABLE_IN_1_10 +NMSetting *nm_setting_ovs_port_new(void); + +NM_AVAILABLE_IN_1_10 +const char *nm_setting_ovs_port_get_vlan_mode(NMSettingOvsPort *self); +NM_AVAILABLE_IN_1_10 +guint nm_setting_ovs_port_get_tag(NMSettingOvsPort *self); +NM_AVAILABLE_IN_1_10 +const char *nm_setting_ovs_port_get_lacp(NMSettingOvsPort *self); +NM_AVAILABLE_IN_1_10 +const char *nm_setting_ovs_port_get_bond_mode(NMSettingOvsPort *self); +NM_AVAILABLE_IN_1_10 +guint nm_setting_ovs_port_get_bond_updelay(NMSettingOvsPort *self); +NM_AVAILABLE_IN_1_10 +guint nm_setting_ovs_port_get_bond_downdelay(NMSettingOvsPort *self); + +G_END_DECLS + +#endif /* __NM_SETTING_OVS_PORT_H__ */ diff --git a/src/libnm-core-public/nm-setting-ppp.h b/src/libnm-core-public/nm-setting-ppp.h new file mode 100644 index 0000000000..91c5347f07 --- /dev/null +++ b/src/libnm-core-public/nm-setting-ppp.h @@ -0,0 +1,88 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2008 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_PPP_H__ +#define __NM_SETTING_PPP_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_PPP (nm_setting_ppp_get_type()) +#define NM_SETTING_PPP(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_PPP, NMSettingPpp)) +#define NM_SETTING_PPP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_PPP, NMSettingPppClass)) +#define NM_IS_SETTING_PPP(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_PPP)) +#define NM_IS_SETTING_PPP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_PPP)) +#define NM_SETTING_PPP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_PPP, NMSettingPppClass)) + +#define NM_SETTING_PPP_SETTING_NAME "ppp" + +#define NM_SETTING_PPP_NOAUTH "noauth" +#define NM_SETTING_PPP_REFUSE_EAP "refuse-eap" +#define NM_SETTING_PPP_REFUSE_PAP "refuse-pap" +#define NM_SETTING_PPP_REFUSE_CHAP "refuse-chap" +#define NM_SETTING_PPP_REFUSE_MSCHAP "refuse-mschap" +#define NM_SETTING_PPP_REFUSE_MSCHAPV2 "refuse-mschapv2" +#define NM_SETTING_PPP_NOBSDCOMP "nobsdcomp" +#define NM_SETTING_PPP_NODEFLATE "nodeflate" +#define NM_SETTING_PPP_NO_VJ_COMP "no-vj-comp" +#define NM_SETTING_PPP_REQUIRE_MPPE "require-mppe" +#define NM_SETTING_PPP_REQUIRE_MPPE_128 "require-mppe-128" +#define NM_SETTING_PPP_MPPE_STATEFUL "mppe-stateful" +#define NM_SETTING_PPP_CRTSCTS "crtscts" +#define NM_SETTING_PPP_BAUD "baud" +#define NM_SETTING_PPP_MRU "mru" +#define NM_SETTING_PPP_MTU "mtu" +#define NM_SETTING_PPP_LCP_ECHO_FAILURE "lcp-echo-failure" +#define NM_SETTING_PPP_LCP_ECHO_INTERVAL "lcp-echo-interval" + +/** + * NMSettingPpp: + * + * Point-to-Point Protocol Settings + */ +struct _NMSettingPpp { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingPppClass; + +GType nm_setting_ppp_get_type(void); + +NMSetting *nm_setting_ppp_new(void); +gboolean nm_setting_ppp_get_noauth(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_refuse_eap(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_refuse_pap(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_refuse_chap(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_refuse_mschap(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_refuse_mschapv2(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_nobsdcomp(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_nodeflate(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_no_vj_comp(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_require_mppe(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_require_mppe_128(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_mppe_stateful(NMSettingPpp *setting); +gboolean nm_setting_ppp_get_crtscts(NMSettingPpp *setting); +guint32 nm_setting_ppp_get_baud(NMSettingPpp *setting); +guint32 nm_setting_ppp_get_mru(NMSettingPpp *setting); +guint32 nm_setting_ppp_get_mtu(NMSettingPpp *setting); +guint32 nm_setting_ppp_get_lcp_echo_failure(NMSettingPpp *setting); +guint32 nm_setting_ppp_get_lcp_echo_interval(NMSettingPpp *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_PPP_H__ */ diff --git a/src/libnm-core-public/nm-setting-pppoe.h b/src/libnm-core-public/nm-setting-pppoe.h new file mode 100644 index 0000000000..0a30f5a189 --- /dev/null +++ b/src/libnm-core-public/nm-setting-pppoe.h @@ -0,0 +1,64 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2011 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_PPPOE_H__ +#define __NM_SETTING_PPPOE_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_PPPOE (nm_setting_pppoe_get_type()) +#define NM_SETTING_PPPOE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_PPPOE, NMSettingPppoe)) +#define NM_SETTING_PPPOE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_PPPOE, NMSettingPppoeClass)) +#define NM_IS_SETTING_PPPOE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_PPPOE)) +#define NM_IS_SETTING_PPPOE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_PPPOE)) +#define NM_SETTING_PPPOE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_PPPOE, NMSettingPppoeClass)) + +#define NM_SETTING_PPPOE_SETTING_NAME "pppoe" + +#define NM_SETTING_PPPOE_PARENT "parent" +#define NM_SETTING_PPPOE_SERVICE "service" +#define NM_SETTING_PPPOE_USERNAME "username" +#define NM_SETTING_PPPOE_PASSWORD "password" +#define NM_SETTING_PPPOE_PASSWORD_FLAGS "password-flags" + +/** + * NMSettingPppoe: + * + * PPP-over-Ethernet Settings + */ +struct _NMSettingPppoe { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingPppoeClass; + +GType nm_setting_pppoe_get_type(void); + +NMSetting *nm_setting_pppoe_new(void); +NM_AVAILABLE_IN_1_10 +const char * nm_setting_pppoe_get_parent(NMSettingPppoe *setting); +const char * nm_setting_pppoe_get_service(NMSettingPppoe *setting); +const char * nm_setting_pppoe_get_username(NMSettingPppoe *setting); +const char * nm_setting_pppoe_get_password(NMSettingPppoe *setting); +NMSettingSecretFlags nm_setting_pppoe_get_password_flags(NMSettingPppoe *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_PPPOE_H__ */ diff --git a/src/libnm-core-public/nm-setting-proxy.h b/src/libnm-core-public/nm-setting-proxy.h new file mode 100644 index 0000000000..70227df169 --- /dev/null +++ b/src/libnm-core-public/nm-setting-proxy.h @@ -0,0 +1,80 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2016 Atul Anand <atulhjp@gmail.com>. + */ + +#ifndef __NM_SETTING_PROXY_H__ +#define __NM_SETTING_PROXY_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +/** + * NMSettingProxyMethod: + * @NM_SETTING_PROXY_METHOD_NONE: No Proxy for the Connection + * @NM_SETTING_PROXY_METHOD_AUTO: DHCP obtained Proxy/ Manual override + * + * The Proxy method. + * + * Since: 1.6 + */ +typedef enum { + NM_SETTING_PROXY_METHOD_NONE = 0, + NM_SETTING_PROXY_METHOD_AUTO = 1, +} NMSettingProxyMethod; + +#define NM_TYPE_SETTING_PROXY (nm_setting_proxy_get_type()) +#define NM_SETTING_PROXY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_PROXY, NMSettingProxy)) +#define NM_SETTING_PROXY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_PROXY, NMSettingProxyClass)) +#define NM_IS_SETTING_PROXY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_PROXY)) +#define NM_IS_SETTING_PROXY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_PROXY)) +#define NM_SETTING_PROXY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_PROXY, NMSettingProxyClass)) + +#define NM_SETTING_PROXY_SETTING_NAME "proxy" + +#define NM_SETTING_PROXY_METHOD "method" +#define NM_SETTING_PROXY_BROWSER_ONLY "browser-only" +#define NM_SETTING_PROXY_PAC_URL "pac-url" +#define NM_SETTING_PROXY_PAC_SCRIPT "pac-script" + +/** + * NMSettingProxy: + * + * WWW Proxy Settings + */ +struct _NMSettingProxy { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + gpointer padding[4]; +} NMSettingProxyClass; + +NM_AVAILABLE_IN_1_6 +GType nm_setting_proxy_get_type(void); + +NM_AVAILABLE_IN_1_6 +NMSetting *nm_setting_proxy_new(void); + +NM_AVAILABLE_IN_1_6 +NMSettingProxyMethod nm_setting_proxy_get_method(NMSettingProxy *setting); +NM_AVAILABLE_IN_1_6 +gboolean nm_setting_proxy_get_browser_only(NMSettingProxy *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_proxy_get_pac_url(NMSettingProxy *setting); +NM_AVAILABLE_IN_1_6 +const char *nm_setting_proxy_get_pac_script(NMSettingProxy *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_PROXY_H__ */ diff --git a/src/libnm-core-public/nm-setting-serial.h b/src/libnm-core-public/nm-setting-serial.h new file mode 100644 index 0000000000..abd232e8f1 --- /dev/null +++ b/src/libnm-core-public/nm-setting-serial.h @@ -0,0 +1,77 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2008 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_SERIAL_H__ +#define __NM_SETTING_SERIAL_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_SERIAL (nm_setting_serial_get_type()) +#define NM_SETTING_SERIAL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_SERIAL, NMSettingSerial)) +#define NM_SETTING_SERIAL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_SERIAL, NMSettingSerialClass)) +#define NM_IS_SETTING_SERIAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_SERIAL)) +#define NM_IS_SETTING_SERIAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_SERIAL)) +#define NM_SETTING_SERIAL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_SERIAL, NMSettingSerialClass)) + +#define NM_SETTING_SERIAL_SETTING_NAME "serial" + +/** + * NMSettingSerialParity: + * @NM_SETTING_SERIAL_PARITY_NONE: No parity bits (default) + * @NM_SETTING_SERIAL_PARITY_EVEN: Even parity + * @NM_SETTING_SERIAL_PARITY_ODD: Odd parity + * + * The parity setting of a serial port. + */ +typedef enum { + NM_SETTING_SERIAL_PARITY_NONE = 0, + NM_SETTING_SERIAL_PARITY_EVEN, + NM_SETTING_SERIAL_PARITY_ODD +} NMSettingSerialParity; + +#define NM_SETTING_SERIAL_BAUD "baud" +#define NM_SETTING_SERIAL_BITS "bits" +#define NM_SETTING_SERIAL_PARITY "parity" +#define NM_SETTING_SERIAL_STOPBITS "stopbits" +#define NM_SETTING_SERIAL_SEND_DELAY "send-delay" + +/** + * NMSettingSerial: + * + * Serial Link Settings + */ +struct _NMSettingSerial { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingSerialClass; + +GType nm_setting_serial_get_type(void); + +NMSetting * nm_setting_serial_new(void); +guint nm_setting_serial_get_baud(NMSettingSerial *setting); +guint nm_setting_serial_get_bits(NMSettingSerial *setting); +NMSettingSerialParity nm_setting_serial_get_parity(NMSettingSerial *setting); +guint nm_setting_serial_get_stopbits(NMSettingSerial *setting); +guint64 nm_setting_serial_get_send_delay(NMSettingSerial *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_SERIAL_H__ */ diff --git a/src/libnm-core-public/nm-setting-sriov.h b/src/libnm-core-public/nm-setting-sriov.h new file mode 100644 index 0000000000..fe5fc3766f --- /dev/null +++ b/src/libnm-core-public/nm-setting-sriov.h @@ -0,0 +1,118 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2018 Red Hat, Inc. + */ + +#ifndef NM_SETTING_SRIOV_H +#define NM_SETTING_SRIOV_H + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_SRIOV (nm_setting_sriov_get_type()) +#define NM_SETTING_SRIOV(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_SRIOV, NMSettingSriov)) +#define NM_SETTING_SRIOV_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_SRIOV, NMSettingSriovClass)) +#define NM_IS_SETTING_SRIOV(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_SRIOV)) +#define NM_IS_SETTING_SRIOV_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_SRIOV)) +#define NM_SETTING_SRIOV_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_SRIOV, NMSettingSriovClass)) + +#define NM_SETTING_SRIOV_SETTING_NAME "sriov" + +#define NM_SETTING_SRIOV_TOTAL_VFS "total-vfs" +#define NM_SETTING_SRIOV_VFS "vfs" +#define NM_SETTING_SRIOV_AUTOPROBE_DRIVERS "autoprobe-drivers" + +#define NM_SRIOV_VF_ATTRIBUTE_MAC "mac" +#define NM_SRIOV_VF_ATTRIBUTE_SPOOF_CHECK "spoof-check" +#define NM_SRIOV_VF_ATTRIBUTE_TRUST "trust" +#define NM_SRIOV_VF_ATTRIBUTE_MIN_TX_RATE "min-tx-rate" +#define NM_SRIOV_VF_ATTRIBUTE_MAX_TX_RATE "max-tx-rate" + +typedef struct _NMSettingSriovClass NMSettingSriovClass; +typedef struct _NMSriovVF NMSriovVF; + +/** + * NMSriovVFVlanProtocol: + * @NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q: use 802.1Q + * @NM_SRIOV_VF_VLAN_PROTOCOL_802_1AD: use 802.1ad + * + * #NMSriovVFVlanProtocol indicates the VLAN protocol to use. + * + * Since: 1.14 + */ +typedef enum { + NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q = 0, + NM_SRIOV_VF_VLAN_PROTOCOL_802_1AD = 1, +} NMSriovVFVlanProtocol; + +NM_AVAILABLE_IN_1_14 +GType nm_setting_sriov_get_type(void); +NM_AVAILABLE_IN_1_14 +NMSetting *nm_setting_sriov_new(void); +NM_AVAILABLE_IN_1_14 +guint nm_setting_sriov_get_total_vfs(NMSettingSriov *setting); +NM_AVAILABLE_IN_1_14 +guint nm_setting_sriov_get_num_vfs(NMSettingSriov *setting); +NM_AVAILABLE_IN_1_14 +NMSriovVF *nm_setting_sriov_get_vf(NMSettingSriov *setting, guint idx); +NM_AVAILABLE_IN_1_14 +void nm_setting_sriov_add_vf(NMSettingSriov *setting, NMSriovVF *vf); +NM_AVAILABLE_IN_1_14 +void nm_setting_sriov_remove_vf(NMSettingSriov *setting, guint idx); +NM_AVAILABLE_IN_1_14 +gboolean nm_setting_sriov_remove_vf_by_index(NMSettingSriov *setting, guint index); +NM_AVAILABLE_IN_1_14 +void nm_setting_sriov_clear_vfs(NMSettingSriov *setting); +NM_AVAILABLE_IN_1_14 +NMTernary nm_setting_sriov_get_autoprobe_drivers(NMSettingSriov *setting); + +NM_AVAILABLE_IN_1_14 +gboolean nm_sriov_vf_add_vlan(NMSriovVF *vf, guint vlan_id); +NM_AVAILABLE_IN_1_14 +gboolean nm_sriov_vf_remove_vlan(NMSriovVF *vf, guint vlan_id); +NM_AVAILABLE_IN_1_14 +const guint *nm_sriov_vf_get_vlan_ids(const NMSriovVF *vf, guint *length); +NM_AVAILABLE_IN_1_14 +void nm_sriov_vf_set_vlan_qos(NMSriovVF *vf, guint vlan_id, guint32 qos); +NM_AVAILABLE_IN_1_14 +void nm_sriov_vf_set_vlan_protocol(NMSriovVF *vf, guint vlan_id, NMSriovVFVlanProtocol protocol); +NM_AVAILABLE_IN_1_14 +guint32 nm_sriov_vf_get_vlan_qos(const NMSriovVF *vf, guint vlan_id); +NM_AVAILABLE_IN_1_14 +NMSriovVFVlanProtocol nm_sriov_vf_get_vlan_protocol(const NMSriovVF *vf, guint vlan_id); + +NM_AVAILABLE_IN_1_14 +GType nm_sriov_vf_get_type(void); +NM_AVAILABLE_IN_1_14 +NMSriovVF *nm_sriov_vf_new(guint index); +NM_AVAILABLE_IN_1_14 +void nm_sriov_vf_ref(NMSriovVF *vf); +NM_AVAILABLE_IN_1_14 +void nm_sriov_vf_unref(NMSriovVF *vf); +NM_AVAILABLE_IN_1_14 +gboolean nm_sriov_vf_equal(const NMSriovVF *vf, const NMSriovVF *other); +NM_AVAILABLE_IN_1_14 +NMSriovVF *nm_sriov_vf_dup(const NMSriovVF *vf); +NM_AVAILABLE_IN_1_14 +guint nm_sriov_vf_get_index(const NMSriovVF *vf); +NM_AVAILABLE_IN_1_14 +void nm_sriov_vf_set_attribute(NMSriovVF *vf, const char *name, GVariant *value); +NM_AVAILABLE_IN_1_14 +const char **nm_sriov_vf_get_attribute_names(const NMSriovVF *vf); +NM_AVAILABLE_IN_1_14 +GVariant *nm_sriov_vf_get_attribute(const NMSriovVF *vf, const char *name); +NM_AVAILABLE_IN_1_14 +gboolean +nm_sriov_vf_attribute_validate(const char *name, GVariant *value, gboolean *known, GError **error); + +G_END_DECLS + +#endif /* NM_SETTING_SRIOV_H */ diff --git a/src/libnm-core-public/nm-setting-tc-config.h b/src/libnm-core-public/nm-setting-tc-config.h new file mode 100644 index 0000000000..a2bc9a0dae --- /dev/null +++ b/src/libnm-core-public/nm-setting-tc-config.h @@ -0,0 +1,162 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 Red Hat, Inc. + */ + +#ifndef NM_SETTING_TC_CONFIG_H +#define NM_SETTING_TC_CONFIG_H + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +typedef struct NMTCQdisc NMTCQdisc; + +NM_AVAILABLE_IN_1_12 +GType nm_tc_qdisc_get_type(void); + +NM_AVAILABLE_IN_1_12 +NMTCQdisc *nm_tc_qdisc_new(const char *kind, guint32 parent, GError **error); + +NM_AVAILABLE_IN_1_12 +void nm_tc_qdisc_ref(NMTCQdisc *qdisc); +NM_AVAILABLE_IN_1_12 +void nm_tc_qdisc_unref(NMTCQdisc *qdisc); +NM_AVAILABLE_IN_1_12 +gboolean nm_tc_qdisc_equal(NMTCQdisc *qdisc, NMTCQdisc *other); + +NM_AVAILABLE_IN_1_12 +NMTCQdisc *nm_tc_qdisc_dup(NMTCQdisc *qdisc); + +NM_AVAILABLE_IN_1_12 +const char *nm_tc_qdisc_get_kind(NMTCQdisc *qdisc); +NM_AVAILABLE_IN_1_12 +guint32 nm_tc_qdisc_get_handle(NMTCQdisc *qdisc); +NM_AVAILABLE_IN_1_12 +void nm_tc_qdisc_set_handle(NMTCQdisc *qdisc, guint32 handle); +NM_AVAILABLE_IN_1_12 +guint32 nm_tc_qdisc_get_parent(NMTCQdisc *qdisc); + +NM_AVAILABLE_IN_1_18 +const char **nm_tc_qdisc_get_attribute_names(NMTCQdisc *qdisc); +NM_AVAILABLE_IN_1_18 +GVariant *nm_tc_qdisc_get_attribute(NMTCQdisc *qdisc, const char *name); +NM_AVAILABLE_IN_1_18 +void nm_tc_qdisc_set_attribute(NMTCQdisc *qdisc, const char *name, GVariant *value); + +typedef struct NMTCAction NMTCAction; + +NM_AVAILABLE_IN_1_12 +GType nm_tc_action_get_type(void); + +NM_AVAILABLE_IN_1_12 +NMTCAction *nm_tc_action_new(const char *kind, GError **error); + +NM_AVAILABLE_IN_1_12 +void nm_tc_action_ref(NMTCAction *action); +NM_AVAILABLE_IN_1_12 +void nm_tc_action_unref(NMTCAction *action); +NM_AVAILABLE_IN_1_12 +gboolean nm_tc_action_equal(NMTCAction *action, NMTCAction *other); + +NM_AVAILABLE_IN_1_12 +NMTCAction *nm_tc_action_dup(NMTCAction *action); + +NM_AVAILABLE_IN_1_12 +const char *nm_tc_action_get_kind(NMTCAction *action); + +NM_AVAILABLE_IN_1_12 +char **nm_tc_action_get_attribute_names(NMTCAction *action); +NM_AVAILABLE_IN_1_12 +GVariant *nm_tc_action_get_attribute(NMTCAction *action, const char *name); +NM_AVAILABLE_IN_1_12 +void nm_tc_action_set_attribute(NMTCAction *action, const char *name, GVariant *value); + +typedef struct NMTCTfilter NMTCTfilter; + +NM_AVAILABLE_IN_1_12 +GType nm_tc_tfilter_get_type(void); + +NM_AVAILABLE_IN_1_12 +NMTCTfilter *nm_tc_tfilter_new(const char *kind, guint32 parent, GError **error); + +NM_AVAILABLE_IN_1_12 +void nm_tc_tfilter_ref(NMTCTfilter *tfilter); +NM_AVAILABLE_IN_1_12 +void nm_tc_tfilter_unref(NMTCTfilter *tfilter); +NM_AVAILABLE_IN_1_12 +gboolean nm_tc_tfilter_equal(NMTCTfilter *tfilter, NMTCTfilter *other); + +NM_AVAILABLE_IN_1_12 +NMTCTfilter *nm_tc_tfilter_dup(NMTCTfilter *tfilter); + +NM_AVAILABLE_IN_1_12 +const char *nm_tc_tfilter_get_kind(NMTCTfilter *tfilter); +NM_AVAILABLE_IN_1_12 +guint32 nm_tc_tfilter_get_handle(NMTCTfilter *tfilter); +NM_AVAILABLE_IN_1_12 +void nm_tc_tfilter_set_handle(NMTCTfilter *tfilter, guint32 handle); +NM_AVAILABLE_IN_1_12 +guint32 nm_tc_tfilter_get_parent(NMTCTfilter *tfilter); +NM_AVAILABLE_IN_1_12 +NMTCAction *nm_tc_tfilter_get_action(NMTCTfilter *tfilter); +NM_AVAILABLE_IN_1_12 +void nm_tc_tfilter_set_action(NMTCTfilter *tfilter, NMTCAction *action); + +#define NM_TYPE_SETTING_TC_CONFIG (nm_setting_tc_config_get_type()) +#define NM_SETTING_TC_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_TC_CONFIG, NMSettingTCConfig)) +#define NM_SETTING_TC_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_TC_CONFIG, NMSettingTCConfigClass)) +#define NM_IS_SETTING_TC_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_TC_CONFIG)) +#define NM_IS_SETTING_TC_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_TC_CONFIG)) +#define NM_SETTING_TC_CONFIG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_TC_CONFIG, NMSettingTCConfigClass)) + +#define NM_SETTING_TC_CONFIG_SETTING_NAME "tc" + +#define NM_SETTING_TC_CONFIG_QDISCS "qdiscs" +#define NM_SETTING_TC_CONFIG_TFILTERS "tfilters" + +typedef struct _NMSettingTCConfigClass NMSettingTCConfigClass; + +GType nm_setting_tc_config_get_type(void); + +NM_AVAILABLE_IN_1_12 +NMSetting *nm_setting_tc_config_new(void); + +NM_AVAILABLE_IN_1_12 +guint nm_setting_tc_config_get_num_qdiscs(NMSettingTCConfig *setting); +NM_AVAILABLE_IN_1_12 +NMTCQdisc *nm_setting_tc_config_get_qdisc(NMSettingTCConfig *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_tc_config_add_qdisc(NMSettingTCConfig *setting, NMTCQdisc *qdisc); +NM_AVAILABLE_IN_1_12 +void nm_setting_tc_config_remove_qdisc(NMSettingTCConfig *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_tc_config_remove_qdisc_by_value(NMSettingTCConfig *setting, NMTCQdisc *qdisc); +NM_AVAILABLE_IN_1_12 +void nm_setting_tc_config_clear_qdiscs(NMSettingTCConfig *setting); + +NM_AVAILABLE_IN_1_12 +guint nm_setting_tc_config_get_num_tfilters(NMSettingTCConfig *setting); +NM_AVAILABLE_IN_1_12 +NMTCTfilter *nm_setting_tc_config_get_tfilter(NMSettingTCConfig *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_tc_config_add_tfilter(NMSettingTCConfig *setting, NMTCTfilter *tfilter); +NM_AVAILABLE_IN_1_12 +void nm_setting_tc_config_remove_tfilter(NMSettingTCConfig *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_tc_config_remove_tfilter_by_value(NMSettingTCConfig *setting, + NMTCTfilter * tfilter); +NM_AVAILABLE_IN_1_12 +void nm_setting_tc_config_clear_tfilters(NMSettingTCConfig *setting); + +G_END_DECLS + +#endif /* NM_SETTING_TC_CONFIG_H */ diff --git a/src/libnm-core-public/nm-setting-team-port.h b/src/libnm-core-public/nm-setting-team-port.h new file mode 100644 index 0000000000..4d4d9bdca0 --- /dev/null +++ b/src/libnm-core-public/nm-setting-team-port.h @@ -0,0 +1,89 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2013 Jiri Pirko <jiri@resnulli.us> + */ + +#ifndef __NM_SETTING_TEAM_PORT_H__ +#define __NM_SETTING_TEAM_PORT_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" +#include "nm-setting-team.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_TEAM_PORT (nm_setting_team_port_get_type()) +#define NM_SETTING_TEAM_PORT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_TEAM_PORT, NMSettingTeamPort)) +#define NM_SETTING_TEAM_PORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_TEAM_PORT, NMSettingTeamPortClass)) +#define NM_IS_SETTING_TEAM_PORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_TEAM_PORT)) +#define NM_IS_SETTING_TEAM_PORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_TEAM_PORT)) +#define NM_SETTING_TEAM_PORT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_TEAM_PORT, NMSettingTeamPortClass)) + +#define NM_SETTING_TEAM_PORT_SETTING_NAME "team-port" + +#define NM_SETTING_TEAM_PORT_CONFIG "config" +#define NM_SETTING_TEAM_PORT_QUEUE_ID "queue-id" +#define NM_SETTING_TEAM_PORT_PRIO "prio" +#define NM_SETTING_TEAM_PORT_STICKY "sticky" +#define NM_SETTING_TEAM_PORT_LACP_PRIO "lacp-prio" +#define NM_SETTING_TEAM_PORT_LACP_KEY "lacp-key" +#define NM_SETTING_TEAM_PORT_LINK_WATCHERS "link-watchers" + +#define NM_SETTING_TEAM_PORT_QUEUE_ID_DEFAULT -1 +#define NM_SETTING_TEAM_PORT_LACP_PRIO_DEFAULT 255 + +/** + * NMSettingTeamPort: + * + * Team Port Settings + */ +struct _NMSettingTeamPort { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingTeamPortClass; + +GType nm_setting_team_port_get_type(void); + +NMSetting *nm_setting_team_port_new(void); + +const char *nm_setting_team_port_get_config(NMSettingTeamPort *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_port_get_queue_id(NMSettingTeamPort *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_port_get_prio(NMSettingTeamPort *setting); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_port_get_sticky(NMSettingTeamPort *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_port_get_lacp_prio(NMSettingTeamPort *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_port_get_lacp_key(NMSettingTeamPort *setting); +NM_AVAILABLE_IN_1_12 +guint nm_setting_team_port_get_num_link_watchers(NMSettingTeamPort *setting); +NM_AVAILABLE_IN_1_12 +NMTeamLinkWatcher *nm_setting_team_port_get_link_watcher(NMSettingTeamPort *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_port_add_link_watcher(NMSettingTeamPort *setting, + NMTeamLinkWatcher *link_watcher); +NM_AVAILABLE_IN_1_12 +void nm_setting_team_port_remove_link_watcher(NMSettingTeamPort *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_port_remove_link_watcher_by_value(NMSettingTeamPort *setting, + NMTeamLinkWatcher *link_watcher); +NM_AVAILABLE_IN_1_12 +void nm_setting_team_port_clear_link_watchers(NMSettingTeamPort *setting); +G_END_DECLS + +#endif /* __NM_SETTING_TEAM_PORT_H__ */ diff --git a/src/libnm-core-public/nm-setting-team.h b/src/libnm-core-public/nm-setting-team.h new file mode 100644 index 0000000000..3f40c8cb9b --- /dev/null +++ b/src/libnm-core-public/nm-setting-team.h @@ -0,0 +1,226 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2013 Jiri Pirko <jiri@resnulli.us> + */ + +#ifndef __NM_SETTING_TEAM_H__ +#define __NM_SETTING_TEAM_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +/** + * NMTeamLinkWatcherArpPingFlags: + * @NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_NONE: no one among the arp_ping link watcher + * boolean options ('validate_active', 'validate_inactive', 'send_always') is + * enabled (set to true). + * @NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_ACTIVE: the arp_ping link watcher + * option 'validate_active' is enabled (set to true). + * @NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_INACTIVE: the arp_ping link watcher + * option 'validate_inactive' is enabled (set to true). + * @NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_SEND_ALWAYS: the arp_ping link watcher option + * 'send_always' is enabled (set to true). + */ +typedef enum { /*< flags >*/ + NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_NONE = 0, /*< skip >*/ + NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_ACTIVE = 0x2, + NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_INACTIVE = 0x4, + NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_SEND_ALWAYS = 0x8, +} NMTeamLinkWatcherArpPingFlags; + +#define NM_TEAM_LINK_WATCHER_ETHTOOL "ethtool" +#define NM_TEAM_LINK_WATCHER_ARP_PING "arp_ping" +#define NM_TEAM_LINK_WATCHER_NSNA_PING "nsna_ping" + +typedef struct NMTeamLinkWatcher NMTeamLinkWatcher; + +GType nm_team_link_watcher_get_type(void); + +NM_AVAILABLE_IN_1_12 +NMTeamLinkWatcher *nm_team_link_watcher_new_ethtool(int delay_up, int delay_down, GError **error); +NM_AVAILABLE_IN_1_12 +NMTeamLinkWatcher *nm_team_link_watcher_new_nsna_ping(int init_wait, + int interval, + int missed_max, + const char *target_host, + GError ** error); +NM_AVAILABLE_IN_1_12 +NMTeamLinkWatcher *nm_team_link_watcher_new_arp_ping(int init_wait, + int interval, + int missed_max, + const char * target_host, + const char * source_host, + NMTeamLinkWatcherArpPingFlags flags, + GError ** error); +NM_AVAILABLE_IN_1_16 +NMTeamLinkWatcher *nm_team_link_watcher_new_arp_ping2(int init_wait, + int interval, + int missed_max, + int vlanid, + const char * target_host, + const char * source_host, + NMTeamLinkWatcherArpPingFlags flags, + GError ** error); +NM_AVAILABLE_IN_1_12 +void nm_team_link_watcher_ref(NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +void nm_team_link_watcher_unref(NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +gboolean nm_team_link_watcher_equal(const NMTeamLinkWatcher *watcher, + const NMTeamLinkWatcher *other); +NM_AVAILABLE_IN_1_12 +NMTeamLinkWatcher *nm_team_link_watcher_dup(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +const char *nm_team_link_watcher_get_name(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +int nm_team_link_watcher_get_delay_up(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +int nm_team_link_watcher_get_delay_down(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +int nm_team_link_watcher_get_init_wait(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +int nm_team_link_watcher_get_interval(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +int nm_team_link_watcher_get_missed_max(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +const char *nm_team_link_watcher_get_target_host(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +const char *nm_team_link_watcher_get_source_host(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_12 +NMTeamLinkWatcherArpPingFlags nm_team_link_watcher_get_flags(const NMTeamLinkWatcher *watcher); +NM_AVAILABLE_IN_1_16 +int nm_team_link_watcher_get_vlanid(const NMTeamLinkWatcher *watcher); + +#define NM_TYPE_SETTING_TEAM (nm_setting_team_get_type()) +#define NM_SETTING_TEAM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_TEAM, NMSettingTeam)) +#define NM_SETTING_TEAM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_TEAM, NMSettingTeamClass)) +#define NM_IS_SETTING_TEAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_TEAM)) +#define NM_IS_SETTING_TEAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_TEAM)) +#define NM_SETTING_TEAM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_TEAM, NMSettingTeamClass)) + +#define NM_SETTING_TEAM_SETTING_NAME "team" + +#define NM_SETTING_TEAM_CONFIG "config" +#define NM_SETTING_TEAM_NOTIFY_PEERS_COUNT "notify-peers-count" +#define NM_SETTING_TEAM_NOTIFY_PEERS_INTERVAL "notify-peers-interval" +#define NM_SETTING_TEAM_MCAST_REJOIN_COUNT "mcast-rejoin-count" +#define NM_SETTING_TEAM_MCAST_REJOIN_INTERVAL "mcast-rejoin-interval" +#define NM_SETTING_TEAM_RUNNER "runner" +#define NM_SETTING_TEAM_RUNNER_HWADDR_POLICY "runner-hwaddr-policy" +#define NM_SETTING_TEAM_RUNNER_TX_HASH "runner-tx-hash" +#define NM_SETTING_TEAM_RUNNER_TX_BALANCER "runner-tx-balancer" +#define NM_SETTING_TEAM_RUNNER_TX_BALANCER_INTERVAL "runner-tx-balancer-interval" +#define NM_SETTING_TEAM_RUNNER_ACTIVE "runner-active" +#define NM_SETTING_TEAM_RUNNER_FAST_RATE "runner-fast-rate" +#define NM_SETTING_TEAM_RUNNER_SYS_PRIO "runner-sys-prio" +#define NM_SETTING_TEAM_RUNNER_MIN_PORTS "runner-min-ports" +#define NM_SETTING_TEAM_RUNNER_AGG_SELECT_POLICY "runner-agg-select-policy" +#define NM_SETTING_TEAM_LINK_WATCHERS "link-watchers" + +#define NM_SETTING_TEAM_RUNNER_BROADCAST "broadcast" +#define NM_SETTING_TEAM_RUNNER_ROUNDROBIN "roundrobin" +#define NM_SETTING_TEAM_RUNNER_RANDOM "random" +#define NM_SETTING_TEAM_RUNNER_ACTIVEBACKUP "activebackup" +#define NM_SETTING_TEAM_RUNNER_LOADBALANCE "loadbalance" +#define NM_SETTING_TEAM_RUNNER_LACP "lacp" + +#define NM_SETTING_TEAM_RUNNER_HWADDR_POLICY_SAME_ALL "same_all" +#define NM_SETTING_TEAM_RUNNER_HWADDR_POLICY_BY_ACTIVE "by_active" +#define NM_SETTING_TEAM_RUNNER_HWADDR_POLICY_ONLY_ACTIVE "only_active" + +#define NM_SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_LACP_PRIO "lacp_prio" +#define NM_SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_LACP_PRIO_STABLE "lacp_prio_stable" +#define NM_SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_BANDWIDTH "bandwidth" +#define NM_SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_COUNT "count" +#define NM_SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_PORT_CONFIG "port_config" + +#define NM_SETTING_TEAM_NOTIFY_PEERS_COUNT_ACTIVEBACKUP_DEFAULT 1 +#define NM_SETTING_TEAM_NOTIFY_MCAST_COUNT_ACTIVEBACKUP_DEFAULT 1 +#define NM_SETTING_TEAM_RUNNER_DEFAULT NM_SETTING_TEAM_RUNNER_ROUNDROBIN +#define NM_SETTING_TEAM_RUNNER_HWADDR_POLICY_DEFAULT NM_SETTING_TEAM_RUNNER_HWADDR_POLICY_SAME_ALL +#define NM_SETTING_TEAM_RUNNER_TX_BALANCER_INTERVAL_DEFAULT 50 +#define NM_SETTING_TEAM_RUNNER_SYS_PRIO_DEFAULT 65535 +#define NM_SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_DEFAULT \ + NM_SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_LACP_PRIO + +/** + * NMSettingTeam: + * + * Teaming Settings + */ +struct _NMSettingTeam { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingTeamClass; + +GType nm_setting_team_get_type(void); + +NMSetting *nm_setting_team_new(void); + +const char *nm_setting_team_get_config(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_get_notify_peers_count(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_get_notify_peers_interval(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_get_mcast_rejoin_count(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_get_mcast_rejoin_interval(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +const char *nm_setting_team_get_runner(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +const char *nm_setting_team_get_runner_hwaddr_policy(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +const char *nm_setting_team_get_runner_tx_balancer(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_get_runner_tx_balancer_interval(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_get_runner_active(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_get_runner_fast_rate(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_get_runner_sys_prio(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +int nm_setting_team_get_runner_min_ports(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +const char *nm_setting_team_get_runner_agg_select_policy(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_remove_runner_tx_hash_by_value(NMSettingTeam *setting, const char *txhash); +NM_AVAILABLE_IN_1_12 +guint nm_setting_team_get_num_runner_tx_hash(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +const char *nm_setting_team_get_runner_tx_hash(NMSettingTeam *setting, guint idx); +NM_AVAILABLE_IN_1_12 +void nm_setting_team_remove_runner_tx_hash(NMSettingTeam *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_add_runner_tx_hash(NMSettingTeam *setting, const char *txhash); +NM_AVAILABLE_IN_1_12 +guint nm_setting_team_get_num_link_watchers(NMSettingTeam *setting); +NM_AVAILABLE_IN_1_12 +NMTeamLinkWatcher *nm_setting_team_get_link_watcher(NMSettingTeam *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_add_link_watcher(NMSettingTeam *setting, NMTeamLinkWatcher *link_watcher); +NM_AVAILABLE_IN_1_12 +void nm_setting_team_remove_link_watcher(NMSettingTeam *setting, guint idx); +NM_AVAILABLE_IN_1_12 +gboolean nm_setting_team_remove_link_watcher_by_value(NMSettingTeam * setting, + NMTeamLinkWatcher *link_watcher); +NM_AVAILABLE_IN_1_12 +void nm_setting_team_clear_link_watchers(NMSettingTeam *setting); +G_END_DECLS + +#endif /* __NM_SETTING_TEAM_H__ */ diff --git a/src/libnm-core-public/nm-setting-tun.h b/src/libnm-core-public/nm-setting-tun.h new file mode 100644 index 0000000000..3fbbf08253 --- /dev/null +++ b/src/libnm-core-public/nm-setting-tun.h @@ -0,0 +1,85 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2015 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_TUN_H__ +#define __NM_SETTING_TUN_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_TUN (nm_setting_tun_get_type()) +#define NM_SETTING_TUN(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_TUN, NMSettingTun)) +#define NM_SETTING_TUN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_TUNCONFIG, NMSettingTunClass)) +#define NM_IS_SETTING_TUN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_TUN)) +#define NM_IS_SETTING_TUN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_TUN)) +#define NM_SETTING_TUN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_TUN, NMSettingTunClass)) + +#define NM_SETTING_TUN_SETTING_NAME "tun" + +#define NM_SETTING_TUN_MODE "mode" +#define NM_SETTING_TUN_OWNER "owner" +#define NM_SETTING_TUN_GROUP "group" +#define NM_SETTING_TUN_PI "pi" +#define NM_SETTING_TUN_VNET_HDR "vnet-hdr" +#define NM_SETTING_TUN_MULTI_QUEUE "multi-queue" + +/** + * NMSettingTunMode: + * @NM_SETTING_TUN_MODE_UNKNOWN: an unknown device type + * @NM_SETTING_TUN_MODE_TUN: a TUN device + * @NM_SETTING_TUN_MODE_TAP: a TAP device + * + * #NMSettingTunMode values indicate the device type (TUN/TAP) + */ +typedef enum { + NM_SETTING_TUN_MODE_UNKNOWN = 0, + NM_SETTING_TUN_MODE_TUN = 1, + NM_SETTING_TUN_MODE_TAP = 2, +} NMSettingTunMode; + +/** + * NMSettingTun: + * + * Tunnel Settings + */ +struct _NMSettingTun { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingTunClass; + +NM_AVAILABLE_IN_1_2 +GType nm_setting_tun_get_type(void); +NM_AVAILABLE_IN_1_2 +NMSetting *nm_setting_tun_new(void); + +NM_AVAILABLE_IN_1_2 +NMSettingTunMode nm_setting_tun_get_mode(NMSettingTun *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_tun_get_owner(NMSettingTun *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_tun_get_group(NMSettingTun *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_tun_get_pi(NMSettingTun *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_tun_get_vnet_hdr(NMSettingTun *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_tun_get_multi_queue(NMSettingTun *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_TUN_H__ */ diff --git a/src/libnm-core-public/nm-setting-user.h b/src/libnm-core-public/nm-setting-user.h new file mode 100644 index 0000000000..b151cd3ee6 --- /dev/null +++ b/src/libnm-core-public/nm-setting-user.h @@ -0,0 +1,55 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2017 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_USER_H__ +#define __NM_SETTING_USER_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_USER (nm_setting_user_get_type()) +#define NM_SETTING_USER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_USER, NMSettingUser)) +#define NM_SETTING_USER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_USER, NMSettingUserClass)) +#define NM_IS_SETTING_USER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_USER)) +#define NM_IS_SETTING_USER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_USER)) +#define NM_SETTING_USER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_USER, NMSettingUserClass)) + +#define NM_SETTING_USER_SETTING_NAME "user" + +#define NM_SETTING_USER_DATA "data" + +typedef struct _NMSettingUserClass NMSettingUserClass; + +NM_AVAILABLE_IN_1_8 +GType nm_setting_user_get_type(void); + +NM_AVAILABLE_IN_1_8 +NMSetting *nm_setting_user_new(void); + +NM_AVAILABLE_IN_1_8 +const char *const *nm_setting_user_get_keys(NMSettingUser *setting, guint *out_len); + +NM_AVAILABLE_IN_1_8 +const char *nm_setting_user_get_data(NMSettingUser *setting, const char *key); +NM_AVAILABLE_IN_1_8 +gboolean +nm_setting_user_set_data(NMSettingUser *setting, const char *key, const char *val, GError **error); + +NM_AVAILABLE_IN_1_8 +gboolean nm_setting_user_check_key(const char *key, GError **error); +NM_AVAILABLE_IN_1_8 +gboolean nm_setting_user_check_val(const char *val, GError **error); + +G_END_DECLS + +#endif /* __NM_SETTING_USER_H__ */ diff --git a/src/libnm-core-public/nm-setting-veth.h b/src/libnm-core-public/nm-setting-veth.h new file mode 100644 index 0000000000..5dbc192742 --- /dev/null +++ b/src/libnm-core-public/nm-setting-veth.h @@ -0,0 +1,41 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2020 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_VETH_H__ +#define __NM_SETTING_VETH_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_VETH (nm_setting_veth_get_type()) +#define NM_SETTING_VETH(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_VETH, NMSettingVeth)) +#define NM_IS_SETTING_VETH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_VETH)) +#define NM_IS_SETTING_VETH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_VETH)) +#define NM_SETTING_VETH_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_VETH, NMSettingVethClass)) + +#define NM_SETTING_VETH_SETTING_NAME "veth" + +#define NM_SETTING_VETH_PEER "peer" + +typedef struct _NMSettingVethClass NMSettingVethClass; + +NM_AVAILABLE_IN_1_30 +GType nm_setting_veth_get_type(void); +NM_AVAILABLE_IN_1_30 +NMSetting *nm_setting_veth_new(void); + +NM_AVAILABLE_IN_1_30 +const char *nm_setting_veth_get_peer(NMSettingVeth *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_VETH_H__ */ diff --git a/src/libnm-core-public/nm-setting-vlan.h b/src/libnm-core-public/nm-setting-vlan.h new file mode 100644 index 0000000000..4b2ca429cf --- /dev/null +++ b/src/libnm-core-public/nm-setting-vlan.h @@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2011 - 2014 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_VLAN_H__ +#define __NM_SETTING_VLAN_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_VLAN (nm_setting_vlan_get_type()) +#define NM_SETTING_VLAN(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_VLAN, NMSettingVlan)) +#define NM_SETTING_VLAN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_VLANCONFIG, NMSettingVlanClass)) +#define NM_IS_SETTING_VLAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_VLAN)) +#define NM_IS_SETTING_VLAN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_VLAN)) +#define NM_SETTING_VLAN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_VLAN, NMSettingVlanClass)) + +#define NM_SETTING_VLAN_SETTING_NAME "vlan" + +#define NM_SETTING_VLAN_PARENT "parent" +#define NM_SETTING_VLAN_ID "id" +#define NM_SETTING_VLAN_FLAGS "flags" +#define NM_SETTING_VLAN_INGRESS_PRIORITY_MAP "ingress-priority-map" +#define NM_SETTING_VLAN_EGRESS_PRIORITY_MAP "egress-priority-map" + +/** + * NMSettingVlan: + * + * VLAN Settings + */ +struct _NMSettingVlan { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingVlanClass; + +/** + * NMVlanPriorityMap: + * @NM_VLAN_INGRESS_MAP: map for incoming data + * @NM_VLAN_EGRESS_MAP: map for outgoing data + * + * A selector for traffic priority maps; these map Linux SKB priorities + * to 802.1p priorities used in VLANs. + **/ +/* clang-format off */ +typedef enum { + NM_VLAN_INGRESS_MAP, + NM_VLAN_EGRESS_MAP +} NMVlanPriorityMap; +/* clang-format on */ + +/** + * NMVlanFlags: + * @NM_VLAN_FLAG_REORDER_HEADERS: indicates that this interface should reorder + * outgoing packet headers to look more like a non-VLAN Ethernet interface + * @NM_VLAN_FLAG_GVRP: indicates that this interface should use GVRP to register + * itself with its switch + * @NM_VLAN_FLAG_LOOSE_BINDING: indicates that this interface's operating + * state is tied to the underlying network interface but other details + * (like routing) are not. + * @NM_VLAN_FLAG_MVRP: indicates that this interface should use MVRP to register + * itself with its switch + * + * #NMVlanFlags values control the behavior of the VLAN interface. + **/ +typedef enum { /*< flags >*/ + NM_VLAN_FLAG_REORDER_HEADERS = 0x1, + NM_VLAN_FLAG_GVRP = 0x2, + NM_VLAN_FLAG_LOOSE_BINDING = 0x4, + NM_VLAN_FLAG_MVRP = 0x8, + + /* NOTE: if adding flags update nm-setting-vlan.c::verify() */ + + /* NOTE: these flags must correspond to the value from the kernel + * header files. */ +} NMVlanFlags; + +#define NM_VLAN_FLAGS_ALL \ + (NM_VLAN_FLAG_REORDER_HEADERS | NM_VLAN_FLAG_GVRP | NM_VLAN_FLAG_LOOSE_BINDING \ + | NM_VLAN_FLAG_MVRP) + +GType nm_setting_vlan_get_type(void); +NMSetting *nm_setting_vlan_new(void); + +const char *nm_setting_vlan_get_parent(NMSettingVlan *setting); +guint32 nm_setting_vlan_get_id(NMSettingVlan *setting); +guint32 nm_setting_vlan_get_flags(NMSettingVlan *setting); + +gint32 nm_setting_vlan_get_num_priorities(NMSettingVlan *setting, NMVlanPriorityMap map); + +gboolean nm_setting_vlan_get_priority(NMSettingVlan * setting, + NMVlanPriorityMap map, + guint32 idx, + guint32 * out_from, + guint32 * out_to); + +gboolean nm_setting_vlan_add_priority(NMSettingVlan * setting, + NMVlanPriorityMap map, + guint32 from, + guint32 to); + +void nm_setting_vlan_remove_priority(NMSettingVlan *setting, NMVlanPriorityMap map, guint32 idx); + +gboolean nm_setting_vlan_remove_priority_by_value(NMSettingVlan * setting, + NMVlanPriorityMap map, + guint32 from, + guint32 to); + +gboolean nm_setting_vlan_remove_priority_str_by_value(NMSettingVlan * setting, + NMVlanPriorityMap map, + const char * str); + +void nm_setting_vlan_clear_priorities(NMSettingVlan *setting, NMVlanPriorityMap map); + +gboolean +nm_setting_vlan_add_priority_str(NMSettingVlan *setting, NMVlanPriorityMap map, const char *str); + +G_END_DECLS + +#endif /* __NM_SETTING_VLAN_H__ */ diff --git a/src/libnm-core-public/nm-setting-vpn.h b/src/libnm-core-public/nm-setting-vpn.h new file mode 100644 index 0000000000..9e5d6e4be3 --- /dev/null +++ b/src/libnm-core-public/nm-setting-vpn.h @@ -0,0 +1,90 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2013 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_VPN_H__ +#define __NM_SETTING_VPN_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_VPN (nm_setting_vpn_get_type()) +#define NM_SETTING_VPN(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_VPN, NMSettingVpn)) +#define NM_SETTING_VPN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_VPN, NMSettingVpnClass)) +#define NM_IS_SETTING_VPN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_VPN)) +#define NM_IS_SETTING_VPN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_VPN)) +#define NM_SETTING_VPN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_VPN, NMSettingVpnClass)) + +#define NM_SETTING_VPN_SETTING_NAME "vpn" + +#define NM_SETTING_VPN_SERVICE_TYPE "service-type" +#define NM_SETTING_VPN_USER_NAME "user-name" +#define NM_SETTING_VPN_PERSISTENT "persistent" +#define NM_SETTING_VPN_DATA "data" +#define NM_SETTING_VPN_SECRETS "secrets" +#define NM_SETTING_VPN_TIMEOUT "timeout" + +/** + * NMSettingVpn: + * + * VPN Settings + */ +struct _NMSettingVpn { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingVpnClass; + +/** + * NMVpnIterFunc: + * @key: the name of the data or secret item + * @value: the value of the data or secret item + * @user_data: User data passed to nm_setting_vpn_foreach_data_item() or + * nm_setting_vpn_foreach_secret() + **/ +typedef void (*NMVpnIterFunc)(const char *key, const char *value, gpointer user_data); + +GType nm_setting_vpn_get_type(void); + +NMSetting * nm_setting_vpn_new(void); +const char *nm_setting_vpn_get_service_type(NMSettingVpn *setting); +const char *nm_setting_vpn_get_user_name(NMSettingVpn *setting); +gboolean nm_setting_vpn_get_persistent(NMSettingVpn *setting); + +guint32 nm_setting_vpn_get_num_data_items(NMSettingVpn *setting); +void nm_setting_vpn_add_data_item(NMSettingVpn *setting, const char *key, const char *item); +const char *nm_setting_vpn_get_data_item(NMSettingVpn *setting, const char *key); +gboolean nm_setting_vpn_remove_data_item(NMSettingVpn *setting, const char *key); +void +nm_setting_vpn_foreach_data_item(NMSettingVpn *setting, NMVpnIterFunc func, gpointer user_data); +NM_AVAILABLE_IN_1_12 +const char **nm_setting_vpn_get_data_keys(NMSettingVpn *setting, guint *out_length); + +guint32 nm_setting_vpn_get_num_secrets(NMSettingVpn *setting); +void nm_setting_vpn_add_secret(NMSettingVpn *setting, const char *key, const char *secret); +const char *nm_setting_vpn_get_secret(NMSettingVpn *setting, const char *key); +gboolean nm_setting_vpn_remove_secret(NMSettingVpn *setting, const char *key); +void nm_setting_vpn_foreach_secret(NMSettingVpn *setting, NMVpnIterFunc func, gpointer user_data); +NM_AVAILABLE_IN_1_12 +const char **nm_setting_vpn_get_secret_keys(NMSettingVpn *setting, guint *out_length); + +NM_AVAILABLE_IN_1_2 +guint32 nm_setting_vpn_get_timeout(NMSettingVpn *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_VPN_H__ */ diff --git a/src/libnm-core-public/nm-setting-vrf.h b/src/libnm-core-public/nm-setting-vrf.h new file mode 100644 index 0000000000..afa044b830 --- /dev/null +++ b/src/libnm-core-public/nm-setting-vrf.h @@ -0,0 +1,38 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +#ifndef __NM_SETTING_VRF_H__ +#define __NM_SETTING_VRF_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_VRF (nm_setting_vrf_get_type()) +#define NM_SETTING_VRF(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_VRF, NMSettingVrf)) +#define NM_SETTING_VRF_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_VRFCONFIG, NMSettingVrfClass)) +#define NM_IS_SETTING_VRF(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_VRF)) +#define NM_IS_SETTING_VRF_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_VRF)) +#define NM_SETTING_VRF_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_VRF, NMSettingVrfClass)) + +#define NM_SETTING_VRF_SETTING_NAME "vrf" + +#define NM_SETTING_VRF_TABLE "table" + +typedef struct _NMSettingVrfClass NMSettingVrfClass; + +NM_AVAILABLE_IN_1_24 +GType nm_setting_vrf_get_type(void); +NM_AVAILABLE_IN_1_24 +NMSetting *nm_setting_vrf_new(void); +NM_AVAILABLE_IN_1_24 +guint32 nm_setting_vrf_get_table(NMSettingVrf *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_VRF_H__ */ diff --git a/src/libnm-core-public/nm-setting-vxlan.h b/src/libnm-core-public/nm-setting-vxlan.h new file mode 100644 index 0000000000..9b987b660c --- /dev/null +++ b/src/libnm-core-public/nm-setting-vxlan.h @@ -0,0 +1,101 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2015 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_VXLAN_H__ +#define __NM_SETTING_VXLAN_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_VXLAN (nm_setting_vxlan_get_type()) +#define NM_SETTING_VXLAN(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_VXLAN, NMSettingVxlan)) +#define NM_SETTING_VXLAN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_VXLANCONFIG, NMSettingVxlanClass)) +#define NM_IS_SETTING_VXLAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_VXLAN)) +#define NM_IS_SETTING_VXLAN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_VXLAN)) +#define NM_SETTING_VXLAN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_VXLAN, NMSettingVxlanClass)) + +#define NM_SETTING_VXLAN_SETTING_NAME "vxlan" + +#define NM_SETTING_VXLAN_PARENT "parent" +#define NM_SETTING_VXLAN_ID "id" +#define NM_SETTING_VXLAN_LOCAL "local" +#define NM_SETTING_VXLAN_REMOTE "remote" +#define NM_SETTING_VXLAN_SOURCE_PORT_MIN "source-port-min" +#define NM_SETTING_VXLAN_SOURCE_PORT_MAX "source-port-max" +#define NM_SETTING_VXLAN_DESTINATION_PORT "destination-port" +#define NM_SETTING_VXLAN_TOS "tos" +#define NM_SETTING_VXLAN_TTL "ttl" +#define NM_SETTING_VXLAN_AGEING "ageing" +#define NM_SETTING_VXLAN_LIMIT "limit" +#define NM_SETTING_VXLAN_PROXY "proxy" +#define NM_SETTING_VXLAN_LEARNING "learning" +#define NM_SETTING_VXLAN_RSC "rsc" +#define NM_SETTING_VXLAN_L2_MISS "l2-miss" +#define NM_SETTING_VXLAN_L3_MISS "l3-miss" + +/** + * NMSettingVxlan: + * + * VXLAN Settings + */ +struct _NMSettingVxlan { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingVxlanClass; + +NM_AVAILABLE_IN_1_2 +GType nm_setting_vxlan_get_type(void); +NM_AVAILABLE_IN_1_2 +NMSetting *nm_setting_vxlan_new(void); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_vxlan_get_parent(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_vxlan_get_id(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_vxlan_get_local(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +const char *nm_setting_vxlan_get_remote(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_vxlan_get_source_port_min(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_vxlan_get_source_port_max(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_vxlan_get_destination_port(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_vxlan_get_tos(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_vxlan_get_ttl(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_vxlan_get_ageing(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +guint nm_setting_vxlan_get_limit(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_vxlan_get_proxy(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_vxlan_get_learning(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_vxlan_get_rsc(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_vxlan_get_l2_miss(NMSettingVxlan *setting); +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_vxlan_get_l3_miss(NMSettingVxlan *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_VXLAN_H__ */ diff --git a/src/libnm-core-public/nm-setting-wifi-p2p.h b/src/libnm-core-public/nm-setting-wifi-p2p.h new file mode 100644 index 0000000000..029b75f065 --- /dev/null +++ b/src/libnm-core-public/nm-setting-wifi-p2p.h @@ -0,0 +1,59 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2019 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_WIFI_P2P_H__ +#define __NM_SETTING_WIFI_P2P_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" +#include "nm-setting-wireless-security.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_WIFI_P2P (nm_setting_wifi_p2p_get_type()) +#define NM_SETTING_WIFI_P2P(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_WIFI_P2P, NMSettingWifiP2P)) +#define NM_SETTING_WIFI_P2P_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_WIFI_P2P, NMSettingWifiP2PClass)) +#define NM_IS_SETTING_WIFI_P2P(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_WIFI_P2P)) +#define NM_IS_SETTING_WIFI_P2P_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_WIFI_P2P)) +#define NM_SETTING_WIFI_P2P_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_WIFI_P2P, NMSettingWifiP2PClass)) + +#define NM_SETTING_WIFI_P2P_SETTING_NAME "wifi-p2p" + +/** + * NM_SETTING_WIFI_P2P_PEER: + * + * The mac address of the peer to connect to. + */ +#define NM_SETTING_WIFI_P2P_PEER "peer" +#define NM_SETTING_WIFI_P2P_WPS_METHOD "wps-method" +#define NM_SETTING_WIFI_P2P_WFD_IES "wfd-ies" + +typedef struct _NMSettingWifiP2PClass NMSettingWifiP2PClass; + +NM_AVAILABLE_IN_1_16 +GType nm_setting_wifi_p2p_get_type(void); + +NM_AVAILABLE_IN_1_16 +NMSetting *nm_setting_wifi_p2p_new(void); + +NM_AVAILABLE_IN_1_16 +const char *nm_setting_wifi_p2p_get_peer(NMSettingWifiP2P *setting); + +NM_AVAILABLE_IN_1_16 +NMSettingWirelessSecurityWpsMethod nm_setting_wifi_p2p_get_wps_method(NMSettingWifiP2P *setting); + +NM_AVAILABLE_IN_1_16 +GBytes *nm_setting_wifi_p2p_get_wfd_ies(NMSettingWifiP2P *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_WIFI_P2P_H__ */ diff --git a/src/libnm-core-public/nm-setting-wimax.h b/src/libnm-core-public/nm-setting-wimax.h new file mode 100644 index 0000000000..7279e043b5 --- /dev/null +++ b/src/libnm-core-public/nm-setting-wimax.h @@ -0,0 +1,60 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2009 Novell, Inc. + */ + +#ifndef __NM_SETTING_WIMAX_H__ +#define __NM_SETTING_WIMAX_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_WIMAX (nm_setting_wimax_get_type()) +#define NM_SETTING_WIMAX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_WIMAX, NMSettingWimax)) +#define NM_SETTING_WIMAX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_WIMAX, NMSettingWimaxClass)) +#define NM_IS_SETTING_WIMAX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_WIMAX)) +#define NM_IS_SETTING_WIMAX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_WIMAX)) +#define NM_SETTING_WIMAX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_WIMAX, NMSettingWimaxClass)) + +#define NM_SETTING_WIMAX_SETTING_NAME "wimax" + +#define NM_SETTING_WIMAX_NETWORK_NAME "network-name" +#define NM_SETTING_WIMAX_MAC_ADDRESS "mac-address" + +/** + * NMSettingWimax: + * + * WiMax Settings + */ +struct _NMSettingWimax { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingWimaxClass; + +NM_DEPRECATED_IN_1_2 +GType nm_setting_wimax_get_type(void); + +NM_DEPRECATED_IN_1_2 +NMSetting *nm_setting_wimax_new(void); +NM_DEPRECATED_IN_1_2 +const char *nm_setting_wimax_get_network_name(NMSettingWimax *setting); +NM_DEPRECATED_IN_1_2 +const char *nm_setting_wimax_get_mac_address(NMSettingWimax *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_WIMAX_H__ */ diff --git a/src/libnm-core-public/nm-setting-wired.h b/src/libnm-core-public/nm-setting-wired.h new file mode 100644 index 0000000000..acabd70646 --- /dev/null +++ b/src/libnm-core-public/nm-setting-wired.h @@ -0,0 +1,142 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2014 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_WIRED_H__ +#define __NM_SETTING_WIRED_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_WIRED (nm_setting_wired_get_type()) +#define NM_SETTING_WIRED(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_WIRED, NMSettingWired)) +#define NM_SETTING_WIRED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_WIRED, NMSettingWiredClass)) +#define NM_IS_SETTING_WIRED(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_WIRED)) +#define NM_IS_SETTING_WIRED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_WIRED)) +#define NM_SETTING_WIRED_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_WIRED, NMSettingWiredClass)) + +#define NM_SETTING_WIRED_SETTING_NAME "802-3-ethernet" + +/** + * NMSettingWiredWakeOnLan: + * @NM_SETTING_WIRED_WAKE_ON_LAN_NONE: Wake-on-LAN disabled + * @NM_SETTING_WIRED_WAKE_ON_LAN_PHY: Wake on PHY activity + * @NM_SETTING_WIRED_WAKE_ON_LAN_UNICAST: Wake on unicast messages + * @NM_SETTING_WIRED_WAKE_ON_LAN_MULTICAST: Wake on multicast messages + * @NM_SETTING_WIRED_WAKE_ON_LAN_BROADCAST: Wake on broadcast messages + * @NM_SETTING_WIRED_WAKE_ON_LAN_ARP: Wake on ARP + * @NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC: Wake on magic packet + * @NM_SETTING_WIRED_WAKE_ON_LAN_ALL: Wake on all events. This does not + * include the exclusive flags @NM_SETTING_WIRED_WAKE_ON_LAN_DEFAULT or + * @NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE. + * @NM_SETTING_WIRED_WAKE_ON_LAN_DEFAULT: Use the default value + * @NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE: Don't change configured settings + * @NM_SETTING_WIRED_WAKE_ON_LAN_EXCLUSIVE_FLAGS: Mask of flags that are + * incompatible with other flags + * + * Options for #NMSettingWired:wake-on-lan. Note that not all options + * are supported by all devices. + * + * Since: 1.2 + */ +typedef enum { /*< flags >*/ + NM_SETTING_WIRED_WAKE_ON_LAN_NONE = 0, /*< skip >*/ + NM_SETTING_WIRED_WAKE_ON_LAN_PHY = 0x2, + NM_SETTING_WIRED_WAKE_ON_LAN_UNICAST = 0x4, + NM_SETTING_WIRED_WAKE_ON_LAN_MULTICAST = 0x8, + NM_SETTING_WIRED_WAKE_ON_LAN_BROADCAST = 0x10, + NM_SETTING_WIRED_WAKE_ON_LAN_ARP = 0x20, + NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC = 0x40, + + NM_SETTING_WIRED_WAKE_ON_LAN_ALL = 0x7E, /*< skip >*/ + + NM_SETTING_WIRED_WAKE_ON_LAN_DEFAULT = 0x1, + NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE = 0x8000, + NM_SETTING_WIRED_WAKE_ON_LAN_EXCLUSIVE_FLAGS = 0x8001, /*< skip >*/ +} NMSettingWiredWakeOnLan; + +#define NM_SETTING_WIRED_PORT "port" +#define NM_SETTING_WIRED_SPEED "speed" +#define NM_SETTING_WIRED_DUPLEX "duplex" +#define NM_SETTING_WIRED_AUTO_NEGOTIATE "auto-negotiate" +#define NM_SETTING_WIRED_MAC_ADDRESS "mac-address" +#define NM_SETTING_WIRED_CLONED_MAC_ADDRESS "cloned-mac-address" +#define NM_SETTING_WIRED_GENERATE_MAC_ADDRESS_MASK "generate-mac-address-mask" +#define NM_SETTING_WIRED_MAC_ADDRESS_BLACKLIST "mac-address-blacklist" +#define NM_SETTING_WIRED_MTU "mtu" +#define NM_SETTING_WIRED_S390_SUBCHANNELS "s390-subchannels" +#define NM_SETTING_WIRED_S390_NETTYPE "s390-nettype" +#define NM_SETTING_WIRED_S390_OPTIONS "s390-options" +#define NM_SETTING_WIRED_WAKE_ON_LAN "wake-on-lan" +#define NM_SETTING_WIRED_WAKE_ON_LAN_PASSWORD "wake-on-lan-password" + +/** + * NMSettingWired: + * + * Wired Ethernet Settings + */ +struct _NMSettingWired { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingWiredClass; + +GType nm_setting_wired_get_type(void); + +NMSetting * nm_setting_wired_new(void); +const char *nm_setting_wired_get_port(NMSettingWired *setting); +guint32 nm_setting_wired_get_speed(NMSettingWired *setting); +const char *nm_setting_wired_get_duplex(NMSettingWired *setting); +gboolean nm_setting_wired_get_auto_negotiate(NMSettingWired *setting); +const char *nm_setting_wired_get_mac_address(NMSettingWired *setting); +const char *nm_setting_wired_get_cloned_mac_address(NMSettingWired *setting); + +NM_AVAILABLE_IN_1_4 +const char *nm_setting_wired_get_generate_mac_address_mask(NMSettingWired *setting); + +const char *const *nm_setting_wired_get_mac_address_blacklist(NMSettingWired *setting); +guint32 nm_setting_wired_get_num_mac_blacklist_items(NMSettingWired *setting); +const char * nm_setting_wired_get_mac_blacklist_item(NMSettingWired *setting, guint32 idx); +gboolean nm_setting_wired_add_mac_blacklist_item(NMSettingWired *setting, const char *mac); +void nm_setting_wired_remove_mac_blacklist_item(NMSettingWired *setting, guint32 idx); +gboolean nm_setting_wired_remove_mac_blacklist_item_by_value(NMSettingWired *setting, + const char * mac); +void nm_setting_wired_clear_mac_blacklist_items(NMSettingWired *setting); + +guint32 nm_setting_wired_get_mtu(NMSettingWired *setting); + +const char *const *nm_setting_wired_get_s390_subchannels(NMSettingWired *setting); +const char * nm_setting_wired_get_s390_nettype(NMSettingWired *setting); + +guint32 nm_setting_wired_get_num_s390_options(NMSettingWired *setting); +gboolean nm_setting_wired_get_s390_option(NMSettingWired *setting, + guint32 idx, + const char ** out_key, + const char ** out_value); +const char *nm_setting_wired_get_s390_option_by_key(NMSettingWired *setting, const char *key); +gboolean +nm_setting_wired_add_s390_option(NMSettingWired *setting, const char *key, const char *value); +gboolean nm_setting_wired_remove_s390_option(NMSettingWired *setting, const char *key); +const char **nm_setting_wired_get_valid_s390_options(NMSettingWired *setting); + +NMSettingWiredWakeOnLan nm_setting_wired_get_wake_on_lan(NMSettingWired *setting); +const char * nm_setting_wired_get_wake_on_lan_password(NMSettingWired *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_WIRED_H__ */ diff --git a/src/libnm-core-public/nm-setting-wireguard.h b/src/libnm-core-public/nm-setting-wireguard.h new file mode 100644 index 0000000000..3f046fc713 --- /dev/null +++ b/src/libnm-core-public/nm-setting-wireguard.h @@ -0,0 +1,202 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2018 - 2019 Red Hat, Inc. + */ + +#ifndef __NM_SETTING_WIREGUARD_H__ +#define __NM_SETTING_WIREGUARD_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" +#include "nm-utils.h" + +G_BEGIN_DECLS + +/*****************************************************************************/ + +#define NM_WIREGUARD_PUBLIC_KEY_LEN 32 +#define NM_WIREGUARD_SYMMETRIC_KEY_LEN 32 + +/*****************************************************************************/ + +typedef struct _NMWireGuardPeer NMWireGuardPeer; + +NM_AVAILABLE_IN_1_16 +GType nm_wireguard_peer_get_type(void); + +NM_AVAILABLE_IN_1_16 +NMWireGuardPeer *nm_wireguard_peer_new(void); + +NM_AVAILABLE_IN_1_16 +NMWireGuardPeer *nm_wireguard_peer_new_clone(const NMWireGuardPeer *self, gboolean with_secrets); + +NM_AVAILABLE_IN_1_16 +NMWireGuardPeer *nm_wireguard_peer_ref(NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +void nm_wireguard_peer_unref(NMWireGuardPeer *self); + +NM_AVAILABLE_IN_1_16 +void nm_wireguard_peer_seal(NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +gboolean nm_wireguard_peer_is_sealed(const NMWireGuardPeer *self); + +NM_AVAILABLE_IN_1_16 +const char *nm_wireguard_peer_get_public_key(const NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +gboolean nm_wireguard_peer_set_public_key(NMWireGuardPeer *self, + const char * public_key, + gboolean accept_invalid); + +NM_AVAILABLE_IN_1_16 +const char *nm_wireguard_peer_get_preshared_key(const NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +gboolean nm_wireguard_peer_set_preshared_key(NMWireGuardPeer *self, + const char * preshared_key, + gboolean accept_invalid); + +NM_AVAILABLE_IN_1_16 +NMSettingSecretFlags nm_wireguard_peer_get_preshared_key_flags(const NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +void nm_wireguard_peer_set_preshared_key_flags(NMWireGuardPeer * self, + NMSettingSecretFlags preshared_key_flags); + +NM_AVAILABLE_IN_1_16 +guint16 nm_wireguard_peer_get_persistent_keepalive(const NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +void nm_wireguard_peer_set_persistent_keepalive(NMWireGuardPeer *self, + guint16 persistent_keepalive); + +NM_AVAILABLE_IN_1_16 +const char *nm_wireguard_peer_get_endpoint(const NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +gboolean +nm_wireguard_peer_set_endpoint(NMWireGuardPeer *self, const char *endpoint, gboolean allow_invalid); + +NM_AVAILABLE_IN_1_16 +guint nm_wireguard_peer_get_allowed_ips_len(const NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +const char * +nm_wireguard_peer_get_allowed_ip(const NMWireGuardPeer *self, guint idx, gboolean *out_is_valid); +NM_AVAILABLE_IN_1_16 +void nm_wireguard_peer_clear_allowed_ips(NMWireGuardPeer *self); +NM_AVAILABLE_IN_1_16 +gboolean nm_wireguard_peer_append_allowed_ip(NMWireGuardPeer *self, + const char * allowed_ip, + gboolean accept_invalid); +NM_AVAILABLE_IN_1_16 +gboolean nm_wireguard_peer_remove_allowed_ip(NMWireGuardPeer *self, guint idx); + +NM_AVAILABLE_IN_1_16 +gboolean nm_wireguard_peer_is_valid(const NMWireGuardPeer *self, + gboolean check_non_secrets, + gboolean check_secrets, + GError ** error); + +NM_AVAILABLE_IN_1_16 +int nm_wireguard_peer_cmp(const NMWireGuardPeer *a, + const NMWireGuardPeer *b, + NMSettingCompareFlags compare_flags); + +/*****************************************************************************/ + +#define NM_TYPE_SETTING_WIREGUARD (nm_setting_wireguard_get_type()) +#define NM_SETTING_WIREGUARD(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_WIREGUARD, NMSettingWireGuard)) +#define NM_SETTING_WIREGUARD_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_WIREGUARD, NMSettingWireGuardClass)) +#define NM_IS_SETTING_WIREGUARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_WIREGUARD)) +#define NM_IS_SETTING_WIREGUARD_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_WIREGUARD)) +#define NM_SETTING_WIREGUARD_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_WIREGUARD, NMSettingWireGuardClass)) + +#define NM_SETTING_WIREGUARD_SETTING_NAME "wireguard" + +#define NM_SETTING_WIREGUARD_FWMARK "fwmark" +#define NM_SETTING_WIREGUARD_LISTEN_PORT "listen-port" +#define NM_SETTING_WIREGUARD_PRIVATE_KEY "private-key" +#define NM_SETTING_WIREGUARD_PRIVATE_KEY_FLAGS "private-key-flags" + +#define NM_SETTING_WIREGUARD_PEERS "peers" + +#define NM_SETTING_WIREGUARD_MTU "mtu" +#define NM_SETTING_WIREGUARD_PEER_ROUTES "peer-routes" +#define NM_SETTING_WIREGUARD_IP4_AUTO_DEFAULT_ROUTE "ip4-auto-default-route" +#define NM_SETTING_WIREGUARD_IP6_AUTO_DEFAULT_ROUTE "ip6-auto-default-route" + +#define NM_WIREGUARD_PEER_ATTR_ALLOWED_IPS "allowed-ips" +#define NM_WIREGUARD_PEER_ATTR_ENDPOINT "endpoint" +#define NM_WIREGUARD_PEER_ATTR_PERSISTENT_KEEPALIVE "persistent-keepalive" +#define NM_WIREGUARD_PEER_ATTR_PRESHARED_KEY "preshared-key" +#define NM_WIREGUARD_PEER_ATTR_PRESHARED_KEY_FLAGS "preshared-key-flags" +#define NM_WIREGUARD_PEER_ATTR_PUBLIC_KEY "public-key" + +/*****************************************************************************/ + +typedef struct _NMSettingWireGuardClass NMSettingWireGuardClass; + +NM_AVAILABLE_IN_1_16 +GType nm_setting_wireguard_get_type(void); + +NM_AVAILABLE_IN_1_16 +NMSetting *nm_setting_wireguard_new(void); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_16 +const char *nm_setting_wireguard_get_private_key(NMSettingWireGuard *self); + +NM_AVAILABLE_IN_1_16 +NMSettingSecretFlags nm_setting_wireguard_get_private_key_flags(NMSettingWireGuard *self); + +NM_AVAILABLE_IN_1_16 +guint16 nm_setting_wireguard_get_listen_port(NMSettingWireGuard *self); + +NM_AVAILABLE_IN_1_16 +guint32 nm_setting_wireguard_get_fwmark(NMSettingWireGuard *self); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_16 +guint nm_setting_wireguard_get_peers_len(NMSettingWireGuard *self); + +NM_AVAILABLE_IN_1_16 +NMWireGuardPeer *nm_setting_wireguard_get_peer(NMSettingWireGuard *self, guint idx); + +NM_AVAILABLE_IN_1_16 +NMWireGuardPeer *nm_setting_wireguard_get_peer_by_public_key(NMSettingWireGuard *self, + const char * public_key, + guint * out_idx); + +NM_AVAILABLE_IN_1_16 +void nm_setting_wireguard_set_peer(NMSettingWireGuard *self, NMWireGuardPeer *peer, guint idx); + +NM_AVAILABLE_IN_1_16 +void nm_setting_wireguard_append_peer(NMSettingWireGuard *self, NMWireGuardPeer *peer); + +NM_AVAILABLE_IN_1_16 +gboolean nm_setting_wireguard_remove_peer(NMSettingWireGuard *self, guint idx); + +NM_AVAILABLE_IN_1_16 +guint nm_setting_wireguard_clear_peers(NMSettingWireGuard *self); + +NM_AVAILABLE_IN_1_16 +gboolean nm_setting_wireguard_get_peer_routes(NMSettingWireGuard *self); + +NM_AVAILABLE_IN_1_16 +guint32 nm_setting_wireguard_get_mtu(NMSettingWireGuard *self); + +NM_AVAILABLE_IN_1_20 +NMTernary nm_setting_wireguard_get_ip4_auto_default_route(NMSettingWireGuard *self); + +NM_AVAILABLE_IN_1_20 +NMTernary nm_setting_wireguard_get_ip6_auto_default_route(NMSettingWireGuard *self); + +/*****************************************************************************/ + +G_END_DECLS + +#endif /* __NM_SETTING_WIREGUARD_H__ */ diff --git a/src/libnm-core-public/nm-setting-wireless-security.h b/src/libnm-core-public/nm-setting-wireless-security.h new file mode 100644 index 0000000000..62a3c6e526 --- /dev/null +++ b/src/libnm-core-public/nm-setting-wireless-security.h @@ -0,0 +1,239 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2017 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_WIRELESS_SECURITY_H__ +#define __NM_SETTING_WIRELESS_SECURITY_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_WIRELESS_SECURITY (nm_setting_wireless_security_get_type()) +#define NM_SETTING_WIRELESS_SECURITY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), \ + NM_TYPE_SETTING_WIRELESS_SECURITY, \ + NMSettingWirelessSecurity)) +#define NM_SETTING_WIRELESS_SECURITY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), \ + NM_TYPE_SETTING_WIRELESS_SECURITY, \ + NMSettingWirelessSecurityClass)) +#define NM_IS_SETTING_WIRELESS_SECURITY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_WIRELESS_SECURITY)) +#define NM_IS_SETTING_WIRELESS_SECURITY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_WIRELESS_SECURITY)) +#define NM_SETTING_WIRELESS_SECURITY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), \ + NM_TYPE_SETTING_WIRELESS_SECURITY, \ + NMSettingWirelessSecurityClass)) + +#define NM_SETTING_WIRELESS_SECURITY_SETTING_NAME "802-11-wireless-security" + +/** + * NMWepKeyType: + * @NM_WEP_KEY_TYPE_UNKNOWN: unknown WEP key type + * @NM_WEP_KEY_TYPE_KEY: indicates a hexadecimal or ASCII formatted WEP key. + * Hex keys are either 10 or 26 hexadecimal characters (ie "5f782f2f5f" or + * "732f2d712e4a394a375d366931"), while ASCII keys are either 5 or 13 ASCII + * characters (ie "abcde" or "blahblah99$*1"). + * @NM_WEP_KEY_TYPE_PASSPHRASE: indicates a WEP passphrase (ex "I bought a duck + * on my way back from the market 235Q&^%^*%") instead of a hexadecimal or ASCII + * key. Passphrases are between 8 and 64 characters inclusive and are hashed + * the actual WEP key using the MD5 hash algorithm. + * @NM_WEP_KEY_TYPE_LAST: placeholder value for bounds-checking + * + * The #NMWepKeyType values specify how any WEP keys present in the setting + * are interpreted. There are no standards governing how to hash the various WEP + * key/passphrase formats into the actual WEP key. Unfortunately some WEP keys + * can be interpreted in multiple ways, requiring the setting to specify how to + * interpret the any WEP keys. For example, the key "732f2d712e4a394a375d366931" + * is both a valid Hexadecimal WEP key and a WEP passphrase. Further, many + * ASCII keys are also valid WEP passphrases, but since passphrases and ASCII + * keys are hashed differently to determine the actual WEP key the type must be + * specified. + */ +typedef enum { + NM_WEP_KEY_TYPE_UNKNOWN = 0, + NM_WEP_KEY_TYPE_KEY = 1, /* Hex or ASCII */ + NM_WEP_KEY_TYPE_PASSPHRASE = 2, /* 104/128-bit Passphrase */ + + NM_WEP_KEY_TYPE_LAST = NM_WEP_KEY_TYPE_PASSPHRASE, /*< skip >*/ +} NMWepKeyType; + +/** + * NMSettingWirelessSecurityPmf: + * @NM_SETTING_WIRELESS_SECURITY_PMF_DEFAULT: use the default value + * @NM_SETTING_WIRELESS_SECURITY_PMF_DISABLE: disable PMF + * @NM_SETTING_WIRELESS_SECURITY_PMF_OPTIONAL: enable PMF if the supplicant and the AP support it + * @NM_SETTING_WIRELESS_SECURITY_PMF_REQUIRED: require PMF and fail if not available + * + * These flags indicate whether PMF must be enabled. + **/ +typedef enum { + NM_SETTING_WIRELESS_SECURITY_PMF_DEFAULT = 0, + NM_SETTING_WIRELESS_SECURITY_PMF_DISABLE = 1, + NM_SETTING_WIRELESS_SECURITY_PMF_OPTIONAL = 2, + NM_SETTING_WIRELESS_SECURITY_PMF_REQUIRED = 3, + _NM_SETTING_WIRELESS_SECURITY_PMF_NUM, /*< skip >*/ + NM_SETTING_WIRELESS_SECURITY_PMF_LAST = _NM_SETTING_WIRELESS_SECURITY_PMF_NUM - 1, /*< skip >*/ +} NMSettingWirelessSecurityPmf; + +/** + * NMSettingWirelessSecurityWpsMethod: + * @NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_DEFAULT: Attempt whichever method AP supports + * @NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_DISABLED: WPS can not be used. + * @NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_AUTO: Use WPS, any method + * @NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_PBC: use WPS push-button method + * @NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_PIN: use PIN method + * + * Configure the use of WPS by a connection while it activates. + * + * Note: prior to 1.16, this was a GEnum type instead of a GFlags type + * although, with the same numeric values. + * + * Since: 1.10 + **/ +typedef enum { /*< flags >*/ + NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_DEFAULT = 0x00000000, + NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_DISABLED = 0x00000001, + NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_AUTO = 0x00000002, + NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_PBC = 0x00000004, + NM_SETTING_WIRELESS_SECURITY_WPS_METHOD_PIN = 0x00000008, +} NMSettingWirelessSecurityWpsMethod; + +/** + * NMSettingWirelessSecurityFils: + * @NM_SETTING_WIRELESS_SECURITY_FILS_DEFAULT: use the default value + * @NM_SETTING_WIRELESS_SECURITY_FILS_DISABLE: disable FILS + * @NM_SETTING_WIRELESS_SECURITY_FILS_OPTIONAL: enable FILS if the supplicant and the AP support it + * @NM_SETTING_WIRELESS_SECURITY_FILS_REQUIRED: require FILS and fail if not available + * @_NM_SETTING_WIRELESS_SECURITY_FILS_NUM: placeholder value for bounds-checking + * @NM_SETTING_WIRELESS_SECURITY_FILS_LAST: placeholder value for bounds-checking + * + * These flags indicate whether FILS must be enabled. + * + * Since: 1.12 + **/ +/* clang-format off */ +typedef enum { + NM_SETTING_WIRELESS_SECURITY_FILS_DEFAULT = 0, + NM_SETTING_WIRELESS_SECURITY_FILS_DISABLE = 1, + NM_SETTING_WIRELESS_SECURITY_FILS_OPTIONAL = 2, + NM_SETTING_WIRELESS_SECURITY_FILS_REQUIRED = 3, + _NM_SETTING_WIRELESS_SECURITY_FILS_NUM, /*< skip >*/ + NM_SETTING_WIRELESS_SECURITY_FILS_LAST = _NM_SETTING_WIRELESS_SECURITY_FILS_NUM - 1, /*< skip >*/ +} NMSettingWirelessSecurityFils; +/* clang-format on */ + +#define NM_SETTING_WIRELESS_SECURITY_KEY_MGMT "key-mgmt" +#define NM_SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX "wep-tx-keyidx" +#define NM_SETTING_WIRELESS_SECURITY_AUTH_ALG "auth-alg" +#define NM_SETTING_WIRELESS_SECURITY_PROTO "proto" +#define NM_SETTING_WIRELESS_SECURITY_PAIRWISE "pairwise" +#define NM_SETTING_WIRELESS_SECURITY_GROUP "group" +#define NM_SETTING_WIRELESS_SECURITY_PMF "pmf" +#define NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME "leap-username" +#define NM_SETTING_WIRELESS_SECURITY_WEP_KEY0 "wep-key0" +#define NM_SETTING_WIRELESS_SECURITY_WEP_KEY1 "wep-key1" +#define NM_SETTING_WIRELESS_SECURITY_WEP_KEY2 "wep-key2" +#define NM_SETTING_WIRELESS_SECURITY_WEP_KEY3 "wep-key3" +#define NM_SETTING_WIRELESS_SECURITY_WEP_KEY_FLAGS "wep-key-flags" +#define NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE "wep-key-type" +#define NM_SETTING_WIRELESS_SECURITY_PSK "psk" +#define NM_SETTING_WIRELESS_SECURITY_PSK_FLAGS "psk-flags" +#define NM_SETTING_WIRELESS_SECURITY_LEAP_PASSWORD "leap-password" +#define NM_SETTING_WIRELESS_SECURITY_LEAP_PASSWORD_FLAGS "leap-password-flags" +#define NM_SETTING_WIRELESS_SECURITY_WPS_METHOD "wps-method" +#define NM_SETTING_WIRELESS_SECURITY_FILS "fils" + +/** + * NMSettingWirelessSecurity: + * + * Wi-Fi Security Settings + */ +struct _NMSettingWirelessSecurity { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingWirelessSecurityClass; + +GType nm_setting_wireless_security_get_type(void); + +NMSetting *nm_setting_wireless_security_new(void); + +const char *nm_setting_wireless_security_get_key_mgmt(NMSettingWirelessSecurity *setting); + +guint32 nm_setting_wireless_security_get_num_protos(NMSettingWirelessSecurity *setting); +const char *nm_setting_wireless_security_get_proto(NMSettingWirelessSecurity *setting, guint32 i); +gboolean nm_setting_wireless_security_add_proto(NMSettingWirelessSecurity *setting, + const char * proto); +void nm_setting_wireless_security_remove_proto(NMSettingWirelessSecurity *setting, guint32 i); +gboolean nm_setting_wireless_security_remove_proto_by_value(NMSettingWirelessSecurity *setting, + const char * proto); +void nm_setting_wireless_security_clear_protos(NMSettingWirelessSecurity *setting); + +guint32 nm_setting_wireless_security_get_num_pairwise(NMSettingWirelessSecurity *setting); +const char *nm_setting_wireless_security_get_pairwise(NMSettingWirelessSecurity *setting, + guint32 i); +gboolean nm_setting_wireless_security_add_pairwise(NMSettingWirelessSecurity *setting, + const char * pairwise); +void nm_setting_wireless_security_remove_pairwise(NMSettingWirelessSecurity *setting, guint32 i); +gboolean nm_setting_wireless_security_remove_pairwise_by_value(NMSettingWirelessSecurity *setting, + const char * pairwise); +void nm_setting_wireless_security_clear_pairwise(NMSettingWirelessSecurity *setting); + +guint32 nm_setting_wireless_security_get_num_groups(NMSettingWirelessSecurity *setting); +const char *nm_setting_wireless_security_get_group(NMSettingWirelessSecurity *setting, guint32 i); +gboolean nm_setting_wireless_security_add_group(NMSettingWirelessSecurity *setting, + const char * group); +void nm_setting_wireless_security_remove_group(NMSettingWirelessSecurity *setting, guint32 i); +gboolean nm_setting_wireless_security_remove_group_by_value(NMSettingWirelessSecurity *setting, + const char * group); +void nm_setting_wireless_security_clear_groups(NMSettingWirelessSecurity *setting); + +NM_AVAILABLE_IN_1_10 +NMSettingWirelessSecurityPmf +nm_setting_wireless_security_get_pmf(NMSettingWirelessSecurity *setting); + +const char * nm_setting_wireless_security_get_psk(NMSettingWirelessSecurity *setting); +NMSettingSecretFlags nm_setting_wireless_security_get_psk_flags(NMSettingWirelessSecurity *setting); + +const char *nm_setting_wireless_security_get_leap_username(NMSettingWirelessSecurity *setting); +const char *nm_setting_wireless_security_get_leap_password(NMSettingWirelessSecurity *setting); +NMSettingSecretFlags +nm_setting_wireless_security_get_leap_password_flags(NMSettingWirelessSecurity *setting); + +const char *nm_setting_wireless_security_get_wep_key(NMSettingWirelessSecurity *setting, + guint32 idx); +void nm_setting_wireless_security_set_wep_key(NMSettingWirelessSecurity *setting, + guint32 idx, + const char * key); +guint32 nm_setting_wireless_security_get_wep_tx_keyidx(NMSettingWirelessSecurity *setting); +const char *nm_setting_wireless_security_get_auth_alg(NMSettingWirelessSecurity *setting); + +NMSettingSecretFlags + nm_setting_wireless_security_get_wep_key_flags(NMSettingWirelessSecurity *setting); +NMWepKeyType nm_setting_wireless_security_get_wep_key_type(NMSettingWirelessSecurity *setting); + +NM_AVAILABLE_IN_1_10 +NMSettingWirelessSecurityWpsMethod +nm_setting_wireless_security_get_wps_method(NMSettingWirelessSecurity *setting); + +NM_AVAILABLE_IN_1_12 +NMSettingWirelessSecurityFils +nm_setting_wireless_security_get_fils(NMSettingWirelessSecurity *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_WIRELESS_SECURITY_H__ */ diff --git a/src/libnm-core-public/nm-setting-wireless.h b/src/libnm-core-public/nm-setting-wireless.h new file mode 100644 index 0000000000..f97e236ce7 --- /dev/null +++ b/src/libnm-core-public/nm-setting-wireless.h @@ -0,0 +1,216 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2014 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_WIRELESS_H__ +#define __NM_SETTING_WIRELESS_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" +#include "nm-setting-wireless-security.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_WIRELESS (nm_setting_wireless_get_type()) +#define NM_SETTING_WIRELESS(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_WIRELESS, NMSettingWireless)) +#define NM_SETTING_WIRELESS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_WIRELESS, NMSettingWirelessClass)) +#define NM_IS_SETTING_WIRELESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_WIRELESS)) +#define NM_IS_SETTING_WIRELESS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_WIRELESS)) +#define NM_SETTING_WIRELESS_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_WIRELESS, NMSettingWirelessClass)) + +#define NM_SETTING_WIRELESS_SETTING_NAME "802-11-wireless" + +/** + * NMSettingWirelessWakeOnWLan: + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_NONE: Wake-on-WLAN disabled + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_ANY: Wake on any activity + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_DISCONNECT: Wake on disconnect + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_MAGIC: Wake on magic packet + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_GTK_REKEY_FAILURE: Wake on GTK rekey failure + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_EAP_IDENTITY_REQUEST: Wake on EAP identity request + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_4WAY_HANDSHAKE: Wake on 4way handshake + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_RFKILL_RELEASE: Wake on rfkill release + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_ALL: Wake on all events. This does not + * include the exclusive flags @NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT or + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE. + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT: Use the default value + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE: Don't change configured settings + * @NM_SETTING_WIRELESS_WAKE_ON_WLAN_EXCLUSIVE_FLAGS: Mask of flags that are + * incompatible with other flags + * + * Options for #NMSettingWireless:wake-on-wlan. Note that not all options + * are supported by all devices. + * + * Since: 1.12 + */ +/* clang-format off */ +typedef enum { /*< flags >*/ + NM_SETTING_WIRELESS_WAKE_ON_WLAN_NONE = 0, /*< skip >*/ + NM_SETTING_WIRELESS_WAKE_ON_WLAN_ANY = 0x2, + NM_SETTING_WIRELESS_WAKE_ON_WLAN_DISCONNECT = 0x4, + NM_SETTING_WIRELESS_WAKE_ON_WLAN_MAGIC = 0x8, + NM_SETTING_WIRELESS_WAKE_ON_WLAN_GTK_REKEY_FAILURE = 0x10, + NM_SETTING_WIRELESS_WAKE_ON_WLAN_EAP_IDENTITY_REQUEST = 0x20, + NM_SETTING_WIRELESS_WAKE_ON_WLAN_4WAY_HANDSHAKE = 0x40, + NM_SETTING_WIRELESS_WAKE_ON_WLAN_RFKILL_RELEASE = 0x80, + NM_SETTING_WIRELESS_WAKE_ON_WLAN_TCP = 0x100, + + NM_SETTING_WIRELESS_WAKE_ON_WLAN_ALL = 0x1FE, + + NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT = 0x1, + NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE = 0x8000, + + NM_SETTING_WIRELESS_WAKE_ON_WLAN_EXCLUSIVE_FLAGS = NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT | NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE, /*< skip >*/ +} NMSettingWirelessWakeOnWLan; +/* clang-format on */ + +#define NM_SETTING_WIRELESS_SSID "ssid" +#define NM_SETTING_WIRELESS_MODE "mode" +#define NM_SETTING_WIRELESS_BAND "band" +#define NM_SETTING_WIRELESS_CHANNEL "channel" +#define NM_SETTING_WIRELESS_BSSID "bssid" +#define NM_SETTING_WIRELESS_RATE "rate" +#define NM_SETTING_WIRELESS_TX_POWER "tx-power" +#define NM_SETTING_WIRELESS_MAC_ADDRESS "mac-address" +#define NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS "cloned-mac-address" +#define NM_SETTING_WIRELESS_GENERATE_MAC_ADDRESS_MASK "generate-mac-address-mask" +#define NM_SETTING_WIRELESS_MAC_ADDRESS_BLACKLIST "mac-address-blacklist" +#define NM_SETTING_WIRELESS_MTU "mtu" +#define NM_SETTING_WIRELESS_SEEN_BSSIDS "seen-bssids" +#define NM_SETTING_WIRELESS_HIDDEN "hidden" +#define NM_SETTING_WIRELESS_POWERSAVE "powersave" +#define NM_SETTING_WIRELESS_MAC_ADDRESS_RANDOMIZATION "mac-address-randomization" +#define NM_SETTING_WIRELESS_WAKE_ON_WLAN "wake-on-wlan" +#define NM_SETTING_WIRELESS_AP_ISOLATION "ap-isolation" + +/** + * NM_SETTING_WIRELESS_MODE_ADHOC: + * + * Indicates Ad-Hoc mode where no access point is expected to be present. + */ +#define NM_SETTING_WIRELESS_MODE_ADHOC "adhoc" + +/** + * NM_SETTING_WIRELESS_MODE_AP: + * + * Indicates AP/master mode where the wireless device is started as an access + * point/hotspot. + */ +#define NM_SETTING_WIRELESS_MODE_AP "ap" + +/** + * NM_SETTING_WIRELESS_MODE_INFRA: + * + * Indicates infrastructure mode where an access point is expected to be present + * for this connection. + */ +#define NM_SETTING_WIRELESS_MODE_INFRA "infrastructure" + +/** + * NM_SETTING_WIRELESS_MODE_MESH: + * + * Indicates that the connection should create a mesh point. + * + * Since: 1.20 + */ +#define NM_SETTING_WIRELESS_MODE_MESH "mesh" + +/** + * NMSettingWirelessPowersave: + * @NM_SETTING_WIRELESS_POWERSAVE_DEFAULT: use the default value + * @NM_SETTING_WIRELESS_POWERSAVE_IGNORE: don't touch existing setting + * @NM_SETTING_WIRELESS_POWERSAVE_DISABLE: disable powersave + * @NM_SETTING_WIRELESS_POWERSAVE_ENABLE: enable powersave + * + * These flags indicate whether wireless powersave must be enabled. + **/ +typedef enum { + NM_SETTING_WIRELESS_POWERSAVE_DEFAULT = 0, + NM_SETTING_WIRELESS_POWERSAVE_IGNORE = 1, + NM_SETTING_WIRELESS_POWERSAVE_DISABLE = 2, + NM_SETTING_WIRELESS_POWERSAVE_ENABLE = 3, + _NM_SETTING_WIRELESS_POWERSAVE_NUM, /*< skip >*/ + NM_SETTING_WIRELESS_POWERSAVE_LAST = _NM_SETTING_WIRELESS_POWERSAVE_NUM - 1, /*< skip >*/ +} NMSettingWirelessPowersave; + +/** + * NMSettingWireless: + * + * Wi-Fi Settings + */ +struct _NMSettingWireless { + NMSetting parent; +}; + +typedef struct { + NMSettingClass parent; + + /*< private >*/ + gpointer padding[4]; +} NMSettingWirelessClass; + +GType nm_setting_wireless_get_type(void); + +NMSetting *nm_setting_wireless_new(void); + +GBytes * nm_setting_wireless_get_ssid(NMSettingWireless *setting); +const char *nm_setting_wireless_get_mode(NMSettingWireless *setting); +const char *nm_setting_wireless_get_band(NMSettingWireless *setting); +guint32 nm_setting_wireless_get_channel(NMSettingWireless *setting); +const char *nm_setting_wireless_get_bssid(NMSettingWireless *setting); +guint32 nm_setting_wireless_get_rate(NMSettingWireless *setting); +guint32 nm_setting_wireless_get_tx_power(NMSettingWireless *setting); +const char *nm_setting_wireless_get_mac_address(NMSettingWireless *setting); +const char *nm_setting_wireless_get_cloned_mac_address(NMSettingWireless *setting); + +NM_AVAILABLE_IN_1_4 +const char *nm_setting_wireless_get_generate_mac_address_mask(NMSettingWireless *setting); + +const char *const *nm_setting_wireless_get_mac_address_blacklist(NMSettingWireless *setting); +guint32 nm_setting_wireless_get_num_mac_blacklist_items(NMSettingWireless *setting); +const char *nm_setting_wireless_get_mac_blacklist_item(NMSettingWireless *setting, guint32 idx); +gboolean nm_setting_wireless_add_mac_blacklist_item(NMSettingWireless *setting, const char *mac); +void nm_setting_wireless_remove_mac_blacklist_item(NMSettingWireless *setting, guint32 idx); +gboolean nm_setting_wireless_remove_mac_blacklist_item_by_value(NMSettingWireless *setting, + const char * mac); +void nm_setting_wireless_clear_mac_blacklist_items(NMSettingWireless *setting); + +guint32 nm_setting_wireless_get_mtu(NMSettingWireless *setting); +gboolean nm_setting_wireless_get_hidden(NMSettingWireless *setting); +NM_AVAILABLE_IN_1_2 +guint32 nm_setting_wireless_get_powersave(NMSettingWireless *setting); + +NM_AVAILABLE_IN_1_2 +NMSettingMacRandomization +nm_setting_wireless_get_mac_address_randomization(NMSettingWireless *setting); + +gboolean nm_setting_wireless_add_seen_bssid(NMSettingWireless *setting, const char *bssid); + +guint32 nm_setting_wireless_get_num_seen_bssids(NMSettingWireless *setting); +const char *nm_setting_wireless_get_seen_bssid(NMSettingWireless *setting, guint32 i); + +gboolean nm_setting_wireless_ap_security_compatible(NMSettingWireless * s_wireless, + NMSettingWirelessSecurity *s_wireless_sec, + NM80211ApFlags ap_flags, + NM80211ApSecurityFlags ap_wpa, + NM80211ApSecurityFlags ap_rsn, + NM80211Mode ap_mode); + +NM_AVAILABLE_IN_1_12 +NMSettingWirelessWakeOnWLan nm_setting_wireless_get_wake_on_wlan(NMSettingWireless *setting); + +NM_AVAILABLE_IN_1_28 +NMTernary nm_setting_wireless_get_ap_isolation(NMSettingWireless *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_WIRELESS_H__ */ diff --git a/src/libnm-core-public/nm-setting-wpan.h b/src/libnm-core-public/nm-setting-wpan.h new file mode 100644 index 0000000000..2a09d49bbd --- /dev/null +++ b/src/libnm-core-public/nm-setting-wpan.h @@ -0,0 +1,57 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2018 Lubomir Rintel <lkundrak@v3.sk> + */ + +#ifndef __NM_SETTING_WPAN_H__ +#define __NM_SETTING_WPAN_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-setting.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING_WPAN (nm_setting_wpan_get_type()) +#define NM_SETTING_WPAN(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING_WPAN, NMSettingWpan)) +#define NM_SETTING_WPAN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING_WPANCONFIG, NMSettingWpanClass)) +#define NM_IS_SETTING_WPAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING_WPAN)) +#define NM_IS_SETTING_WPAN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING_WPAN)) +#define NM_SETTING_WPAN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING_WPAN, NMSettingWpanClass)) + +#define NM_SETTING_WPAN_SETTING_NAME "wpan" +#define NM_SETTING_WPAN_MAC_ADDRESS "mac-address" +#define NM_SETTING_WPAN_PAN_ID "pan-id" +#define NM_SETTING_WPAN_SHORT_ADDRESS "short-address" +#define NM_SETTING_WPAN_PAGE "page" +#define NM_SETTING_WPAN_CHANNEL "channel" + +#define NM_SETTING_WPAN_PAGE_DEFAULT -1 +#define NM_SETTING_WPAN_CHANNEL_DEFAULT -1 + +typedef struct _NMSettingWpanClass NMSettingWpanClass; + +NM_AVAILABLE_IN_1_14 +GType nm_setting_wpan_get_type(void); +NM_AVAILABLE_IN_1_14 +NMSetting *nm_setting_wpan_new(void); + +NM_AVAILABLE_IN_1_14 +const char *nm_setting_wpan_get_mac_address(NMSettingWpan *setting); +NM_AVAILABLE_IN_1_14 +guint16 nm_setting_wpan_get_pan_id(NMSettingWpan *setting); +NM_AVAILABLE_IN_1_14 +guint16 nm_setting_wpan_get_short_address(NMSettingWpan *setting); +NM_AVAILABLE_IN_1_16 +gint16 nm_setting_wpan_get_page(NMSettingWpan *setting); +NM_AVAILABLE_IN_1_16 +gint16 nm_setting_wpan_get_channel(NMSettingWpan *setting); + +G_END_DECLS + +#endif /* __NM_SETTING_WPAN_H__ */ diff --git a/src/libnm-core-public/nm-setting.h b/src/libnm-core-public/nm-setting.h new file mode 100644 index 0000000000..e5cf753dc6 --- /dev/null +++ b/src/libnm-core-public/nm-setting.h @@ -0,0 +1,353 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2007 - 2011 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#ifndef __NM_SETTING_H__ +#define __NM_SETTING_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-core-types.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SETTING (nm_setting_get_type()) +#define NM_SETTING(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SETTING, NMSetting)) +#define NM_SETTING_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SETTING, NMSettingClass)) +#define NM_IS_SETTING(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SETTING)) +#define NM_IS_SETTING_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SETTING)) +#define NM_SETTING_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SETTING, NMSettingClass)) + +/* The property of the #NMSetting is required for the setting to be valid */ +#define NM_SETTING_PARAM_REQUIRED (1 << (1 + G_PARAM_USER_SHIFT)) + +/* The property of the #NMSetting is a secret */ +#define NM_SETTING_PARAM_SECRET (1 << (2 + G_PARAM_USER_SHIFT)) + +/* The property of the #NMSetting should be ignored during comparisons that + * use the %NM_SETTING_COMPARE_FLAG_FUZZY flag. + */ +#define NM_SETTING_PARAM_FUZZY_IGNORE (1 << (3 + G_PARAM_USER_SHIFT)) + +/* Note: all non-glib GParamFlags bits are reserved by NetworkManager */ + +#define NM_SETTING_NAME "name" + +/** + * NMSettingSecretFlags: + * @NM_SETTING_SECRET_FLAG_NONE: the system is responsible for providing and + * storing this secret (default) + * @NM_SETTING_SECRET_FLAG_AGENT_OWNED: a user secret agent is responsible + * for providing and storing this secret; when it is required agents will be + * asked to retrieve it + * @NM_SETTING_SECRET_FLAG_NOT_SAVED: this secret should not be saved, but + * should be requested from the user each time it is needed + * @NM_SETTING_SECRET_FLAG_NOT_REQUIRED: in situations where it cannot be + * automatically determined that the secret is required (some VPNs and PPP + * providers don't require all secrets) this flag indicates that the specific + * secret is not required + * + * These flags indicate specific behavior related to handling of a secret. Each + * secret has a corresponding set of these flags which indicate how the secret + * is to be stored and/or requested when it is needed. + * + **/ +typedef enum { /*< flags >*/ + NM_SETTING_SECRET_FLAG_NONE = 0x00000000, + NM_SETTING_SECRET_FLAG_AGENT_OWNED = 0x00000001, + NM_SETTING_SECRET_FLAG_NOT_SAVED = 0x00000002, + NM_SETTING_SECRET_FLAG_NOT_REQUIRED = 0x00000004 + + /* NOTE: if adding flags, update nm-core-internal.h as well */ +} NMSettingSecretFlags; + +/** + * NMSettingCompareFlags: + * @NM_SETTING_COMPARE_FLAG_EXACT: match all properties exactly + * @NM_SETTING_COMPARE_FLAG_FUZZY: match only important attributes, like SSID, + * type, security settings, etc. Does not match, for example, connection ID + * or UUID. + * @NM_SETTING_COMPARE_FLAG_IGNORE_ID: ignore the connection's ID + * @NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS: ignore all secrets + * @NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS: ignore secrets for which + * the secret's flags indicate the secret is owned by a user secret agent + * (ie, the secret's flag includes @NM_SETTING_SECRET_FLAG_AGENT_OWNED) + * @NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS: ignore secrets for which + * the secret's flags indicate the secret should not be saved to persistent + * storage (ie, the secret's flag includes @NM_SETTING_SECRET_FLAG_NOT_SAVED) + * @NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT: if this flag is set, + * nm_setting_diff() and nm_connection_diff() will also include properties that + * are set to their default value. See also @NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT. + * @NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT: if this flag is set, + * nm_setting_diff() and nm_connection_diff() will not include properties that + * are set to their default value. This is the opposite of + * @NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT. If both flags are set together, + * @NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT wins. If both flags are unset, + * this means to exclude default properties if there is a setting to compare, + * but include all properties, if the setting 'b' is missing. This is the legacy + * behaviour of libnm-util, where nm_setting_diff() behaved differently depending + * on whether the setting 'b' was available. If @NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT + * is set, nm_setting_diff() will also set the flags @NM_SETTING_DIFF_RESULT_IN_A_DEFAULT + * and @NM_SETTING_DIFF_RESULT_IN_B_DEFAULT, if the values are default values. + * @NM_SETTING_COMPARE_FLAG_IGNORE_TIMESTAMP: ignore the connection's timestamp + * + * These flags modify the comparison behavior when comparing two settings or + * two connections. + * + **/ +typedef enum { + NM_SETTING_COMPARE_FLAG_EXACT = 0x00000000, + NM_SETTING_COMPARE_FLAG_FUZZY = 0x00000001, + NM_SETTING_COMPARE_FLAG_IGNORE_ID = 0x00000002, + NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS = 0x00000004, + NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS = 0x00000008, + NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS = 0x00000010, + NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT = 0x00000020, + NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT = 0x00000040, + NM_SETTING_COMPARE_FLAG_IGNORE_TIMESTAMP = 0x00000080, + + /* Higher flags like 0x80000000 and 0x40000000 are used internally as private flags */ +} NMSettingCompareFlags; + +/** + * NMSettingMacRandomization: + * @NM_SETTING_MAC_RANDOMIZATION_DEFAULT: the default value, which unless + * overridden by user-controlled defaults configuration, is "never". + * @NM_SETTING_MAC_RANDOMIZATION_NEVER: the device's MAC address is always used. + * @NM_SETTING_MAC_RANDOMIZATION_ALWAYS: a random MAC address is used. + * + * Controls if and how the MAC address of a device is randomzied. + **/ +typedef enum { + NM_SETTING_MAC_RANDOMIZATION_DEFAULT = 0, + NM_SETTING_MAC_RANDOMIZATION_NEVER, + NM_SETTING_MAC_RANDOMIZATION_ALWAYS, +} NMSettingMacRandomization; + +/** + * NMSetting: + * + * The NMSetting struct contains only private data. + * It should only be accessed through the functions described below. + */ +struct _NMSetting { + GObject parent; +}; + +/** + * NMSettingClearSecretsWithFlagsFn: + * @setting: The setting for which secrets are being iterated + * @secret: The secret's name + * @flags: The secret's flags, eg %NM_SETTING_SECRET_FLAG_AGENT_OWNED + * @user_data: User data passed to nm_connection_clear_secrets_with_flags() + * + * Returns: %TRUE to clear the secret, %FALSE to not clear the secret + */ +typedef gboolean (*NMSettingClearSecretsWithFlagsFn)(NMSetting * setting, + const char * secret, + NMSettingSecretFlags flags, + gpointer user_data); + +struct _NMMetaSettingInfo; +struct _NMSettInfoSetting; +struct _NMSettInfoProperty; + +/** + * NMSettingValueIterFn: + * @setting: The setting for which properties are being iterated, given to + * nm_setting_enumerate_values() + * @key: The value/property name + * @value: The property's value + * @flags: The property's flags, like %NM_SETTING_PARAM_SECRET + * @user_data: User data passed to nm_setting_enumerate_values() + */ +typedef void (*NMSettingValueIterFn)(NMSetting * setting, + const char * key, + const GValue *value, + GParamFlags flags, + gpointer user_data); + +/*< private >*/ +typedef gboolean (*_NMConnectionForEachSecretFunc)(NMSettingSecretFlags flags, gpointer user_data); + +typedef struct { + GObjectClass parent; + + /* Virtual functions */ + int (*verify)(NMSetting *setting, NMConnection *connection, GError **error); + + gboolean (*verify_secrets)(NMSetting *setting, NMConnection *connection, GError **error); + + GPtrArray *(*need_secrets)(NMSetting *setting); + + int (*update_one_secret)(NMSetting *setting, const char *key, GVariant *value, GError **error); + + gboolean (*get_secret_flags)(NMSetting * setting, + const char * secret_name, + NMSettingSecretFlags *out_flags, + GError ** error); + + gboolean (*set_secret_flags)(NMSetting * setting, + const char * secret_name, + NMSettingSecretFlags flags, + GError ** error); + + /*< private >*/ + gboolean (*clear_secrets)(const struct _NMSettInfoSetting *sett_info, + guint property_idx, + NMSetting * setting, + NMSettingClearSecretsWithFlagsFn func, + gpointer user_data); + + /* compare_property() returns a ternary, where DEFAULT means that the property should not + * be compared due to the compare @flags. A TRUE/FALSE result means that the property is + * equal/not-equal. + * + * @other may be %NULL, in which case the function only determines whether + * the setting should be compared (TRUE) or not (DEFAULT). */ + /*< private >*/ + NMTernary (*compare_property)(const struct _NMSettInfoSetting *sett_info, + guint property_idx, + NMConnection * con_a, + NMSetting * set_a, + NMConnection * con_b, + NMSetting * set_b, + NMSettingCompareFlags flags); + + /*< private >*/ + void (*duplicate_copy_properties)(const struct _NMSettInfoSetting *sett_info, + NMSetting * src, + NMSetting * dst); + + /*< private >*/ + void (*enumerate_values)(const struct _NMSettInfoProperty *property_info, + NMSetting * setting, + NMSettingValueIterFn func, + gpointer user_data); + + /*< private >*/ + gboolean (*aggregate)(NMSetting *setting, int type_i, gpointer arg); + + /*< private >*/ + void (*for_each_secret)(NMSetting * setting, + const char * secret_name, + GVariant * val, + gboolean remove_non_secrets, + _NMConnectionForEachSecretFunc callback, + gpointer callback_data, + GVariantBuilder * setting_builder); + + /*< private >*/ + gboolean (*init_from_dbus)(NMSetting * setting, + GHashTable * keys, + GVariant * setting_dict, + GVariant * connection_dict, + guint /* NMSettingParseFlags */ parse_flags, + GError ** error); + + /*< private >*/ + gpointer padding[1]; + + /*< private >*/ + const struct _NMMetaSettingInfo *setting_info; +} NMSettingClass; + +GType nm_setting_get_type(void); + +GType nm_setting_lookup_type(const char *name); + +NMSetting *nm_setting_duplicate(NMSetting *setting); + +const char *nm_setting_get_name(NMSetting *setting); + +gboolean nm_setting_verify(NMSetting *setting, NMConnection *connection, GError **error); + +NM_AVAILABLE_IN_1_2 +gboolean nm_setting_verify_secrets(NMSetting *setting, NMConnection *connection, GError **error); + +gboolean nm_setting_compare(NMSetting *a, NMSetting *b, NMSettingCompareFlags flags); + +/** + * NMSettingDiffResult: + * @NM_SETTING_DIFF_RESULT_UNKNOWN: unknown result + * @NM_SETTING_DIFF_RESULT_IN_A: the property is present in setting A + * @NM_SETTING_DIFF_RESULT_IN_B: the property is present in setting B + * @NM_SETTING_DIFF_RESULT_IN_A_DEFAULT: the property is present in + * setting A but is set to the default value. This flag is only set, + * if you specify @NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT. + * @NM_SETTING_DIFF_RESULT_IN_B_DEFAULT: analog to @NM_SETTING_DIFF_RESULT_IN_A_DEFAULT. + * + * These values indicate the result of a setting difference operation. + **/ +typedef enum { + NM_SETTING_DIFF_RESULT_UNKNOWN = 0x00000000, + NM_SETTING_DIFF_RESULT_IN_A = 0x00000001, + NM_SETTING_DIFF_RESULT_IN_B = 0x00000002, + NM_SETTING_DIFF_RESULT_IN_A_DEFAULT = 0x00000004, + NM_SETTING_DIFF_RESULT_IN_B_DEFAULT = 0x00000008, +} NMSettingDiffResult; + +gboolean nm_setting_diff(NMSetting * a, + NMSetting * b, + NMSettingCompareFlags flags, + gboolean invert_results, + GHashTable ** results); + +void nm_setting_enumerate_values(NMSetting *setting, NMSettingValueIterFn func, gpointer user_data); + +char *nm_setting_to_string(NMSetting *setting); + +/*****************************************************************************/ + +gboolean nm_setting_get_secret_flags(NMSetting * setting, + const char * secret_name, + NMSettingSecretFlags *out_flags, + GError ** error); + +gboolean nm_setting_set_secret_flags(NMSetting * setting, + const char * secret_name, + NMSettingSecretFlags flags, + GError ** error); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_26 +GVariant *nm_setting_option_get(NMSetting *setting, const char *opt_name); + +NM_AVAILABLE_IN_1_26 +gboolean +nm_setting_option_get_boolean(NMSetting *setting, const char *opt_name, gboolean *out_value); + +NM_AVAILABLE_IN_1_26 +gboolean nm_setting_option_get_uint32(NMSetting *setting, const char *opt_name, guint32 *out_value); + +NM_AVAILABLE_IN_1_26 +void nm_setting_option_set(NMSetting *setting, const char *opt_name, GVariant *variant); + +NM_AVAILABLE_IN_1_26 +void nm_setting_option_set_uint32(NMSetting *setting, const char *opt_name, guint32 value); + +NM_AVAILABLE_IN_1_26 +void nm_setting_option_set_boolean(NMSetting *setting, const char *opt_name, gboolean value); + +NM_AVAILABLE_IN_1_26 +const char *const *nm_setting_option_get_all_names(NMSetting *setting, guint *out_len); + +NM_AVAILABLE_IN_1_26 +void nm_setting_option_clear_by_name(NMSetting *setting, NMUtilsPredicateStr predicate); + +/*****************************************************************************/ + +const GVariantType *nm_setting_get_dbus_property_type(NMSetting * setting, + const char *property_name); + +/*****************************************************************************/ + +G_END_DECLS + +#endif /* __NM_SETTING_H__ */ diff --git a/src/libnm-core-public/nm-simple-connection.h b/src/libnm-core-public/nm-simple-connection.h new file mode 100644 index 0000000000..38473b6287 --- /dev/null +++ b/src/libnm-core-public/nm-simple-connection.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2014 Red Hat, Inc. + */ + +#ifndef __NM_SIMPLE_CONNECTION_H__ +#define __NM_SIMPLE_CONNECTION_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include "nm-connection.h" + +G_BEGIN_DECLS + +#define NM_TYPE_SIMPLE_CONNECTION (nm_simple_connection_get_type()) +#define NM_SIMPLE_CONNECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_SIMPLE_CONNECTION, NMSimpleConnection)) +#define NM_SIMPLE_CONNECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_SIMPLE_CONNECTION, NMSimpleConnectionClass)) +#define NM_IS_SIMPLE_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_SIMPLE_CONNECTION)) +#define NM_IS_SIMPLE_CONNECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_SIMPLE_CONNECTION)) +#define NM_SIMPLE_CONNECTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_SIMPLE_CONNECTION, NMSimpleConnectionClass)) + +/** + * NMSimpleConnection: + */ +struct _NMSimpleConnection { + GObject parent; +}; + +typedef struct { + GObjectClass parent_class; + + /*< private >*/ + gpointer padding[4]; +} NMSimpleConnectionClass; + +GType nm_simple_connection_get_type(void); + +NMConnection *nm_simple_connection_new(void); + +NMConnection *nm_simple_connection_new_from_dbus(GVariant *dict, GError **error); + +NMConnection *nm_simple_connection_new_clone(NMConnection *connection); + +G_END_DECLS + +#endif /* __NM_SIMPLE_CONNECTION__ */ diff --git a/src/libnm-core-public/nm-utils.h b/src/libnm-core-public/nm-utils.h new file mode 100644 index 0000000000..0f8dcda09e --- /dev/null +++ b/src/libnm-core-public/nm-utils.h @@ -0,0 +1,259 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2005 - 2017 Red Hat, Inc. + */ + +#ifndef __NM_UTILS_H__ +#define __NM_UTILS_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include <glib.h> + +#include "nm-core-enum-types.h" +#include "nm-setting-sriov.h" +#include "nm-setting-tc-config.h" +#include "nm-setting-wireless-security.h" + +G_BEGIN_DECLS + +/*****************************************************************************/ + +typedef struct _NMVariantAttributeSpec NMVariantAttributeSpec; + +/* SSID helpers */ +gboolean nm_utils_is_empty_ssid(const guint8 *ssid, gsize len); +const char *nm_utils_escape_ssid(const guint8 *ssid, gsize len); +gboolean nm_utils_same_ssid(const guint8 *ssid1, + gsize len1, + const guint8 *ssid2, + gsize len2, + gboolean ignore_trailing_null); +char * nm_utils_ssid_to_utf8(const guint8 *ssid, gsize len); + +/** + * NMUtilsSecurityType: + * @NMU_SEC_INVALID: unknown or invalid security, placeholder and not used + * @NMU_SEC_NONE: unencrypted and open + * @NMU_SEC_STATIC_WEP: static WEP keys are used for encryption + * @NMU_SEC_LEAP: Cisco LEAP is used for authentication and for generating the + * dynamic WEP keys automatically + * @NMU_SEC_DYNAMIC_WEP: standard 802.1x is used for authentication and + * generating the dynamic WEP keys automatically + * @NMU_SEC_WPA_PSK: WPA1 is used with Pre-Shared Keys (PSK) + * @NMU_SEC_WPA_ENTERPRISE: WPA1 is used with 802.1x authentication + * @NMU_SEC_WPA2_PSK: WPA2/RSN is used with Pre-Shared Keys (PSK) + * @NMU_SEC_WPA2_ENTERPRISE: WPA2 is used with 802.1x authentication + * @NMU_SEC_SAE: is used with WPA3 Enterprise + * @NMU_SEC_OWE: is used with Enhanced Open + * @NMU_SEC_WPA3_SUITE_B_192: is used with WPA3 Enterprise Suite-B 192 bit mode. Since: 1.30. + * + * Describes generic security mechanisms that 802.11 access points may offer. + * Used with nm_utils_security_valid() for checking whether a given access + * point is compatible with a network device. + **/ +typedef enum { + NMU_SEC_INVALID = 0, + NMU_SEC_NONE, + NMU_SEC_STATIC_WEP, + NMU_SEC_LEAP, + NMU_SEC_DYNAMIC_WEP, + NMU_SEC_WPA_PSK, + NMU_SEC_WPA_ENTERPRISE, + NMU_SEC_WPA2_PSK, + NMU_SEC_WPA2_ENTERPRISE, + NMU_SEC_SAE, + NMU_SEC_OWE, + NMU_SEC_WPA3_SUITE_B_192, +} NMUtilsSecurityType; + +gboolean nm_utils_security_valid(NMUtilsSecurityType type, + NMDeviceWifiCapabilities wifi_caps, + gboolean have_ap, + gboolean adhoc, + NM80211ApFlags ap_flags, + NM80211ApSecurityFlags ap_wpa, + NM80211ApSecurityFlags ap_rsn); + +gboolean nm_utils_ap_mode_security_valid(NMUtilsSecurityType type, + NMDeviceWifiCapabilities wifi_caps); + +gboolean nm_utils_wep_key_valid(const char *key, NMWepKeyType wep_type); +gboolean nm_utils_wpa_psk_valid(const char *psk); + +NM_AVAILABLE_IN_1_6 +gboolean nm_utils_is_json_object(const char *str, GError **error); + +GVariant * nm_utils_ip4_dns_to_variant(char **dns); +char ** nm_utils_ip4_dns_from_variant(GVariant *value); +GVariant * nm_utils_ip4_addresses_to_variant(GPtrArray *addresses, const char *gateway); +GPtrArray *nm_utils_ip4_addresses_from_variant(GVariant *value, char **out_gateway); +GVariant * nm_utils_ip4_routes_to_variant(GPtrArray *routes); +GPtrArray *nm_utils_ip4_routes_from_variant(GVariant *value); + +guint32 nm_utils_ip4_netmask_to_prefix(guint32 netmask); +guint32 nm_utils_ip4_prefix_to_netmask(guint32 prefix); +guint32 nm_utils_ip4_get_default_prefix(guint32 ip); + +GVariant * nm_utils_ip6_dns_to_variant(char **dns); +char ** nm_utils_ip6_dns_from_variant(GVariant *value); +GVariant * nm_utils_ip6_addresses_to_variant(GPtrArray *addresses, const char *gateway); +GPtrArray *nm_utils_ip6_addresses_from_variant(GVariant *value, char **out_gateway); +GVariant * nm_utils_ip6_routes_to_variant(GPtrArray *routes); +GPtrArray *nm_utils_ip6_routes_from_variant(GVariant *value); + +GVariant * nm_utils_ip_addresses_to_variant(GPtrArray *addresses); +GPtrArray *nm_utils_ip_addresses_from_variant(GVariant *value, int family); +GVariant * nm_utils_ip_routes_to_variant(GPtrArray *routes); +GPtrArray *nm_utils_ip_routes_from_variant(GVariant *value, int family); + +char *nm_utils_uuid_generate(void); + +gboolean nm_utils_file_is_certificate(const char *filename); +gboolean nm_utils_file_is_private_key(const char *filename, gboolean *out_encrypted); +gboolean nm_utils_file_is_pkcs12(const char *filename); + +typedef gboolean (*NMUtilsFileSearchInPathsPredicate)(const char *filename, gpointer user_data); + +struct stat; + +typedef gboolean (*NMUtilsCheckFilePredicate)(const char * filename, + const struct stat *stat, + gpointer user_data, + GError ** error); + +const char *nm_utils_file_search_in_paths(const char * progname, + const char * try_first, + const char *const * paths, + GFileTest file_test_flags, + NMUtilsFileSearchInPathsPredicate predicate, + gpointer user_data, + GError ** error); + +guint32 nm_utils_wifi_freq_to_channel(guint32 freq); +guint32 nm_utils_wifi_channel_to_freq(guint32 channel, const char *band); +guint32 nm_utils_wifi_find_next_channel(guint32 channel, int direction, char *band); +gboolean nm_utils_wifi_is_channel_valid(guint32 channel, const char *band); +NM_AVAILABLE_IN_1_2 +const guint *nm_utils_wifi_2ghz_freqs(void); +NM_AVAILABLE_IN_1_2 +const guint *nm_utils_wifi_5ghz_freqs(void); + +const char *nm_utils_wifi_strength_bars(guint8 strength); + +/** + * NM_UTILS_HWADDR_LEN_MAX: + * + * The maximum length of hardware addresses handled by NetworkManager itself, + * nm_utils_hwaddr_len(), and nm_utils_hwaddr_aton(). + */ +#define NM_UTILS_HWADDR_LEN_MAX 20 /* INFINIBAND_ALEN */ + +gsize nm_utils_hwaddr_len(int type) G_GNUC_PURE; + +char * nm_utils_hwaddr_ntoa(gconstpointer addr, gsize length); +GByteArray *nm_utils_hwaddr_atoba(const char *asc, gsize length); +guint8 * nm_utils_hwaddr_aton(const char *asc, gpointer buffer, gsize length); + +gboolean nm_utils_hwaddr_valid(const char *asc, gssize length); +char * nm_utils_hwaddr_canonical(const char *asc, gssize length); +gboolean nm_utils_hwaddr_matches(gconstpointer hwaddr1, + gssize hwaddr1_len, + gconstpointer hwaddr2, + gssize hwaddr2_len); + +char * nm_utils_bin2hexstr(gconstpointer src, gsize len, int final_len); +GBytes *nm_utils_hexstr2bin(const char *hex); + +NM_DEPRECATED_IN_1_6_FOR(nm_utils_is_valid_iface_name) +gboolean nm_utils_iface_valid_name(const char *name); +NM_AVAILABLE_IN_1_6 +gboolean nm_utils_is_valid_iface_name(const char *name, GError **error); + +gboolean nm_utils_is_uuid(const char *str); + +/** + * NM_UTILS_INET_ADDRSTRLEN: + * + * Defines the minimal length for a char buffer that is suitable as @dst argument + * for both nm_utils_inet4_ntop() and nm_utils_inet6_ntop(). + **/ +#define NM_UTILS_INET_ADDRSTRLEN INET6_ADDRSTRLEN + +const char *nm_utils_inet4_ntop(guint32 inaddr, char *dst); + +struct in6_addr; +const char *nm_utils_inet6_ntop(const struct in6_addr *in6addr, char *dst); + +gboolean nm_utils_ipaddr_valid(int family, const char *ip); + +gboolean nm_utils_check_virtual_device_compatibility(GType virtual_type, GType other_type); + +NM_AVAILABLE_IN_1_2 +int nm_utils_bond_mode_string_to_int(const char *mode); +NM_AVAILABLE_IN_1_2 +const char *nm_utils_bond_mode_int_to_string(int mode); + +NM_AVAILABLE_IN_1_2 +char *nm_utils_enum_to_str(GType type, int value); + +NM_AVAILABLE_IN_1_2 +gboolean nm_utils_enum_from_str(GType type, const char *str, int *out_value, char **err_token); + +NM_AVAILABLE_IN_1_2 +const char **nm_utils_enum_get_values(GType type, int from, int to); + +NM_AVAILABLE_IN_1_6 +guint nm_utils_version(void); + +NM_AVAILABLE_IN_1_8 +GHashTable *nm_utils_parse_variant_attributes(const char *string, + char attr_separator, + char key_value_separator, + gboolean ignore_unknown, + const NMVariantAttributeSpec *const *spec, + GError ** error); + +NM_AVAILABLE_IN_1_8 +char *nm_utils_format_variant_attributes(GHashTable *attributes, + char attr_separator, + char key_value_separator); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_12 +NMTCQdisc *nm_utils_tc_qdisc_from_str(const char *str, GError **error); +NM_AVAILABLE_IN_1_12 +char *nm_utils_tc_qdisc_to_str(NMTCQdisc *qdisc, GError **error); + +NM_AVAILABLE_IN_1_12 +NMTCAction *nm_utils_tc_action_from_str(const char *str, GError **error); +NM_AVAILABLE_IN_1_12 +char *nm_utils_tc_action_to_str(NMTCAction *action, GError **error); + +NM_AVAILABLE_IN_1_12 +NMTCTfilter *nm_utils_tc_tfilter_from_str(const char *str, GError **error); +NM_AVAILABLE_IN_1_12 +char *nm_utils_tc_tfilter_to_str(NMTCTfilter *tfilter, GError **error); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_14 +char *nm_utils_sriov_vf_to_str(const NMSriovVF *vf, gboolean omit_index, GError **error); +NM_AVAILABLE_IN_1_14 +NMSriovVF *nm_utils_sriov_vf_from_str(const char *str, GError **error); + +/*****************************************************************************/ + +NM_AVAILABLE_IN_1_12 +gint64 nm_utils_get_timestamp_msec(void); + +NM_AVAILABLE_IN_1_16 +gboolean +nm_utils_base64secret_decode(const char *base64_key, gsize required_key_len, guint8 *out_key); + +G_END_DECLS + +#endif /* __NM_UTILS_H__ */ diff --git a/src/libnm-core-public/nm-version-macros.h.in b/src/libnm-core-public/nm-version-macros.h.in new file mode 100644 index 0000000000..4a6f46e9f0 --- /dev/null +++ b/src/libnm-core-public/nm-version-macros.h.in @@ -0,0 +1,91 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2011, 2015 Red Hat, Inc. + */ + +#ifndef __NM_VERSION_MACROS_H__ +#define __NM_VERSION_MACROS_H__ + +/* This header must not include glib or libnm. */ + +/** + * NM_MAJOR_VERSION: + * + * Evaluates to the major version number of NetworkManager which this source + * is compiled against. + */ +#define NM_MAJOR_VERSION (@NM_MAJOR_VERSION@) + +/** + * NM_MINOR_VERSION: + * + * Evaluates to the minor version number of NetworkManager which this source + * is compiled against. + */ +#define NM_MINOR_VERSION (@NM_MINOR_VERSION@) + +/** + * NM_MICRO_VERSION: + * + * Evaluates to the micro version number of NetworkManager which this source + * compiled against. + */ +#define NM_MICRO_VERSION (@NM_MICRO_VERSION@) + +/** + * NM_CHECK_VERSION: + * @major: major version (e.g. 1 for version 1.2.5) + * @minor: minor version (e.g. 2 for version 1.2.5) + * @micro: micro version (e.g. 5 for version 1.2.5) + * + * Returns: %TRUE if the version of the NetworkManager header files + * is the same as or newer than the passed-in version. + */ +#define NM_CHECK_VERSION(major,minor,micro) \ + (NM_MAJOR_VERSION > (major) || \ + (NM_MAJOR_VERSION == (major) && NM_MINOR_VERSION > (minor)) || \ + (NM_MAJOR_VERSION == (major) && NM_MINOR_VERSION == (minor) && NM_MICRO_VERSION >= (micro))) + + +#define NM_ENCODE_VERSION(major,minor,micro) ((major) << 16 | (minor) << 8 | (micro)) + +#define NM_VERSION_0_9_8 (NM_ENCODE_VERSION (0, 9, 8)) +#define NM_VERSION_0_9_10 (NM_ENCODE_VERSION (0, 9, 10)) +#define NM_VERSION_1_0 (NM_ENCODE_VERSION (1, 0, 0)) +#define NM_VERSION_1_2 (NM_ENCODE_VERSION (1, 2, 0)) +#define NM_VERSION_1_4 (NM_ENCODE_VERSION (1, 4, 0)) +#define NM_VERSION_1_6 (NM_ENCODE_VERSION (1, 6, 0)) +#define NM_VERSION_1_8 (NM_ENCODE_VERSION (1, 8, 0)) +#define NM_VERSION_1_10 (NM_ENCODE_VERSION (1, 10, 0)) +#define NM_VERSION_1_12 (NM_ENCODE_VERSION (1, 12, 0)) +#define NM_VERSION_1_14 (NM_ENCODE_VERSION (1, 14, 0)) +#define NM_VERSION_1_16 (NM_ENCODE_VERSION (1, 16, 0)) +#define NM_VERSION_1_18 (NM_ENCODE_VERSION (1, 18, 0)) +#define NM_VERSION_1_20 (NM_ENCODE_VERSION (1, 20, 0)) +#define NM_VERSION_1_22 (NM_ENCODE_VERSION (1, 22, 0)) +#define NM_VERSION_1_24 (NM_ENCODE_VERSION (1, 24, 0)) +#define NM_VERSION_1_26 (NM_ENCODE_VERSION (1, 26, 0)) +#define NM_VERSION_1_28 (NM_ENCODE_VERSION (1, 28, 0)) +#define NM_VERSION_1_30 (NM_ENCODE_VERSION (1, 30, 0)) + +/* For releases, NM_API_VERSION is equal to NM_VERSION. + * + * For development builds, NM_API_VERSION is the next + * stable API after NM_VERSION. When you run a development + * version, you are already using the future API, even if + * it is not yet release. Hence, the currently used API + * version is the future one. */ +#define NM_API_VERSION \ + (((NM_MINOR_VERSION % 2) == 1) \ + ? NM_ENCODE_VERSION (NM_MAJOR_VERSION, NM_MINOR_VERSION + 1, 0 ) \ + : NM_ENCODE_VERSION (NM_MAJOR_VERSION, NM_MINOR_VERSION , ((NM_MICRO_VERSION + 1) / 2) * 2)) + +/* deprecated. */ +#define NM_VERSION_CUR_STABLE NM_API_VERSION + +/* deprecated. */ +#define NM_VERSION_NEXT_STABLE NM_API_VERSION + +#define NM_VERSION NM_ENCODE_VERSION (NM_MAJOR_VERSION, NM_MINOR_VERSION, NM_MICRO_VERSION) + +#endif /* __NM_VERSION_MACROS_H__ */ diff --git a/src/libnm-core-public/nm-version.h b/src/libnm-core-public/nm-version.h new file mode 100644 index 0000000000..3f1ad3f2eb --- /dev/null +++ b/src/libnm-core-public/nm-version.h @@ -0,0 +1,301 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2011, 2015 Red Hat, Inc. + */ + +#ifndef NM_VERSION_H +#define NM_VERSION_H + +#include <glib.h> + +#include "nm-version-macros.h" + +/* Deprecation / Availability macros */ + +#if !defined(NM_VERSION_MIN_REQUIRED) || (NM_VERSION_MIN_REQUIRED == 0) + #undef NM_VERSION_MIN_REQUIRED + #define NM_VERSION_MIN_REQUIRED (NM_API_VERSION) +#endif + +#if !defined(NM_VERSION_MAX_ALLOWED) || (NM_VERSION_MAX_ALLOWED == 0) + #undef NM_VERSION_MAX_ALLOWED + #define NM_VERSION_MAX_ALLOWED (NM_API_VERSION) +#endif + +/* sanity checks */ +#if NM_VERSION_MIN_REQUIRED > NM_API_VERSION + #error "NM_VERSION_MIN_REQUIRED must be <= NM_API_VERSION" +#endif +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_MIN_REQUIRED + #error "NM_VERSION_MAX_ALLOWED must be >= NM_VERSION_MIN_REQUIRED" +#endif +#if NM_VERSION_MIN_REQUIRED < NM_VERSION_0_9_8 + #error "NM_VERSION_MIN_REQUIRED must be >= NM_VERSION_0_9_8" +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_0_9_10 + #define NM_DEPRECATED_IN_0_9_10 G_DEPRECATED + #define NM_DEPRECATED_IN_0_9_10_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_0_9_10 + #define NM_DEPRECATED_IN_0_9_10_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_0_9_10 + #define NM_AVAILABLE_IN_0_9_10 G_UNAVAILABLE(0.9, 10) +#else + #define NM_AVAILABLE_IN_0_9_10 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_0 + #define NM_DEPRECATED_IN_1_0 G_DEPRECATED + #define NM_DEPRECATED_IN_1_0_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_0 + #define NM_DEPRECATED_IN_1_0_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_0 + #define NM_AVAILABLE_IN_1_0 G_UNAVAILABLE(1, 0) +#else + #define NM_AVAILABLE_IN_1_0 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_2 + #define NM_DEPRECATED_IN_1_2 G_DEPRECATED + #define NM_DEPRECATED_IN_1_2_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_2 + #define NM_DEPRECATED_IN_1_2_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_2 + #define NM_AVAILABLE_IN_1_2 G_UNAVAILABLE(1, 2) +#else + #define NM_AVAILABLE_IN_1_2 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_4 + #define NM_DEPRECATED_IN_1_4 G_DEPRECATED + #define NM_DEPRECATED_IN_1_4_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_4 + #define NM_DEPRECATED_IN_1_4_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_4 + #define NM_AVAILABLE_IN_1_4 G_UNAVAILABLE(1, 4) +#else + #define NM_AVAILABLE_IN_1_4 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_6 + #define NM_DEPRECATED_IN_1_6 G_DEPRECATED + #define NM_DEPRECATED_IN_1_6_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_6 + #define NM_DEPRECATED_IN_1_6_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_6 + #define NM_AVAILABLE_IN_1_6 G_UNAVAILABLE(1, 6) +#else + #define NM_AVAILABLE_IN_1_6 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_8 + #define NM_DEPRECATED_IN_1_8 G_DEPRECATED + #define NM_DEPRECATED_IN_1_8_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_8 + #define NM_DEPRECATED_IN_1_8_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_8 + #define NM_AVAILABLE_IN_1_8 G_UNAVAILABLE(1, 8) +#else + #define NM_AVAILABLE_IN_1_8 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_10 + #define NM_DEPRECATED_IN_1_10 G_DEPRECATED + #define NM_DEPRECATED_IN_1_10_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_10 + #define NM_DEPRECATED_IN_1_10_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_10 + #define NM_AVAILABLE_IN_1_10 G_UNAVAILABLE(1, 10) +#else + #define NM_AVAILABLE_IN_1_10 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_12 + #define NM_DEPRECATED_IN_1_12 G_DEPRECATED + #define NM_DEPRECATED_IN_1_12_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_12 + #define NM_DEPRECATED_IN_1_12_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_12 + #define NM_AVAILABLE_IN_1_12 G_UNAVAILABLE(1, 12) +#else + #define NM_AVAILABLE_IN_1_12 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_14 + #define NM_DEPRECATED_IN_1_14 G_DEPRECATED + #define NM_DEPRECATED_IN_1_14_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_14 + #define NM_DEPRECATED_IN_1_14_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_14 + #define NM_AVAILABLE_IN_1_14 G_UNAVAILABLE(1, 14) +#else + #define NM_AVAILABLE_IN_1_14 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_16 + #define NM_DEPRECATED_IN_1_16 G_DEPRECATED + #define NM_DEPRECATED_IN_1_16_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_16 + #define NM_DEPRECATED_IN_1_16_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_16 + #define NM_AVAILABLE_IN_1_16 G_UNAVAILABLE(1, 16) +#else + #define NM_AVAILABLE_IN_1_16 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_18 + #define NM_DEPRECATED_IN_1_18 G_DEPRECATED + #define NM_DEPRECATED_IN_1_18_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_18 + #define NM_DEPRECATED_IN_1_18_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_18 + #define NM_AVAILABLE_IN_1_18 G_UNAVAILABLE(1, 18) +#else + #define NM_AVAILABLE_IN_1_18 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_20 + #define NM_DEPRECATED_IN_1_20 G_DEPRECATED + #define NM_DEPRECATED_IN_1_20_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_20 + #define NM_DEPRECATED_IN_1_20_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_20 + #define NM_AVAILABLE_IN_1_20 G_UNAVAILABLE(1, 20) +#else + #define NM_AVAILABLE_IN_1_20 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_22 + #define NM_DEPRECATED_IN_1_22 G_DEPRECATED + #define NM_DEPRECATED_IN_1_22_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_22 + #define NM_DEPRECATED_IN_1_22_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_22 + #define NM_AVAILABLE_IN_1_22 G_UNAVAILABLE(1, 22) +#else + #define NM_AVAILABLE_IN_1_22 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_24 + #define NM_DEPRECATED_IN_1_24 G_DEPRECATED + #define NM_DEPRECATED_IN_1_24_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_24 + #define NM_DEPRECATED_IN_1_24_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_24 + #define NM_AVAILABLE_IN_1_24 G_UNAVAILABLE(1, 24) +#else + #define NM_AVAILABLE_IN_1_24 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_26 + #define NM_DEPRECATED_IN_1_26 G_DEPRECATED + #define NM_DEPRECATED_IN_1_26_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_26 + #define NM_DEPRECATED_IN_1_26_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_26 + #define NM_AVAILABLE_IN_1_26 G_UNAVAILABLE(1, 26) +#else + #define NM_AVAILABLE_IN_1_26 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_28 + #define NM_DEPRECATED_IN_1_28 G_DEPRECATED + #define NM_DEPRECATED_IN_1_28_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_28 + #define NM_DEPRECATED_IN_1_28_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_28 + #define NM_AVAILABLE_IN_1_28 G_UNAVAILABLE(1, 28) +#else + #define NM_AVAILABLE_IN_1_28 +#endif + +#if NM_VERSION_MIN_REQUIRED >= NM_VERSION_1_30 + #define NM_DEPRECATED_IN_1_30 G_DEPRECATED + #define NM_DEPRECATED_IN_1_30_FOR(f) G_DEPRECATED_FOR(f) +#else + #define NM_DEPRECATED_IN_1_30 + #define NM_DEPRECATED_IN_1_30_FOR(f) +#endif + +#if NM_VERSION_MAX_ALLOWED < NM_VERSION_1_30 + #define NM_AVAILABLE_IN_1_30 G_UNAVAILABLE(1, 30) +#else + #define NM_AVAILABLE_IN_1_30 +#endif + +/* + * Synchronous API for calling D-Bus in libnm is deprecated. See + * https://developer.gnome.org/libnm/stable/usage.html#sync-api + * + * Note that "deprecated" here does not really mean that the API is going + * to be removed. We don't break API. Just comment that it is awkward and + * discouraged. The user may: + * + * - continue to use this API. It's deprecated, awkward and discouraged, + * but if it works for you, that's fine. + * + * - use asynchronous API. That's the only sensible way to use D-Bus. + * If libnm lacks a certain asynchronous counterpart, it should be + * added. + * + * - use GDBusConnection directly. There really isn't anything wrong + * with D-Bus or GDBusConnection. This deprecated API is just a wrapper + * around g_dbus_connection_call_sync(). You may call it directly + * without feeling dirty. + * + * The API is marked as deprecated since 1.22, however the macro only starts + * complaining in 1.24. That's intentional, because in 1.22 the asynchronous + * alternative was not yet available. + */ +#define _NM_DEPRECATED_SYNC_METHOD NM_DEPRECATED_IN_1_24 +#define _NM_DEPRECATED_SYNC_WRITABLE_PROPERTY /* NM_DEPRECATED_IN_1_22 */ + +#endif /* NM_VERSION_H */ diff --git a/src/libnm-core-public/nm-vpn-dbus-interface.h b/src/libnm-core-public/nm-vpn-dbus-interface.h new file mode 100644 index 0000000000..c0e23f6fc1 --- /dev/null +++ b/src/libnm-core-public/nm-vpn-dbus-interface.h @@ -0,0 +1,302 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2004 Red Hat, Inc. + */ + +/* D-Bus-related definitions for NetworkManager VPN plugins. + * + * Note that although this header is installed as part of libnm, it is also + * used by some external code that does not link to libnm. + */ + +#ifndef __NM_VPN_DBUS_INTERFACE_H__ +#define __NM_VPN_DBUS_INTERFACE_H__ + +#include "nm-dbus-interface.h" + +#ifndef NM_VERSION_H + #define NM_DEPRECATED_IN_1_8_FOR(n) +#endif + +/* + * dbus services details + */ +#define NM_DBUS_PATH_VPN "/org/freedesktop/NetworkManager/VPN/Manager" +#define NM_DBUS_INTERFACE_VPN "org.freedesktop.NetworkManager.VPN.Manager" + +#define NM_DBUS_PATH_VPN_CONNECTION "/org/freedesktop/NetworkManager/VPN/Connection" +#define NM_DBUS_INTERFACE_VPN_CONNECTION "org.freedesktop.NetworkManager.VPN.Connection" + +#define NM_VPN_DBUS_PLUGIN_PATH "/org/freedesktop/NetworkManager/VPN/Plugin" +#define NM_VPN_DBUS_PLUGIN_INTERFACE "org.freedesktop.NetworkManager.VPN.Plugin" + +/* + * VPN Errors + */ +#define NM_DBUS_NO_ACTIVE_VPN_CONNECTION \ + "org.freedesktop.NetworkManager.VPNConnections.NoActiveVPNConnection" +#define NM_DBUS_NO_VPN_CONNECTIONS "org.freedesktop.NetworkManager.VPNConnections.NoVPNConnections" +#define NM_DBUS_INVALID_VPN_CONNECTION \ + "org.freedesktop.NetworkManager.VPNConnections.InvalidVPNConnection" + +#define NM_DBUS_VPN_ERROR_PREFIX "org.freedesktop.NetworkManager.VPN.Error" +#define NM_DBUS_VPN_STARTING_IN_PROGRESS "StartingInProgress" +#define NM_DBUS_VPN_ALREADY_STARTED "AlreadyStarted" +#define NM_DBUS_VPN_STOPPING_IN_PROGRESS "StoppingInProgress" +#define NM_DBUS_VPN_ALREADY_STOPPED "AlreadyStopped" +#define NM_DBUS_VPN_WRONG_STATE "WrongState" +#define NM_DBUS_VPN_BAD_ARGUMENTS "BadArguments" +#define NM_DBUS_VPN_INTERACTIVE_NOT_SUPPORTED "InteractiveNotSupported" + +/* + * VPN daemon signals + */ +#define NM_DBUS_VPN_SIGNAL_LOGIN_BANNER "LoginBanner" +#define NM_DBUS_VPN_SIGNAL_LOGIN_FAILED "LoginFailed" +#define NM_DBUS_VPN_SIGNAL_LAUNCH_FAILED "LaunchFailed" +#define NM_DBUS_VPN_SIGNAL_CONNECT_FAILED "ConnectFailed" +#define NM_DBUS_VPN_SIGNAL_VPN_CONFIG_BAD "VPNConfigBad" +#define NM_DBUS_VPN_SIGNAL_IP_CONFIG_BAD "IPConfigBad" +#define NM_DBUS_VPN_SIGNAL_STATE_CHANGE "StateChange" +#define NM_DBUS_VPN_SIGNAL_IP4_CONFIG "IP4Config" + +/** + * NMVpnServiceState: + * @NM_VPN_SERVICE_STATE_UNKNOWN: The state of the VPN plugin is unknown. + * @NM_VPN_SERVICE_STATE_INIT: The VPN plugin is initialized. + * @NM_VPN_SERVICE_STATE_SHUTDOWN: Not used. + * @NM_VPN_SERVICE_STATE_STARTING: The plugin is attempting to connect to a VPN server. + * @NM_VPN_SERVICE_STATE_STARTED: The plugin has connected to a VPN server. + * @NM_VPN_SERVICE_STATE_STOPPING: The plugin is disconnecting from the VPN server. + * @NM_VPN_SERVICE_STATE_STOPPED: The plugin has disconnected from the VPN server. + * + * VPN daemon states + */ +typedef enum { + NM_VPN_SERVICE_STATE_UNKNOWN = 0, + NM_VPN_SERVICE_STATE_INIT, + NM_VPN_SERVICE_STATE_SHUTDOWN, + NM_VPN_SERVICE_STATE_STARTING, + NM_VPN_SERVICE_STATE_STARTED, + NM_VPN_SERVICE_STATE_STOPPING, + NM_VPN_SERVICE_STATE_STOPPED +} NMVpnServiceState; + +/** + * NMVpnConnectionState: + * @NM_VPN_CONNECTION_STATE_UNKNOWN: The state of the VPN connection is + * unknown. + * @NM_VPN_CONNECTION_STATE_PREPARE: The VPN connection is preparing to + * connect. + * @NM_VPN_CONNECTION_STATE_NEED_AUTH: The VPN connection needs authorization + * credentials. + * @NM_VPN_CONNECTION_STATE_CONNECT: The VPN connection is being established. + * @NM_VPN_CONNECTION_STATE_IP_CONFIG_GET: The VPN connection is getting an IP + * address. + * @NM_VPN_CONNECTION_STATE_ACTIVATED: The VPN connection is active. + * @NM_VPN_CONNECTION_STATE_FAILED: The VPN connection failed. + * @NM_VPN_CONNECTION_STATE_DISCONNECTED: The VPN connection is disconnected. + * + * VPN connection states + */ +typedef enum { + NM_VPN_CONNECTION_STATE_UNKNOWN = 0, + NM_VPN_CONNECTION_STATE_PREPARE, + NM_VPN_CONNECTION_STATE_NEED_AUTH, + NM_VPN_CONNECTION_STATE_CONNECT, + NM_VPN_CONNECTION_STATE_IP_CONFIG_GET, + NM_VPN_CONNECTION_STATE_ACTIVATED, + NM_VPN_CONNECTION_STATE_FAILED, + NM_VPN_CONNECTION_STATE_DISCONNECTED +} NMVpnConnectionState; + +/** + * NMVpnConnectionStateReason: + * @NM_VPN_CONNECTION_STATE_REASON_UNKNOWN: The reason for the VPN connection + * state change is unknown. + * @NM_VPN_CONNECTION_STATE_REASON_NONE: No reason was given for the VPN + * connection state change. + * @NM_VPN_CONNECTION_STATE_REASON_USER_DISCONNECTED: The VPN connection changed + * state because the user disconnected it. + * @NM_VPN_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED: The VPN connection + * changed state because the device it was using was disconnected. + * @NM_VPN_CONNECTION_STATE_REASON_SERVICE_STOPPED: The service providing the + * VPN connection was stopped. + * @NM_VPN_CONNECTION_STATE_REASON_IP_CONFIG_INVALID: The IP config of the VPN + * connection was invalid. + * @NM_VPN_CONNECTION_STATE_REASON_CONNECT_TIMEOUT: The connection attempt to + * the VPN service timed out. + * @NM_VPN_CONNECTION_STATE_REASON_SERVICE_START_TIMEOUT: A timeout occurred + * while starting the service providing the VPN connection. + * @NM_VPN_CONNECTION_STATE_REASON_SERVICE_START_FAILED: Starting the service + * starting the service providing the VPN connection failed. + * @NM_VPN_CONNECTION_STATE_REASON_NO_SECRETS: Necessary secrets for the VPN + * connection were not provided. + * @NM_VPN_CONNECTION_STATE_REASON_LOGIN_FAILED: Authentication to the VPN + * server failed. + * @NM_VPN_CONNECTION_STATE_REASON_CONNECTION_REMOVED: The connection was + * deleted from settings. + * + * VPN connection state reasons + */ +NM_DEPRECATED_IN_1_8_FOR(NMActiveConnectionStateReason) +typedef enum { + NM_VPN_CONNECTION_STATE_REASON_UNKNOWN = 0, + NM_VPN_CONNECTION_STATE_REASON_NONE = 1, + NM_VPN_CONNECTION_STATE_REASON_USER_DISCONNECTED = 2, + NM_VPN_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED = 3, + NM_VPN_CONNECTION_STATE_REASON_SERVICE_STOPPED = 4, + NM_VPN_CONNECTION_STATE_REASON_IP_CONFIG_INVALID = 5, + NM_VPN_CONNECTION_STATE_REASON_CONNECT_TIMEOUT = 6, + NM_VPN_CONNECTION_STATE_REASON_SERVICE_START_TIMEOUT = 7, + NM_VPN_CONNECTION_STATE_REASON_SERVICE_START_FAILED = 8, + NM_VPN_CONNECTION_STATE_REASON_NO_SECRETS = 9, + NM_VPN_CONNECTION_STATE_REASON_LOGIN_FAILED = 10, + NM_VPN_CONNECTION_STATE_REASON_CONNECTION_REMOVED = 11, +} NMVpnConnectionStateReason; + +/** + * NMVpnPluginFailure: + * @NM_VPN_PLUGIN_FAILURE_LOGIN_FAILED: Login failed. + * @NM_VPN_PLUGIN_FAILURE_CONNECT_FAILED: Connect failed. + * @NM_VPN_PLUGIN_FAILURE_BAD_IP_CONFIG: Invalid IP configuration returned from + * the VPN plugin. + * + * VPN plugin failure reasons + */ +typedef enum { + NM_VPN_PLUGIN_FAILURE_LOGIN_FAILED, + NM_VPN_PLUGIN_FAILURE_CONNECT_FAILED, + NM_VPN_PLUGIN_FAILURE_BAD_IP_CONFIG +} NMVpnPluginFailure; + +#ifndef NM_VERSION_H + #undef NM_DEPRECATED_IN_1_8_FOR +#endif + +/*** Generic config ***/ + +/* string: VPN interface name (tun0, tap0, etc) */ +#define NM_VPN_PLUGIN_CONFIG_TUNDEV "tundev" + +/* string: Proxy PAC */ +#define NM_VPN_PLUGIN_CONFIG_PROXY_PAC "pac" + +/* string: Login message */ +#define NM_VPN_PLUGIN_CONFIG_BANNER "banner" + +/* uint32 / array of uint8: IP address of the public external VPN gateway (network byte order) */ +#define NM_VPN_PLUGIN_CONFIG_EXT_GATEWAY "gateway" + +/* uint32: Maximum Transfer Unit that the VPN interface should use */ +#define NM_VPN_PLUGIN_CONFIG_MTU "mtu" + +/* boolean: Has IP4 configuration? */ +#define NM_VPN_PLUGIN_CONFIG_HAS_IP4 "has-ip4" + +/* boolean: Has IP6 configuration? */ +#define NM_VPN_PLUGIN_CONFIG_HAS_IP6 "has-ip6" + +/* boolean: If %TRUE the VPN plugin can persist/reconnect the connection over + * link changes and VPN server dropouts. + */ +#define NM_VPN_PLUGIN_CAN_PERSIST "can-persist" + +/*** Ip4Config ***/ + +/* uint32: IP address of the internal gateway of the subnet the VPN interface is + * on, if the VPN uses subnet configuration (network byte order) + */ +#define NM_VPN_PLUGIN_IP4_CONFIG_INT_GATEWAY "internal-gateway" + +/* uint32: internal IP address of the local VPN interface (network byte order) */ +#define NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS "address" + +/* uint32: IP address of the other side of Point-to-Point connection if the VPN + * uses Point-to-Point configuration. (network byte order) + */ +#define NM_VPN_PLUGIN_IP4_CONFIG_PTP "ptp" + +/* uint32: IP prefix of the VPN interface; 1 - 32 inclusive */ +#define NM_VPN_PLUGIN_IP4_CONFIG_PREFIX "prefix" + +/* array of uint32: IP addresses of DNS servers for the VPN (network byte order) */ +#define NM_VPN_PLUGIN_IP4_CONFIG_DNS "dns" + +/* array of uint32: IP addresses of NBNS/WINS servers for the VPN (network byte order) */ +#define NM_VPN_PLUGIN_IP4_CONFIG_NBNS "nbns" + +/* uint32: Message Segment Size that the VPN interface should use */ +#define NM_VPN_PLUGIN_IP4_CONFIG_MSS "mss" + +/* string: DNS domain name */ +#define NM_VPN_PLUGIN_IP4_CONFIG_DOMAIN "domain" + +/* array of strings: DNS domain names */ +#define NM_VPN_PLUGIN_IP4_CONFIG_DOMAINS "domains" + +/* [ip4 routes]: custom routes the client should apply, in the format used + * by nm_utils_ip4_routes_to/from_gvalue + */ +#define NM_VPN_PLUGIN_IP4_CONFIG_ROUTES "routes" + +/* whether the previous IP4 routing configuration should be preserved. */ +#define NM_VPN_PLUGIN_IP4_CONFIG_PRESERVE_ROUTES "preserve-routes" + +/* boolean: prevent this VPN connection from ever getting the default route */ +#define NM_VPN_PLUGIN_IP4_CONFIG_NEVER_DEFAULT "never-default" + +/* Deprecated */ +#define NM_VPN_PLUGIN_IP4_CONFIG_GATEWAY NM_VPN_PLUGIN_IP4_CONFIG_EXT_GATEWAY + +/* Legacy IP4 items; these are included in the IP4 config by older plugins, + * but in the generic config by newer plugins. + */ + +#define NM_VPN_PLUGIN_IP4_CONFIG_BANNER NM_VPN_PLUGIN_CONFIG_BANNER +#define NM_VPN_PLUGIN_IP4_CONFIG_EXT_GATEWAY NM_VPN_PLUGIN_CONFIG_EXT_GATEWAY +#define NM_VPN_PLUGIN_IP4_CONFIG_MTU NM_VPN_PLUGIN_CONFIG_MTU +#define NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV NM_VPN_PLUGIN_CONFIG_TUNDEV + +/*** Ip6Config ***/ + +/* array of uint8: IP address of the internal gateway of the subnet the VPN interface is + * on, if the VPN uses subnet configuration (network byte order) + */ +#define NM_VPN_PLUGIN_IP6_CONFIG_INT_GATEWAY "internal-gateway" + +/* array of uint8: internal IP address of the local VPN interface (network byte order) */ +#define NM_VPN_PLUGIN_IP6_CONFIG_ADDRESS "address" + +/* array of uint8: IP address of the other side of Point-to-Point connection if the VPN + * uses Point-to-Point configuration. (network byte order) + */ +#define NM_VPN_PLUGIN_IP6_CONFIG_PTP "ptp" + +/* uint32: prefix length of the VPN interface; 1 - 128 inclusive */ +#define NM_VPN_PLUGIN_IP6_CONFIG_PREFIX "prefix" + +/* array of array of uint8: IP addresses of DNS servers for the VPN (network byte order) */ +#define NM_VPN_PLUGIN_IP6_CONFIG_DNS "dns" + +/* uint32: Message Segment Size that the VPN interface should use */ +#define NM_VPN_PLUGIN_IP6_CONFIG_MSS "mss" + +/* string: DNS domain name */ +#define NM_VPN_PLUGIN_IP6_CONFIG_DOMAIN "domain" + +/* array of strings: DNS domain names */ +#define NM_VPN_PLUGIN_IP6_CONFIG_DOMAINS "domains" + +/* [ip6 routes]: custom routes the client should apply, in the format used + * by nm_utils_ip6_routes_to/from_gvalue + */ +#define NM_VPN_PLUGIN_IP6_CONFIG_ROUTES "routes" + +/* whether the previous IP6 routing configuration should be preserved. */ +#define NM_VPN_PLUGIN_IP6_CONFIG_PRESERVE_ROUTES "preserve-routes" + +/* boolean: prevent this VPN connection from ever getting the default route */ +#define NM_VPN_PLUGIN_IP6_CONFIG_NEVER_DEFAULT "never-default" + +#endif /* __NM_VPN_DBUS_INTERFACE_H__ */ diff --git a/src/libnm-core-public/nm-vpn-editor-plugin.h b/src/libnm-core-public/nm-vpn-editor-plugin.h new file mode 100644 index 0000000000..e318da07b8 --- /dev/null +++ b/src/libnm-core-public/nm-vpn-editor-plugin.h @@ -0,0 +1,159 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2008 Novell, Inc. + * Copyright (C) 2008 - 2015 Red Hat, Inc. + */ + +#ifndef __NM_VPN_EDITOR_PLUGIN_H__ +#define __NM_VPN_EDITOR_PLUGIN_H__ + +#if !defined(__NETWORKMANAGER_H_INSIDE__) && !defined(NETWORKMANAGER_COMPILATION) + #error "Only <NetworkManager.h> can be included directly." +#endif + +#include <glib.h> +#include <glib-object.h> + +#include "nm-connection.h" +#include "nm-utils.h" + +G_BEGIN_DECLS + +typedef struct _NMVpnPluginInfo NMVpnPluginInfo; + +typedef struct _NMVpnEditorPlugin NMVpnEditorPlugin; +typedef struct _NMVpnEditor NMVpnEditor; + +/* Plugin's factory function that returns a GObject that implements + * NMVpnEditorPlugin. + */ +#ifndef __GI_SCANNER__ +typedef NMVpnEditorPlugin *(*NMVpnEditorPluginFactory)(GError **error); +NMVpnEditorPlugin *nm_vpn_editor_plugin_factory(GError **error); +#endif + +/*****************************************************************************/ +/* Editor plugin interface */ +/*****************************************************************************/ + +#define NM_TYPE_VPN_EDITOR_PLUGIN (nm_vpn_editor_plugin_get_type()) +#define NM_VPN_EDITOR_PLUGIN(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_VPN_EDITOR_PLUGIN, NMVpnEditorPlugin)) +#define NM_IS_VPN_EDITOR_PLUGIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_VPN_EDITOR_PLUGIN)) +#define NM_VPN_EDITOR_PLUGIN_GET_INTERFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE((obj), NM_TYPE_VPN_EDITOR_PLUGIN, NMVpnEditorPluginInterface)) + +/** + * NMVpnEditorPluginCapability: + * @NM_VPN_EDITOR_PLUGIN_CAPABILITY_NONE: unknown or no capability + * @NM_VPN_EDITOR_PLUGIN_CAPABILITY_IMPORT: the plugin can import new connections + * @NM_VPN_EDITOR_PLUGIN_CAPABILITY_EXPORT: the plugin can export connections + * @NM_VPN_EDITOR_PLUGIN_CAPABILITY_IPV6: the plugin supports IPv6 addressing + * + * Flags that indicate certain capabilities of the plugin to editor programs. + **/ +typedef enum /*< flags >*/ { + NM_VPN_EDITOR_PLUGIN_CAPABILITY_NONE = 0x00, + NM_VPN_EDITOR_PLUGIN_CAPABILITY_IMPORT = 0x01, + NM_VPN_EDITOR_PLUGIN_CAPABILITY_EXPORT = 0x02, + NM_VPN_EDITOR_PLUGIN_CAPABILITY_IPV6 = 0x04 +} NMVpnEditorPluginCapability; + +/* Short display name of the VPN plugin */ +#define NM_VPN_EDITOR_PLUGIN_NAME "name" + +/* Longer description of the VPN plugin */ +#define NM_VPN_EDITOR_PLUGIN_DESCRIPTION "description" + +/* D-Bus service name of the plugin's VPN service */ +#define NM_VPN_EDITOR_PLUGIN_SERVICE "service" + +typedef struct _NMVpnEditorPluginVT NMVpnEditorPluginVT; + +/** + * NMVpnEditorPluginInterface: + * @g_iface: the parent interface + * @get_editor: returns an #NMVpnEditor, pre-filled with values from @connection + * if non-%NULL. + * @get_capabilities: returns a bitmask of capabilities. + * @import_from_file: Try to import a connection from the specified path. On + * success, return a partial #NMConnection object. On error, return %NULL and + * set @error with additional information. Note that @error can be %NULL, in + * which case no additional error information should be provided. + * @export_to_file: Export the given connection to the specified path. Return + * %TRUE on success. On error, return %FALSE and set @error with additional + * error information. Note that @error can be %NULL, in which case no + * additional error information should be provided. + * @get_suggested_filename: For a given connection, return a suggested file + * name. Returned value will be %NULL or a suggested file name to be freed by + * the caller. + * @notify_plugin_info_set: A callback to be called when the plugin info is set. + * @get_vt: return a virtual function table to implement further functions in + * the plugin, without requiring to update libnm. Used by nm_vpn_editor_plugin_get_vt(). + * + * Interface for VPN editor plugins. + */ +typedef struct { + GTypeInterface g_iface; + + NMVpnEditor *(*get_editor)(NMVpnEditorPlugin *plugin, NMConnection *connection, GError **error); + + NMVpnEditorPluginCapability (*get_capabilities)(NMVpnEditorPlugin *plugin); + + NMConnection *(*import_from_file)(NMVpnEditorPlugin *plugin, const char *path, GError **error); + + gboolean (*export_to_file)(NMVpnEditorPlugin *plugin, + const char * path, + NMConnection * connection, + GError ** error); + + char *(*get_suggested_filename)(NMVpnEditorPlugin *plugin, NMConnection *connection); + + void (*notify_plugin_info_set)(NMVpnEditorPlugin *plugin, NMVpnPluginInfo *plugin_info); + + const NMVpnEditorPluginVT *(*get_vt)(NMVpnEditorPlugin *plugin, gsize *out_vt_size); +} NMVpnEditorPluginInterface; + +GType nm_vpn_editor_plugin_get_type(void); + +NMVpnEditor *nm_vpn_editor_plugin_get_editor(NMVpnEditorPlugin *plugin, + NMConnection * connection, + GError ** error); + +NMVpnEditorPluginCapability nm_vpn_editor_plugin_get_capabilities(NMVpnEditorPlugin *plugin); + +NM_AVAILABLE_IN_1_4 +gsize +nm_vpn_editor_plugin_get_vt(NMVpnEditorPlugin *plugin, NMVpnEditorPluginVT *vt, gsize vt_size); + +NMConnection * + nm_vpn_editor_plugin_import(NMVpnEditorPlugin *plugin, const char *path, GError **error); +gboolean nm_vpn_editor_plugin_export(NMVpnEditorPlugin *plugin, + const char * path, + NMConnection * connection, + GError ** error); +char * nm_vpn_editor_plugin_get_suggested_filename(NMVpnEditorPlugin *plugin, + NMConnection * connection); + +NM_AVAILABLE_IN_1_2 +NMVpnEditorPlugin *nm_vpn_editor_plugin_load_from_file(const char * plugin_name, + const char * check_service, + int check_owner, + NMUtilsCheckFilePredicate check_file, + gpointer user_data, + GError ** error); + +NM_AVAILABLE_IN_1_4 +NMVpnEditorPlugin * +nm_vpn_editor_plugin_load(const char *plugin_name, const char *check_service, GError **error); + +NM_AVAILABLE_IN_1_4 +NMVpnPluginInfo *nm_vpn_editor_plugin_get_plugin_info(NMVpnEditorPlugin *plugin); +NM_AVAILABLE_IN_1_4 +void nm_vpn_editor_plugin_set_plugin_info(NMVpnEditorPlugin *plugin, NMVpnPluginInfo *plugin_info); + +#include "nm-vpn-plugin-info.h" + +G_END_DECLS + +#endif /* __NM_VPN_EDITOR_PLUGIN_H__ */ diff --git a/src/libnm-core-public/nm-vpn-plugin-info.h b/src/libnm-core-public/nm-vpn-plugin-info.h new file mode 100644 index 0000000000..1e9870c88e --- /dev/null +++ b/src/libnm-core-public/nm-vpn-plugin-info.h @@ -0,0 +1,105 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2015 Red Hat, Inc. + */ + +#ifndef __NM_VPN_PLUGIN_INFO_H__ +#define __NM_VPN_PLUGIN_INFO_H__ + +#include <glib.h> +#include <glib-object.h> + +#include "nm-utils.h" +#include "nm-vpn-editor-plugin.h" + +G_BEGIN_DECLS + +#define NM_TYPE_VPN_PLUGIN_INFO (nm_vpn_plugin_info_get_type()) +#define NM_VPN_PLUGIN_INFO(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_VPN_PLUGIN_INFO, NMVpnPluginInfo)) +#define NM_VPN_PLUGIN_INFO_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_VPN_PLUGIN_INFO, NMVpnPluginInfoClass)) +#define NM_IS_VPN_PLUGIN_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_VPN_PLUGIN_INFO)) +#define NM_IS_VPN_PLUGIN_INFO_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_VPN_PLUGIN_INFO)) +#define NM_VPN_PLUGIN_INFO_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_VPN_PLUGIN_INFO, NMVpnPluginInfoClass)) + +#define NM_VPN_PLUGIN_INFO_NAME "name" +#define NM_VPN_PLUGIN_INFO_FILENAME "filename" +#define NM_VPN_PLUGIN_INFO_KEYFILE "keyfile" + +#define NM_VPN_PLUGIN_INFO_KF_GROUP_CONNECTION "VPN Connection" +#define NM_VPN_PLUGIN_INFO_KF_GROUP_LIBNM "libnm" +#define NM_VPN_PLUGIN_INFO_KF_GROUP_GNOME "GNOME" + +typedef struct _NMVpnPluginInfoClass NMVpnPluginInfoClass; + +NM_AVAILABLE_IN_1_2 +GType nm_vpn_plugin_info_get_type(void); + +NM_AVAILABLE_IN_1_2 +NMVpnPluginInfo *nm_vpn_plugin_info_new_from_file(const char *filename, GError **error); + +NM_AVAILABLE_IN_1_2 +NMVpnPluginInfo * +nm_vpn_plugin_info_new_with_data(const char *filename, GKeyFile *keyfile, GError **error); + +NM_AVAILABLE_IN_1_4 +NMVpnPluginInfo *nm_vpn_plugin_info_new_search_file(const char *name, const char *service); + +NM_AVAILABLE_IN_1_2 +const char *nm_vpn_plugin_info_get_name(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_2 +const char *nm_vpn_plugin_info_get_filename(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_4 +const char *nm_vpn_plugin_info_get_service(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_2 +const char *nm_vpn_plugin_info_get_plugin(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_2 +const char *nm_vpn_plugin_info_get_program(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_4 +const char *nm_vpn_plugin_info_get_auth_dialog(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_4 +gboolean nm_vpn_plugin_info_supports_hints(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_2 +gboolean nm_vpn_plugin_info_supports_multiple(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_4 +const char *const *nm_vpn_plugin_info_get_aliases(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_2 +const char * +nm_vpn_plugin_info_lookup_property(NMVpnPluginInfo *self, const char *group, const char *key); + +NM_AVAILABLE_IN_1_2 +gboolean nm_vpn_plugin_info_validate_filename(const char *filename); + +NM_AVAILABLE_IN_1_2 +GSList *nm_vpn_plugin_info_list_load(void); +NM_AVAILABLE_IN_1_2 +gboolean nm_vpn_plugin_info_list_add(GSList **list, NMVpnPluginInfo *plugin_info, GError **error); +NM_AVAILABLE_IN_1_2 +gboolean nm_vpn_plugin_info_list_remove(GSList **list, NMVpnPluginInfo *plugin_info); +NM_AVAILABLE_IN_1_2 +NMVpnPluginInfo *nm_vpn_plugin_info_list_find_by_name(GSList *list, const char *name); +NM_AVAILABLE_IN_1_2 +NMVpnPluginInfo *nm_vpn_plugin_info_list_find_by_filename(GSList *list, const char *filename); +NM_AVAILABLE_IN_1_2 +NMVpnPluginInfo *nm_vpn_plugin_info_list_find_by_service(GSList *list, const char *service); + +NM_AVAILABLE_IN_1_4 +char *nm_vpn_plugin_info_list_find_service_type(GSList *list, const char *name); +NM_AVAILABLE_IN_1_4 +char **nm_vpn_plugin_info_list_get_service_types(GSList * list, + gboolean only_existing, + gboolean with_abbreviations); + +NM_AVAILABLE_IN_1_2 +NMVpnEditorPlugin *nm_vpn_plugin_info_get_editor_plugin(NMVpnPluginInfo *self); +NM_AVAILABLE_IN_1_2 +void nm_vpn_plugin_info_set_editor_plugin(NMVpnPluginInfo *self, NMVpnEditorPlugin *plugin); +NM_AVAILABLE_IN_1_2 +NMVpnEditorPlugin *nm_vpn_plugin_info_load_editor_plugin(NMVpnPluginInfo *self, GError **error); + +G_END_DECLS + +#endif /* __NM_VPN_PLUGIN_INFO_H__ */ |