src/bin/nm.c

   1 #include <E_Nm.h>
   2 #include <Ecore_Data.h>
   3 #include <dbus/dbus.h>
   4
   5 #define E_NM_DEVICE_TYPE_WIRED 1
   6 #define E_NM_DEVICE_TYPE_WIRELESS 2
   7
   8 typedef struct NM_Manager NM_Manager;
   9 struct NM_Manager
  10 {
  11   E_NM_Context *ctx;
  12   Ecore_List *devices;
  13 };
  14
  15 static void
  16 cb_manager_get_udi(void *data, void *reply, DBusError *err)
  17 {
  18     DBusMessageIter iter, sub;
  19     char *udi;
  20
  21     if (dbus_error_is_set(err))
  22     {
  23         printf("Error: %s - %s\n", err->name, err->message);
  24         return;
  25     }
  26
  27     dbus_message_iter_init(reply, &iter);
  28     dbus_message_iter_recurse(&iter, &sub);
  29     dbus_message_iter_get_basic(&sub, &udi);
  30
  31     printf("Got udi: %s\n", udi);
  32 }
  33
  34 static void
  35 cb_manager_get_interface(void *data, void *reply, DBusError *err)
  36 {
  37     DBusMessageIter iter, sub;
  38     char *interface;
  39
  40     if (dbus_error_is_set(err))
  41     {
  42         printf("Error: %s - %s\n", err->name, err->message);
  43         return;
  44     }
  45
  46     dbus_message_iter_init(reply, &iter);
  47     dbus_message_iter_recurse(&iter, &sub);
  48     dbus_message_iter_get_basic(&sub, &interface);
  49
  50     printf("Got interface: %s\n", interface);
  51 }
  52
  53 static void
  54 cb_manager_get_driver(void *data, void *reply, DBusError *err)
  55 {
  56     DBusMessageIter iter, sub;
  57     char *driver;
  58
  59     if (dbus_error_is_set(err))
  60     {
  61         printf("Error: %s - %s\n", err->name, err->message);
  62         return;
  63     }
  64
  65     dbus_message_iter_init(reply, &iter);
  66     dbus_message_iter_recurse(&iter, &sub);
  67     dbus_message_iter_get_basic(&sub, &driver);
  68
  69     printf("Got driver: %s\n", driver);
  70 }
  71
  72 static void
  73 cb_manager_get_capabilities(void *data, void *reply, DBusError *err)
  74 {
  75     DBusMessageIter iter, sub;
  76     dbus_uint32_t caps;
  77
  78     if (dbus_error_is_set(err))
  79     {
  80         printf("Error: %s - %s\n", err->name, err->message);
  81         return;
  82     }
  83
  84     dbus_message_iter_init(reply, &iter);
  85     dbus_message_iter_recurse(&iter, &sub);
  86     dbus_message_iter_get_basic(&sub, &caps);
  87
  88     printf("Got capabilities:\n");
  89     if (caps & E_NM_DEVICE_CAP_NM_SUPPORTED)
  90         printf("\tNM_DEVICE_CAP_NM_SUPPORTED\n");
  91     if (caps & E_NM_DEVICE_CAP_CARRIER_DETECT)
  92         printf("\tNM_DEVICE_CAP_CARRIER_DETECT\n");
  93     if (!caps)
  94         printf("\tNM_DEVICE_CAP_NONE\n");
  95
  96 }
  97
  98 static void
  99 cb_manager_get_ip4address(void *data, void *reply, DBusError *err)
 100 {
 101     DBusMessageIter iter, sub;
 102     dbus_int32_t ip;
 103
 104     if (dbus_error_is_set(err))
 105     {
 106         printf("Error: %s - %s\n", err->name, err->message);
 107         return;
 108     }
 109
 110     dbus_message_iter_init(reply, &iter);
 111     dbus_message_iter_recurse(&iter, &sub);
 112     dbus_message_iter_get_basic(&sub, &ip);
 113
 114     printf("Got IPv4 address: %i.%i.%i.%i\n",
 115            (ip       & 0xff),
 116            ((ip >> 8 ) & 0xff),
 117            ((ip >> 16) & 0xff),
 118            ((ip >> 24) & 0xff)
 119            );
 120 }
 121
 122 static void
 123 cb_manager_get_state(void *data, void *reply, DBusError *err)
 124 {
 125     DBusMessageIter iter, sub;
 126     dbus_uint32_t state;
 127
 128     if (dbus_error_is_set(err))
 129     {
 130         printf("Error: %s - %s\n", err->name, err->message);
 131         return;
 132     }
 133
 134     dbus_message_iter_init(reply, &iter);
 135     dbus_message_iter_recurse(&iter, &sub);
 136     dbus_message_iter_get_basic(&sub, &state);
 137
 138     printf("Got state: %i = ", state);
 139     switch (state)
 140     {
 141         case E_NM_DEVICE_STATE_UNKNOWN:
 142             printf("NM_DEVICE_STATE_UNKNOWN\n");
 143             break;
 144         case E_NM_DEVICE_STATE_DOWN:
 145             printf("NM_DEVICE_STATE_DOWN\n");
 146             break;
 147         case E_NM_DEVICE_STATE_DISCONNECTED:
 148             printf("NM_DEVICE_STATE_DISCONNECTED\n");
 149             break;
 150         case E_NM_DEVICE_STATE_PREPARE:
 151             printf("NM_DEVICE_STATE_PREPARE\n");
 152             break;
 153         case E_NM_DEVICE_STATE_CONFIG:
 154             printf("NM_DEVICE_STATE_CONFIG\n");
 155             break;
 156         case E_NM_DEVICE_STATE_NEED_AUTH:
 157             printf("NM_DEVICE_STATE_NEED_AUTH\n");
 158             break;
 159         case E_NM_DEVICE_STATE_IP_CONFIG:
 160             printf("NM_DEVICE_STATE_IP_CONFIG\n");
 161             break;
 162         case E_NM_DEVICE_STATE_ACTIVATED:
 163             printf("NM_DEVICE_STATE_ACTIVATED\n");
 164             break;
 165         case E_NM_DEVICE_STATE_FAILED:
 166             printf("NM_DEVICE_STATE_FAILED\n");
 167             break;
 168         case E_NM_DEVICE_STATE_CANCELLED:
 169             printf("NM_DEVICE_STATE_CANCELLED\n");
 170             break;
 171     }
 172 }
 173
 174 static void
 175 cb_manager_get_ip4config(void *data, void *reply, DBusError *err)
 176 {
 177     DBusMessageIter iter, sub;
 178     char *ip4config;
 179
 180     if (dbus_error_is_set(err))
 181     {
 182         printf("Error: %s - %s\n", err->name, err->message);
 183         return;
 184      }
 185
 186     dbus_message_iter_init(reply, &iter);
 187     dbus_message_iter_recurse(&iter, &sub);
 188     dbus_message_iter_get_basic(&sub, &ip4config);
 189
 190     printf("Got IPv4 config path: %s\n", ip4config);
 191 }
 192
 193 static void
 194 cb_manager_get_carrier(void *data, void *reply, DBusError *err)
 195 {
 196     DBusMessageIter iter, sub;
 197     dbus_uint32_t carrier;
 198
 199     if (dbus_error_is_set(err))
 200     {
 201         printf("Error: %s - %s\n", err->name, err->message);
 202         return;
 203     }
 204
 205     dbus_message_iter_init(reply, &iter);
 206     dbus_message_iter_recurse(&iter, &sub);
 207     dbus_message_iter_get_basic(&sub, &carrier);
 208
 209     printf("Got carrier: %i\n", carrier);
 210 }
 211
 212 static void
 213 cb_manager_get_type(void *data, void *reply, DBusError *err)
 214 {
 215     DBusMessageIter iter, sub;
 216     dbus_uint32_t type;
 217
 218     if (dbus_error_is_set(err))
 219     {
 220         printf("Error: %s - %s\n", err->name, err->message);
 221         return;
 222     }
 223
 224     dbus_message_iter_init(reply, &iter);
 225     dbus_message_iter_recurse(&iter, &sub);
 226     dbus_message_iter_get_basic(&sub, &type);
 227
 228     printf("Got type: %i (1 = ethernet, 2 = wireless)\n", type);
 229 }
 230
 231 static void
 232 cb_manager_get_devices(void *data, void *reply, DBusError *err)
 233 {
 234     NM_Manager *app = data;
 235     const char *dev;
 236
 237     if (dbus_error_is_set(err))
 238     {
 239         printf("Error: %s - %s\n", err->name, err->message);
 240         return;
 241     }
 242
 243     app->devices = reply;
 244     ecore_list_first_goto(app->devices);
 245     printf("Got devices:\n");
 246     while ((dev = ecore_list_next(app->devices)))
 247     {
 248         printf("%s\n", dev);
 249         e_nm_device_get_udi(app->ctx, dev, cb_manager_get_udi, app);
 250         e_nm_device_get_interface(app->ctx, dev, cb_manager_get_interface, app);
 251         e_nm_device_get_driver(app->ctx, dev, cb_manager_get_driver, app);
 252         e_nm_device_get_capabilities(app->ctx, dev, cb_manager_get_capabilities, app);
 253         e_nm_device_get_ip4address(app->ctx, dev, cb_manager_get_ip4address, app);
 254         e_nm_device_get_state(app->ctx, dev, cb_manager_get_state, app);
 255         /* FIXME: Getting the ip4config needs fixing */
 256         //e_nm_device_get_ip4config(app->ctx, dev, cb_manager_get_ip4config, app);
 257         /* FIXME: Only call this when the device supports it */
 258         // e_nm_device_get_carrier(app->ctx, dev, cb_manager_get_carrier, app);
 259         e_nm_device_get_type(app->ctx, dev, cb_manager_get_type, app);
 260      }
 261 }
 262
 263 int
 264 main(int argc, char **argv)
 265 {
 266     NM_Manager *app;
 267     ecore_init();
 268     eina_stringshare_init();
 269     e_dbus_init();
 270
 271     app = calloc(1, sizeof(NM_Manager));
 272
 273     app->ctx = e_nm_new();
 274     if (!app->ctx)
 275     {
 276         printf("Error connecting to system bus. Is it running?\n");
 277         return 1;
 278     }
 279
 280     e_nm_get_devices(app->ctx, cb_manager_get_devices, app);
 281
 282     ecore_main_loop_begin();
 283
 284     e_nm_free(app->ctx);
 285     free(app);
 286     e_dbus_shutdown();
 287     eina_stringshare_shutdown();
 288     ecore_shutdown();
 289     return 0;
 290 }