~darkxst/ubuntu/saucy/gdm/lp1212408 : revision 268

1

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-

2

*

3

4

*

5

* This program is free software; you can redistribute it and/or modify

6

* it under the terms of the GNU General Public License as published by

7

* the Free Software Foundation; either version 2 of the License, or

8

* (at your option) any later version.

9

*

10

* This program is distributed in the hope that it will be useful,

11

* but WITHOUT ANY WARRANTY; without even the implied warranty of

12

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

13

* GNU General Public License for more details.

14

*

15

* You should have received a copy of the GNU General Public License

16

* along with this program; if not, write to the Free Software

17

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

18

*

19

*/

20

21

#include "config.h"

22

23

#include <stdlib.h>

24

#include <stdio.h>

25

#include <fcntl.h>

26

#include <unistd.h>

27

#include <string.h>

28

#include <sys/types.h>

29

#include <sys/wait.h>

30

#include <errno.h>

31

32

#ifdef HAVE_LOGINDEVPERM

33

#include <libdevinfo.h>

34

#endif /* HAVE_LOGINDEVPERM */

35

36

#include <glib.h>

37

#include <glib/gi18n.h>

38

#include <glib/gstdio.h>

39

#include <glib-object.h>

40

41

#include <X11/Xlib.h> /* for Display */

42

43

#include <act/act-user-manager.h>

44

45

#include "gdm-common.h"

46

47

#include "gdm-settings-client.h"

48

#include "gdm-settings-keys.h"

49

50

#include "gdm-simple-slave.h"

51

52

#include "gdm-server.h"

53

#include "gdm-session.h"

54

#include "gdm-session-glue.h"

55

#include "gdm-launch-environment.h"

56

#include "gdm-settings-direct.h"

57

#include "gdm-settings-keys.h"

58

59

#define GDM_SIMPLE_SLAVE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GDM_TYPE_SIMPLE_SLAVE, GdmSimpleSlavePrivate))

60

61

#define GDM_DBUS_NAME "org.gnome.DisplayManager"

62

#define GDM_DBUS_DISPLAY_INTERFACE "org.gnome.DisplayManager.Display"

63

64

#define MAX_CONNECT_ATTEMPTS 10

65

#define DEFAULT_PING_INTERVAL 15

66

67

#define INITIAL_SETUP_USERNAME "gnome-initial-setup"

68

69

struct GdmSimpleSlavePrivate

70

{

71

GPid pid;

72

gint greeter_reset_id;

73

guint start_session_id;

74

75

char *start_session_service_name;

76

77

int ping_interval;

78

79

GPid server_pid;

80

guint connection_attempts;

81

82

GdmServer *server;

83

84

/* we control the user session */

85

GdmSession *session;

86

87

/* this spawns and controls the greeter session */

88

GdmLaunchEnvironment *greeter_environment;

89

90

GHashTable *open_reauthentication_requests;

91

92

guint start_session_when_ready : 1;

93

guint waiting_to_start_session : 1;

94

guint session_is_running : 1;

95

#ifdef HAVE_LOGINDEVPERM

96

gboolean use_logindevperm;

97

#endif

98

#ifdef WITH_PLYMOUTH

99

guint plymouth_is_running : 1;

100

#endif

101

};

102

103

enum {

104

PROP_0,

105

};

106

107

static void gdm_simple_slave_class_init (GdmSimpleSlaveClass *klass);

108

static void gdm_simple_slave_init (GdmSimpleSlave *simple_slave);

109

static void gdm_simple_slave_finalize (GObject *object);

110

static void gdm_simple_slave_open_reauthentication_channel (GdmSlave *slave,

111

const char *username,

112

GPid pid_of_caller,

113

uid_t uid_of_caller,

114

GAsyncReadyCallback callback,

115

gpointer user_data,

116

GCancellable *cancellable);

117

118

G_DEFINE_TYPE (GdmSimpleSlave, gdm_simple_slave, GDM_TYPE_SLAVE)

119

120

static void create_new_session (GdmSimpleSlave *slave);

121

static void start_session (GdmSimpleSlave *slave);

122

static void queue_start_session (GdmSimpleSlave *slave,

123

const char *service_name);

124

125

static void

126

on_session_started (GdmSession *session,

127

const char *service_name,

128

int pid,

129

GdmSimpleSlave *slave)

130

{

131

char *username;

132

char *session_id;

133

134

g_debug ("GdmSimpleSlave: session started %d", pid);

135

136

slave->priv->session_is_running = TRUE;

137

138

session_id = gdm_session_get_session_id (session);

139

g_object_set (GDM_SLAVE (slave), "session-id", session_id, NULL);

140

g_free (session_id);

141

142

/* Run the PreSession script. gdmslave suspends until script has terminated */

143

username = gdm_session_get_username (slave->priv->session);

144

if (username != NULL) {

145

gdm_slave_run_script (GDM_SLAVE (slave), GDMCONFDIR "/PreSession", username);

146

}

147

g_free (username);

148

149

/* FIXME: should we do something here?

150

* Note that error return status from PreSession script should

151

* be ignored in the case of a X-GDM-BypassXsession session, which can

152

* be checked by calling:

153

* gdm_session_bypasses_xsession (session)

154

*/

155

}

156

157

#ifdef HAVE_LOGINDEVPERM

158

static void

159

gdm_simple_slave_grant_console_permissions (GdmSimpleSlave *slave)

160

{

161

char *username;

162

char *display_device;

163

struct passwd *passwd_entry;

164

165

username = gdm_session_get_username (slave->priv->session);

166

display_device = gdm_session_get_display_device (slave->priv->session);

167

168

if (username != NULL) {

169

gdm_get_pwent_for_name (username, &passwd_entry);

170

171

/*

172

* Only do logindevperm processing if /dev/console or

173

* a device associated with a VT

174

*/

175

if (display_device != NULL &&

176

(strncmp (display_device, "/dev/vt/", strlen ("/dev/vt/")) == 0 ||

177

strcmp (display_device, "/dev/console") == 0)) {

178

g_debug ("Logindevperm login for user %s, device %s",

179

username, display_device);

180

(void) di_devperm_login (display_device,

181

passwd_entry->pw_uid,

182

passwd_entry->pw_gid,

183

NULL);

184

slave->priv->use_logindevperm = TRUE;

185

}

186

}

187

188

if (!slave->priv->use_logindevperm) {

189

g_debug ("Not calling di_devperm_login login for user %s, device %s",

190

username, display_device);

191

}

192

}

193

194

static void

195

gdm_simple_slave_revoke_console_permissions (GdmSimpleSlave *slave)

196

{

197

char *username;

198

char *display_device;

199

200

username = gdm_session_get_username (slave->priv->session);

201

display_device = gdm_session_get_display_device (slave->priv->session);

202

203

/*

204

* Only do logindevperm processing if /dev/console or a device

205

* associated with a VT. Do this after processing the PostSession

206

* script so that permissions for devices are not returned to root

207

* before running the script.

208

*/

209

if (slave->priv->use_logindevperm == TRUE &&

210

display_device != NULL &&

211

(strncmp (display_device, "/dev/vt/", strlen ("/dev/vt/")) == 0 ||

212

strcmp (display_device, "/dev/console") == 0)) {

213

g_debug ("di_devperm_logout for user %s, device %s",

214

username, display_device);

215

(void) di_devperm_logout (display_device);

216

slave->priv->use_logindevperm = FALSE;

217

} else {

218

g_debug ("Not calling di_devperm_logout logout for user %s, device %s",

219

username, display_device);

220

}

221

222

g_free (username);

223

g_free (display_device);

224

}

225

#endif /* HAVE_LOGINDEVPERM */

226

227

static void

228

on_session_exited (GdmSession *session,

229

int exit_code,

230

GdmSimpleSlave *slave)

231

{

232

g_object_set (GDM_SLAVE (slave), "session-id", NULL, NULL);

233

234

g_debug ("GdmSimpleSlave: session exited with code %d\n", exit_code);

235

gdm_slave_stop (GDM_SLAVE (slave));

236

}

237

238

static void

239

on_session_died (GdmSession *session,

240

int signal_number,

241

GdmSimpleSlave *slave)

242

{

243

g_object_set (GDM_SLAVE (slave), "session-id", NULL, NULL);

244

245

g_debug ("GdmSimpleSlave: session died with signal %d, (%s)",

246

signal_number,

247

g_strsignal (signal_number));

248

gdm_slave_stop (GDM_SLAVE (slave));

249

}

250

251

static gboolean

252

add_user_authorization (GdmSimpleSlave *slave,

253

char **filename)

254

{

255

char *username;

256

gboolean ret;

257

258

username = gdm_session_get_username (slave->priv->session);

259

ret = gdm_slave_add_user_authorization (GDM_SLAVE (slave),

260

username,

261

filename);

262

g_free (username);

263

264

return ret;

265

}

266

267

static void

268

reset_session (GdmSimpleSlave *slave)

269

{

270

if (slave->priv->session == NULL) {

271

return;

272

}

273

274

gdm_session_reset (slave->priv->session);

275

}

276

277

static gboolean

278

greeter_reset_timeout (GdmSimpleSlave *slave)

279

{

280

g_debug ("GdmSimpleSlave: resetting greeter");

281

282

reset_session (slave);

283

284

slave->priv->greeter_reset_id = 0;

285

return FALSE;

286

}

287

288

static void

289

queue_greeter_reset (GdmSimpleSlave *slave)

290

{

291

if (slave->priv->greeter_reset_id > 0) {

292

return;

293

}

294

295

slave->priv->greeter_reset_id = g_idle_add ((GSourceFunc)greeter_reset_timeout, slave);

296

}

297

298

static void

299

gdm_simple_slave_start_session_when_ready (GdmSimpleSlave *slave,

300

const char *service_name)

301

{

302

if (slave->priv->start_session_when_ready) {

303

slave->priv->waiting_to_start_session = FALSE;

304

queue_start_session (slave, service_name);

305

} else {

306

slave->priv->waiting_to_start_session = TRUE;

307

}

308

}

309

310

static gboolean

311

try_migrate_session (GdmSimpleSlave *slave)

312

{

313

char *username;

314

gboolean res;

315

316

g_debug ("GdmSimpleSlave: trying to migrate session");

317

318

username = gdm_session_get_username (slave->priv->session);

319

320

/* try to switch to an existing session */

321

res = gdm_slave_switch_to_user_session (GDM_SLAVE (slave), username);

322

g_free (username);

323

324

return res;

325

}

326

327

static void

328

stop_greeter (GdmSimpleSlave *slave)

329

{

330

char *username;

331

gboolean script_successful;

332

333

g_debug ("GdmSimpleSlave: Stopping greeter");

334

335

if (slave->priv->greeter_environment == NULL) {

336

g_debug ("GdmSimpleSlave: No greeter running");

337

return;

338

}

339

340

/* Run the PostLogin script. gdmslave suspends until script has terminated */

341

username = NULL;

342

if (slave->priv->session != NULL) {

343

username = gdm_session_get_username (slave->priv->session);

344

}

345

346

if (username != NULL) {

347

script_successful = gdm_slave_run_script (GDM_SLAVE (slave), GDMCONFDIR "/PostLogin", username);

348

} else {

349

script_successful = TRUE;

350

}

351

g_free (username);

352

353

if (!script_successful) {

354

g_debug ("GdmSimpleSlave: PostLogin script unsuccessful");

355

356

slave->priv->start_session_id = 0;

357

queue_greeter_reset (slave);

358

return;

359

}

360

361

gdm_launch_environment_stop (GDM_LAUNCH_ENVIRONMENT (slave->priv->greeter_environment));

362

}

363

364

static void

365

start_session (GdmSimpleSlave *slave)

366

{

367

char *auth_file;

368

369

auth_file = NULL;

370

add_user_authorization (slave, &auth_file);

371

372

g_assert (auth_file != NULL);

373

374

g_object_set (slave->priv->session,

375

"user-x11-authority-file", auth_file,

376

NULL);

377

378

g_free (auth_file);

379

380

gdm_session_start_session (slave->priv->session,

381

slave->priv->start_session_service_name);

382

383

slave->priv->start_session_id = 0;

384

g_free (slave->priv->start_session_service_name);

385

slave->priv->start_session_service_name = NULL;

386

}

387

388

static gboolean

389

start_session_timeout (GdmSimpleSlave *slave)

390

{

391

gboolean migrated;

392

393

394

g_debug ("GdmSimpleSlave: accredited");

395

396

migrated = try_migrate_session (slave);

397

g_debug ("GdmSimpleSlave: migrated: %d", migrated);

398

if (migrated) {

399

/* We don't stop the slave here because

400

when Xorg exits it switches to the VT it was

401

started from. That interferes with fast

402

user switching. */

403

gdm_session_reset (slave->priv->session);

404

405

slave->priv->start_session_id = 0;

406

g_free (slave->priv->start_session_service_name);

407

slave->priv->start_session_service_name = NULL;

408

} else {

409

if (slave->priv->greeter_environment == NULL) {

410

/* auto login */

411

start_session (slave);

412

} else {

413

/* Session actually gets started from on_greeter_environment_session_stop */

414

stop_greeter (slave);

415

}

416

}

417

418

return FALSE;

419

}

420

421

static void

422

queue_start_session (GdmSimpleSlave *slave,

423

const char *service_name)

424

{

425

if (slave->priv->start_session_id > 0) {

426

return;

427

}

428

429

slave->priv->start_session_id = g_idle_add ((GSourceFunc)start_session_timeout, slave);

430

slave->priv->start_session_service_name = g_strdup (service_name);

431

}

432

433

static void

434

on_session_reauthenticated (GdmSession *session,

435

const char *service_name,

436

GdmSimpleSlave *slave)

437

{

438

try_migrate_session (slave);

439

}

440

441

static void

442

on_session_opened (GdmSession *session,

443

const char *service_name,

444

const char *session_id,

445

GdmSimpleSlave *slave)

446

{

447

448

#ifdef HAVE_LOGINDEVPERM

449

gdm_simple_slave_grant_console_permissions (slave);

450

#endif /* HAVE_LOGINDEVPERM */

451

452

if (gdm_session_client_is_connected (slave->priv->session)) {

453

gdm_simple_slave_start_session_when_ready (slave, service_name);

454

} else {

455

/* Auto login */

456

slave->priv->start_session_when_ready = TRUE;

457

gdm_simple_slave_start_session_when_ready (slave, service_name);

458

}

459

}

460

461

static void

462

on_session_conversation_started (GdmSession *session,

463

const char *service_name,

464

GdmSimpleSlave *slave)

465

{

466

gboolean enabled;

467

char *username;

468

int delay;

469

470

471

g_debug ("GdmSimpleSlave: session conversation started");

472

enabled = FALSE;

473

gdm_slave_get_timed_login_details (GDM_SLAVE (slave), &enabled, &username, &delay);

474

if (! enabled) {

475

return;

476

}

477

478

if (delay == 0) {

479

g_debug ("GdmSimpleSlave: begin auto login for user '%s'", username);

480

/* service_name will be "gdm-autologin"

481

*/

482

gdm_session_setup_for_user (slave->priv->session, service_name, username);

483

}

484

485

g_free (username);

486

}

487

488

static void

489

on_session_conversation_stopped (GdmSession *session,

490

const char *service_name,

491

GdmSimpleSlave *slave)

492

{

493

g_debug ("GdmSimpleSlave: conversation stopped");

494

495

}

496

497

static void

498

start_autologin_conversation_if_necessary (GdmSimpleSlave *slave)

499

{

500

gboolean enabled;

501

502

gdm_slave_get_timed_login_details (GDM_SLAVE (slave), &enabled, NULL, NULL);

503

504

if (!enabled) {

505

return;

506

}

507

508

g_debug ("GdmSimpleSlave: Starting automatic login conversation");

509

gdm_session_start_conversation (slave->priv->session, "gdm-autologin");

510

}

511

512

static void

513

on_session_reauthentication_started (GdmSession *session,

514

int pid_of_caller,

515

const char *address,

516

GdmSimpleSlave *slave)

517

{

518

GSimpleAsyncResult *result;

519

gpointer source_tag;

520

521

g_debug ("GdmSimpleSlave: reauthentication started");

522

523

source_tag = GINT_TO_POINTER (pid_of_caller);

524

525

result = g_hash_table_lookup (slave->priv->open_reauthentication_requests,

526

source_tag);

527

528

if (result != NULL) {

529

g_simple_async_result_set_op_res_gpointer (result,

530

g_strdup (address),

531

(GDestroyNotify)

532

g_free);

533

g_simple_async_result_complete_in_idle (result);

534

}

535

536

g_hash_table_remove (slave->priv->open_reauthentication_requests,

537

source_tag);

538

}

539

540

static void

541

on_session_client_ready_for_session_to_start (GdmSession *session,

542

const char *service_name,

543

gboolean client_is_ready,

544

GdmSimpleSlave *slave)

545

{

546

if (client_is_ready) {

547

g_debug ("GdmSimpleSlave: Will start session when ready");

548

} else {

549

g_debug ("GdmSimpleSlave: Will start session when ready and told");

550

}

551

552

if (slave->priv->greeter_reset_id > 0) {

553

return;

554

}

555

556

slave->priv->start_session_when_ready = client_is_ready;

557

558

if (client_is_ready && slave->priv->waiting_to_start_session) {

559

gdm_simple_slave_start_session_when_ready (slave, service_name);

560

}

561

}

562

563

static void

564

on_ready_to_request_timed_login (GdmSession *session,

565

GSimpleAsyncResult *result,

566

gpointer *user_data)

567

{

568

int delay = GPOINTER_TO_INT (user_data);

569

GCancellable *cancellable;

570

char *username;

571

572

cancellable = g_object_get_data (G_OBJECT (result),

573

"cancellable");

574

if (g_cancellable_is_cancelled (cancellable)) {

575

return;

576

}

577

578

username = g_simple_async_result_get_source_tag (result);

579

580

gdm_session_request_timed_login (session, username, delay);

581

582

g_object_weak_unref (G_OBJECT (session),

583

(GWeakNotify)

584

g_cancellable_cancel,

585

cancellable);

586

g_object_weak_unref (G_OBJECT (session),

587

(GWeakNotify)

588

g_object_unref,

589

cancellable);

590

g_object_weak_unref (G_OBJECT (session),

591

(GWeakNotify)

592

g_free,

593

username);

594

595

g_free (username);

596

}

597

598

static gboolean

599

on_wait_for_greeter_timeout (GSimpleAsyncResult *result)

600

{

601

g_simple_async_result_complete (result);

602

603

return FALSE;

604

}

605

606

static void

607

on_session_client_connected (GdmSession *session,

608

GCredentials *credentials,

609

GPid pid_of_client,

610

GdmSimpleSlave *slave)

611

{

612

gboolean timed_login_enabled;

613

char *username;

614

int delay;

615

gboolean display_is_local;

616

617

g_debug ("GdmSimpleSlave: client connected");

618

619

g_object_get (slave,

620

"display-is-local", &display_is_local,

621

NULL);

622

623

/* If XDMCP stop pinging */

624

if ( ! display_is_local) {

625

alarm (0);

626

}

627

628

timed_login_enabled = FALSE;

629

gdm_slave_get_timed_login_details (GDM_SLAVE (slave), &timed_login_enabled, &username, &delay);

630

631

if (! timed_login_enabled) {

632

return;

633

}

634

635

/* temporary hack to fix timed login

636

* http://bugzilla.gnome.org/680348

637

*/

638

if (delay > 0) {

639

GSimpleAsyncResult *result;

640

GCancellable *cancellable;

641

guint timeout_id;

642

gpointer source_tag;

643

644

delay = MAX (delay, 4);

645

646

cancellable = g_cancellable_new ();

647

source_tag = g_strdup (username);

648

result = g_simple_async_result_new (G_OBJECT (session),

649

(GAsyncReadyCallback)

650

on_ready_to_request_timed_login,

651

GINT_TO_POINTER (delay),

652

source_tag);

653

g_simple_async_result_set_check_cancellable (result, cancellable);

654

g_object_set_data (G_OBJECT (result),

655

"cancellable",

656

cancellable);

657

658

timeout_id = g_timeout_add_seconds_full (delay - 2,

659

G_PRIORITY_DEFAULT,

660

(GSourceFunc)

661

on_wait_for_greeter_timeout,

662

g_object_ref (result),

663

(GDestroyNotify)

664

g_object_unref);

665

g_cancellable_connect (cancellable,

666

G_CALLBACK (g_source_remove),

667

GINT_TO_POINTER (timeout_id),

668

NULL);

669

670

g_object_weak_ref (G_OBJECT (session),

671

(GWeakNotify)

672

g_cancellable_cancel,

673

cancellable);

674

g_object_weak_ref (G_OBJECT (session),

675

(GWeakNotify)

676

g_object_unref,

677

cancellable);

678

g_object_weak_ref (G_OBJECT (session),

679

(GWeakNotify)

680

g_free,

681

source_tag);

682

}

683

684

g_free (username);

685

}

686

687

static void

688

on_session_client_disconnected (GdmSession *session,

689

GCredentials *credentials,

690

GPid pid_of_client,

691

GdmSimpleSlave *slave)

692

{

693

gboolean display_is_local;

694

695

g_debug ("GdmSimpleSlave: client disconnected");

696

697

g_object_get (slave,

698

"display-is-local", &display_is_local,

699

NULL);

700

701

if ( ! display_is_local && !slave->priv->session_is_running) {

702

gdm_slave_stop (GDM_SLAVE (slave));

703

}

704

}

705

706

static void

707

on_session_cancelled (GdmSession *session,

708

GdmSimpleSlave *slave)

709

{

710

g_debug ("GdmSimpleSlave: Session was cancelled");

711

queue_greeter_reset (slave);

712

}

713

714

static void

715

create_new_session (GdmSimpleSlave *slave)

716

{

717

gboolean display_is_local;

718

char *display_id;

719

char *display_name;

720

char *display_hostname;

721

char *display_device;

722

char *display_seat_id;

723

char *display_x11_authority_file;

724

GdmSession *greeter_session;

725

uid_t greeter_uid;

726

727

g_debug ("GdmSimpleSlave: Creating new session");

728

729

if (slave->priv->greeter_environment != NULL) {

730

greeter_session = gdm_launch_environment_get_session (GDM_LAUNCH_ENVIRONMENT (slave->priv->greeter_environment));

731

greeter_uid = gdm_session_get_allowed_user (greeter_session);

732

} else {

733

greeter_uid = 0;

734

}

735

736

g_object_get (slave,

737

"display-id", &display_id,

738

"display-name", &display_name,

739

"display-hostname", &display_hostname,

740

"display-is-local", &display_is_local,

741

"display-x11-authority-file", &display_x11_authority_file,

742

"display-seat-id", &display_seat_id,

743

NULL);

744

745

display_device = NULL;

746

if (slave->priv->server != NULL) {

747

display_device = gdm_server_get_display_device (slave->priv->server);

748

}

749

750

slave->priv->session = gdm_session_new (GDM_SESSION_VERIFICATION_MODE_LOGIN,

751

greeter_uid,

752

display_name,

753

display_hostname,

754

display_device,

755

display_seat_id,

756

display_x11_authority_file,

757

display_is_local,

758

NULL);

759

760

g_free (display_id);

761

g_free (display_name);

762

g_free (display_device);

763

g_free (display_hostname);

764

765

g_signal_connect (slave->priv->session,

766

"reauthentication-started",

767

G_CALLBACK (on_session_reauthentication_started),

768

slave);

769

g_signal_connect (slave->priv->session,

770

"reauthenticated",

771

G_CALLBACK (on_session_reauthenticated),

772

slave);

773

g_signal_connect (slave->priv->session,

774

"client-ready-for-session-to-start",

775

G_CALLBACK (on_session_client_ready_for_session_to_start),

776

slave);

777

g_signal_connect (slave->priv->session,

778

"client-connected",

779

G_CALLBACK (on_session_client_connected),

780

slave);

781

g_signal_connect (slave->priv->session,

782

"client-disconnected",

783

G_CALLBACK (on_session_client_disconnected),

784

slave);

785

g_signal_connect (slave->priv->session,

786

"cancelled",

787

G_CALLBACK (on_session_cancelled),

788

slave);

789

g_signal_connect (slave->priv->session,

790

"conversation-started",

791

G_CALLBACK (on_session_conversation_started),

792

slave);

793

g_signal_connect (slave->priv->session,

794

"conversation-stopped",

795

G_CALLBACK (on_session_conversation_stopped),

796

slave);

797

g_signal_connect (slave->priv->session,

798

"session-opened",

799

G_CALLBACK (on_session_opened),

800

slave);

801

g_signal_connect (slave->priv->session,

802

"session-started",

803

G_CALLBACK (on_session_started),

804

slave);

805

g_signal_connect (slave->priv->session,

806

"session-exited",

807

G_CALLBACK (on_session_exited),

808

slave);

809

g_signal_connect (slave->priv->session,

810

"session-died",

811

G_CALLBACK (on_session_died),

812

slave);

813

814

start_autologin_conversation_if_necessary (slave);

815

}

816

817

static void

818

on_greeter_environment_session_opened (GdmLaunchEnvironment *greeter_environment,

819

GdmSimpleSlave *slave)

820

{

821

char *session_id;

822

823

g_debug ("GdmSimpleSlave: Greeter session opened");

824

session_id = gdm_launch_environment_get_session_id (GDM_LAUNCH_ENVIRONMENT (greeter_environment));

825

826

g_object_set (GDM_SLAVE (slave), "session-id", session_id, NULL);

827

g_free (session_id);

828

}

829

830

static void

831

on_greeter_environment_session_started (GdmLaunchEnvironment *greeter_environment,

832

GdmSimpleSlave *slave)

833

{

834

g_debug ("GdmSimpleSlave: Greeter started");

835

}

836

837

static void

838

on_greeter_environment_session_stopped (GdmLaunchEnvironment *greeter_environment,

839

GdmSimpleSlave *slave)

840

{

841

g_debug ("GdmSimpleSlave: Greeter stopped");

842

if (slave->priv->start_session_service_name == NULL) {

843

gdm_slave_stop (GDM_SLAVE (slave));

844

} else {

845

start_session (slave);

846

}

847

848

g_object_unref (slave->priv->greeter_environment);

849

slave->priv->greeter_environment = NULL;

850

}

851

852

static void

853

on_greeter_environment_session_exited (GdmLaunchEnvironment *greeter_environment,

854

int code,

855

GdmSimpleSlave *slave)

856

{

857

g_debug ("GdmSimpleSlave: Greeter exited: %d", code);

858

if (slave->priv->start_session_service_name == NULL) {

859

gdm_slave_stop (GDM_SLAVE (slave));

860

}

861

}

862

863

static void

864

on_greeter_environment_session_died (GdmLaunchEnvironment *greeter_environment,

865

int signal,

866

GdmSimpleSlave *slave)

867

{

868

g_debug ("GdmSimpleSlave: Greeter died: %d", signal);

869

if (slave->priv->start_session_service_name == NULL) {

870

gdm_slave_stop (GDM_SLAVE (slave));

871

}

872

}

873

874

#ifdef WITH_PLYMOUTH

875

static gboolean

876

plymouth_is_running (void)

877

{

878

int status;

879

gboolean res;

880

GError *error;

881

882

error = NULL;

883

res = g_spawn_command_line_sync ("/bin/plymouth --ping",

884

NULL, NULL, &status, &error);

885

if (! res) {

886

g_debug ("Could not ping plymouth: %s", error->message);

887

g_error_free (error);

888

return FALSE;

889

}

890

891

return WIFEXITED (status) && WEXITSTATUS (status) == 0;

892

}

893

894

static void

895

plymouth_prepare_for_transition (GdmSimpleSlave *slave)

896

{

897

gboolean res;

898

GError *error;

899

900

error = NULL;

901

res = g_spawn_command_line_sync ("/bin/plymouth deactivate",

902

NULL, NULL, NULL, &error);

903

if (! res) {

904

g_warning ("Could not deactivate plymouth: %s", error->message);

905

g_error_free (error);

906

}

907

}

908

909

static void

910

plymouth_quit_with_transition (GdmSimpleSlave *slave)

911

{

912

gboolean res;

913

GError *error;

914

915

error = NULL;

916

res = g_spawn_command_line_sync ("/bin/plymouth quit --retain-splash",

917

NULL, NULL, NULL, &error);

918

if (! res) {

919

g_warning ("Could not quit plymouth: %s", error->message);

920

g_error_free (error);

921

}

922

slave->priv->plymouth_is_running = FALSE;

923

}

924

925

static void

926

plymouth_quit_without_transition (GdmSimpleSlave *slave)

927

{

928

gboolean res;

929

GError *error;

930

931

error = NULL;

932

res = g_spawn_command_line_sync ("/bin/plymouth quit",

933

NULL, NULL, NULL, &error);

934

if (! res) {

935

g_warning ("Could not quit plymouth: %s", error->message);

936

g_error_free (error);

937

}

938

slave->priv->plymouth_is_running = FALSE;

939

}

940

#endif

941

942

static void

943

setup_server (GdmSimpleSlave *slave)

944

{

945

/* Put cursor out of the way on first head */

946

gdm_slave_set_initial_cursor_position (GDM_SLAVE (slave));

947

948

/* Set the busy cursor */

949

gdm_slave_set_busy_cursor (GDM_SLAVE (slave));

950

951

/* The root window has a background that may be useful

952

* to cross fade or transition from when setting the

953

* login screen background. We read it here, and stuff

954

* it into the standard _XROOTPMAP_ID root window property,

955

* so gnome-settings-daemon can get at it.

956

*/

957

gdm_slave_save_root_windows (GDM_SLAVE (slave));

958

959

#ifdef WITH_PLYMOUTH

960

/* Plymouth is waiting for the go-ahead to exit */

961

if (slave->priv->plymouth_is_running) {

962

plymouth_quit_with_transition (slave);

963

}

964

#endif

965

}

966

967

static GdmLaunchEnvironment *

968

create_environment (const char *session_id,

969

const char *user_name,

970

const char *display_name,

971

const char *seat_id,

972

const char *display_device,

973

const char *display_hostname,

974

gboolean display_is_local)

975

{

976

gboolean debug = FALSE;

977

char *command;

978

GdmLaunchEnvironment *launch_environment;

979

char **argv;

980

GPtrArray *args;

981

982

gdm_settings_direct_get_boolean (GDM_KEY_DEBUG, &debug);

983

984

args = g_ptr_array_new ();

985

g_ptr_array_add (args, BINDIR "/gnome-session");

986

987

g_ptr_array_add (args, "--autostart");

988

g_ptr_array_add (args, DATADIR "/gdm/greeter/autostart");

989

990

if (debug) {

991

g_ptr_array_add (args, "--debug");

992

}

993

994

if (session_id != NULL) {

995

g_ptr_array_add (args, " --session");

996

g_ptr_array_add (args, (char *) session_id);

997

}

998

999

g_ptr_array_add (args, NULL);

1000

1001

argv = (char **) g_ptr_array_free (args, FALSE);

1002

command = g_strjoinv (" ", argv);

1003

g_free (argv);

1004

1005

launch_environment = g_object_new (GDM_TYPE_LAUNCH_ENVIRONMENT,

1006

"command", command,

1007

"user-name", user_name,

1008

"x11-display-name", display_name,

1009

"x11-display-seat-id", seat_id,

1010

"x11-display-device", display_device,

1011

"x11-display-hostname", display_hostname,

1012

"x11-display-is-local", display_is_local,

1013

"runtime-dir", GDM_SCREENSHOT_DIR,

1014

NULL);

1015

1016

g_free (command);

1017

return launch_environment;

1018

}

1019

1020

static void

1021

start_launch_environment (GdmSimpleSlave *slave,

1022

char *username,

1023

char *session_id)

1024

{

1025

gboolean display_is_local;

1026

char *display_id;

1027

char *display_name;

1028

char *seat_id;

1029

char *display_device;

1030

char *display_hostname;

1031

char *auth_file;

1032

gboolean res;

1033

1034

g_debug ("GdmSimpleSlave: Running greeter");

1035

1036

display_is_local = FALSE;

1037

display_id = NULL;

1038

display_name = NULL;

1039

seat_id = NULL;

1040

auth_file = NULL;

1041

display_device = NULL;

1042

display_hostname = NULL;

1043

1044

g_object_get (slave,

1045

"display-id", &display_id,

1046

"display-is-local", &display_is_local,

1047

"display-name", &display_name,

1048

"display-seat-id", &seat_id,

1049

"display-hostname", &display_hostname,

1050

"display-x11-authority-file", &auth_file,

1051

NULL);

1052

1053

g_debug ("GdmSimpleSlave: Creating greeter for %s %s", display_name, display_hostname);

1054

1055

if (slave->priv->server != NULL) {

1056

display_device = gdm_server_get_display_device (slave->priv->server);

1057

}

1058

1059

/* FIXME: send a signal back to the master */

1060

1061

/* If XDMCP setup pinging */

1062

slave->priv->ping_interval = DEFAULT_PING_INTERVAL;

1063

res = gdm_settings_direct_get_int (GDM_KEY_PING_INTERVAL,

1064

&(slave->priv->ping_interval));

1065

1066

if ( ! display_is_local && res && slave->priv->ping_interval > 0) {

1067

alarm (slave->priv->ping_interval);

1068

}

1069

1070

/* Run the init script. gdmslave suspends until script has terminated */

1071

gdm_slave_run_script (GDM_SLAVE (slave), GDMCONFDIR "/Init", GDM_USERNAME);

1072

1073

g_debug ("GdmSimpleSlave: Creating greeter on %s %s %s", display_name, display_device, display_hostname);

1074

slave->priv->greeter_environment = create_environment (session_id,

1075

username,

1076

display_name,

1077

seat_id,

1078

display_device,

1079

display_hostname,

1080

display_is_local);

1081

g_signal_connect (slave->priv->greeter_environment,

1082

"opened",

1083

G_CALLBACK (on_greeter_environment_session_opened),

1084

slave);

1085

g_signal_connect (slave->priv->greeter_environment,

1086

"started",

1087

G_CALLBACK (on_greeter_environment_session_started),

1088

slave);

1089

g_signal_connect (slave->priv->greeter_environment,

1090

"stopped",

1091

G_CALLBACK (on_greeter_environment_session_stopped),

1092

slave);

1093

g_signal_connect (slave->priv->greeter_environment,

1094

"exited",

1095

G_CALLBACK (on_greeter_environment_session_exited),

1096

slave);

1097

g_signal_connect (slave->priv->greeter_environment,

1098

"died",

1099

G_CALLBACK (on_greeter_environment_session_died),

1100

slave);

1101

g_object_set (slave->priv->greeter_environment,

1102

"x11-authority-file", auth_file,

1103

NULL);

1104

1105

gdm_launch_environment_start (GDM_LAUNCH_ENVIRONMENT (slave->priv->greeter_environment));

1106

1107

g_free (display_id);

1108

g_free (display_name);

1109

g_free (seat_id);

1110

g_free (display_device);

1111

g_free (display_hostname);

1112

g_free (auth_file);

1113

}

1114

1115

static void

1116

start_greeter (GdmSimpleSlave *slave)

1117

{

1118

start_launch_environment (slave, GDM_USERNAME, NULL);

1119

}

1120

1121

#define RULES_DIR LOCALSTATEDIR "/lib/polkit-1/localauthority/10-vendor.d/"

1122

#define RULES_FILE "20-gnome-initial-setup.rules"

1123

1124

static const gboolean

1125

create_initial_setup_user (GdmSimpleSlave *slave)

1126

{

1127

gboolean ret = TRUE;

1128

ActUserManager *act;

1129

ActUser *user;

1130

GFile *src_file, *dest_file;

1131

GError *error = NULL;

1132

const char *e = NULL;

1133

1134

/* First, create the user */

1135

act = act_user_manager_get_default ();

1136

1137

user = act_user_manager_create_user (act, INITIAL_SETUP_USERNAME, "", 0, &error);

1138

if (user == NULL) {

1139

if (g_dbus_error_is_remote_error (error)) {

1140

e = g_dbus_error_get_remote_error (error);

1141

}

1142

1143

g_warning ("Creating user '%s' failed: %s / %s",

1144

INITIAL_SETUP_USERNAME, e, error->message);

1145

1146

if (g_strcmp0 (e, "org.freedesktop.Accounts.Error.UserExists") != 0) {

1147

ret = FALSE;

1148

goto out;

1149

}

1150

} else {

1151

g_object_unref (user);

1152

}

1153

1154

/* Now, make sure the PolicyKit policy is in place */

1155

src_file = g_file_new_for_path (DATADIR "/gnome-initial-setup" RULES_FILE);

1156

dest_file = g_file_new_for_path (RULES_DIR RULES_FILE);

1157

1158

if (!g_file_copy (src_file,

1159

dest_file,

1160

G_FILE_COPY_OVERWRITE,

1161

NULL, NULL, NULL, &error)) {

1162

g_warning ("Failed to copy '%s' to '%s': %s",

1163

g_file_get_path (src_file),

1164

g_file_get_path (dest_file),

1165

error->message);

1166

ret = FALSE;

1167

goto out_clear_files;

1168

}

1169

1170

out_clear_files:

1171

g_object_unref (src_file);

1172

g_object_unref (dest_file);

1173

1174

out:

1175

g_clear_pointer (&e, g_free);

1176

g_clear_error (&error);

1177

return ret;

1178

}

1179

1180

static void

1181

destroy_initial_setup_user (GdmSimpleSlave *slave)

1182

{

1183

ActUserManager *act;

1184

ActUser *user;

1185

const char *filename;

1186

GError *error;

1187

1188

filename = RULES_DIR RULES_FILE;

1189

1190

if (g_remove (filename) < 0) {

1191

g_warning ("Failed to remove '%s': %s", filename, g_strerror (errno));

1192

}

1193

1194

act = act_user_manager_get_default ();

1195

1196

error = NULL;

1197

user = act_user_manager_get_user (act, INITIAL_SETUP_USERNAME);

1198

if (!act_user_manager_delete_user (act, user, TRUE, &error)) {

1199

g_warning ("Failed to delete user '%s': %s", INITIAL_SETUP_USERNAME, error->message);

1200

g_error_free (error);

1201

}

1202

1203

g_object_unref (user);

1204

}

1205

1206

static void

1207

start_initial_setup (GdmSimpleSlave *slave)

1208

{

1209

create_initial_setup_user (slave);

1210

start_launch_environment (slave, INITIAL_SETUP_USERNAME, "gnome-initial-setup");

1211

destroy_initial_setup_user (slave);

1212

}

1213

1214

static gboolean

1215

wants_autologin (GdmSimpleSlave *slave)

1216

{

1217

gboolean enabled = FALSE;

1218

int delay = 0;

1219

/* FIXME: handle wait-for-go */

1220

1221

gdm_slave_get_timed_login_details (GDM_SLAVE (slave), &enabled, NULL, &delay);

1222

return enabled && delay == 0;

1223

}

1224

1225

#define INITIAL_SETUP_TRIGGER_FILE LOCALSTATEDIR "/lib/gdm/run-initial-setup"

1226

1227

static gboolean

1228

wants_initial_setup (GdmSimpleSlave *slave)

1229

{

1230

gboolean enabled;

1231

1232

if (!g_file_test (INITIAL_SETUP_TRIGGER_FILE, G_FILE_TEST_EXISTS)) {

1233

return FALSE;

1234

}

1235

1236

if (!gdm_settings_direct_get_boolean (GDM_KEY_INITIAL_SETUP_ENABLE, &enabled)) {

1237

return FALSE;

1238

}

1239

1240

if (!enabled) {

1241

return FALSE;

1242

}

1243

1244

return TRUE;

1245

}

1246

1247

static gboolean

1248

idle_connect_to_display (GdmSimpleSlave *slave)

1249

{

1250

gboolean res;

1251

1252

slave->priv->connection_attempts++;

1253

1254

res = gdm_slave_connect_to_x11_display (GDM_SLAVE (slave));

1255

if (res) {

1256

setup_server (slave);

1257

1258

if (wants_initial_setup (slave)) {

1259

start_initial_setup (slave);

1260

} else if (wants_autologin (slave)) {

1261

/* Run the init script. gdmslave suspends until script has terminated */

1262

gdm_slave_run_script (GDM_SLAVE (slave), GDMCONFDIR "/Init", GDM_USERNAME);

1263

} else {

1264

start_greeter (slave);

1265

}

1266

create_new_session (slave);

1267

} else {

1268

if (slave->priv->connection_attempts >= MAX_CONNECT_ATTEMPTS) {

1269

g_warning ("Unable to connect to display after %d tries - bailing out", slave->priv->connection_attempts);

1270

exit (1);

1271

}

1272

return TRUE;

1273

}

1274

1275

return FALSE;

1276

}

1277

1278

static void

1279

on_server_ready (GdmServer *server,

1280

GdmSimpleSlave *slave)

1281

{

1282

g_idle_add ((GSourceFunc)idle_connect_to_display, slave);

1283

}

1284

1285

static void

1286

on_server_exited (GdmServer *server,

1287

int exit_code,

1288

GdmSimpleSlave *slave)

1289

{

1290

g_debug ("GdmSimpleSlave: server exited with code %d\n", exit_code);

1291

1292

gdm_slave_stop (GDM_SLAVE (slave));

1293

1294

#ifdef WITH_PLYMOUTH

1295

if (slave->priv->plymouth_is_running) {

1296

plymouth_quit_without_transition (slave);

1297

}

1298

#endif

1299

}

1300

1301

static void

1302

on_server_died (GdmServer *server,

1303

int signal_number,

1304

GdmSimpleSlave *slave)

1305

{

1306

g_debug ("GdmSimpleSlave: server died with signal %d, (%s)",

1307

signal_number,

1308

g_strsignal (signal_number));

1309

1310

gdm_slave_stop (GDM_SLAVE (slave));

1311

1312

#ifdef WITH_PLYMOUTH

1313

if (slave->priv->plymouth_is_running) {

1314

plymouth_quit_without_transition (slave);

1315

}

1316

#endif

1317

}

1318

1319

static gboolean

1320

gdm_simple_slave_run (GdmSimpleSlave *slave)

1321

{

1322

char *display_name;

1323

char *auth_file;

1324

char *seat_id;

1325

gboolean display_is_local;

1326

gboolean display_is_initial;

1327

1328

g_object_get (slave,

1329

"display-is-local", &display_is_local,

1330

"display-name", &display_name,

1331

"display-seat-id", &seat_id,

1332

"display-x11-authority-file", &auth_file,

1333

"display-is-initial", &display_is_initial,

1334

NULL);

1335

1336

/* if this is local display start a server if one doesn't

1337

* exist */

1338

if (display_is_local) {

1339

gboolean res;

1340

gboolean disable_tcp;

1341

1342

slave->priv->server = gdm_server_new (display_name, seat_id, auth_file, display_is_initial);

1343

1344

disable_tcp = TRUE;

1345

if (gdm_settings_client_get_boolean (GDM_KEY_DISALLOW_TCP,

1346

&disable_tcp)) {

1347

g_object_set (slave->priv->server,

1348

"disable-tcp", disable_tcp,

1349

NULL);

1350

}

1351

1352

g_signal_connect (slave->priv->server,

1353

"exited",

1354

G_CALLBACK (on_server_exited),

1355

slave);

1356

g_signal_connect (slave->priv->server,

1357

"died",

1358

G_CALLBACK (on_server_died),

1359

slave);

1360

g_signal_connect (slave->priv->server,

1361

"ready",

1362

G_CALLBACK (on_server_ready),

1363

slave);

1364

1365

#ifdef WITH_PLYMOUTH

1366

slave->priv->plymouth_is_running = plymouth_is_running ();

1367

1368

if (slave->priv->plymouth_is_running) {

1369

plymouth_prepare_for_transition (slave);

1370

}

1371

#endif

1372

res = gdm_server_start (slave->priv->server);

1373

if (! res) {

1374

g_warning (_("Could not start the X "

1375

"server (your graphical environment) "

1376

"due to an internal error. "

1377

"Please contact your system administrator "

1378

"or check your syslog to diagnose. "

1379

"In the meantime this display will be "

1380

"disabled. Please restart GDM when "

1381

"the problem is corrected."));

1382

#ifdef WITH_PLYMOUTH

1383

if (slave->priv->plymouth_is_running) {

1384

plymouth_quit_without_transition (slave);

1385

}

1386

#endif

1387

exit (1);

1388

}

1389

1390

g_debug ("GdmSimpleSlave: Started X server");

1391

} else {

1392

g_timeout_add (500, (GSourceFunc)idle_connect_to_display, slave);

1393

}

1394

1395

g_free (display_name);

1396

g_free (auth_file);

1397

1398

return TRUE;

1399

}

1400

1401

static gboolean

1402

gdm_simple_slave_open_session (GdmSlave *slave,

1403

GPid pid_of_caller,

1404

uid_t uid_of_caller,

1405

char **address,

1406

GError **error)

1407

{

1408

GdmSimpleSlave *self = GDM_SIMPLE_SLAVE (slave);

1409

uid_t allowed_user;

1410

1411

if (self->priv->session_is_running) {

1412

g_set_error (error,

1413

G_DBUS_ERROR,

1414

G_DBUS_ERROR_ACCESS_DENIED,

1415

_("Can only be called before user is logged in"));

1416

return FALSE;

1417

}

1418

1419

allowed_user = gdm_session_get_allowed_user (self->priv->session);

1420

1421

if (uid_of_caller != allowed_user) {

1422

g_set_error (error,

1423

G_DBUS_ERROR,

1424

G_DBUS_ERROR_ACCESS_DENIED,

1425

_("Caller not GDM"));

1426

return FALSE;

1427

}

1428

1429

*address = gdm_session_get_server_address (self->priv->session);

1430

1431

return TRUE;

1432

}

1433

1434

static char *

1435

gdm_simple_slave_open_reauthentication_channel_finish (GdmSlave *slave,

1436

GAsyncResult *result,

1437

GError **error)

1438

{

1439

GdmSimpleSlave *self = GDM_SIMPLE_SLAVE (slave);

1440

const char *address;

1441

1442

g_return_val_if_fail (g_simple_async_result_is_valid (result,

1443

G_OBJECT (self),

1444

gdm_simple_slave_open_reauthentication_channel), NULL);

1445

1446

address = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));

1447

1448

if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) {

1449

return NULL;

1450

}

1451

1452

return g_strdup (address);

1453

}

1454

1455

static void

1456

gdm_simple_slave_open_reauthentication_channel (GdmSlave *slave,

1457

const char *username,

1458

GPid pid_of_caller,

1459

uid_t uid_of_caller,

1460

GAsyncReadyCallback callback,

1461

gpointer user_data,

1462

GCancellable *cancellable)

1463

{

1464

GdmSimpleSlave *self = GDM_SIMPLE_SLAVE (slave);

1465

GSimpleAsyncResult *result;

1466

1467

result = g_simple_async_result_new (G_OBJECT (slave),

1468

callback,

1469

user_data,

1470

gdm_simple_slave_open_reauthentication_channel);

1471

1472

g_simple_async_result_set_check_cancellable (result, cancellable);

1473

1474

if (!self->priv->session_is_running) {

1475

g_simple_async_result_set_error (result,

1476

G_DBUS_ERROR,

1477

G_DBUS_ERROR_ACCESS_DENIED,

1478

_("User not logged in"));

1479

g_simple_async_result_complete_in_idle (result);

1480

1481

} else {

1482

g_hash_table_insert (self->priv->open_reauthentication_requests,

1483

GINT_TO_POINTER (pid_of_caller),

1484

g_object_ref (result));

1485

1486

gdm_session_start_reauthentication (self->priv->session,

1487

pid_of_caller,

1488

uid_of_caller);

1489

}

1490

1491

g_object_unref (result);

1492

}

1493

1494

static gboolean

1495

gdm_simple_slave_start (GdmSlave *slave)

1496

{

1497

GDM_SLAVE_CLASS (gdm_simple_slave_parent_class)->start (slave);

1498

1499

gdm_simple_slave_run (GDM_SIMPLE_SLAVE (slave));

1500

1501

return TRUE;

1502

}

1503

1504

static gboolean

1505

gdm_simple_slave_stop (GdmSlave *slave)

1506

{

1507

GdmSimpleSlave *self = GDM_SIMPLE_SLAVE (slave);

1508

1509

g_debug ("GdmSimpleSlave: Stopping simple_slave");

1510

1511

GDM_SLAVE_CLASS (gdm_simple_slave_parent_class)->stop (slave);

1512

1513

if (self->priv->greeter_environment != NULL) {

1514

stop_greeter (self);

1515

self->priv->greeter_environment = NULL;

1516

}

1517

1518

if (self->priv->session_is_running) {

1519

char *username;

1520

1521

/* Run the PostSession script. gdmslave suspends until script

1522

* has terminated

1523

*/

1524

username = gdm_session_get_username (self->priv->session);

1525

if (username != NULL) {

1526

gdm_slave_run_script (slave, GDMCONFDIR "/PostSession", username);

1527

}

1528

g_free (username);

1529

1530

#ifdef HAVE_LOGINDEVPERM

1531

gdm_simple_slave_revoke_console_permissions (self);

1532

#endif

1533

1534

self->priv->session_is_running = FALSE;

1535

}

1536

1537

if (self->priv->session != NULL) {

1538

gdm_session_close (self->priv->session);

1539

g_clear_object (&self->priv->session);

1540

}

1541

1542

if (self->priv->server != NULL) {

1543

gdm_server_stop (self->priv->server);

1544

g_clear_object (&self->priv->server);

1545

}

1546

1547

return TRUE;

1548

}

1549

1550

static void

1551

gdm_simple_slave_class_init (GdmSimpleSlaveClass *klass)

1552

{

1553

GObjectClass *object_class = G_OBJECT_CLASS (klass);

1554

GdmSlaveClass *slave_class = GDM_SLAVE_CLASS (klass);

1555

1556

object_class->finalize = gdm_simple_slave_finalize;

1557

1558

slave_class->start = gdm_simple_slave_start;

1559

slave_class->stop = gdm_simple_slave_stop;

1560

slave_class->open_session = gdm_simple_slave_open_session;

1561

slave_class->open_reauthentication_channel = gdm_simple_slave_open_reauthentication_channel;

1562

slave_class->open_reauthentication_channel_finish = gdm_simple_slave_open_reauthentication_channel_finish;

1563

1564

g_type_class_add_private (klass, sizeof (GdmSimpleSlavePrivate));

1565

}

1566

1567

static void

1568

gdm_simple_slave_init (GdmSimpleSlave *slave)

1569

{

1570

slave->priv = GDM_SIMPLE_SLAVE_GET_PRIVATE (slave);

1571

#ifdef HAVE_LOGINDEVPERM

1572

slave->priv->use_logindevperm = FALSE;

1573

#endif

1574

1575

slave->priv->open_reauthentication_requests = g_hash_table_new_full (NULL,

1576

NULL,

1577

(GDestroyNotify)

1578

NULL,

1579

(GDestroyNotify)

1580

g_object_unref);

1581

}

1582

1583

static void

1584

gdm_simple_slave_finalize (GObject *object)

1585

{

1586

GdmSimpleSlave *slave;

1587

1588

g_return_if_fail (object != NULL);

1589

g_return_if_fail (GDM_IS_SIMPLE_SLAVE (object));

1590

1591

slave = GDM_SIMPLE_SLAVE (object);

1592

1593

g_return_if_fail (slave->priv != NULL);

1594

1595

gdm_slave_stop (GDM_SLAVE (slave));

1596

1597

g_hash_table_unref (slave->priv->open_reauthentication_requests);

1598

1599

if (slave->priv->greeter_reset_id > 0) {

1600

g_source_remove (slave->priv->greeter_reset_id);

1601

slave->priv->greeter_reset_id = 0;

1602

}

1603

1604

G_OBJECT_CLASS (gdm_simple_slave_parent_class)->finalize (object);

1605

}

1606

1607

GdmSlave *

1608

gdm_simple_slave_new (const char *id)

1609

{

1610

GObject *object;

1611

1612

object = g_object_new (GDM_TYPE_SIMPLE_SLAVE,

1613

"display-id", id,

1614

NULL);

1615

1616

return GDM_SLAVE (object);

1617

}