summaryrefslogtreecommitdiffstats
path: root/js/gdm
diff options
context:
space:
mode:
Diffstat (limited to 'js/gdm')
-rw-r--r--js/gdm/authPrompt.js551
-rw-r--r--js/gdm/batch.js208
-rw-r--r--js/gdm/credentialManager.js24
-rw-r--r--js/gdm/fingerprint.js33
-rw-r--r--js/gdm/loginDialog.js1287
-rw-r--r--js/gdm/oVirt.js51
-rw-r--r--js/gdm/realmd.js108
-rw-r--r--js/gdm/util.js625
-rw-r--r--js/gdm/vmware.js54
9 files changed, 2941 insertions, 0 deletions
diff --git a/js/gdm/authPrompt.js b/js/gdm/authPrompt.js
new file mode 100644
index 0000000..43798b3
--- /dev/null
+++ b/js/gdm/authPrompt.js
@@ -0,0 +1,551 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported AuthPrompt */
+
+const { Clutter, GObject, Pango, Shell, St } = imports.gi;
+
+const Animation = imports.ui.animation;
+const Batch = imports.gdm.batch;
+const GdmUtil = imports.gdm.util;
+const OVirt = imports.gdm.oVirt;
+const Vmware = imports.gdm.vmware;
+const Params = imports.misc.params;
+const ShellEntry = imports.ui.shellEntry;
+const UserWidget = imports.ui.userWidget;
+const Util = imports.misc.util;
+
+var DEFAULT_BUTTON_WELL_ICON_SIZE = 16;
+var DEFAULT_BUTTON_WELL_ANIMATION_DELAY = 1000;
+var DEFAULT_BUTTON_WELL_ANIMATION_TIME = 300;
+
+var MESSAGE_FADE_OUT_ANIMATION_TIME = 500;
+
+var AuthPromptMode = {
+ UNLOCK_ONLY: 0,
+ UNLOCK_OR_LOG_IN: 1,
+};
+
+var AuthPromptStatus = {
+ NOT_VERIFYING: 0,
+ VERIFYING: 1,
+ VERIFICATION_FAILED: 2,
+ VERIFICATION_SUCCEEDED: 3,
+ VERIFICATION_CANCELLED: 4,
+};
+
+var BeginRequestType = {
+ PROVIDE_USERNAME: 0,
+ DONT_PROVIDE_USERNAME: 1,
+};
+
+var AuthPrompt = GObject.registerClass({
+ Signals: {
+ 'cancelled': {},
+ 'failed': {},
+ 'next': {},
+ 'prompted': {},
+ 'reset': { param_types: [GObject.TYPE_UINT] },
+ },
+}, class AuthPrompt extends St.BoxLayout {
+ _init(gdmClient, mode) {
+ super._init({
+ style_class: 'login-dialog-prompt-layout',
+ vertical: true,
+ x_expand: true,
+ x_align: Clutter.ActorAlign.CENTER,
+ });
+
+ this.verificationStatus = AuthPromptStatus.NOT_VERIFYING;
+
+ this._gdmClient = gdmClient;
+ this._mode = mode;
+ this._defaultButtonWellActor = null;
+
+ let reauthenticationOnly;
+ if (this._mode == AuthPromptMode.UNLOCK_ONLY)
+ reauthenticationOnly = true;
+ else if (this._mode == AuthPromptMode.UNLOCK_OR_LOG_IN)
+ reauthenticationOnly = false;
+
+ this._userVerifier = new GdmUtil.ShellUserVerifier(this._gdmClient, { reauthenticationOnly });
+
+ this._userVerifier.connect('ask-question', this._onAskQuestion.bind(this));
+ this._userVerifier.connect('show-message', this._onShowMessage.bind(this));
+ this._userVerifier.connect('verification-failed', this._onVerificationFailed.bind(this));
+ this._userVerifier.connect('verification-complete', this._onVerificationComplete.bind(this));
+ this._userVerifier.connect('reset', this._onReset.bind(this));
+ this._userVerifier.connect('smartcard-status-changed', this._onSmartcardStatusChanged.bind(this));
+ this._userVerifier.connect('credential-manager-authenticated', this._onCredentialManagerAuthenticated.bind(this));
+ this.smartcardDetected = this._userVerifier.smartcardDetected;
+
+ this.connect('destroy', this._onDestroy.bind(this));
+
+ this._userWell = new St.Bin({
+ x_expand: true,
+ y_expand: true,
+ });
+ this.add_child(this._userWell);
+
+ this._hasCancelButton = this._mode === AuthPromptMode.UNLOCK_OR_LOG_IN;
+
+ this._initEntryRow();
+
+ let capsLockPlaceholder = new St.Label();
+ this.add_child(capsLockPlaceholder);
+
+ this._capsLockWarningLabel = new ShellEntry.CapsLockWarning({
+ x_expand: true,
+ x_align: Clutter.ActorAlign.CENTER,
+ });
+ this.add_child(this._capsLockWarningLabel);
+
+ this._capsLockWarningLabel.bind_property('visible',
+ capsLockPlaceholder, 'visible',
+ GObject.BindingFlags.SYNC_CREATE | GObject.BindingFlags.INVERT_BOOLEAN);
+
+ this._message = new St.Label({
+ opacity: 0,
+ styleClass: 'login-dialog-message',
+ y_expand: true,
+ x_expand: true,
+ y_align: Clutter.ActorAlign.START,
+ x_align: Clutter.ActorAlign.CENTER,
+ });
+ this._message.clutter_text.line_wrap = true;
+ this._message.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+ this.add_child(this._message);
+ }
+
+ _onDestroy() {
+ this._userVerifier.destroy();
+ this._userVerifier = null;
+ }
+
+ vfunc_key_press_event(keyPressEvent) {
+ if (keyPressEvent.keyval == Clutter.KEY_Escape)
+ this.cancel();
+ return super.vfunc_key_press_event(keyPressEvent);
+ }
+
+ _initEntryRow() {
+ this._mainBox = new St.BoxLayout({
+ style_class: 'login-dialog-button-box',
+ vertical: false,
+ });
+ this.add_child(this._mainBox);
+
+ this.cancelButton = new St.Button({
+ style_class: 'modal-dialog-button button cancel-button',
+ accessible_name: _('Cancel'),
+ button_mask: St.ButtonMask.ONE | St.ButtonMask.THREE,
+ reactive: this._hasCancelButton,
+ can_focus: this._hasCancelButton,
+ x_align: Clutter.ActorAlign.START,
+ y_align: Clutter.ActorAlign.CENTER,
+ child: new St.Icon({ icon_name: 'go-previous-symbolic' }),
+ });
+ if (this._hasCancelButton)
+ this.cancelButton.connect('clicked', () => this.cancel());
+ else
+ this.cancelButton.opacity = 0;
+ this._mainBox.add_child(this.cancelButton);
+
+ let entryParams = {
+ style_class: 'login-dialog-prompt-entry',
+ can_focus: true,
+ x_expand: true,
+ };
+
+ this._entry = null;
+
+ this._textEntry = new St.Entry(entryParams);
+ ShellEntry.addContextMenu(this._textEntry, { actionMode: Shell.ActionMode.NONE });
+
+ this._passwordEntry = new St.PasswordEntry(entryParams);
+ ShellEntry.addContextMenu(this._passwordEntry, { actionMode: Shell.ActionMode.NONE });
+
+ this._entry = this._passwordEntry;
+ this._mainBox.add_child(this._entry);
+ this._entry.grab_key_focus();
+
+ [this._textEntry, this._passwordEntry].forEach(entry => {
+ entry.clutter_text.connect('text-changed', () => {
+ if (!this._userVerifier.hasPendingMessages)
+ this._fadeOutMessage();
+ });
+
+ entry.clutter_text.connect('activate', () => {
+ let shouldSpin = entry === this._passwordEntry;
+ if (entry.reactive)
+ this._activateNext(shouldSpin);
+ });
+ });
+
+ this._defaultButtonWell = new St.Widget({
+ layout_manager: new Clutter.BinLayout(),
+ x_align: Clutter.ActorAlign.END,
+ y_align: Clutter.ActorAlign.CENTER,
+ });
+ this._defaultButtonWell.add_constraint(new Clutter.BindConstraint({
+ source: this.cancelButton,
+ coordinate: Clutter.BindCoordinate.WIDTH,
+ }));
+ this._mainBox.add_child(this._defaultButtonWell);
+
+ this._spinner = new Animation.Spinner(DEFAULT_BUTTON_WELL_ICON_SIZE);
+ this._defaultButtonWell.add_child(this._spinner);
+ }
+
+ _activateNext(shouldSpin) {
+ this.updateSensitivity(false);
+
+ if (shouldSpin)
+ this.startSpinning();
+
+ if (this._queryingService)
+ this._userVerifier.answerQuery(this._queryingService, this._entry.text);
+ else
+ this._preemptiveAnswer = this._entry.text;
+
+ this.emit('next');
+ }
+
+ _updateEntry(secret) {
+ if (secret && this._entry !== this._passwordEntry) {
+ this._mainBox.replace_child(this._entry, this._passwordEntry);
+ this._entry = this._passwordEntry;
+ } else if (!secret && this._entry !== this._textEntry) {
+ this._mainBox.replace_child(this._entry, this._textEntry);
+ this._entry = this._textEntry;
+ }
+ this._capsLockWarningLabel.visible = secret;
+ }
+
+ _onAskQuestion(verifier, serviceName, question, secret) {
+ if (this._queryingService)
+ this.clear();
+
+ this._queryingService = serviceName;
+ if (this._preemptiveAnswer) {
+ this._userVerifier.answerQuery(this._queryingService, this._preemptiveAnswer);
+ this._preemptiveAnswer = null;
+ return;
+ }
+
+ this._updateEntry(secret);
+
+ // Hack: The question string comes directly from PAM, if it's "Password:"
+ // we replace it with our own to allow localization, if it's something
+ // else we remove the last colon and any trailing or leading spaces.
+ if (question === 'Password:' || question === 'Password: ')
+ this.setQuestion(_('Password'));
+ else
+ this.setQuestion(question.replace(/: *$/, '').trim());
+
+ this.updateSensitivity(true);
+ this.emit('prompted');
+ }
+
+ _onCredentialManagerAuthenticated() {
+ if (this.verificationStatus != AuthPromptStatus.VERIFICATION_SUCCEEDED)
+ this.reset();
+ }
+
+ _onSmartcardStatusChanged() {
+ this.smartcardDetected = this._userVerifier.smartcardDetected;
+
+ // Most of the time we want to reset if the user inserts or removes
+ // a smartcard. Smartcard insertion "preempts" what the user was
+ // doing, and smartcard removal aborts the preemption.
+ // The exceptions are: 1) Don't reset on smartcard insertion if we're already verifying
+ // with a smartcard
+ // 2) Don't reset if we've already succeeded at verification and
+ // the user is getting logged in.
+ if (this._userVerifier.serviceIsDefault(GdmUtil.SMARTCARD_SERVICE_NAME) &&
+ this.verificationStatus == AuthPromptStatus.VERIFYING &&
+ this.smartcardDetected)
+ return;
+
+ if (this.verificationStatus != AuthPromptStatus.VERIFICATION_SUCCEEDED)
+ this.reset();
+ }
+
+ _onShowMessage(userVerifier, message, type) {
+ this.setMessage(message, type);
+ this.emit('prompted');
+ }
+
+ _onVerificationFailed(userVerifier, canRetry) {
+ this._queryingService = null;
+ this.clear();
+
+ this.updateSensitivity(canRetry);
+ this.setActorInDefaultButtonWell(null);
+ this.verificationStatus = AuthPromptStatus.VERIFICATION_FAILED;
+
+ Util.wiggle(this._entry);
+ }
+
+ _onVerificationComplete() {
+ this.setActorInDefaultButtonWell(null);
+ this.verificationStatus = AuthPromptStatus.VERIFICATION_SUCCEEDED;
+ this.cancelButton.reactive = false;
+ this.cancelButton.can_focus = false;
+ }
+
+ _onReset() {
+ this.verificationStatus = AuthPromptStatus.NOT_VERIFYING;
+ this.reset();
+ }
+
+ setActorInDefaultButtonWell(actor, animate) {
+ if (!this._defaultButtonWellActor &&
+ !actor)
+ return;
+
+ let oldActor = this._defaultButtonWellActor;
+
+ if (oldActor)
+ oldActor.remove_all_transitions();
+
+ let wasSpinner;
+ if (oldActor == this._spinner)
+ wasSpinner = true;
+ else
+ wasSpinner = false;
+
+ let isSpinner;
+ if (actor == this._spinner)
+ isSpinner = true;
+ else
+ isSpinner = false;
+
+ if (this._defaultButtonWellActor != actor && oldActor) {
+ if (!animate) {
+ oldActor.opacity = 0;
+
+ if (wasSpinner) {
+ if (this._spinner)
+ this._spinner.stop();
+ }
+ } else {
+ oldActor.ease({
+ opacity: 0,
+ duration: DEFAULT_BUTTON_WELL_ANIMATION_TIME,
+ delay: DEFAULT_BUTTON_WELL_ANIMATION_DELAY,
+ mode: Clutter.AnimationMode.LINEAR,
+ onComplete: () => {
+ if (wasSpinner) {
+ if (this._spinner)
+ this._spinner.stop();
+ }
+ },
+ });
+ }
+ }
+
+ if (actor) {
+ if (isSpinner)
+ this._spinner.play();
+
+ if (!animate) {
+ actor.opacity = 255;
+ } else {
+ actor.ease({
+ opacity: 255,
+ duration: DEFAULT_BUTTON_WELL_ANIMATION_TIME,
+ delay: DEFAULT_BUTTON_WELL_ANIMATION_DELAY,
+ mode: Clutter.AnimationMode.LINEAR,
+ });
+ }
+ }
+
+ this._defaultButtonWellActor = actor;
+ }
+
+ startSpinning() {
+ this.setActorInDefaultButtonWell(this._spinner, true);
+ }
+
+ stopSpinning() {
+ this.setActorInDefaultButtonWell(null, false);
+ }
+
+ clear() {
+ this._entry.text = '';
+ this.stopSpinning();
+ }
+
+ setQuestion(question) {
+ this._entry.hint_text = question;
+
+ this._entry.show();
+ this._entry.grab_key_focus();
+ }
+
+ getAnswer() {
+ let text;
+
+ if (this._preemptiveAnswer) {
+ text = this._preemptiveAnswer;
+ this._preemptiveAnswer = null;
+ } else {
+ text = this._entry.get_text();
+ }
+
+ return text;
+ }
+
+ _fadeOutMessage() {
+ if (this._message.opacity == 0)
+ return;
+ this._message.remove_all_transitions();
+ this._message.ease({
+ opacity: 0,
+ duration: MESSAGE_FADE_OUT_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ });
+ }
+
+ setMessage(message, type) {
+ if (type == GdmUtil.MessageType.ERROR)
+ this._message.add_style_class_name('login-dialog-message-warning');
+ else
+ this._message.remove_style_class_name('login-dialog-message-warning');
+
+ if (type == GdmUtil.MessageType.HINT)
+ this._message.add_style_class_name('login-dialog-message-hint');
+ else
+ this._message.remove_style_class_name('login-dialog-message-hint');
+
+ if (message) {
+ this._message.remove_all_transitions();
+ this._message.text = message;
+ this._message.opacity = 255;
+ } else {
+ this._message.opacity = 0;
+ }
+ }
+
+ updateSensitivity(sensitive) {
+ if (this._entry.reactive === sensitive)
+ return;
+
+ this._entry.reactive = sensitive;
+
+ if (sensitive)
+ this._entry.grab_key_focus();
+ else if (this._entry === this._passwordEntry)
+ this._entry.password_visible = false;
+ }
+
+ vfunc_hide() {
+ this.setActorInDefaultButtonWell(null, true);
+ super.vfunc_hide();
+ this._message.opacity = 0;
+
+ this.setUser(null);
+
+ this.updateSensitivity(true);
+ this._entry.set_text('');
+ }
+
+ setUser(user) {
+ let oldChild = this._userWell.get_child();
+ if (oldChild)
+ oldChild.destroy();
+
+ let userWidget = new UserWidget.UserWidget(user, Clutter.Orientation.VERTICAL);
+ this._userWell.set_child(userWidget);
+
+ if (!user)
+ this._updateEntry(false);
+ }
+
+ reset() {
+ let oldStatus = this.verificationStatus;
+ this.verificationStatus = AuthPromptStatus.NOT_VERIFYING;
+ this.cancelButton.reactive = this._hasCancelButton;
+ this.cancelButton.can_focus = this._hasCancelButton;
+ this._preemptiveAnswer = null;
+
+ if (this._userVerifier)
+ this._userVerifier.cancel();
+
+ this._queryingService = null;
+ this.clear();
+ this._message.opacity = 0;
+ this.setUser(null);
+ this._updateEntry(true);
+ this.stopSpinning();
+
+ if (oldStatus == AuthPromptStatus.VERIFICATION_FAILED)
+ this.emit('failed');
+ else if (oldStatus === AuthPromptStatus.VERIFICATION_CANCELLED)
+ this.emit('cancelled');
+
+ let beginRequestType;
+
+ if (this._mode == AuthPromptMode.UNLOCK_ONLY) {
+ // The user is constant at the unlock screen, so it will immediately
+ // respond to the request with the username
+ if (oldStatus === AuthPromptStatus.VERIFICATION_CANCELLED)
+ return;
+ beginRequestType = BeginRequestType.PROVIDE_USERNAME;
+ } else if (this._userVerifier.serviceIsForeground(OVirt.SERVICE_NAME) ||
+ this._userVerifier.serviceIsForeground(Vmware.SERVICE_NAME) ||
+ this._userVerifier.serviceIsForeground(GdmUtil.SMARTCARD_SERVICE_NAME)) {
+ // We don't need to know the username if the user preempted the login screen
+ // with a smartcard or with preauthenticated oVirt credentials
+ beginRequestType = BeginRequestType.DONT_PROVIDE_USERNAME;
+ } else {
+ // In all other cases, we should get the username up front.
+ beginRequestType = BeginRequestType.PROVIDE_USERNAME;
+ }
+
+ this.emit('reset', beginRequestType);
+ }
+
+ addCharacter(unichar) {
+ if (!this._entry.visible)
+ return;
+
+ this._entry.grab_key_focus();
+ this._entry.clutter_text.insert_unichar(unichar);
+ }
+
+ begin(params) {
+ params = Params.parse(params, { userName: null,
+ hold: null });
+
+ this.updateSensitivity(false);
+
+ let hold = params.hold;
+ if (!hold)
+ hold = new Batch.Hold();
+
+ this._userVerifier.begin(params.userName, hold);
+ this.verificationStatus = AuthPromptStatus.VERIFYING;
+ }
+
+ finish(onComplete) {
+ if (!this._userVerifier.hasPendingMessages) {
+ this._userVerifier.clear();
+ onComplete();
+ return;
+ }
+
+ let signalId = this._userVerifier.connect('no-more-messages', () => {
+ this._userVerifier.disconnect(signalId);
+ this._userVerifier.clear();
+ onComplete();
+ });
+ }
+
+ cancel() {
+ if (this.verificationStatus == AuthPromptStatus.VERIFICATION_SUCCEEDED)
+ return;
+
+ this.verificationStatus = AuthPromptStatus.VERIFICATION_CANCELLED;
+ this.reset();
+ }
+});
diff --git a/js/gdm/batch.js b/js/gdm/batch.js
new file mode 100644
index 0000000..ca29fc7
--- /dev/null
+++ b/js/gdm/batch.js
@@ -0,0 +1,208 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/*
+ * Copyright 2011 Red Hat, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * In order for transformation animations to look good, they need to be
+ * incremental and have some order to them (e.g., fade out hidden items,
+ * then shrink to close the void left over). Chaining animations in this way can
+ * be error-prone and wordy using just ease() callbacks.
+ *
+ * The classes in this file help with this:
+ *
+ * - Task. encapsulates schedulable work to be run in a specific scope.
+ *
+ * - ConsecutiveBatch. runs a series of tasks in order and completes
+ * when the last in the series finishes.
+ *
+ * - ConcurrentBatch. runs a set of tasks at the same time and completes
+ * when the last to finish completes.
+ *
+ * - Hold. prevents a batch from completing the pending task until
+ * the hold is released.
+ *
+ * The tasks associated with a batch are specified in a list at batch
+ * construction time as either task objects or plain functions.
+ * Batches are task objects, themselves, so they can be nested.
+ *
+ * These classes aren't specific to GDM, but were found to be unintuitive and so
+ * are not used elsewhere. These APIs may ultimately get dropped entirely and
+ * replaced by something else.
+ */
+
+const { GObject } = imports.gi;
+const Signals = imports.signals;
+
+var Task = class {
+ constructor(scope, handler) {
+ if (scope)
+ this.scope = scope;
+ else
+ this.scope = this;
+
+ this.handler = handler;
+ }
+
+ run() {
+ if (this.handler)
+ return this.handler.call(this.scope);
+
+ return null;
+ }
+};
+Signals.addSignalMethods(Task.prototype);
+
+var Hold = class extends Task {
+ constructor() {
+ super(null, () => this);
+
+ this._acquisitions = 1;
+ }
+
+ acquire() {
+ if (this._acquisitions <= 0)
+ throw new Error("Cannot acquire hold after it's been released");
+ this._acquisitions++;
+ }
+
+ acquireUntilAfter(hold) {
+ if (!hold.isAcquired())
+ return;
+
+ this.acquire();
+ let signalId = hold.connect('release', () => {
+ hold.disconnect(signalId);
+ this.release();
+ });
+ }
+
+ release() {
+ this._acquisitions--;
+
+ if (this._acquisitions == 0)
+ this.emit('release');
+ }
+
+ isAcquired() {
+ return this._acquisitions > 0;
+ }
+};
+Signals.addSignalMethods(Hold.prototype);
+
+var Batch = class extends Task {
+ constructor(scope, tasks) {
+ super();
+
+ this.tasks = [];
+
+ for (let i = 0; i < tasks.length; i++) {
+ let task;
+
+ if (tasks[i] instanceof Task)
+ task = tasks[i];
+ else if (typeof tasks[i] == 'function')
+ task = new Task(scope, tasks[i]);
+ else
+ throw new Error('Batch tasks must be functions or Task, Hold or Batch objects');
+
+ this.tasks.push(task);
+ }
+ }
+
+ process() {
+ throw new GObject.NotImplementedError(`process in ${this.constructor.name}`);
+ }
+
+ runTask() {
+ if (!(this._currentTaskIndex in this.tasks))
+ return null;
+
+ return this.tasks[this._currentTaskIndex].run();
+ }
+
+ _finish() {
+ this.hold.release();
+ }
+
+ nextTask() {
+ this._currentTaskIndex++;
+
+ // if the entire batch of tasks is finished, release
+ // the hold and notify anyone waiting on the batch
+ if (this._currentTaskIndex >= this.tasks.length) {
+ this._finish();
+ return;
+ }
+
+ this.process();
+ }
+
+ _start() {
+ // acquire a hold to get released when the entire
+ // batch of tasks is finished
+ this.hold = new Hold();
+ this._currentTaskIndex = 0;
+ this.process();
+ }
+
+ run() {
+ this._start();
+
+ // hold may be destroyed at this point
+ // if we're already done running
+ return this.hold;
+ }
+
+ cancel() {
+ this.tasks = this.tasks.splice(0, this._currentTaskIndex + 1);
+ }
+};
+Signals.addSignalMethods(Batch.prototype);
+
+var ConcurrentBatch = class extends Batch {
+ process() {
+ let hold = this.runTask();
+
+ if (hold)
+ this.hold.acquireUntilAfter(hold);
+
+ // Regardless of the state of the just run task,
+ // fire off the next one, so all the tasks can run
+ // concurrently.
+ this.nextTask();
+ }
+};
+Signals.addSignalMethods(ConcurrentBatch.prototype);
+
+var ConsecutiveBatch = class extends Batch {
+ process() {
+ let hold = this.runTask();
+
+ if (hold && hold.isAcquired()) {
+ // This task is inhibiting the batch. Wait on it
+ // before processing the next one.
+ let signalId = hold.connect('release', () => {
+ hold.disconnect(signalId);
+ this.nextTask();
+ });
+ } else {
+ // This task finished, process the next one
+ this.nextTask();
+ }
+ }
+};
+Signals.addSignalMethods(ConsecutiveBatch.prototype);
diff --git a/js/gdm/credentialManager.js b/js/gdm/credentialManager.js
new file mode 100644
index 0000000..5c4bc7e
--- /dev/null
+++ b/js/gdm/credentialManager.js
@@ -0,0 +1,24 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported CredentialManager */
+
+var CredentialManager = class CredentialManager {
+ constructor(service) {
+ this._token = null;
+ this._service = service;
+ this._authenticatedSignalId = null;
+ }
+
+ get token() {
+ return this._token;
+ }
+
+ set token(t) {
+ this._token = t;
+ if (this._token)
+ this.emit('user-authenticated', this._token);
+ }
+
+ get service() {
+ return this._service;
+ }
+};
diff --git a/js/gdm/fingerprint.js b/js/gdm/fingerprint.js
new file mode 100644
index 0000000..e23a77b
--- /dev/null
+++ b/js/gdm/fingerprint.js
@@ -0,0 +1,33 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported FprintManager */
+
+const Gio = imports.gi.Gio;
+
+const FprintManagerIface = `
+<node>
+<interface name="net.reactivated.Fprint.Manager">
+<method name="GetDefaultDevice">
+ <arg type="o" direction="out" />
+</method>
+</interface>
+</node>`;
+
+const FprintManagerInfo = Gio.DBusInterfaceInfo.new_for_xml(FprintManagerIface);
+
+function FprintManager() {
+ var self = new Gio.DBusProxy({ g_connection: Gio.DBus.system,
+ g_interface_name: FprintManagerInfo.name,
+ g_interface_info: FprintManagerInfo,
+ g_name: 'net.reactivated.Fprint',
+ g_object_path: '/net/reactivated/Fprint/Manager',
+ g_flags: Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES });
+
+ try {
+ self.init(null);
+ } catch (e) {
+ log(`Failed to connect to Fprint service: ${e.message}`);
+ return null;
+ }
+
+ return self;
+}
diff --git a/js/gdm/loginDialog.js b/js/gdm/loginDialog.js
new file mode 100644
index 0000000..ad84c3e
--- /dev/null
+++ b/js/gdm/loginDialog.js
@@ -0,0 +1,1287 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported LoginDialog */
+/*
+ * Copyright 2011 Red Hat, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+const { AccountsService, Atk, Clutter, Gdm, Gio,
+ GLib, GObject, Meta, Pango, Shell, St } = imports.gi;
+
+const AuthPrompt = imports.gdm.authPrompt;
+const Batch = imports.gdm.batch;
+const BoxPointer = imports.ui.boxpointer;
+const CtrlAltTab = imports.ui.ctrlAltTab;
+const GdmUtil = imports.gdm.util;
+const Layout = imports.ui.layout;
+const LoginManager = imports.misc.loginManager;
+const Main = imports.ui.main;
+const PopupMenu = imports.ui.popupMenu;
+const Realmd = imports.gdm.realmd;
+const UserWidget = imports.ui.userWidget;
+
+const _FADE_ANIMATION_TIME = 250;
+const _SCROLL_ANIMATION_TIME = 500;
+const _TIMED_LOGIN_IDLE_THRESHOLD = 5.0;
+
+var UserListItem = GObject.registerClass({
+ Signals: { 'activate': {} },
+}, class UserListItem extends St.Button {
+ _init(user) {
+ let layout = new St.BoxLayout({
+ vertical: true,
+ });
+ super._init({
+ style_class: 'login-dialog-user-list-item',
+ button_mask: St.ButtonMask.ONE | St.ButtonMask.THREE,
+ can_focus: true,
+ x_expand: true,
+ child: layout,
+ reactive: true,
+ });
+
+ this.user = user;
+ this._userChangedId = this.user.connect('changed',
+ this._onUserChanged.bind(this));
+
+ this.connect('destroy', this._onDestroy.bind(this));
+ this.connect('notify::hover', () => {
+ this._setSelected(this.hover);
+ });
+
+ this._userWidget = new UserWidget.UserWidget(this.user);
+ layout.add(this._userWidget);
+
+ this._userWidget.bind_property('label-actor', this, 'label-actor',
+ GObject.BindingFlags.SYNC_CREATE);
+
+ this._timedLoginIndicator = new St.Bin({ style_class: 'login-dialog-timed-login-indicator',
+ scale_x: 0,
+ visible: false });
+ layout.add(this._timedLoginIndicator);
+
+ this._onUserChanged();
+ }
+
+ vfunc_key_focus_in() {
+ super.vfunc_key_focus_in();
+ this._setSelected(true);
+ }
+
+ vfunc_key_focus_out() {
+ super.vfunc_key_focus_out();
+ this._setSelected(false);
+ }
+
+ _onUserChanged() {
+ this._updateLoggedIn();
+ }
+
+ _updateLoggedIn() {
+ if (this.user.is_logged_in())
+ this.add_style_pseudo_class('logged-in');
+ else
+ this.remove_style_pseudo_class('logged-in');
+ }
+
+ _onDestroy() {
+ this.user.disconnect(this._userChangedId);
+ }
+
+ vfunc_clicked() {
+ this.emit('activate');
+ }
+
+ _setSelected(selected) {
+ if (selected) {
+ this.add_style_pseudo_class('selected');
+ this.grab_key_focus();
+ } else {
+ this.remove_style_pseudo_class('selected');
+ }
+ }
+
+ showTimedLoginIndicator(time) {
+ let hold = new Batch.Hold();
+
+ this.hideTimedLoginIndicator();
+
+ this._timedLoginIndicator.visible = true;
+
+ let startTime = GLib.get_monotonic_time();
+
+ this._timedLoginTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 33,
+ () => {
+ let currentTime = GLib.get_monotonic_time();
+ let elapsedTime = (currentTime - startTime) / GLib.USEC_PER_SEC;
+ this._timedLoginIndicator.scale_x = elapsedTime / time;
+ if (elapsedTime >= time) {
+ this._timedLoginTimeoutId = 0;
+ hold.release();
+ return GLib.SOURCE_REMOVE;
+ }
+
+ return GLib.SOURCE_CONTINUE;
+ });
+
+ GLib.Source.set_name_by_id(this._timedLoginTimeoutId, '[gnome-shell] this._timedLoginTimeoutId');
+
+ return hold;
+ }
+
+ hideTimedLoginIndicator() {
+ if (this._timedLoginTimeoutId) {
+ GLib.source_remove(this._timedLoginTimeoutId);
+ this._timedLoginTimeoutId = 0;
+ }
+
+ this._timedLoginIndicator.visible = false;
+ this._timedLoginIndicator.scale_x = 0.;
+ }
+});
+
+var UserList = GObject.registerClass({
+ Signals: {
+ 'activate': { param_types: [UserListItem.$gtype] },
+ 'item-added': { param_types: [UserListItem.$gtype] },
+ },
+}, class UserList extends St.ScrollView {
+ _init() {
+ super._init({
+ style_class: 'login-dialog-user-list-view',
+ x_expand: true,
+ y_expand: true,
+ });
+ this.set_policy(St.PolicyType.NEVER,
+ St.PolicyType.AUTOMATIC);
+
+ this._box = new St.BoxLayout({ vertical: true,
+ style_class: 'login-dialog-user-list',
+ pseudo_class: 'expanded' });
+
+ this.add_actor(this._box);
+ this._items = {};
+ }
+
+ vfunc_key_focus_in() {
+ super.vfunc_key_focus_in();
+ this._moveFocusToItems();
+ }
+
+ _moveFocusToItems() {
+ let hasItems = Object.keys(this._items).length > 0;
+
+ if (!hasItems)
+ return;
+
+ if (global.stage.get_key_focus() != this)
+ return;
+
+ let focusSet = this.navigate_focus(null, St.DirectionType.TAB_FORWARD, false);
+ if (!focusSet) {
+ Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
+ this._moveFocusToItems();
+ return false;
+ });
+ }
+ }
+
+ _onItemActivated(activatedItem) {
+ this.emit('activate', activatedItem);
+ }
+
+ updateStyle(isExpanded) {
+ if (isExpanded)
+ this._box.add_style_pseudo_class('expanded');
+ else
+ this._box.remove_style_pseudo_class('expanded');
+
+ for (let userName in this._items) {
+ let item = this._items[userName];
+ item.sync_hover();
+ }
+ }
+
+ scrollToItem(item) {
+ let box = item.get_allocation_box();
+
+ let adjustment = this.get_vscroll_bar().get_adjustment();
+
+ let value = (box.y1 + adjustment.step_increment / 2.0) - (adjustment.page_size / 2.0);
+ adjustment.ease(value, {
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ duration: _SCROLL_ANIMATION_TIME,
+ });
+ }
+
+ jumpToItem(item) {
+ let box = item.get_allocation_box();
+
+ let adjustment = this.get_vscroll_bar().get_adjustment();
+
+ let value = (box.y1 + adjustment.step_increment / 2.0) - (adjustment.page_size / 2.0);
+
+ adjustment.set_value(value);
+ }
+
+ getItemFromUserName(userName) {
+ let item = this._items[userName];
+
+ if (!item)
+ return null;
+
+ return item;
+ }
+
+ containsUser(user) {
+ return this._items[user.get_user_name()] != null;
+ }
+
+ addUser(user) {
+ if (!user.is_loaded)
+ return;
+
+ if (user.is_system_account())
+ return;
+
+ if (user.locked)
+ return;
+
+ let userName = user.get_user_name();
+
+ if (!userName)
+ return;
+
+ this.removeUser(user);
+
+ let item = new UserListItem(user);
+ this._box.add_child(item);
+
+ this._items[userName] = item;
+
+ item.connect('activate', this._onItemActivated.bind(this));
+
+ // Try to keep the focused item front-and-center
+ item.connect('key-focus-in', () => this.scrollToItem(item));
+
+ this._moveFocusToItems();
+
+ this.emit('item-added', item);
+ }
+
+ removeUser(user) {
+ if (!user.is_loaded)
+ return;
+
+ let userName = user.get_user_name();
+
+ if (!userName)
+ return;
+
+ let item = this._items[userName];
+
+ if (!item)
+ return;
+
+ item.destroy();
+ delete this._items[userName];
+ }
+
+ numItems() {
+ return Object.keys(this._items).length;
+ }
+});
+
+var SessionMenuButton = GObject.registerClass({
+ Signals: { 'session-activated': { param_types: [GObject.TYPE_STRING] } },
+}, class SessionMenuButton extends St.Bin {
+ _init() {
+ let gearIcon = new St.Icon({ icon_name: 'emblem-system-symbolic' });
+ let button = new St.Button({
+ style_class: 'modal-dialog-button button login-dialog-session-list-button',
+ reactive: true,
+ track_hover: true,
+ can_focus: true,
+ accessible_name: _("Choose Session"),
+ accessible_role: Atk.Role.MENU,
+ x_align: Clutter.ActorAlign.CENTER,
+ y_align: Clutter.ActorAlign.CENTER,
+ child: gearIcon,
+ });
+
+ super._init({ child: button });
+ this._button = button;
+
+ this._menu = new PopupMenu.PopupMenu(this._button, 0, St.Side.BOTTOM);
+ Main.uiGroup.add_actor(this._menu.actor);
+ this._menu.actor.hide();
+
+ this._menu.connect('open-state-changed', (menu, isOpen) => {
+ if (isOpen)
+ this._button.add_style_pseudo_class('active');
+ else
+ this._button.remove_style_pseudo_class('active');
+ });
+
+ this._manager = new PopupMenu.PopupMenuManager(this._button,
+ { actionMode: Shell.ActionMode.NONE });
+ this._manager.addMenu(this._menu);
+
+ this._button.connect('clicked', () => this._menu.toggle());
+
+ this._items = {};
+ this._activeSessionId = null;
+ this._populate();
+ }
+
+ updateSensitivity(sensitive) {
+ this._button.reactive = sensitive;
+ this._button.can_focus = sensitive;
+ this.opacity = sensitive ? 255 : 0;
+ this._menu.close(BoxPointer.PopupAnimation.NONE);
+ }
+
+ _updateOrnament() {
+ let itemIds = Object.keys(this._items);
+ for (let i = 0; i < itemIds.length; i++) {
+ if (itemIds[i] == this._activeSessionId)
+ this._items[itemIds[i]].setOrnament(PopupMenu.Ornament.DOT);
+ else
+ this._items[itemIds[i]].setOrnament(PopupMenu.Ornament.NONE);
+ }
+ }
+
+ setActiveSession(sessionId) {
+ if (sessionId == this._activeSessionId)
+ return;
+
+ this._activeSessionId = sessionId;
+ this._updateOrnament();
+ }
+
+ close() {
+ this._menu.close();
+ }
+
+ _populate() {
+ let ids = Gdm.get_session_ids();
+ ids.sort();
+
+ if (ids.length <= 1) {
+ this._button.hide();
+ return;
+ }
+
+ for (let i = 0; i < ids.length; i++) {
+ let [sessionName, sessionDescription_] = Gdm.get_session_name_and_description(ids[i]);
+
+ let id = ids[i];
+ let item = new PopupMenu.PopupMenuItem(sessionName);
+ this._menu.addMenuItem(item);
+ this._items[id] = item;
+
+ item.connect('activate', () => {
+ this.setActiveSession(id);
+ this.emit('session-activated', this._activeSessionId);
+ });
+ }
+ }
+});
+
+var LoginDialog = GObject.registerClass({
+ Signals: {
+ 'failed': {},
+ 'wake-up-screen': {},
+ },
+}, class LoginDialog extends St.Widget {
+ _init(parentActor) {
+ super._init({ style_class: 'login-dialog', visible: false });
+
+ this.get_accessible().set_role(Atk.Role.WINDOW);
+
+ this.add_constraint(new Layout.MonitorConstraint({ primary: true }));
+ this.connect('destroy', this._onDestroy.bind(this));
+ parentActor.add_child(this);
+
+ this._userManager = AccountsService.UserManager.get_default();
+ this._gdmClient = new Gdm.Client();
+
+ this._settings = new Gio.Settings({ schema_id: GdmUtil.LOGIN_SCREEN_SCHEMA });
+
+ this._settings.connect('changed::%s'.format(GdmUtil.BANNER_MESSAGE_KEY),
+ this._updateBanner.bind(this));
+ this._settings.connect('changed::%s'.format(GdmUtil.BANNER_MESSAGE_TEXT_KEY),
+ this._updateBanner.bind(this));
+ this._settings.connect('changed::%s'.format(GdmUtil.DISABLE_USER_LIST_KEY),
+ this._updateDisableUserList.bind(this));
+ this._settings.connect('changed::%s'.format(GdmUtil.LOGO_KEY),
+ this._updateLogo.bind(this));
+
+ this._textureCache = St.TextureCache.get_default();
+ this._updateLogoTextureId = this._textureCache.connect('texture-file-changed',
+ this._updateLogoTexture.bind(this));
+
+ this._userSelectionBox = new St.BoxLayout({ style_class: 'login-dialog-user-selection-box',
+ x_align: Clutter.ActorAlign.CENTER,
+ y_align: Clutter.ActorAlign.CENTER,
+ vertical: true,
+ visible: false });
+ this.add_child(this._userSelectionBox);
+
+ this._userList = new UserList();
+ this._userSelectionBox.add_child(this._userList);
+
+ this._authPrompt = new AuthPrompt.AuthPrompt(this._gdmClient, AuthPrompt.AuthPromptMode.UNLOCK_OR_LOG_IN);
+ this._authPrompt.connect('prompted', this._onPrompted.bind(this));
+ this._authPrompt.connect('reset', this._onReset.bind(this));
+ this._authPrompt.hide();
+ this.add_child(this._authPrompt);
+
+ // translators: this message is shown below the user list on the
+ // login screen. It can be activated to reveal an entry for
+ // manually entering the username.
+ let notListedLabel = new St.Label({
+ text: _("Not listed?"),
+ style_class: 'login-dialog-not-listed-label',
+ });
+ this._notListedButton = new St.Button({
+ style_class: 'login-dialog-not-listed-button',
+ button_mask: St.ButtonMask.ONE | St.ButtonMask.THREE,
+ can_focus: true,
+ child: notListedLabel,
+ reactive: true,
+ x_align: Clutter.ActorAlign.START,
+ label_actor: notListedLabel,
+ });
+
+ this._notListedButton.connect('clicked', this._hideUserListAskForUsernameAndBeginVerification.bind(this));
+
+ this._notListedButton.hide();
+
+ this._userSelectionBox.add_child(this._notListedButton);
+
+ this._bannerView = new St.ScrollView({ style_class: 'login-dialog-banner-view',
+ opacity: 0,
+ vscrollbar_policy: St.PolicyType.AUTOMATIC,
+ hscrollbar_policy: St.PolicyType.NEVER });
+ this.add_child(this._bannerView);
+
+ let bannerBox = new St.BoxLayout({ vertical: true });
+
+ this._bannerView.add_actor(bannerBox);
+ this._bannerLabel = new St.Label({ style_class: 'login-dialog-banner',
+ text: '' });
+ this._bannerLabel.clutter_text.line_wrap = true;
+ this._bannerLabel.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+ bannerBox.add_child(this._bannerLabel);
+ this._updateBanner();
+
+ this._sessionMenuButton = new SessionMenuButton();
+ this._sessionMenuButton.connect('session-activated',
+ (list, sessionId) => {
+ this._greeter.call_select_session_sync(sessionId, null);
+ });
+ this._sessionMenuButton.opacity = 0;
+ this._sessionMenuButton.show();
+ this.add_child(this._sessionMenuButton);
+
+ this._logoBin = new St.Widget({ style_class: 'login-dialog-logo-bin',
+ x_align: Clutter.ActorAlign.CENTER,
+ y_align: Clutter.ActorAlign.END });
+ this._logoBin.connect('resource-scale-changed', () => {
+ this._updateLogoTexture(this._textureCache, this._logoFile);
+ });
+ this.add_child(this._logoBin);
+ this._updateLogo();
+
+ this._userList.connect('activate', (userList, item) => {
+ this._onUserListActivated(item);
+ });
+
+ this._disableUserList = undefined;
+ this._userListLoaded = false;
+
+ this._realmManager = new Realmd.Manager();
+ this._realmSignalId = this._realmManager.connect('login-format-changed',
+ this._showRealmLoginHint.bind(this));
+
+ LoginManager.getLoginManager().getCurrentSessionProxy(this._gotGreeterSessionProxy.bind(this));
+
+ // If the user list is enabled, it should take key focus; make sure the
+ // screen shield is initialized first to prevent it from stealing the
+ // focus later
+ this._startupCompleteId = Main.layoutManager.connect('startup-complete',
+ this._updateDisableUserList.bind(this));
+ }
+
+ _getBannerAllocation(dialogBox) {
+ let actorBox = new Clutter.ActorBox();
+
+ let [, , natWidth, natHeight] = this._bannerView.get_preferred_size();
+ let centerX = dialogBox.x1 + (dialogBox.x2 - dialogBox.x1) / 2;
+
+ actorBox.x1 = Math.floor(centerX - natWidth / 2);
+ actorBox.y1 = dialogBox.y1 + Main.layoutManager.panelBox.height;
+ actorBox.x2 = actorBox.x1 + natWidth;
+ actorBox.y2 = actorBox.y1 + natHeight;
+
+ return actorBox;
+ }
+
+ _getLogoBinAllocation(dialogBox) {
+ let actorBox = new Clutter.ActorBox();
+
+ let [, , natWidth, natHeight] = this._logoBin.get_preferred_size();
+ let centerX = dialogBox.x1 + (dialogBox.x2 - dialogBox.x1) / 2;
+
+ actorBox.x1 = Math.floor(centerX - natWidth / 2);
+ actorBox.y1 = dialogBox.y2 - natHeight;
+ actorBox.x2 = actorBox.x1 + natWidth;
+ actorBox.y2 = actorBox.y1 + natHeight;
+
+ return actorBox;
+ }
+
+ _getSessionMenuButtonAllocation(dialogBox) {
+ let actorBox = new Clutter.ActorBox();
+
+ let [, , natWidth, natHeight] = this._sessionMenuButton.get_preferred_size();
+
+ if (this.get_text_direction() === Clutter.TextDirection.RTL)
+ actorBox.x1 = dialogBox.x1 + natWidth;
+ else
+ actorBox.x1 = dialogBox.x2 - (natWidth * 2);
+
+ actorBox.y1 = dialogBox.y2 - (natHeight * 2);
+ actorBox.x2 = actorBox.x1 + natWidth;
+ actorBox.y2 = actorBox.y1 + natHeight;
+
+ return actorBox;
+ }
+
+ _getCenterActorAllocation(dialogBox, actor) {
+ let actorBox = new Clutter.ActorBox();
+
+ let [, , natWidth, natHeight] = actor.get_preferred_size();
+ let centerX = dialogBox.x1 + (dialogBox.x2 - dialogBox.x1) / 2;
+ let centerY = dialogBox.y1 + (dialogBox.y2 - dialogBox.y1) / 2;
+
+ natWidth = Math.min(natWidth, dialogBox.x2 - dialogBox.x1);
+ natHeight = Math.min(natHeight, dialogBox.y2 - dialogBox.y1);
+
+ actorBox.x1 = Math.floor(centerX - natWidth / 2);
+ actorBox.y1 = Math.floor(centerY - natHeight / 2);
+ actorBox.x2 = actorBox.x1 + natWidth;
+ actorBox.y2 = actorBox.y1 + natHeight;
+
+ return actorBox;
+ }
+
+ vfunc_allocate(dialogBox) {
+ this.set_allocation(dialogBox);
+
+ let themeNode = this.get_theme_node();
+ dialogBox = themeNode.get_content_box(dialogBox);
+
+ let dialogWidth = dialogBox.x2 - dialogBox.x1;
+ let dialogHeight = dialogBox.y2 - dialogBox.y1;
+
+ // First find out what space the children require
+ let bannerAllocation = null;
+ let bannerHeight = 0;
+ if (this._bannerView.visible) {
+ bannerAllocation = this._getBannerAllocation(dialogBox, this._bannerView);
+ bannerHeight = bannerAllocation.y2 - bannerAllocation.y1;
+ }
+
+ let authPromptAllocation = null;
+ let authPromptWidth = 0;
+ if (this._authPrompt.visible) {
+ authPromptAllocation = this._getCenterActorAllocation(dialogBox, this._authPrompt);
+ authPromptWidth = authPromptAllocation.x2 - authPromptAllocation.x1;
+ }
+
+ let userSelectionAllocation = null;
+ let userSelectionHeight = 0;
+ if (this._userSelectionBox.visible) {
+ userSelectionAllocation = this._getCenterActorAllocation(dialogBox, this._userSelectionBox);
+ userSelectionHeight = userSelectionAllocation.y2 - userSelectionAllocation.y1;
+ }
+
+ let logoAllocation = null;
+ let logoHeight = 0;
+ if (this._logoBin.visible) {
+ logoAllocation = this._getLogoBinAllocation(dialogBox);
+ logoHeight = logoAllocation.y2 - logoAllocation.y1;
+ }
+
+ let sessionMenuButtonAllocation = null;
+ if (this._sessionMenuButton.visible)
+ sessionMenuButtonAllocation = this._getSessionMenuButtonAllocation(dialogBox);
+
+ // Then figure out if we're overly constrained and need to
+ // try a different layout, or if we have what extra space we
+ // can hand out
+ if (bannerAllocation) {
+ let bannerSpace;
+
+ if (authPromptAllocation)
+ bannerSpace = authPromptAllocation.y1 - bannerAllocation.y1;
+ else
+ bannerSpace = 0;
+
+ let leftOverYSpace = bannerSpace - bannerHeight;
+
+ if (leftOverYSpace > 0) {
+ // First figure out how much left over space is up top
+ let leftOverTopSpace = leftOverYSpace / 2;
+
+ // Then, shift the banner into the middle of that extra space
+ let yShift = Math.floor(leftOverTopSpace / 2);
+
+ bannerAllocation.y1 += yShift;
+ bannerAllocation.y2 += yShift;
+ } else {
+ // Then figure out how much space there would be if we switched to a
+ // wide layout with banner on one side and authprompt on the other.
+ let leftOverXSpace = dialogWidth - authPromptWidth;
+
+ // In a wide view, half of the available space goes to the banner,
+ // and the other half goes to the margins.
+ let wideBannerWidth = leftOverXSpace / 2;
+ let wideSpacing = leftOverXSpace - wideBannerWidth;
+
+ // If we do go with a wide layout, we need there to be at least enough
+ // space for the banner and the auth prompt to be the same width,
+ // so it doesn't look unbalanced.
+ if (authPromptWidth > 0 && wideBannerWidth > authPromptWidth) {
+ let centerX = dialogBox.x1 + dialogWidth / 2;
+ let centerY = dialogBox.y1 + dialogHeight / 2;
+
+ // A small portion of the spacing goes down the center of the
+ // screen to help delimit the two columns of the wide view
+ let centerGap = wideSpacing / 8;
+
+ // place the banner along the left edge of the center margin
+ bannerAllocation.x2 = Math.floor(centerX - centerGap / 2);
+ bannerAllocation.x1 = Math.floor(bannerAllocation.x2 - wideBannerWidth);
+
+ // figure out how tall it would like to be and try to accommodate
+ // but don't let it get too close to the logo
+ let [, wideBannerHeight] = this._bannerView.get_preferred_height(wideBannerWidth);
+
+ let maxWideHeight = dialogHeight - 3 * logoHeight;
+ wideBannerHeight = Math.min(maxWideHeight, wideBannerHeight);
+ bannerAllocation.y1 = Math.floor(centerY - wideBannerHeight / 2);
+ bannerAllocation.y2 = bannerAllocation.y1 + wideBannerHeight;
+
+ // place the auth prompt along the right edge of the center margin
+ authPromptAllocation.x1 = Math.floor(centerX + centerGap / 2);
+ authPromptAllocation.x2 = authPromptAllocation.x1 + authPromptWidth;
+ } else {
+ // If we aren't going to do a wide view, then we need to limit
+ // the height of the banner so it will present scrollbars
+
+ // First figure out how much space there is without the banner
+ leftOverYSpace += bannerHeight;
+
+ // Then figure out how much of that space is up top
+ let availableTopSpace = Math.floor(leftOverYSpace / 2);
+
+ // Then give all of that space to the banner
+ bannerAllocation.y2 = bannerAllocation.y1 + availableTopSpace;
+ }
+ }
+ } else if (userSelectionAllocation) {
+ // Grow the user list to fill the space
+ let leftOverYSpace = dialogHeight - userSelectionHeight - logoHeight;
+
+ if (leftOverYSpace > 0) {
+ let topExpansion = Math.floor(leftOverYSpace / 2);
+ let bottomExpansion = topExpansion;
+
+ userSelectionAllocation.y1 -= topExpansion;
+ userSelectionAllocation.y2 += bottomExpansion;
+ }
+ }
+
+ // Finally hand out the allocations
+ if (bannerAllocation)
+ this._bannerView.allocate(bannerAllocation);
+
+ if (authPromptAllocation)
+ this._authPrompt.allocate(authPromptAllocation);
+
+ if (userSelectionAllocation)
+ this._userSelectionBox.allocate(userSelectionAllocation);
+
+ if (logoAllocation)
+ this._logoBin.allocate(logoAllocation);
+
+ if (sessionMenuButtonAllocation)
+ this._sessionMenuButton.allocate(sessionMenuButtonAllocation);
+ }
+
+ _ensureUserListLoaded() {
+ if (!this._userManager.is_loaded) {
+ this._userManagerLoadedId = this._userManager.connect('notify::is-loaded',
+ () => {
+ if (this._userManager.is_loaded) {
+ this._loadUserList();
+ this._userManager.disconnect(this._userManagerLoadedId);
+ this._userManagerLoadedId = 0;
+ }
+ });
+ } else {
+ let id = GLib.idle_add(GLib.PRIORITY_DEFAULT, this._loadUserList.bind(this));
+ GLib.Source.set_name_by_id(id, '[gnome-shell] _loadUserList');
+ }
+ }
+
+ _updateDisableUserList() {
+ let disableUserList = this._settings.get_boolean(GdmUtil.DISABLE_USER_LIST_KEY);
+
+ // Disable user list when there are no users.
+ if (this._userListLoaded && this._userList.numItems() == 0)
+ disableUserList = true;
+
+ if (disableUserList != this._disableUserList) {
+ this._disableUserList = disableUserList;
+
+ if (this._authPrompt.verificationStatus == AuthPrompt.AuthPromptStatus.NOT_VERIFYING)
+ this._authPrompt.reset();
+ }
+ }
+
+ _updateCancelButton() {
+ let cancelVisible;
+
+ // Hide the cancel button if the user list is disabled and we're asking for
+ // a username
+ if (this._authPrompt.verificationStatus == AuthPrompt.AuthPromptStatus.NOT_VERIFYING && this._disableUserList)
+ cancelVisible = false;
+ else
+ cancelVisible = true;
+
+ this._authPrompt.cancelButton.visible = cancelVisible;
+ }
+
+ _updateBanner() {
+ let enabled = this._settings.get_boolean(GdmUtil.BANNER_MESSAGE_KEY);
+ let text = this._settings.get_string(GdmUtil.BANNER_MESSAGE_TEXT_KEY);
+
+ if (enabled && text) {
+ this._bannerLabel.set_text(text);
+ this._bannerLabel.show();
+ } else {
+ this._bannerLabel.hide();
+ }
+ }
+
+ _fadeInBannerView() {
+ this._bannerView.show();
+ this._bannerView.ease({
+ opacity: 255,
+ duration: _FADE_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ });
+ }
+
+ _hideBannerView() {
+ this._bannerView.remove_all_transitions();
+ this._bannerView.opacity = 0;
+ this._bannerView.hide();
+ }
+
+ _updateLogoTexture(cache, file) {
+ if (this._logoFile && !this._logoFile.equal(file))
+ return;
+
+ this._logoBin.destroy_all_children();
+ const resourceScale = this._logoBin.get_resource_scale();
+ if (this._logoFile) {
+ let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor;
+ this._logoBin.add_child(this._textureCache.load_file_async(this._logoFile,
+ -1, -1,
+ scaleFactor,
+ resourceScale));
+ }
+ }
+
+ _updateLogo() {
+ let path = this._settings.get_string(GdmUtil.LOGO_KEY);
+
+ this._logoFile = path ? Gio.file_new_for_path(path) : null;
+ this._updateLogoTexture(this._textureCache, this._logoFile);
+ }
+
+ _onPrompted() {
+ const showSessionMenu = this._shouldShowSessionMenuButton();
+
+ this._sessionMenuButton.updateSensitivity(showSessionMenu);
+ this._sessionMenuButton.visible = showSessionMenu;
+ this._showPrompt();
+ }
+
+ _resetGreeterProxy() {
+ if (GLib.getenv('GDM_GREETER_TEST') != '1') {
+ if (this._greeter)
+ this._greeter.run_dispose();
+
+ this._greeter = this._gdmClient.get_greeter_sync(null);
+
+ this._defaultSessionChangedId = this._greeter.connect('default-session-name-changed',
+ this._onDefaultSessionChanged.bind(this));
+ this._sessionOpenedId = this._greeter.connect('session-opened',
+ this._onSessionOpened.bind(this));
+ this._timedLoginRequestedId = this._greeter.connect('timed-login-requested',
+ this._onTimedLoginRequested.bind(this));
+ }
+ }
+
+ _onReset(authPrompt, beginRequest) {
+ this._resetGreeterProxy();
+ this._sessionMenuButton.updateSensitivity(true);
+
+ this._user = null;
+
+ if (this._nextSignalId) {
+ this._authPrompt.disconnect(this._nextSignalId);
+ this._nextSignalId = 0;
+ }
+
+ if (beginRequest == AuthPrompt.BeginRequestType.PROVIDE_USERNAME) {
+ if (!this._disableUserList)
+ this._showUserList();
+ else
+ this._hideUserListAskForUsernameAndBeginVerification();
+ } else {
+ this._hideUserListAndBeginVerification();
+ }
+ }
+
+ _onDefaultSessionChanged(client, sessionId) {
+ this._sessionMenuButton.setActiveSession(sessionId);
+ }
+
+ _shouldShowSessionMenuButton() {
+ if (this._authPrompt.verificationStatus != AuthPrompt.AuthPromptStatus.VERIFYING &&
+ this._authPrompt.verificationStatus != AuthPrompt.AuthPromptStatus.VERIFICATION_FAILED)
+ return false;
+
+ if (this._user && this._user.is_loaded && this._user.is_logged_in())
+ return false;
+
+ return true;
+ }
+
+ _showPrompt() {
+ if (this._authPrompt.visible)
+ return;
+ this._authPrompt.opacity = 0;
+ this._authPrompt.show();
+ this._authPrompt.ease({
+ opacity: 255,
+ duration: _FADE_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ });
+ this._fadeInBannerView();
+ }
+
+ _showRealmLoginHint(realmManager, hint) {
+ if (!hint)
+ return;
+
+ hint = hint.replace(/%U/g, 'user');
+ hint = hint.replace(/%D/g, 'DOMAIN');
+ hint = hint.replace(/%[^UD]/g, '');
+
+ // Translators: this message is shown below the username entry field
+ // to clue the user in on how to login to the local network realm
+ this._authPrompt.setMessage(_("(e.g., user or %s)").format(hint), GdmUtil.MessageType.HINT);
+ }
+
+ _askForUsernameAndBeginVerification() {
+ this._authPrompt.setUser(null);
+ this._authPrompt.setQuestion(_('Username'));
+
+ this._showRealmLoginHint(this._realmManager.loginFormat);
+
+ if (this._nextSignalId)
+ this._authPrompt.disconnect(this._nextSignalId);
+ this._nextSignalId = this._authPrompt.connect('next',
+ () => {
+ this._authPrompt.disconnect(this._nextSignalId);
+ this._nextSignalId = 0;
+ this._authPrompt.updateSensitivity(false);
+ let answer = this._authPrompt.getAnswer();
+ this._user = this._userManager.get_user(answer);
+ this._authPrompt.clear();
+ this._authPrompt.begin({ userName: answer });
+ this._updateCancelButton();
+ });
+ this._updateCancelButton();
+
+ this._sessionMenuButton.updateSensitivity(false);
+ this._authPrompt.updateSensitivity(true);
+ this._showPrompt();
+ }
+
+ _bindOpacity() {
+ this._bindings = Main.layoutManager.uiGroup.get_children()
+ .filter(c => c != Main.layoutManager.screenShieldGroup)
+ .map(c => this.bind_property('opacity', c, 'opacity', 0));
+ }
+
+ _unbindOpacity() {
+ this._bindings.forEach(b => b.unbind());
+ }
+
+ _loginScreenSessionActivated() {
+ if (this.opacity == 255 && this._authPrompt.verificationStatus == AuthPrompt.AuthPromptStatus.NOT_VERIFYING)
+ return;
+
+ if (this._authPrompt.verificationStatus !== AuthPrompt.AuthPromptStatus.NOT_VERIFYING)
+ this._authPrompt.reset();
+
+ this._bindOpacity();
+ this.ease({
+ opacity: 255,
+ duration: _FADE_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ onComplete: () => this._unbindOpacity(),
+ });
+ }
+
+ _gotGreeterSessionProxy(proxy) {
+ this._greeterSessionProxy = proxy;
+ this._greeterSessionProxyChangedId =
+ proxy.connect('g-properties-changed', () => {
+ if (proxy.Active)
+ this._loginScreenSessionActivated();
+ });
+ }
+
+ _startSession(serviceName) {
+ this._bindOpacity();
+ this.ease({
+ opacity: 0,
+ duration: _FADE_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ onComplete: () => {
+ this._greeter.call_start_session_when_ready_sync(serviceName, true, null);
+ this._unbindOpacity();
+ },
+ });
+ }
+
+ _onSessionOpened(client, serviceName) {
+ this._authPrompt.finish(() => this._startSession(serviceName));
+ }
+
+ _waitForItemForUser(userName) {
+ let item = this._userList.getItemFromUserName(userName);
+
+ if (item)
+ return null;
+
+ let hold = new Batch.Hold();
+ let signalId = this._userList.connect('item-added',
+ () => {
+ item = this._userList.getItemFromUserName(userName);
+
+ if (item)
+ hold.release();
+ });
+
+ hold.connect('release', () => this._userList.disconnect(signalId));
+
+ return hold;
+ }
+
+ _blockTimedLoginUntilIdle() {
+ let hold = new Batch.Hold();
+
+ this._timedLoginIdleTimeOutId = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, _TIMED_LOGIN_IDLE_THRESHOLD,
+ () => {
+ this._timedLoginIdleTimeOutId = 0;
+ hold.release();
+ return GLib.SOURCE_REMOVE;
+ });
+ GLib.Source.set_name_by_id(this._timedLoginIdleTimeOutId, '[gnome-shell] this._timedLoginIdleTimeOutId');
+ return hold;
+ }
+
+ _startTimedLogin(userName, delay) {
+ let firstRun = true;
+
+ // Cancel execution of old batch
+ if (this._timedLoginBatch) {
+ this._timedLoginBatch.cancel();
+ this._timedLoginBatch = null;
+ firstRun = false;
+ }
+
+ // Reset previous idle-timeout
+ if (this._timedLoginIdleTimeOutId) {
+ GLib.source_remove(this._timedLoginIdleTimeOutId);
+ this._timedLoginIdleTimeOutId = 0;
+ }
+
+ let loginItem = null;
+ let animationTime;
+
+ let tasks = [() => this._waitForItemForUser(userName),
+
+ () => {
+ loginItem = this._userList.getItemFromUserName(userName);
+
+ // If there is an animation running on the item, reset it.
+ loginItem.hideTimedLoginIndicator();
+ },
+
+ () => {
+ // If we're just starting out, start on the right item.
+ if (!this._userManager.is_loaded)
+ this._userList.jumpToItem(loginItem);
+ },
+
+ () => {
+ // This blocks the timed login animation until a few
+ // seconds after the user stops interacting with the
+ // login screen.
+
+ // We skip this step if the timed login delay is very short.
+ if (delay > _TIMED_LOGIN_IDLE_THRESHOLD) {
+ animationTime = delay - _TIMED_LOGIN_IDLE_THRESHOLD;
+ return this._blockTimedLoginUntilIdle();
+ } else {
+ animationTime = delay;
+ return null;
+ }
+ },
+
+ () => {
+ // If idle timeout is done, make sure the timed login indicator is shown
+ if (delay > _TIMED_LOGIN_IDLE_THRESHOLD &&
+ this._authPrompt.visible)
+ this._authPrompt.cancel();
+
+ if (delay > _TIMED_LOGIN_IDLE_THRESHOLD || firstRun) {
+ this._userList.scrollToItem(loginItem);
+ loginItem.grab_key_focus();
+ }
+ },
+
+ () => loginItem.showTimedLoginIndicator(animationTime),
+
+ () => {
+ this._timedLoginBatch = null;
+ this._greeter.call_begin_auto_login_sync(userName, null);
+ }];
+
+ this._timedLoginBatch = new Batch.ConsecutiveBatch(this, tasks);
+
+ return this._timedLoginBatch.run();
+ }
+
+ _onTimedLoginRequested(client, userName, seconds) {
+ if (this._timedLoginBatch)
+ return;
+
+ this._startTimedLogin(userName, seconds);
+
+ // Restart timed login on user interaction
+ global.stage.connect('captured-event', (actor, event) => {
+ if (event.type() == Clutter.EventType.KEY_PRESS ||
+ event.type() == Clutter.EventType.BUTTON_PRESS)
+ this._startTimedLogin(userName, seconds);
+
+ return Clutter.EVENT_PROPAGATE;
+ });
+ }
+
+ _setUserListExpanded(expanded) {
+ this._userList.updateStyle(expanded);
+ this._userSelectionBox.visible = expanded;
+ }
+
+ _hideUserList() {
+ this._setUserListExpanded(false);
+ if (this._userSelectionBox.visible)
+ GdmUtil.cloneAndFadeOutActor(this._userSelectionBox);
+ }
+
+ _hideUserListAskForUsernameAndBeginVerification() {
+ this._hideUserList();
+ this._askForUsernameAndBeginVerification();
+ }
+
+ _hideUserListAndBeginVerification() {
+ this._hideUserList();
+ this._authPrompt.begin();
+ }
+
+ _showUserList() {
+ this._ensureUserListLoaded();
+ this._authPrompt.hide();
+ this._hideBannerView();
+ this._sessionMenuButton.close();
+ this._sessionMenuButton.hide();
+ this._setUserListExpanded(true);
+ this._notListedButton.show();
+ this._userList.grab_key_focus();
+ }
+
+ _beginVerificationForItem(item) {
+ this._authPrompt.setUser(item.user);
+
+ let userName = item.user.get_user_name();
+ let hold = new Batch.Hold();
+
+ this._authPrompt.begin({ userName, hold });
+ return hold;
+ }
+
+ _onUserListActivated(activatedItem) {
+ this._user = activatedItem.user;
+
+ this._updateCancelButton();
+
+ let batch = new Batch.ConcurrentBatch(this, [GdmUtil.cloneAndFadeOutActor(this._userSelectionBox),
+ this._beginVerificationForItem(activatedItem)]);
+ batch.run();
+ }
+
+ _onDestroy() {
+ if (this._userManagerLoadedId) {
+ this._userManager.disconnect(this._userManagerLoadedId);
+ this._userManagerLoadedId = 0;
+ }
+ if (this._userAddedId) {
+ this._userManager.disconnect(this._userAddedId);
+ this._userAddedId = 0;
+ }
+ if (this._userRemovedId) {
+ this._userManager.disconnect(this._userRemovedId);
+ this._userRemovedId = 0;
+ }
+ if (this._userChangedId) {
+ this._userManager.disconnect(this._userChangedId);
+ this._userChangedId = 0;
+ }
+ this._textureCache.disconnect(this._updateLogoTextureId);
+ Main.layoutManager.disconnect(this._startupCompleteId);
+ if (this._settings) {
+ this._settings.run_dispose();
+ this._settings = null;
+ }
+ if (this._greeter) {
+ this._greeter.disconnect(this._defaultSessionChangedId);
+ this._greeter.disconnect(this._sessionOpenedId);
+ this._greeter.disconnect(this._timedLoginRequestedId);
+ this._greeter = null;
+ }
+ if (this._greeterSessionProxy) {
+ this._greeterSessionProxy.disconnect(this._greeterSessionProxyChangedId);
+ this._greeterSessionProxy = null;
+ }
+ if (this._realmManager) {
+ this._realmManager.disconnect(this._realmSignalId);
+ this._realmSignalId = 0;
+ this._realmManager.release();
+ this._realmManager = null;
+ }
+ }
+
+ _loadUserList() {
+ if (this._userListLoaded)
+ return GLib.SOURCE_REMOVE;
+
+ this._userListLoaded = true;
+
+ let users = this._userManager.list_users();
+
+ for (let i = 0; i < users.length; i++)
+ this._userList.addUser(users[i]);
+
+ this._updateDisableUserList();
+
+ this._userAddedId = this._userManager.connect('user-added',
+ (userManager, user) => {
+ this._userList.addUser(user);
+ this._updateDisableUserList();
+ });
+
+ this._userRemovedId = this._userManager.connect('user-removed',
+ (userManager, user) => {
+ this._userList.removeUser(user);
+ this._updateDisableUserList();
+ });
+
+ this._userChangedId = this._userManager.connect('user-changed',
+ (userManager, user) => {
+ if (this._userList.containsUser(user) && user.locked)
+ this._userList.removeUser(user);
+ else if (!this._userList.containsUser(user) && !user.locked)
+ this._userList.addUser(user);
+ this._updateDisableUserList();
+ });
+
+ return GLib.SOURCE_REMOVE;
+ }
+
+ activate() {
+ this._userList.grab_key_focus();
+ this.show();
+ }
+
+ open() {
+ Main.ctrlAltTabManager.addGroup(this,
+ _("Login Window"),
+ 'dialog-password-symbolic',
+ { sortGroup: CtrlAltTab.SortGroup.MIDDLE });
+ this.activate();
+
+ this.opacity = 0;
+
+ Main.pushModal(this, { actionMode: Shell.ActionMode.LOGIN_SCREEN });
+
+ this.ease({
+ opacity: 255,
+ duration: 1000,
+ mode: Clutter.AnimationMode.EASE_IN_QUAD,
+ });
+
+ return true;
+ }
+
+ close() {
+ Main.popModal(this);
+ Main.ctrlAltTabManager.removeGroup(this);
+ }
+
+ cancel() {
+ this._authPrompt.cancel();
+ }
+
+ addCharacter(_unichar) {
+ // Don't allow type ahead at the login screen
+ }
+
+ finish(onComplete) {
+ this._authPrompt.finish(onComplete);
+ }
+});
diff --git a/js/gdm/oVirt.js b/js/gdm/oVirt.js
new file mode 100644
index 0000000..94a22b8
--- /dev/null
+++ b/js/gdm/oVirt.js
@@ -0,0 +1,51 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported getOVirtCredentialsManager */
+
+const Gio = imports.gi.Gio;
+const Signals = imports.signals;
+const Credential = imports.gdm.credentialManager;
+
+var SERVICE_NAME = 'gdm-ovirtcred';
+
+const OVirtCredentialsIface = `
+<node>
+<interface name="org.ovirt.vdsm.Credentials">
+<signal name="UserAuthenticated">
+ <arg type="s" name="token"/>
+</signal>
+</interface>
+</node>`;
+
+const OVirtCredentialsInfo = Gio.DBusInterfaceInfo.new_for_xml(OVirtCredentialsIface);
+
+let _oVirtCredentialsManager = null;
+
+function OVirtCredentials() {
+ var self = new Gio.DBusProxy({ g_connection: Gio.DBus.system,
+ g_interface_name: OVirtCredentialsInfo.name,
+ g_interface_info: OVirtCredentialsInfo,
+ g_name: 'org.ovirt.vdsm.Credentials',
+ g_object_path: '/org/ovirt/vdsm/Credentials',
+ g_flags: Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES });
+ self.init(null);
+ return self;
+}
+
+var OVirtCredentialsManager = class OVirtCredentialsManager extends Credential.CredentialManager {
+ constructor() {
+ super(SERVICE_NAME);
+ this._credentials = new OVirtCredentials();
+ this._credentials.connectSignal('UserAuthenticated',
+ (proxy, sender, [token]) => {
+ this.token = token;
+ });
+ }
+};
+Signals.addSignalMethods(OVirtCredentialsManager.prototype);
+
+function getOVirtCredentialsManager() {
+ if (!_oVirtCredentialsManager)
+ _oVirtCredentialsManager = new OVirtCredentialsManager();
+
+ return _oVirtCredentialsManager;
+}
diff --git a/js/gdm/realmd.js b/js/gdm/realmd.js
new file mode 100644
index 0000000..7584968
--- /dev/null
+++ b/js/gdm/realmd.js
@@ -0,0 +1,108 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+
+const Gio = imports.gi.Gio;
+const Signals = imports.signals;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const ProviderIface = loadInterfaceXML("org.freedesktop.realmd.Provider");
+const Provider = Gio.DBusProxy.makeProxyWrapper(ProviderIface);
+
+const ServiceIface = loadInterfaceXML("org.freedesktop.realmd.Service");
+const Service = Gio.DBusProxy.makeProxyWrapper(ServiceIface);
+
+const RealmIface = loadInterfaceXML("org.freedesktop.realmd.Realm");
+const Realm = Gio.DBusProxy.makeProxyWrapper(RealmIface);
+
+var Manager = class {
+ constructor() {
+ this._aggregateProvider = Provider(Gio.DBus.system,
+ 'org.freedesktop.realmd',
+ '/org/freedesktop/realmd',
+ this._reloadRealms.bind(this));
+ this._realms = {};
+ this._loginFormat = null;
+
+ this._signalId = this._aggregateProvider.connect('g-properties-changed',
+ (proxy, properties) => {
+ if ('Realms' in properties.deep_unpack())
+ this._reloadRealms();
+ });
+ }
+
+ _reloadRealms() {
+ let realmPaths = this._aggregateProvider.Realms;
+
+ if (!realmPaths)
+ return;
+
+ for (let i = 0; i < realmPaths.length; i++) {
+ Realm(Gio.DBus.system,
+ 'org.freedesktop.realmd',
+ realmPaths[i],
+ this._onRealmLoaded.bind(this));
+ }
+ }
+
+ _reloadRealm(realm) {
+ if (!realm.Configured) {
+ if (this._realms[realm.get_object_path()])
+ delete this._realms[realm.get_object_path()];
+
+ return;
+ }
+
+ this._realms[realm.get_object_path()] = realm;
+
+ this._updateLoginFormat();
+ }
+
+ _onRealmLoaded(realm, error) {
+ if (error)
+ return;
+
+ this._reloadRealm(realm);
+
+ realm.connect('g-properties-changed', (proxy, properties) => {
+ if ('Configured' in properties.deep_unpack())
+ this._reloadRealm(realm);
+ });
+ }
+
+ _updateLoginFormat() {
+ let newLoginFormat;
+
+ for (let realmPath in this._realms) {
+ let realm = this._realms[realmPath];
+ if (realm.LoginFormats && realm.LoginFormats.length > 0) {
+ newLoginFormat = realm.LoginFormats[0];
+ break;
+ }
+ }
+
+ if (this._loginFormat != newLoginFormat) {
+ this._loginFormat = newLoginFormat;
+ this.emit('login-format-changed', newLoginFormat);
+ }
+ }
+
+ get loginFormat() {
+ if (this._loginFormat)
+ return this._loginFormat;
+
+ this._updateLoginFormat();
+
+ return this._loginFormat;
+ }
+
+ release() {
+ Service(Gio.DBus.system,
+ 'org.freedesktop.realmd',
+ '/org/freedesktop/realmd',
+ service => service.ReleaseRemote());
+ this._aggregateProvider.disconnect(this._signalId);
+ this._realms = { };
+ this._updateLoginFormat();
+ }
+};
+Signals.addSignalMethods(Manager.prototype);
diff --git a/js/gdm/util.js b/js/gdm/util.js
new file mode 100644
index 0000000..c31ae92
--- /dev/null
+++ b/js/gdm/util.js
@@ -0,0 +1,625 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported BANNER_MESSAGE_KEY, BANNER_MESSAGE_TEXT_KEY, LOGO_KEY,
+ DISABLE_USER_LIST_KEY, fadeInActor, fadeOutActor, cloneAndFadeOutActor */
+
+const { Clutter, Gdm, Gio, GLib } = imports.gi;
+const Signals = imports.signals;
+
+const Batch = imports.gdm.batch;
+const Fprint = imports.gdm.fingerprint;
+const OVirt = imports.gdm.oVirt;
+const Vmware = imports.gdm.vmware;
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+const SmartcardManager = imports.misc.smartcardManager;
+
+Gio._promisify(Gdm.Client.prototype,
+ 'open_reauthentication_channel', 'open_reauthentication_channel_finish');
+Gio._promisify(Gdm.Client.prototype,
+ 'get_user_verifier', 'get_user_verifier_finish');
+Gio._promisify(Gdm.UserVerifierProxy.prototype,
+ 'call_begin_verification_for_user', 'call_begin_verification_for_user_finish');
+Gio._promisify(Gdm.UserVerifierProxy.prototype,
+ 'call_begin_verification', 'call_begin_verification_finish');
+
+var PASSWORD_SERVICE_NAME = 'gdm-password';
+var FINGERPRINT_SERVICE_NAME = 'gdm-fingerprint';
+var SMARTCARD_SERVICE_NAME = 'gdm-smartcard';
+var FADE_ANIMATION_TIME = 160;
+var CLONE_FADE_ANIMATION_TIME = 250;
+
+var LOGIN_SCREEN_SCHEMA = 'org.gnome.login-screen';
+var PASSWORD_AUTHENTICATION_KEY = 'enable-password-authentication';
+var FINGERPRINT_AUTHENTICATION_KEY = 'enable-fingerprint-authentication';
+var SMARTCARD_AUTHENTICATION_KEY = 'enable-smartcard-authentication';
+var BANNER_MESSAGE_KEY = 'banner-message-enable';
+var BANNER_MESSAGE_TEXT_KEY = 'banner-message-text';
+var ALLOWED_FAILURES_KEY = 'allowed-failures';
+
+var LOGO_KEY = 'logo';
+var DISABLE_USER_LIST_KEY = 'disable-user-list';
+
+// Give user 48ms to read each character of a PAM message
+var USER_READ_TIME = 48;
+
+var MessageType = {
+ NONE: 0,
+ ERROR: 1,
+ INFO: 2,
+ HINT: 3,
+};
+
+function fadeInActor(actor) {
+ if (actor.opacity == 255 && actor.visible)
+ return null;
+
+ let hold = new Batch.Hold();
+ actor.show();
+ let [, naturalHeight] = actor.get_preferred_height(-1);
+
+ actor.opacity = 0;
+ actor.set_height(0);
+ actor.ease({
+ opacity: 255,
+ height: naturalHeight,
+ duration: FADE_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ onComplete: () => {
+ this.set_height(-1);
+ hold.release();
+ },
+ });
+
+ return hold;
+}
+
+function fadeOutActor(actor) {
+ if (!actor.visible || actor.opacity == 0) {
+ actor.opacity = 0;
+ actor.hide();
+ return null;
+ }
+
+ let hold = new Batch.Hold();
+ actor.ease({
+ opacity: 0,
+ height: 0,
+ duration: FADE_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ onComplete: () => {
+ this.hide();
+ this.set_height(-1);
+ hold.release();
+ },
+ });
+ return hold;
+}
+
+function cloneAndFadeOutActor(actor) {
+ // Immediately hide actor so its sibling can have its space
+ // and position, but leave a non-reactive clone on-screen,
+ // so from the user's point of view it smoothly fades away
+ // and reveals its sibling.
+ actor.hide();
+
+ let clone = new Clutter.Clone({ source: actor,
+ reactive: false });
+
+ Main.uiGroup.add_child(clone);
+
+ let [x, y] = actor.get_transformed_position();
+ clone.set_position(x, y);
+
+ let hold = new Batch.Hold();
+ clone.ease({
+ opacity: 0,
+ duration: CLONE_FADE_ANIMATION_TIME,
+ mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+ onComplete: () => {
+ clone.destroy();
+ hold.release();
+ },
+ });
+ return hold;
+}
+
+var ShellUserVerifier = class {
+ constructor(client, params) {
+ params = Params.parse(params, { reauthenticationOnly: false });
+ this._reauthOnly = params.reauthenticationOnly;
+
+ this._client = client;
+
+ this._defaultService = null;
+ this._preemptingService = null;
+
+ this._settings = new Gio.Settings({ schema_id: LOGIN_SCREEN_SCHEMA });
+ this._settings.connect('changed',
+ this._updateDefaultService.bind(this));
+ this._updateDefaultService();
+
+ this._fprintManager = Fprint.FprintManager();
+ this._smartcardManager = SmartcardManager.getSmartcardManager();
+
+ // We check for smartcards right away, since an inserted smartcard
+ // at startup should result in immediately initiating authentication.
+ // This is different than fingerprint readers, where we only check them
+ // after a user has been picked.
+ this.smartcardDetected = false;
+ this._checkForSmartcard();
+
+ this._smartcardInsertedId = this._smartcardManager.connect('smartcard-inserted',
+ this._checkForSmartcard.bind(this));
+ this._smartcardRemovedId = this._smartcardManager.connect('smartcard-removed',
+ this._checkForSmartcard.bind(this));
+
+ this._messageQueue = [];
+ this._messageQueueTimeoutId = 0;
+ this.hasPendingMessages = false;
+ this.reauthenticating = false;
+
+ this._failCounter = 0;
+ this._unavailableServices = new Set();
+
+ this._credentialManagers = {};
+ this._credentialManagers[OVirt.SERVICE_NAME] = OVirt.getOVirtCredentialsManager();
+ this._credentialManagers[Vmware.SERVICE_NAME] = Vmware.getVmwareCredentialsManager();
+
+ for (let service in this._credentialManagers) {
+ if (this._credentialManagers[service].token) {
+ this._onCredentialManagerAuthenticated(this._credentialManagers[service],
+ this._credentialManagers[service].token);
+ }
+
+ this._credentialManagers[service]._authenticatedSignalId =
+ this._credentialManagers[service].connect('user-authenticated',
+ this._onCredentialManagerAuthenticated.bind(this));
+ }
+ }
+
+ begin(userName, hold) {
+ this._cancellable = new Gio.Cancellable();
+ this._hold = hold;
+ this._userName = userName;
+ this.reauthenticating = false;
+
+ this._checkForFingerprintReader();
+
+ // If possible, reauthenticate an already running session,
+ // so any session specific credentials get updated appropriately
+ if (userName)
+ this._openReauthenticationChannel(userName);
+ else
+ this._getUserVerifier();
+ }
+
+ cancel() {
+ if (this._cancellable)
+ this._cancellable.cancel();
+
+ if (this._userVerifier) {
+ this._userVerifier.call_cancel_sync(null);
+ this.clear();
+ }
+ }
+
+ _clearUserVerifier() {
+ if (this._userVerifier) {
+ this._userVerifier.run_dispose();
+ this._userVerifier = null;
+ }
+ }
+
+ clear() {
+ if (this._cancellable) {
+ this._cancellable.cancel();
+ this._cancellable = null;
+ }
+
+ this._clearUserVerifier();
+ this._clearMessageQueue();
+ }
+
+ destroy() {
+ this.cancel();
+
+ this._settings.run_dispose();
+ this._settings = null;
+
+ this._smartcardManager.disconnect(this._smartcardInsertedId);
+ this._smartcardManager.disconnect(this._smartcardRemovedId);
+ this._smartcardManager = null;
+
+ for (let service in this._credentialManagers) {
+ let credentialManager = this._credentialManagers[service];
+ credentialManager.disconnect(credentialManager._authenticatedSignalId);
+ credentialManager = null;
+ }
+ }
+
+ answerQuery(serviceName, answer) {
+ if (!this.hasPendingMessages) {
+ this._userVerifier.call_answer_query(serviceName, answer, this._cancellable, null);
+ } else {
+ const cancellable = this._cancellable;
+ let signalId = this.connect('no-more-messages', () => {
+ this.disconnect(signalId);
+ if (!cancellable.is_cancelled())
+ this._userVerifier.call_answer_query(serviceName, answer, cancellable, null);
+ });
+ }
+ }
+
+ _getIntervalForMessage(message) {
+ // We probably could be smarter here
+ return message.length * USER_READ_TIME;
+ }
+
+ finishMessageQueue() {
+ if (!this.hasPendingMessages)
+ return;
+
+ this._messageQueue = [];
+
+ this.hasPendingMessages = false;
+ this.emit('no-more-messages');
+ }
+
+ _queueMessageTimeout() {
+ if (this._messageQueue.length == 0) {
+ this.finishMessageQueue();
+ return;
+ }
+
+ if (this._messageQueueTimeoutId != 0)
+ return;
+
+ let message = this._messageQueue.shift();
+
+ this.emit('show-message', message.text, message.type);
+
+ this._messageQueueTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT,
+ message.interval,
+ () => {
+ this._messageQueueTimeoutId = 0;
+ this._queueMessageTimeout();
+ return GLib.SOURCE_REMOVE;
+ });
+ GLib.Source.set_name_by_id(this._messageQueueTimeoutId, '[gnome-shell] this._queueMessageTimeout');
+ }
+
+ _queueMessage(message, messageType) {
+ let interval = this._getIntervalForMessage(message);
+
+ this.hasPendingMessages = true;
+ this._messageQueue.push({ text: message, type: messageType, interval });
+ this._queueMessageTimeout();
+ }
+
+ _clearMessageQueue() {
+ this.finishMessageQueue();
+
+ if (this._messageQueueTimeoutId != 0) {
+ GLib.source_remove(this._messageQueueTimeoutId);
+ this._messageQueueTimeoutId = 0;
+ }
+ this.emit('show-message', null, MessageType.NONE);
+ }
+
+ _checkForFingerprintReader() {
+ this._haveFingerprintReader = false;
+
+ if (!this._settings.get_boolean(FINGERPRINT_AUTHENTICATION_KEY) ||
+ this._fprintManager == null) {
+ this._updateDefaultService();
+ return;
+ }
+
+ this._fprintManager.GetDefaultDeviceRemote(Gio.DBusCallFlags.NONE, this._cancellable,
+ (device, error) => {
+ if (!error && device) {
+ this._haveFingerprintReader = true;
+ this._updateDefaultService();
+ }
+ });
+ }
+
+ _onCredentialManagerAuthenticated(credentialManager, _token) {
+ this._preemptingService = credentialManager.service;
+ this.emit('credential-manager-authenticated');
+ }
+
+ _checkForSmartcard() {
+ let smartcardDetected;
+
+ if (!this._settings.get_boolean(SMARTCARD_AUTHENTICATION_KEY))
+ smartcardDetected = false;
+ else if (this._reauthOnly)
+ smartcardDetected = this._smartcardManager.hasInsertedLoginToken();
+ else
+ smartcardDetected = this._smartcardManager.hasInsertedTokens();
+
+ if (smartcardDetected != this.smartcardDetected) {
+ this.smartcardDetected = smartcardDetected;
+
+ if (this.smartcardDetected)
+ this._preemptingService = SMARTCARD_SERVICE_NAME;
+ else if (this._preemptingService == SMARTCARD_SERVICE_NAME)
+ this._preemptingService = null;
+
+ this.emit('smartcard-status-changed');
+ }
+ }
+
+ _reportInitError(where, error) {
+ logError(error, where);
+ this._hold.release();
+
+ this._queueMessage(_("Authentication error"), MessageType.ERROR);
+ this._verificationFailed(false);
+ }
+
+ async _openReauthenticationChannel(userName) {
+ try {
+ this._clearUserVerifier();
+ this._userVerifier = await this._client.open_reauthentication_channel(
+ userName, this._cancellable);
+ } catch (e) {
+ if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+ return;
+ if (e.matches(Gio.DBusError, Gio.DBusError.ACCESS_DENIED) &&
+ !this._reauthOnly) {
+ // Gdm emits org.freedesktop.DBus.Error.AccessDenied when there
+ // is no session to reauthenticate. Fall back to performing
+ // verification from this login session
+ this._getUserVerifier();
+ return;
+ }
+
+ this._reportInitError('Failed to open reauthentication channel', e);
+ return;
+ }
+
+ this.reauthenticating = true;
+ this._connectSignals();
+ this._beginVerification();
+ this._hold.release();
+ }
+
+ async _getUserVerifier() {
+ try {
+ this._clearUserVerifier();
+ this._userVerifier =
+ await this._client.get_user_verifier(this._cancellable);
+ } catch (e) {
+ if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+ return;
+ this._reportInitError('Failed to obtain user verifier', e);
+ return;
+ }
+
+ this._connectSignals();
+ this._beginVerification();
+ this._hold.release();
+ }
+
+ _connectSignals() {
+ this._userVerifier.connect('info', this._onInfo.bind(this));
+ this._userVerifier.connect('problem', this._onProblem.bind(this));
+ this._userVerifier.connect('info-query', this._onInfoQuery.bind(this));
+ this._userVerifier.connect('secret-info-query', this._onSecretInfoQuery.bind(this));
+ this._userVerifier.connect('conversation-stopped', this._onConversationStopped.bind(this));
+ this._userVerifier.connect('service-unavailable', this._onServiceUnavailable.bind(this));
+ this._userVerifier.connect('reset', this._onReset.bind(this));
+ this._userVerifier.connect('verification-complete', this._onVerificationComplete.bind(this));
+ }
+
+ _getForegroundService() {
+ if (this._preemptingService)
+ return this._preemptingService;
+
+ return this._defaultService;
+ }
+
+ serviceIsForeground(serviceName) {
+ return serviceName == this._getForegroundService();
+ }
+
+ serviceIsDefault(serviceName) {
+ return serviceName == this._defaultService;
+ }
+
+ serviceIsFingerprint(serviceName) {
+ return serviceName === FINGERPRINT_SERVICE_NAME &&
+ this._haveFingerprintReader;
+ }
+
+ _updateDefaultService() {
+ if (this._settings.get_boolean(PASSWORD_AUTHENTICATION_KEY))
+ this._defaultService = PASSWORD_SERVICE_NAME;
+ else if (this._settings.get_boolean(SMARTCARD_AUTHENTICATION_KEY))
+ this._defaultService = SMARTCARD_SERVICE_NAME;
+ else if (this._haveFingerprintReader)
+ this._defaultService = FINGERPRINT_SERVICE_NAME;
+
+ if (!this._defaultService) {
+ log("no authentication service is enabled, using password authentication");
+ this._defaultService = PASSWORD_SERVICE_NAME;
+ }
+ }
+
+ async _startService(serviceName) {
+ this._hold.acquire();
+ try {
+ if (this._userName) {
+ await this._userVerifier.call_begin_verification_for_user(
+ serviceName, this._userName, this._cancellable);
+ } else {
+ await this._userVerifier.call_begin_verification(
+ serviceName, this._cancellable);
+ }
+ } catch (e) {
+ if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+ return;
+ if (!this.serviceIsForeground(serviceName)) {
+ logError(e, 'Failed to start %s for %s'.format(serviceName, this._userName));
+ this._hold.release();
+ return;
+ }
+ this._reportInitError(this._userName
+ ? 'Failed to start verification for user'
+ : 'Failed to start verification', e);
+ return;
+ }
+ this._hold.release();
+ }
+
+ _beginVerification() {
+ this._startService(this._getForegroundService());
+
+ if (this._userName && this._haveFingerprintReader && !this.serviceIsForeground(FINGERPRINT_SERVICE_NAME))
+ this._startService(FINGERPRINT_SERVICE_NAME);
+ }
+
+ _onInfo(client, serviceName, info) {
+ if (this.serviceIsForeground(serviceName)) {
+ this._queueMessage(info, MessageType.INFO);
+ } else if (this.serviceIsFingerprint(serviceName)) {
+ // We don't show fingerprint messages directly since it's
+ // not the main auth service. Instead we use the messages
+ // as a cue to display our own message.
+
+ // Translators: this message is shown below the password entry field
+ // to indicate the user can swipe their finger instead
+ this._queueMessage(_("(or swipe finger)"), MessageType.HINT);
+ }
+ }
+
+ _onProblem(client, serviceName, problem) {
+ const isFingerprint = this.serviceIsFingerprint(serviceName);
+
+ if (!this.serviceIsForeground(serviceName) && !isFingerprint)
+ return;
+
+ this._queueMessage(problem, MessageType.ERROR);
+ }
+
+ _onInfoQuery(client, serviceName, question) {
+ if (!this.serviceIsForeground(serviceName))
+ return;
+
+ this.emit('ask-question', serviceName, question, false);
+ }
+
+ _onSecretInfoQuery(client, serviceName, secretQuestion) {
+ if (!this.serviceIsForeground(serviceName))
+ return;
+
+ let token = null;
+ if (this._credentialManagers[serviceName])
+ token = this._credentialManagers[serviceName].token;
+
+ if (token) {
+ this.answerQuery(serviceName, token);
+ return;
+ }
+
+ this.emit('ask-question', serviceName, secretQuestion, true);
+ }
+
+ _onReset() {
+ // Clear previous attempts to authenticate
+ this._failCounter = 0;
+ this._unavailableServices.clear();
+ this._updateDefaultService();
+
+ this.emit('reset');
+ }
+
+ _onVerificationComplete() {
+ this.emit('verification-complete');
+ }
+
+ _cancelAndReset() {
+ this.cancel();
+ this._onReset();
+ }
+
+ _retry() {
+ this.cancel();
+ this.begin(this._userName, new Batch.Hold());
+ }
+
+ _verificationFailed(retry) {
+ // For Not Listed / enterprise logins, immediately reset
+ // the dialog
+ // Otherwise, when in login mode we allow ALLOWED_FAILURES attempts.
+ // After that, we go back to the welcome screen.
+
+ this._failCounter++;
+ let canRetry = retry && this._userName &&
+ (this._reauthOnly ||
+ this._failCounter < this._settings.get_int(ALLOWED_FAILURES_KEY));
+
+ if (canRetry) {
+ if (!this.hasPendingMessages) {
+ this._retry();
+ } else {
+ const cancellable = this._cancellable;
+ let signalId = this.connect('no-more-messages', () => {
+ this.disconnect(signalId);
+ if (!cancellable.is_cancelled())
+ this._retry();
+ });
+ }
+ } else {
+ // eslint-disable-next-line no-lonely-if
+ if (!this.hasPendingMessages) {
+ this._cancelAndReset();
+ } else {
+ const cancellable = this._cancellable;
+ let signalId = this.connect('no-more-messages', () => {
+ this.disconnect(signalId);
+ if (!cancellable.is_cancelled())
+ this._cancelAndReset();
+ });
+ }
+ }
+
+ this.emit('verification-failed', canRetry);
+ }
+
+ _onServiceUnavailable(_client, serviceName, errorMessage) {
+ this._unavailableServices.add(serviceName);
+
+ if (!errorMessage)
+ return;
+
+ if (this.serviceIsForeground(serviceName) || this.serviceIsFingerprint(serviceName))
+ this._queueMessage(errorMessage, MessageType.ERROR);
+ }
+
+ _onConversationStopped(client, serviceName) {
+ // If the login failed with the preauthenticated oVirt credentials
+ // then discard the credentials and revert to default authentication
+ // mechanism.
+ let foregroundService = Object.keys(this._credentialManagers).find(service =>
+ this.serviceIsForeground(service));
+ if (foregroundService) {
+ this._credentialManagers[foregroundService].token = null;
+ this._preemptingService = null;
+ this._verificationFailed(false);
+ return;
+ }
+
+ if (this._unavailableServices.has(serviceName))
+ return;
+
+ // if the password service fails, then cancel everything.
+ // But if, e.g., fingerprint fails, still give
+ // password authentication a chance to succeed
+ if (this.serviceIsForeground(serviceName))
+ this._verificationFailed(true);
+ }
+};
+Signals.addSignalMethods(ShellUserVerifier.prototype);
diff --git a/js/gdm/vmware.js b/js/gdm/vmware.js
new file mode 100644
index 0000000..20d57e8
--- /dev/null
+++ b/js/gdm/vmware.js
@@ -0,0 +1,54 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported getVmwareCredentialsManager */
+
+const Gio = imports.gi.Gio;
+const Signals = imports.signals;
+const Credential = imports.gdm.credentialManager;
+
+const dbusPath = '/org/vmware/viewagent/Credentials';
+const dbusInterface = 'org.vmware.viewagent.Credentials';
+
+var SERVICE_NAME = 'gdm-vmwcred';
+
+const VmwareCredentialsIface = '<node> \
+<interface name="' + dbusInterface + '"> \
+<signal name="UserAuthenticated"> \
+ <arg type="s" name="token"/> \
+</signal> \
+</interface> \
+</node>';
+
+
+const VmwareCredentialsInfo = Gio.DBusInterfaceInfo.new_for_xml(VmwareCredentialsIface);
+
+let _vmwareCredentialsManager = null;
+
+function VmwareCredentials() {
+ var self = new Gio.DBusProxy({ g_connection: Gio.DBus.session,
+ g_interface_name: VmwareCredentialsInfo.name,
+ g_interface_info: VmwareCredentialsInfo,
+ g_name: dbusInterface,
+ g_object_path: dbusPath,
+ g_flags: Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES });
+ self.init(null);
+ return self;
+}
+
+var VmwareCredentialsManager = class VmwareCredentialsManager extends Credential.CredentialManager {
+ constructor() {
+ super(SERVICE_NAME);
+ this._credentials = new VmwareCredentials();
+ this._credentials.connectSignal('UserAuthenticated',
+ (proxy, sender, [token]) => {
+ this.token = token;
+ });
+ }
+};
+Signals.addSignalMethods(VmwareCredentialsManager.prototype);
+
+function getVmwareCredentialsManager() {
+ if (!_vmwareCredentialsManager)
+ _vmwareCredentialsManager = new VmwareCredentialsManager();
+
+ return _vmwareCredentialsManager;
+}