source: appstream-generator/build/girepo/gio/DBusAuthObserver.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 7.9 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gio.DBusAuthObserver;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import gio.Credentials;
26private import gio.IOStream;
27private import glib.ConstructionException;
28private import glib.Str;
29private import gobject.ObjectG;
30private import gobject.Signals;
31private import std.algorithm;
32
33
34/**
35 * The #GDBusAuthObserver type provides a mechanism for participating
36 * in how a #GDBusServer (or a #GDBusConnection) authenticates remote
37 * peers. Simply instantiate a #GDBusAuthObserver and connect to the
38 * signals you are interested in. Note that new signals may be added
39 * in the future
40 *
41 * ## Controlling Authentication # {#auth-observer}
42 *
43 * For example, if you only want to allow D-Bus connections from
44 * processes owned by the same uid as the server, you would use a
45 * signal handler like the following:
46 *
47 * |[<!-- language="C" -->
48 * static gboolean
49 * on_authorize_authenticated_peer (GDBusAuthObserver *observer,
50 * GIOStream         *stream,
51 * GCredentials      *credentials,
52 * gpointer           user_data)
53 * {
54 * gboolean authorized;
55 *
56 * authorized = FALSE;
57 * if (credentials != NULL)
58 * {
59 * GCredentials *own_credentials;
60 * own_credentials = g_credentials_new ();
61 * if (g_credentials_is_same_user (credentials, own_credentials, NULL))
62 * authorized = TRUE;
63 * g_object_unref (own_credentials);
64 * }
65 *
66 * return authorized;
67 * }
68 * ]|
69 *
70 * Since: 2.26
71 */
72public class DBusAuthObserver : ObjectG
73{
74        /** the main Gtk struct */
75        protected GDBusAuthObserver* gDBusAuthObserver;
76
77        /** Get the main Gtk struct */
78        public GDBusAuthObserver* getDBusAuthObserverStruct()
79        {
80                return gDBusAuthObserver;
81        }
82
83        /** the main Gtk struct as a void* */
84        protected override void* getStruct()
85        {
86                return cast(void*)gDBusAuthObserver;
87        }
88
89        protected override void setStruct(GObject* obj)
90        {
91                gDBusAuthObserver = cast(GDBusAuthObserver*)obj;
92                super.setStruct(obj);
93        }
94
95        /**
96         * Sets our main struct and passes it to the parent class.
97         */
98        public this (GDBusAuthObserver* gDBusAuthObserver, bool ownedRef = false)
99        {
100                this.gDBusAuthObserver = gDBusAuthObserver;
101                super(cast(GObject*)gDBusAuthObserver, ownedRef);
102        }
103
104
105        /** */
106        public static GType getType()
107        {
108                return g_dbus_auth_observer_get_type();
109        }
110
111        /**
112         * Creates a new #GDBusAuthObserver object.
113         *
114         * Returns: A #GDBusAuthObserver. Free with g_object_unref().
115         *
116         * Since: 2.26
117         *
118         * Throws: ConstructionException GTK+ fails to create the object.
119         */
120        public this()
121        {
122                auto p = g_dbus_auth_observer_new();
123               
124                if(p is null)
125                {
126                        throw new ConstructionException("null returned by new");
127                }
128               
129                this(cast(GDBusAuthObserver*) p, true);
130        }
131
132        /**
133         * Emits the #GDBusAuthObserver::allow-mechanism signal on @observer.
134         *
135         * Params:
136         *     mechanism = The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`.
137         *
138         * Returns: %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not.
139         *
140         * Since: 2.34
141         */
142        public bool allowMechanism(string mechanism)
143        {
144                return g_dbus_auth_observer_allow_mechanism(gDBusAuthObserver, Str.toStringz(mechanism)) != 0;
145        }
146
147        /**
148         * Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on @observer.
149         *
150         * Params:
151         *     stream = A #GIOStream for the #GDBusConnection.
152         *     credentials = Credentials received from the peer or %NULL.
153         *
154         * Returns: %TRUE if the peer is authorized, %FALSE if not.
155         *
156         * Since: 2.26
157         */
158        public bool authorizeAuthenticatedPeer(IOStream stream, Credentials credentials)
159        {
160                return g_dbus_auth_observer_authorize_authenticated_peer(gDBusAuthObserver, (stream is null) ? null : stream.getIOStreamStruct(), (credentials is null) ? null : credentials.getCredentialsStruct()) != 0;
161        }
162
163        protected class OnAllowMechanismDelegateWrapper
164        {
165                static OnAllowMechanismDelegateWrapper[] listeners;
166                bool delegate(string, DBusAuthObserver) dlg;
167                gulong handlerId;
168               
169                this(bool delegate(string, DBusAuthObserver) dlg)
170                {
171                        this.dlg = dlg;
172                        this.listeners ~= this;
173                }
174               
175                void remove(OnAllowMechanismDelegateWrapper source)
176                {
177                        foreach(index, wrapper; listeners)
178                        {
179                                if (wrapper.handlerId == source.handlerId)
180                                {
181                                        listeners[index] = null;
182                                        listeners = std.algorithm.remove(listeners, index);
183                                        break;
184                                }
185                        }
186                }
187        }
188
189        /**
190         * Emitted to check if @mechanism is allowed to be used.
191         *
192         * Params:
193         *     mechanism = The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`.
194         *
195         * Returns: %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not.
196         *
197         * Since: 2.34
198         */
199        gulong addOnAllowMechanism(bool delegate(string, DBusAuthObserver) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
200        {
201                auto wrapper = new OnAllowMechanismDelegateWrapper(dlg);
202                wrapper.handlerId = Signals.connectData(
203                        this,
204                        "allow-mechanism",
205                        cast(GCallback)&callBackAllowMechanism,
206                        cast(void*)wrapper,
207                        cast(GClosureNotify)&callBackAllowMechanismDestroy,
208                        connectFlags);
209                return wrapper.handlerId;
210        }
211       
212        extern(C) static int callBackAllowMechanism(GDBusAuthObserver* dbusauthobserverStruct, char* mechanism, OnAllowMechanismDelegateWrapper wrapper)
213        {
214                return wrapper.dlg(Str.toString(mechanism), wrapper.outer);
215        }
216       
217        extern(C) static void callBackAllowMechanismDestroy(OnAllowMechanismDelegateWrapper wrapper, GClosure* closure)
218        {
219                wrapper.remove(wrapper);
220        }
221
222        protected class OnAuthorizeAuthenticatedPeerDelegateWrapper
223        {
224                static OnAuthorizeAuthenticatedPeerDelegateWrapper[] listeners;
225                bool delegate(IOStream, Credentials, DBusAuthObserver) dlg;
226                gulong handlerId;
227               
228                this(bool delegate(IOStream, Credentials, DBusAuthObserver) dlg)
229                {
230                        this.dlg = dlg;
231                        this.listeners ~= this;
232                }
233               
234                void remove(OnAuthorizeAuthenticatedPeerDelegateWrapper source)
235                {
236                        foreach(index, wrapper; listeners)
237                        {
238                                if (wrapper.handlerId == source.handlerId)
239                                {
240                                        listeners[index] = null;
241                                        listeners = std.algorithm.remove(listeners, index);
242                                        break;
243                                }
244                        }
245                }
246        }
247
248        /**
249         * Emitted to check if a peer that is successfully authenticated
250         * is authorized.
251         *
252         * Params:
253         *     stream = A #GIOStream for the #GDBusConnection.
254         *     credentials = Credentials received from the peer or %NULL.
255         *
256         * Returns: %TRUE if the peer is authorized, %FALSE if not.
257         *
258         * Since: 2.26
259         */
260        gulong addOnAuthorizeAuthenticatedPeer(bool delegate(IOStream, Credentials, DBusAuthObserver) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
261        {
262                auto wrapper = new OnAuthorizeAuthenticatedPeerDelegateWrapper(dlg);
263                wrapper.handlerId = Signals.connectData(
264                        this,
265                        "authorize-authenticated-peer",
266                        cast(GCallback)&callBackAuthorizeAuthenticatedPeer,
267                        cast(void*)wrapper,
268                        cast(GClosureNotify)&callBackAuthorizeAuthenticatedPeerDestroy,
269                        connectFlags);
270                return wrapper.handlerId;
271        }
272       
273        extern(C) static int callBackAuthorizeAuthenticatedPeer(GDBusAuthObserver* dbusauthobserverStruct, GIOStream* stream, GCredentials* credentials, OnAuthorizeAuthenticatedPeerDelegateWrapper wrapper)
274        {
275                return wrapper.dlg(ObjectG.getDObject!(IOStream)(stream), ObjectG.getDObject!(Credentials)(credentials), wrapper.outer);
276        }
277       
278        extern(C) static void callBackAuthorizeAuthenticatedPeerDestroy(OnAuthorizeAuthenticatedPeerDelegateWrapper wrapper, GClosure* closure)
279        {
280                wrapper.remove(wrapper);
281        }
282}
Note: See TracBrowser for help on using the repository browser.