← Back to branch summary

~ubuntu-branches/debian/squeeze/hal/squeeze

« back to all changes in this revision

Viewing changes to hald/hald_runner.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2007-10-23 12:33:58 UTC
  • Revision ID: james.westby@ubuntu.com-20071023123358-xaf8mjc5n84d5gtz
Tags: upstream-0.5.10
Import upstream version 0.5.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
hald/hald_runner.c
4
4
 * hald_runner.c - Interface to the hal runner helper daemon
5
5
 *
6
6
 * Copyright (C) 2006 Sjoerd Simons, <sjoerd@luon.net>
 
7
 * Copyright (C) 2007 Codethink Ltd. Author Rob Taylor <rob.taylor@codethink.co.uk>
7
8
 *
8
9
 * Licensed under the Academic Free License version 2.1
9
10
 *
65
66
        GPid pid;
66
67
        HalDevice *device;
67
68
        HalRunTerminatedCB cb;
 
69
        gboolean is_singleton;
68
70
        gpointer data1;
69
71
        gpointer data2;
70
72
} RunningProcess;
341
343
static void
342
344
add_env (DBusMessageIter * iter, const gchar * key, const gchar * value)
343
345
{
344
 
        gchar *env;
345
 
        env = g_strdup_printf ("%s=%s", key, value);
346
 
        dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &env);
347
 
        g_free (env);
 
346
        if (value != NULL) {
 
347
                gchar *env;
 
348
                env = g_strdup_printf ("%s=%s", key, value);
 
349
                dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &env);
 
350
                g_free (env);
 
351
        }
348
352
}
349
353
 
350
354
static void
364
368
        if (hald_use_syslog) {
365
369
                add_env (iter, "HALD_USE_SYSLOG", "1");
366
370
        }
367
 
        add_env (iter, "UDI", udi);
 
371
        if (udi)
 
372
                add_env (iter, "UDI", udi);
368
373
        add_env (iter, "HALD_DIRECT_ADDR", hald_dbus_local_server_addr ());
 
374
 
 
375
        /* I'm sure it would be easy to remove use of getenv(3) to add these variables... */
 
376
 
 
377
        add_env (iter, "LD_LIBRARY_PATH", getenv ("LD_LIBRARY_PATH"));
369
378
#ifdef HAVE_POLKIT
370
379
        add_env (iter, "HAVE_POLKIT", "1");
 
380
        add_env (iter, "POLKIT_POLICY_DIR", getenv ("POLKIT_POLICY_DIR"));
 
381
        add_env (iter, "POLKIT_DEBUG", getenv ("POLKIT_DEBUG"));
371
382
#endif
372
383
 
373
384
 
379
390
                GString *seats_string;
380
391
                char *s;
381
392
                char *p;
 
393
                int num_seats;
 
394
                int num_sessions_total;
382
395
 
383
396
                seats_string = g_string_new ("");
384
397
 
385
398
                seats = ck_tracker_get_seats (ck_tracker);
 
399
                num_seats = g_slist_length (seats);
 
400
                num_sessions_total = 0;
386
401
                for (i = seats; i != NULL; i = g_slist_next (i)) {
387
402
                        GSList *j;
388
403
                        CKSeat *seat;
389
404
                        GSList *sessions;
390
405
                        const char *seat_id;
391
406
                        GString *sessions_string;
 
407
                        int num_sessions;
392
408
 
393
409
                        sessions_string = g_string_new ("");
394
410
 
404
420
                        g_string_append (seats_string, seat_id);
405
421
 
406
422
                        sessions = ck_seat_get_sessions (seat);
 
423
                        num_sessions = g_slist_length (sessions);
 
424
                        num_sessions_total += num_sessions;
407
425
                        for (j = sessions; j != NULL; j = g_slist_next (j)) {
408
426
                                CKSession *session;
409
427
                                const char *session_id;
 
428
                                const char *q;
410
429
 
411
430
                                session = j->data;
412
431
                                /* basename again; e.g. Session1 rather than /org/freedesktop/ConsoleKit/Session1 */
417
436
                                }
418
437
                                g_string_append (sessions_string, session_id);
419
438
 
420
 
                                /* for each Session, export IS_ACTIVE and UID 
 
439
                                /* for each Session, export IS_ACTIVE, UID, IS_LOCAL, HOSTNAME
421
440
                                 *
 
441
                                 * CK_SESSION_SEAT_Session2=Seat1
422
442
                                 * CK_SESSION_IS_ACTIVE_Session2=true|false
423
443
                                 * CK_SESSION_UID_Session2=501
424
444
                                 * CK_SESSION_IS_LOCAL_Session2=true|false
425
445
                                 * CK_SESSION_HOSTNAME_Session2=192.168.1.112
426
446
                                 */
 
447
                                s = g_strdup_printf ("CK_SESSION_SEAT_%s", session_id);
 
448
                                add_env (iter, s, seat_id);
 
449
                                g_free (s);
427
450
                                s = g_strdup_printf ("CK_SESSION_IS_ACTIVE_%s", session_id);
428
451
                                add_env (iter, s, ck_session_is_active (session) ? "true" : "false");
429
452
                                g_free (s);
435
458
                                s = g_strdup_printf ("CK_SESSION_IS_LOCAL_%s", session_id);
436
459
                                add_env (iter, s, ck_session_is_local (session) ? "true" : "false");
437
460
                                g_free (s);
438
 
                                s = g_strdup_printf ("CK_SESSION_HOSTNAME_%s", session_id);
439
 
                                p = g_strdup_printf ("%s", ck_session_get_hostname (session));
440
 
                                add_env (iter, s, p);
441
 
                                g_free (s);
442
 
                                g_free (p);
 
461
                                q = ck_session_get_hostname (session);
 
462
                                if (q != NULL && strlen (q) > 0) {
 
463
                                        s = g_strdup_printf ("CK_SESSION_HOSTNAME_%s", session_id);
 
464
                                        add_env (iter, s, q);
 
465
                                        g_free (s);
 
466
                                }
443
467
                        }
444
468
 
445
469
                        /* for each Seat, export sessions on each seat 
446
470
                         *
447
471
                         * CK_SEAT_Seat1=Session1 Session3 Session7
 
472
                         * CK_SEAT_NUM_SESSIONS_Seat1=3
448
473
                         */
449
474
                        s = g_strdup_printf ("CK_SEAT_%s", seat_id);
450
475
                        add_env (iter, s, sessions_string->str);
451
476
                        g_string_free (sessions_string, TRUE);
452
477
                        g_free (s);
453
478
 
 
479
                        s = g_strdup_printf ("CK_SEAT_NUM_SESSIONS_%s", seat_id);
 
480
                        p = g_strdup_printf ("%d", num_sessions);
 
481
                        add_env (iter, s, p);
 
482
                        g_free (p);
 
483
                        g_free (s);
 
484
 
454
485
                }
455
486
 
456
487
                /* Export all detected seats 
459
490
                 */
460
491
                add_env (iter, "CK_SEATS", seats_string->str);
461
492
                g_string_free (seats_string, TRUE);
 
493
 
 
494
                /* Export total number of sessions
 
495
                 *
 
496
                 * CK_NUM_SESSIONS=5
 
497
                 */
 
498
                p = g_strdup_printf ("%d", num_sessions_total);
 
499
                add_env (iter, "CK_NUM_SESSIONS", p);
 
500
                g_free (p);
 
501
 
 
502
                /* Export number of seats
 
503
                 *
 
504
                 * CK_NUM_SEATS=5
 
505
                 */
 
506
                p = g_strdup_printf ("%d", num_seats);
 
507
                add_env (iter, "CK_NUM_SEATS", p);
 
508
                g_free (p);
 
509
 
462
510
        }
463
511
#endif /* HAVE_CONKIT */
464
512
 
514
562
        return TRUE;
515
563
}
516
564
 
517
 
static gboolean
518
 
add_first_part (DBusMessageIter * iter, HalDevice * device,
519
 
                const gchar * command_line, char **extra_env)
 
565
static void
 
566
add_udi (DBusMessageIter * iter, HalDevice * device)
520
567
{
521
 
        DBusMessageIter array_iter;
522
568
        const char *udi;
523
569
 
524
570
        if (device != NULL)
527
573
                udi = "";
528
574
 
529
575
        dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &udi);
 
576
}
530
577
 
 
578
static gboolean
 
579
add_environment (DBusMessageIter * iter, HalDevice * device,
 
580
                const gchar * command_line, char **extra_env)
 
581
{
 
582
        DBusMessageIter array_iter;
531
583
        dbus_message_iter_open_container (iter,
532
584
                                          DBUS_TYPE_ARRAY,
533
585
                                          DBUS_TYPE_STRING_AS_STRING,
535
587
        if (device != NULL)
536
588
                hal_device_property_foreach (device, add_property_to_msg,
537
589
                                             &array_iter);
538
 
        add_basic_env (&array_iter, udi);
 
590
        add_basic_env (&array_iter, device ? hal_device_get_udi (device): NULL);
539
591
        add_extra_env (&array_iter, extra_env);
540
592
        dbus_message_iter_close_container (iter, &array_iter);
541
593
 
546
598
}
547
599
 
548
600
/* Start a helper, returns true on a successfull start */
549
 
gboolean
550
 
hald_runner_start (HalDevice * device, const gchar * command_line,
551
 
                   char **extra_env, HalRunTerminatedCB cb, gpointer data1,
552
 
                   gpointer data2)
 
601
static gboolean
 
602
runner_start (HalDevice * device, const gchar * command_line,
 
603
              char **extra_env, gboolean singleton,
 
604
              HalRunTerminatedCB cb, gpointer data1, gpointer data2)
553
605
{
554
606
        DBusMessage *msg, *reply;
555
 
        DBusError err;
 
607
        DBusError error;
556
608
        DBusMessageIter iter;
557
609
 
558
 
        dbus_error_init (&err);
 
610
        dbus_error_init (&error);
559
611
        msg = dbus_message_new_method_call ("org.freedesktop.HalRunner",
560
612
                                            "/org/freedesktop/HalRunner",
561
613
                                            "org.freedesktop.HalRunner",
562
 
                                            "Start");
 
614
                                            singleton ? "StartSingleton" : "Start");
563
615
        if (msg == NULL)
564
616
                DIE (("No memory"));
565
617
        dbus_message_iter_init_append (msg, &iter);
566
618
 
567
 
        if (!add_first_part (&iter, device, command_line, extra_env))
 
619
        if (!singleton)
 
620
                add_udi (&iter, device);
 
621
 
 
622
        if (!add_environment (&iter, device, command_line, extra_env)) {
 
623
                HAL_ERROR (("Error adding environment, device =%p, singleton=%d",
 
624
                        device, singleton));
568
625
                goto error;
 
626
        }
569
627
 
570
628
        /* Wait for the reply, should be almost instantanious */
571
629
        reply =
572
630
            dbus_connection_send_with_reply_and_block (runner_connection,
573
 
                                                       msg, -1, &err);
 
631
                                                       msg, -1, &error);
574
632
        if (reply) {
575
633
                gboolean ret =
576
634
                    (dbus_message_get_type (reply) ==
578
636
 
579
637
                if (ret) {
580
638
                        dbus_int64_t pid_from_runner;
581
 
                        if (dbus_message_get_args (reply, &err,
 
639
                        if (dbus_message_get_args (reply, &error,
582
640
                                                   DBUS_TYPE_INT64,
583
641
                                                   &pid_from_runner,
584
642
                                                   DBUS_TYPE_INVALID)) {
587
645
                                        rp = g_new0 (RunningProcess, 1);
588
646
                                        rp->pid = (GPid) pid_from_runner;
589
647
                                        rp->cb = cb;
590
 
                                        rp->device = device;
 
648
                                        rp->is_singleton = singleton;
 
649
                                        if (singleton)
 
650
                                                rp->device = NULL;
 
651
                                        else
 
652
                                                rp->device = device;
591
653
                                        rp->data1 = data1;
592
654
                                        rp->data2 = data2;
593
655
 
604
666
                dbus_message_unref (reply);
605
667
                dbus_message_unref (msg);
606
668
                return ret;
 
669
        } else {
 
670
                if (dbus_error_is_set (&error)) {
 
671
                        HAL_ERROR (("Error running '%s': %s: %s", command_line, error.name, error.message));
 
672
                }
607
673
        }
608
674
 
609
675
      error:
611
677
        return FALSE;
612
678
}
613
679
 
 
680
gboolean
 
681
hald_runner_start (HalDevice * device, const gchar * command_line,
 
682
                   char **extra_env, HalRunTerminatedCB cb,
 
683
                   gpointer data1, gpointer data2)
 
684
{
 
685
        return runner_start (device, command_line, extra_env, FALSE, cb, data1, data2);
 
686
}
 
687
 
 
688
gboolean
 
689
hald_runner_start_singleton (const gchar * command_line,
 
690
                             char **extra_env, HalRunTerminatedCB cb,
 
691
                             gpointer data1, gpointer data2)
 
692
{
 
693
        return runner_start (NULL, command_line, extra_env, TRUE, cb, data1, data2);
 
694
}
 
695
 
 
696
 
614
697
static void
615
698
process_reply (DBusMessage *m, HelperData *hb)
616
699
{
714
797
                DIE (("No memory"));
715
798
        dbus_message_iter_init_append (msg, &iter);
716
799
 
717
 
        if (!add_first_part (&iter, device, command_line, extra_env))
 
800
        add_udi (&iter, device);
 
801
        if (!add_environment (&iter, device, command_line, extra_env))
718
802
                goto error;
719
803
 
720
804
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &input);
783
867
                DIE (("No memory"));
784
868
        dbus_message_iter_init_append (msg, &iter);
785
869
 
786
 
        if (!add_first_part (&iter, device, command_line, extra_env))
 
870
        add_udi (&iter, device);
 
871
        if (!add_environment (&iter, device, command_line, extra_env))
787
872
                goto error;
788
873
 
789
874
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &input);
853
938
}
854
939
 
855
940
void
856
 
hald_runner_kill_all (HalDevice * device)
 
941
hald_runner_kill_all ()
857
942
{
858
943
        DBusMessage *msg, *reply;
859
944
        DBusError err;
860
945
 
861
 
        running_processes_remove_device (device);
862
 
 
863
946
        msg = dbus_message_new_method_call ("org.freedesktop.HalRunner",
864
947
                                            "/org/freedesktop/HalRunner",
865
948
                                            "org.freedesktop.HalRunner",