summaryrefslogtreecommitdiff
path: root/server/dbus/tests/test_client.c
blob: 8a82284c8374e4f94d16dec1d503ac8893bca0b4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include "events.h"
#include "dbus/dbus.h"
#include "monitor.h"
#include "dbus/sssd_dbus_common.h"
#include "dbus/sssd_dbus_client.h"
#include "util/util.h"

static void request_version_timed(struct event_context *ev,
        DBusConnection *conn);

static void print_version (DBusPendingCall *pending, void *ptr) {
    DBusMessage *reply;
    DBusError error;
    const char *version_string;
    int type;

    dbus_error_init(&error);

    reply = dbus_pending_call_steal_reply(pending);
    if (!reply) {
        /* reply should never be null. This function shouldn't be called
         * until reply is valid. If reply is NULL here, something is seriously
         * wrong and we should bail out.
         */
        DEBUG(0,("Serious error. A reply callback was called but no reply was received"));
        exit(3);
    }

    type = dbus_message_get_type(reply);

    if (type == DBUS_MESSAGE_TYPE_METHOD_RETURN) {
        if(dbus_message_get_args(reply, &error, DBUS_TYPE_STRING, &version_string, DBUS_TYPE_INVALID)) {
            fprintf(stdout, "Version: %s\n", version_string);
            fflush(stdout);
        }
        else {
            DEBUG(0, ("Error getting arguments in print_version"));
        }
    }
    else if (type == DBUS_MESSAGE_TYPE_ERROR) {

    }
    else {
        DEBUG(0, ("Received unexpected message"));
        exit(4);
    }
}

static void test_timed_handler(struct event_context *ev,
                               struct timed_event *te,
                               struct timeval t, void *ptr) {
    DBusConnection *conn;
    DBusPendingCall *pending_reply;
    DBusMessage *version_request;
    DBusError error;
    conn = (DBusConnection *) ptr;

    fprintf(stdout, ".");
    fflush(stdout);

    dbus_error_init(&error);
    version_request = dbus_message_new_method_call(
            NULL, MONITOR_DBUS_PATH, MONITOR_DBUS_INTERFACE,
            MONITOR_METHOD_VERSION);

    if(!dbus_connection_send_with_reply(conn, version_request, &pending_reply, -1)){
        /* Critical failure */
        DEBUG(0,("Failed to send version_request"));
        exit(2);
    }

    dbus_pending_call_set_notify(pending_reply, print_version, NULL, NULL);

    dbus_message_unref(version_request);

    request_version_timed(ev,conn);
}

static void request_version_timed(struct event_context *ev, DBusConnection *conn) {
    struct timed_event *te = NULL;
    struct timeval tv;

    gettimeofday(&tv, NULL);
    tv.tv_sec += 5;
    tv.tv_usec = 0;
    te = event_add_timed(ev, ev, tv, test_timed_handler, conn);
    if (te == NULL) {
        DEBUG(0, ("failed to add event!\n"));
        exit(1);
    }
}

int main (int argc, const char *argv[]) {
    DBusError dbus_error;
    DBusConnection *dbus_conn;
    struct event_context *event_ctx;

    event_ctx = event_context_init(talloc_autofree_context());

    dbus_error_init(&dbus_error);
    dbus_conn = dbus_connection_open(DBUS_ADDRESS, &dbus_error);
    if (dbus_conn == NULL) {
        printf ("Error: name=%s, message=%s\n", dbus_error.name, dbus_error.message);
        exit(1);
    }

    integrate_connection_with_event_loop(event_ctx,dbus_conn);
    dbus_connection_set_exit_on_disconnect (dbus_conn, TRUE);

    /* Set up a timed event to request the server version every
     * five seconds and print it to the screen.
     */
    request_version_timed(event_ctx,dbus_conn);

    /* Enter the main loop (and hopefully never return) */
    event_loop_wait(event_ctx);

    talloc_free(event_ctx);
    return EXIT_SUCCESS;
}