rom/dbus/test/dbus-amiga.c

   1 /*
   2  * AmigaOS D-BUS connection handling using a slave process as the main
   3  * loop.
   4  */
   5
   6 #include <dos/dostags.h>
   7 #include <exec/tasks.h>
   8
   9 #include <clib/alib_protos.h>
  10 #define DBUS_API_SUBJECT_TO_CHANGE
  11 #include <proto/dbus.h>
  12 #include <proto/exec.h>
  13 #include <proto/dos.h>
  14
  15 #define DEBUG 1
  16 #include <aros/debug.h>
  17
  18 #include "dbus-amiga.h"
  19
  20 struct WatchData {
  21     struct MinNode node;
  22     BOOL           enabled;
  23     DBusWatch*     watch;
  24 };
  25
  26 struct ConnectionData {
  27     struct Task*    main;
  28     struct Task*    creator;
  29     BYTE            signal;
  30     struct MinList  watches;
  31     DBusConnection* connection;
  32 };
  33
  34 static dbus_int32_t Slot = -1;
  35
  36 static void DeleteConnectionData(struct ConnectionData* c);
  37 static void CleanupAmigaConnection(void* data);
  38
  39 static void MainLoop() {
  40   struct ConnectionData* c = (struct ConnectionData*) FindTask(NULL)->tc_UserData;
  41   kprintf("MainLoop started %08lx (cd %08lx)\n", FindTask(NULL), c);
  42
  43   c->signal = AllocSignal(-1);
  44
  45   if (c->signal == -1) {
  46     goto exit;
  47   }
  48
  49   Signal(c->creator, SIGF_SINGLE);
  50
  51   while(TRUE) {
  52     ULONG signals = Wait(SIGBREAKF_CTRL_C | (1UL << c->signal));
  53
  54     kprintf("MainLoop got a signal %lx\n", signals);
  55
  56     if (signals & SIGBREAKF_CTRL_C) {
  57       break;
  58     }
  59
  60     if (signals & (1UL << c->signal)) {
  61       struct WatchData* w;
  62
  63 //      dbus_connection_ref(c->connection);
  64
  65       kprintf("Checking watches\n");
  66       for(w = (struct WatchData*) c->watches.mlh_Head;
  67           w->node.mln_Succ != NULL;
  68           w = (struct WatchData*) w->node.mln_Succ) {
  69         kprintf("%s watch on fd %ld, flags %lx\n",
  70                 w->enabled ? "Enabled" : "Disabled",
  71                 dbus_watch_get_fd(w->watch), dbus_watch_get_flags(w->watch));
  72         if (w->enabled) {
  73           dbus_watch_handle(w->watch, dbus_watch_get_flags(w->watch));
  74         }
  75       }
  76
  77       kprintf("Dispatching messages\n");
  78       /* Dispatch messages */
  79       while (dbus_connection_dispatch(c->connection) == DBUS_DISPATCH_DATA_REMAINS) {
  80         kprintf("More messages available\n");
  81       }
  82
  83 //      dbus_connection_unref(c->connection);
  84     }
  85   }
  86
  87 exit:
  88   c->main = NULL;
  89   Signal(c->creator, SIGF_SINGLE);
  90   kprintf("MainLoop terminating\n");
  91 }
  92
  93 static void* CreateWatchData(DBusWatch* watch) {
  94   struct WatchData* w = AllocVec(sizeof(struct WatchData), MEMF_ANY|MEMF_CLEAR);
  95
  96   if (w != NULL) {
  97     w->enabled = dbus_watch_get_enabled(watch);
  98     w->watch   = watch;
  99   }
 100
 101   return w;
 102 }
 103
 104
 105 static void DeleteWatchData(void* memory) {
 106   struct WatchData* w = (struct WatchData*) memory;
 107
 108   if (w != NULL) {
 109     if (w->node.mln_Succ != NULL) {
 110       Remove((struct Node*) w);
 111     }
 112
 113     FreeVec(w);
 114   }
 115 }
 116
 117 static void* CreateConnectionData(DBusConnection* connection) {
 118   struct ConnectionData* c = AllocVec(sizeof(struct ConnectionData), MEMF_ANY|MEMF_CLEAR);
 119
 120   kprintf("CreateConnectionData %08lx\n", c);
 121
 122   if (c != NULL) {
 123     c->connection = connection;
 124     c->creator = FindTask(NULL);
 125     NewList((struct List*) &c->watches);
 126
 127     Forbid();
 128     kprintf("creating mainloop\n");
 129     c->main   = (struct Task*) CreateNewProcTags(NP_Entry,    (ULONG) MainLoop,
 130                                                  NP_Name,     (ULONG) "dbus.library main loop",
 131                                                  NP_Priority, 0,
 132                                                  TAG_DONE);
 133     kprintf("created mainloop %08lx\n", c->main);
 134     if (c->main != NULL) {
 135       c->main->tc_UserData = c;
 136     }
 137
 138     SetSignal(0, SIGF_SINGLE);
 139     Permit();
 140
 141     Wait(SIGF_SINGLE);
 142
 143     if (c->main == NULL) {
 144       DeleteConnectionData(c);
 145       c = NULL;
 146     }
 147   }
 148
 149   return c;
 150 }
 151
 152
 153 static void DeleteConnectionData(struct ConnectionData* c) {
 154   kprintf("DeleteConnectionData %08lx\n", c);
 155
 156   if (c != NULL) {
 157     if (c->main != NULL) {
 158       SetSignal(0, SIGF_SINGLE);
 159       Signal(c->main, SIGBREAKF_CTRL_C);
 160       Wait(SIGF_SINGLE);
 161     }
 162
 163     FreeVec(c);
 164   }
 165 }
 166
 167 static dbus_bool_t AddWatchFunction(DBusWatch* watch,
 168                                     void*      data) {
 169   struct ConnectionData* c = (struct ConnectionData*) data;
 170   struct WatchData*      w;
 171
 172   kprintf("AddWatchFunction\n");
 173
 174   w = CreateWatchData(watch);
 175
 176   if (w == NULL) {
 177     return FALSE;
 178   }
 179
 180   AddTail((struct List*) &c->watches, (struct Node*) w);
 181   dbus_watch_set_data(watch, w, NULL);
 182
 183   return TRUE;
 184 }
 185
 186 static void WatchToggledFunction(DBusWatch* watch,
 187                                  void*      data) {
 188   struct ConnectionData* c = (struct ConnectionData*) data;
 189   struct WatchData*      w = (struct WatchData*) dbus_watch_get_data(watch);
 190
 191   kprintf("WatchToggledFunction %lx\n", w);
 192
 193   w->enabled = dbus_watch_get_enabled(watch);
 194 }
 195
 196 static void RemoveWatchFunction(DBusWatch* watch,
 197                                 void*      data) {
 198   struct ConnectionData* c = (struct ConnectionData*) data;
 199   struct WatchData*      w = (struct WatchData*) dbus_watch_get_data(watch);
 200
 201   kprintf("RemoveWatchFunction %lx\n", w);
 202
 203   dbus_watch_set_data(watch, NULL, NULL);
 204   DeleteWatchData(w);
 205 }
 206
 207 static dbus_bool_t AddTimeoutFunction(DBusTimeout* timeout,
 208                                       void*        data) {
 209   struct ConnectionData* c = (struct ConnectionData*) data;
 210
 211   kprintf("AddTimeoutFunction\n");
 212   return TRUE;
 213 }
 214
 215 static void TimeoutToggledFunction(DBusTimeout* timeout,
 216                                    void* data) {
 217   struct ConnectionData* c = (struct ConnectionData*) data;
 218
 219   kprintf("TimeoutToggledFunction\n");
 220 }
 221
 222 static void RemoveTimeoutFunction(DBusTimeout* timeout,
 223                                   void*        data) {
 224   struct ConnectionData* c = (struct ConnectionData*) data;
 225
 226   kprintf("RemoveTimeoutFunction\n");
 227 }
 228
 229
 230 static void DispatchStatusFunction(DBusConnection*    connection,
 231                                    DBusDispatchStatus new_status,
 232                                    void*              data) {
 233   struct ConnectionData* c = (struct ConnectionData*) data;
 234
 235   kprintf("DispatchStatusFunction %d\n", new_status);
 236
 237   if (new_status == DBUS_DISPATCH_DATA_REMAINS) {
 238     Signal(c->main, 1UL << c->signal);
 239   }
 240 }
 241
 242 static void WakeupMainFunction(void* data) {
 243   struct ConnectionData* c = (struct ConnectionData*) data;
 244
 245   kprintf("WakeupMainFunction\n");
 246   Signal(c->main, 1UL << c->signal);
 247 }
 248
 249 dbus_bool_t dbus_a_setup_connection(DBusConnection* connection) {
 250   struct ConnectionData* c;
 251
 252   c = CreateConnectionData(connection);
 253
 254   if (c != NULL) {
 255     dbus_connection_set_watch_functions(connection,
 256                                         AddWatchFunction,
 257                                         RemoveWatchFunction,
 258                                         WatchToggledFunction,
 259                                         c, NULL);
 260
 261     dbus_connection_set_timeout_functions(connection,
 262                                           AddTimeoutFunction,
 263                                           RemoveTimeoutFunction,
 264                                           TimeoutToggledFunction,
 265                                           c, NULL);
 266
 267     dbus_connection_set_dispatch_status_function(connection, DispatchStatusFunction,
 268                                                  c, NULL);
 269
 270     dbus_connection_set_wakeup_main_function(connection, WakeupMainFunction,
 271                                              c, NULL);
 272
 273     kprintf("Slot A: %ld\n", Slot);
 274     if (dbus_connection_allocate_data_slot(&Slot)) {
 275       kprintf("Slot B: %ld\n", Slot);
 276       if (dbus_connection_set_data(connection, Slot, c, DeleteConnectionData)) {
 277         kprintf("Slot C: %ld\n", Slot);
 278         return TRUE;
 279       }
 280     }
 281   }
 282
 283   DeleteConnectionData(c);
 284   return FALSE;
 285 }
 286
 287 void dbus_a_cleanup_connection(DBusConnection* connection) {
 288   struct ConnectionData* c;
 289
 290   kprintf("CleanupAmigaConnection\n");
 291
 292   kprintf("Slot X: %ld\n", Slot);
 293   c = dbus_connection_get_data(connection, Slot);
 294
 295   if (c != NULL) {
 296     dbus_connection_set_data(connection, Slot, NULL, NULL);
 297     dbus_connection_free_data_slot(&Slot);
 298     kprintf("Slot Y: %ld\n", Slot);
 299   }
 300
 301   dbus_connection_set_dispatch_status_function(connection, NULL, NULL, NULL);
 302   dbus_connection_set_wakeup_main_function(connection, NULL, NULL, NULL);
 303   dbus_connection_set_watch_functions(connection, NULL, NULL, NULL, NULL, NULL);
 304   dbus_connection_set_timeout_functions(connection, NULL, NULL, NULL, NULL, NULL);
 305
 306   kprintf("Slot X: %ld\n", Slot);
 307 }