started communication with data provider

1 files changed, 225 insertions, 10 deletions

diff --git a/worker/sbus_client.c b/worker/sbus_client.c
index cbc9650..e8a6820 100644
--- a/worker/sbus_client.c
+++ b/worker/sbus_client.c
@@ -1,45 +1,178 @@
 #include <errno.h>
 #include <sys/time.h>
 
-#include "events.h"
+#include "tevent.h"
 #include "util/util.h"
 #include "sbus/sssd_dbus.h"
 #include "sbus_interfaces.h"
 #include "util/service_helpers.h"
+#include "providers/data_provider.h"
 
 
+struct pp_context {
+    struct event_context *event_ctx; 
+    struct service_sbus_ctx *sbus_dp_ctx;
+};
 
 static void task_check_for_new_policies(struct event_context *ev_ctx,
                                         struct timed_event *te,
-                                        struct timeval tval, void *main_ctx);
-static void set_task_check_for_new_policies(struct main_context *main_ctx) {
+                                        struct timeval tval, void *ptr);
+static void process_dp_reply(DBusPendingCall *pending, void *ptr);
+
+static void set_task_check_for_new_policies(struct pp_context *pp_ctx) {
     struct timed_event *te = NULL;
     struct timeval tv;
 
     gettimeofday(&tv, NULL);
     tv.tv_sec += 5;
     tv.tv_usec = 0;
-    te = event_add_timed(main_ctx->event_ctx, main_ctx, tv, task_check_for_new_policies, main_ctx);
+    te = event_add_timed(pp_ctx->event_ctx, pp_ctx, tv, task_check_for_new_policies, pp_ctx);
     if (te == NULL) exit(1);
 }
 
 static void task_check_for_new_policies(struct event_context *ev_ctx,
                                         struct timed_event *te,
-                                        struct timeval tval, void *main_ctx) {
+                                        struct timeval tval, void *ptr) {
+    DBusMessage* msg;
+    DBusConnection *conn;
+    DBusPendingCall* pending;
+
+    struct pp_context *pp_ctx = talloc_get_type(ptr, struct pp_context);
+
+    
     DEBUG(0,("Hello, I'm task_check_for_new_policies.\n"));
 
-    set_task_check_for_new_policies(main_ctx);
+    conn = sbus_get_connection(pp_ctx->sbus_dp_ctx->scon_ctx);
+
+    msg = dbus_message_new_method_call(NULL,
+          DP_CLI_PATH,
+          DP_CLI_INTERFACE,
+          DP_PP_GET_POLICIES);
+
+    if (msg == NULL) {
+        DEBUG(0, ("dbus_message_new_method_call returned NULL, I do not know what to do, aborting ...\n"));
+        /* FIXME */
+        exit(1);
+    }
+
+    if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { 
+        DEBUG(0, ("Out Of Memory!\n")); 
+        /* FIXME */
+        exit(1);
+    }
+
+    if ( pending == NULL ) {
+        DEBUG(0, ("pending is NULL\n")); 
+        /* FIXME */
+        exit(1);
+    }
+
+    dbus_pending_call_set_notify(pending, process_dp_reply, pp_ctx, NULL);
+    dbus_message_unref(msg);
+}
+
+
+static void process_dp_reply(DBusPendingCall *pending, void *ptr) {
+    DBusError dbus_error;
+    DBusMessage* msg;
+    int ret;
+    int type;
+    dbus_uint32_t ans;
+
+    dbus_error_init(&dbus_error);
+
+    dbus_pending_call_block(pending);
+    msg = dbus_pending_call_steal_reply(pending);
+    if (msg == NULL) {
+        DEBUG(0, ("Reply Null\n")); 
+        /* FIXME */
+        exit(1); 
+    }
+
+    type = dbus_message_get_type(msg);
+    switch (type) {
+        case DBUS_MESSAGE_TYPE_METHOD_RETURN:
+            ret = dbus_message_get_args(msg, &dbus_error,
+                                        DBUS_TYPE_UINT32, &ans,
+                                        DBUS_TYPE_INVALID);
+            if (!ret) {
+                DEBUG(0, ("Failed to parse reply.\n"));
+                exit(1);
+            } else {
+                switch(ans) {
+                    case POL_ANS_OFFLINE:
+                        DEBUG(3, ("Got POL_ANS_OFFLINE\n"));
+                        break;
+                    case POL_ANS_NOTHING_TO_DO:
+                        DEBUG(3, ("Got POL_ANS_NOTHING_TO_DO\n"));
+                        break;
+                    case POL_ANS_NEW_POL_AVAIL:
+                        DEBUG(3, ("Got POL_ANS_NEW_POL_AVAIL\n"));
+                        break;
+                    case POL_ANS_ERROR:
+                        DEBUG(3, ("Got POL_ANS_ERROR\n"));
+                        break;
+                    default:
+                        DEBUG(3, ("Got unknow reply: %d\n", ans));
+                }
+            }
+            break;
+        case DBUS_MESSAGE_TYPE_ERROR:
+            DEBUG(0, ("Reply error.\n"));
+            break;
+        default:
+            DEBUG(0, ("Default... what now?.\n"));
+    }
+
+
+    dbus_pending_call_unref(pending);
+    dbus_message_unref(msg);   
+   
+
+    set_task_check_for_new_policies(ptr);
 }
 
 static int service_identity(DBusMessage *message, void *data, DBusMessage **r);
 static int service_pong(DBusMessage *message, void *data, DBusMessage **r);
+static int dp_cli_identity(DBusMessage *message, void *data, DBusMessage **r);
 
-struct sbus_method sbus_methods[] = {
+struct sbus_method sbus_monitor_methods[] = {
     {SERVICE_METHOD_IDENTITY, service_identity},
     {SERVICE_METHOD_PING, service_pong},
     {NULL, NULL}
 };
 
+struct sbus_method sbus_dp_methods[] = {
+    {DP_CLI_METHOD_IDENTITY, dp_cli_identity},
+    {NULL, NULL}
+};
+
+
+static int dp_cli_identity(DBusMessage *message, void *data, DBusMessage **r) {
+    dbus_uint16_t version = 0x0001; /*FIXME */
+    dbus_uint16_t clitype = DP_CLI_FRONTEND;
+    DBusMessage *reply;
+    dbus_bool_t ret;
+    char *name="PolicyProcessor";
+    char *domain="IPA";
+    DEBUG(0, ("dp_cli_identity got called.\n"));
+
+    reply = dbus_message_new_method_return(message);
+    ret = dbus_message_append_args(reply,
+                                   DBUS_TYPE_UINT16, &clitype,
+                                   DBUS_TYPE_UINT16, &version,
+                                   DBUS_TYPE_STRING, &name,
+                                   DBUS_TYPE_STRING, &domain,
+                                   DBUS_TYPE_INVALID);
+    if (!ret) {
+        return EIO;
+    }
+
+    *r = reply;
+    return EOK;
+}
+
+
 static int service_identity(DBusMessage *message, void *data, DBusMessage **r)
 {
     dbus_uint16_t version = 0x0001;
@@ -47,6 +180,7 @@ static int service_identity(DBusMessage *message, void *data, DBusMessage **r)
     DBusMessage *reply;
     dbus_bool_t ret;
 
+    DEBUG(0, ("service_identity got called.\n"));
     reply = dbus_message_new_method_return(message);
     ret = dbus_message_append_args(reply,
                                    DBUS_TYPE_STRING, &name,
@@ -75,10 +209,76 @@ static int service_pong(DBusMessage *message, void *data, DBusMessage **r)
     return EOK;
 }
 
+static int sssd_dp_sbus_init(TALLOC_CTX *mem_ctx,
+                                           struct event_context *ev,
+                                           struct confdb_ctx *cdb,
+                                           struct sbus_method *methods,
+                                           struct service_sbus_ctx **srvs_ctx,
+                                           sbus_conn_destructor_fn destructor) {
+    struct service_sbus_ctx *ss_ctx;
+    struct sbus_method_ctx *sm_ctx;
+    TALLOC_CTX *ctx;
+    char *default_dp_address;
+    int ret;
+
+    ctx = talloc_new(mem_ctx);
+    if (ctx == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ss_ctx = talloc_zero(ctx, struct service_sbus_ctx);
+    if (ss_ctx == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+    ss_ctx->ev = ev;
+    
+    default_dp_address = talloc_asprintf(ctx, "unix:path=%s/%s",
+                                         PIPE_PATH, DATA_PROVIDER_PIPE);
+    if (default_dp_address == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = sbus_new_connection(ss_ctx, ss_ctx->ev,
+                              default_dp_address, &ss_ctx->scon_ctx,
+                              destructor);
+    if (ret != EOK) goto done;
+
+    sm_ctx = talloc_zero(ss_ctx, struct sbus_method_ctx);
+    if (sm_ctx == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+
+    sm_ctx->interface = talloc_strdup(sm_ctx, DATA_PROVIDER_INTERFACE);
+    sm_ctx->path = talloc_strdup(sm_ctx, DATA_PROVIDER_PATH);
+    if (!sm_ctx->interface || !sm_ctx->path) {
+        ret = ENOMEM;
+        goto done;
+    }
+
+    sm_ctx->methods = methods;
+    sm_ctx->message_handler = sbus_message_handler;
+    sbus_conn_add_method_ctx(ss_ctx->scon_ctx, sm_ctx);
+
+    talloc_steal(mem_ctx,ss_ctx);
+    *srvs_ctx = ss_ctx;
+    ret = EOK;
+
+done:
+    talloc_free(ctx);
+    return ret;
+}
+
+
 int setup_sbus_and_server_loop(void) {
     int ret=0;
     struct main_context *main_ctx = NULL;
     struct service_sbus_ctx *sbus_ctx = NULL;
+    struct service_sbus_ctx *sbus_dp_ctx = NULL;
+    struct pp_context *pp_ctx;
 
     ret = server_setup("PolicyProcessor", 0, &main_ctx);
     if (ret != EOK ) {
@@ -87,12 +287,27 @@ int setup_sbus_and_server_loop(void) {
     }
 
     sbus_ctx = sssd_service_sbus_init(main_ctx, main_ctx->event_ctx,
-                                      main_ctx->confdb_ctx, sbus_methods, NULL);
+                                      main_ctx->confdb_ctx, sbus_monitor_methods, NULL);
     if (sbus_ctx == NULL) return -1;
 
-    set_task_check_for_new_policies(main_ctx);
+    ret = sssd_dp_sbus_init(main_ctx, main_ctx->event_ctx,
+                            main_ctx->confdb_ctx, sbus_dp_methods,
+                            &sbus_dp_ctx, NULL);
+    if (ret != EOK) goto done;
+
+    pp_ctx = talloc_zero(main_ctx, struct pp_context);
+    if (pp_ctx == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+    pp_ctx->event_ctx = main_ctx->event_ctx;
+    pp_ctx->sbus_dp_ctx = sbus_dp_ctx;
+
+    set_task_check_for_new_policies(pp_ctx);
 
     server_loop(main_ctx);
 
-    return 0;
+done:
+    talloc_free(main_ctx);
+    return ret;
 }