nemunaire/eiwd
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: Phase 1 & 2 - Build system and D-Bus layer

Browse source 
Phase 1: Build System & Module Skeleton
- Set up Meson build system with EFL dependencies
- Created module entry point with e_modapi_init/shutdown/save
- Implemented configuration system using EET
- Added module.desktop metadata file
- Configured proper installation paths

Phase 2: D-Bus Layer (iwd Backend)
- Implemented D-Bus connection management to net.connman.iwd
- Created device abstraction layer (iwd_device.c) for Wi-Fi interfaces
- Created network abstraction layer (iwd_network.c) for access points
- Implemented D-Bus agent for passphrase requests (iwd_agent.c)
- Added ObjectManager support for device/network discovery
- Implemented daemon restart detection and reconnection
- Property change signal handling for devices and networks

Features:
- Connects to system D-Bus and iwd daemon
- Discovers wireless devices and networks via ObjectManager
- Monitors iwd daemon availability (handles restart)
- Agent registered for WPA/WPA2/WPA3 authentication
- Signal-driven updates (no polling)

Files created: 16 source/header files
Build status: Compiles successfully with gcc 15.2.1

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
nemunaire 2025-12-28 18:31:33 +07:00
commit 8cefafafb8
16 changed files with 1822 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

48
.gitignore vendored Normal file
View file

@ -0,0 +1,48 @@
# Build directories
build/
builddir/
# Meson files
.mesonpy*
compile_commands.json
# Compiled files
*.o
*.so
*.a
*.la
*.lo
# Editor files
*~
*.swp
*.swo
.*.sw?
*.bak
.vscode/
.idea/
# System files
.DS_Store
Thumbs.db
# Generated files
config.h
*.edj
# Autotools (if used)
.deps/
.libs/
Makefile
Makefile.in
*.log
*.trs
autom4te.cache/
config.status
configure
aclocal.m4
# Core dumps
core
core.*
vgcore.*

17
data/meson.build Normal file
View file

@ -0,0 +1,17 @@
# Install desktop file
install_data('module.desktop',
install_dir: dir_module
)
# TODO: Theme compilation will be added in Phase 6
# edje_cc = find_program('edje_cc', required: false)
# if edje_cc.found()
# custom_target('theme',
# input: 'theme.edc',
# output: 'e-module-iwd.edj',
# command: [edje_cc, '-id', join_paths(meson.current_source_dir(), 'icons'),
# '@INPUT@', '@OUTPUT@'],
# install: true,
# install_dir: dir_module
# )
# endif

8
data/module.desktop Normal file
View file

@ -0,0 +1,8 @@
[Desktop Entry]
Type=Link
Name=IWD Wi-Fi
Name[en]=IWD Wi-Fi Manager
Comment=Manage Wi-Fi connections using iwd
Comment[en]=Control Wi-Fi networks using Intel Wireless Daemon
Icon=e-module-iwd
X-Enlightenment-ModuleType=system

61
meson.build Normal file
View file

@ -0,0 +1,61 @@
project('e-iwd', 'c',
version: '0.1.0',
default_options: ['c_std=c11', 'warning_level=2'],
meson_version: '>= 0.56.0'
)
# Dependencies
enlightenment = dependency('enlightenment')
eldbus = dependency('eldbus')
elementary = dependency('elementary')
ecore = dependency('ecore')
evas = dependency('evas')
edje = dependency('edje')
eina = dependency('eina')
# Get Enlightenment module API version
e_version = enlightenment.version().split('.')
e_major = e_version[0]
e_minor = e_version[1]
# Installation paths
module_name = 'iwd'
module_arch = '@0@-@1@-@2@.@3@'.format(
host_machine.system(),
host_machine.cpu_family(),
e_major,
e_minor
)
dir_module = join_paths(get_option('libdir'), 'enlightenment', 'modules', module_name)
dir_module_arch = join_paths(dir_module, module_arch)
# Configuration
conf_data = configuration_data()
conf_data.set_quoted('PACKAGE', meson.project_name())
conf_data.set_quoted('VERSION', meson.project_version())
conf_data.set_quoted('MODULE_ARCH', module_arch)
configure_file(
output: 'config.h',
configuration: conf_data
)
# Add configuration include and feature test macros
add_project_arguments(
'-include', 'config.h',
'-D_GNU_SOURCE',
language: 'c'
)
# Subdirectories
subdir('src')
subdir('data')
# Summary
summary({
'Module name': module_name,
'Module architecture': module_arch,
'Installation path': dir_module_arch,
'Enlightenment version': enlightenment.version(),
}, section: 'Configuration')

1
meson_options.txt Normal file
View file

@ -0,0 +1 @@
# No custom options for now

233
src/e_mod_main.c Normal file
View file

@ -0,0 +1,233 @@
#include "e_mod_main.h"
/* Module metadata */
E_API E_Module_Api e_modapi = {
E_MODULE_API_VERSION,
"IWD"
};
/* Global module instance */
Mod *iwd_mod = NULL;
/* Logging domain */
int _e_iwd_log_dom = -1;
/* Forward declarations */
static void _iwd_config_load(void);
static void _iwd_config_free(void);
/* Module initialization */
E_API void *
e_modapi_init(E_Module *m)
{
Mod *mod;
/* Initialize logging */
_e_iwd_log_dom = eina_log_domain_register("e-iwd", EINA_COLOR_CYAN);
if (_e_iwd_log_dom < 0)
{
EINA_LOG_ERR("Could not register log domain 'e-iwd'");
return NULL;
}
INF("IWD Module initializing");
/* Allocate module structure */
mod = E_NEW(Mod, 1);
if (!mod)
{
ERR("Failed to allocate module structure");
eina_log_domain_unregister(_e_iwd_log_dom);
_e_iwd_log_dom = -1;
return NULL;
}
mod->module = m;
mod->log_dom = _e_iwd_log_dom;
iwd_mod = mod;
/* Initialize configuration */
e_iwd_config_init();
_iwd_config_load();
/* Initialize D-Bus and iwd subsystems (Phase 2) */
iwd_device_init();
iwd_network_init();
if (!iwd_dbus_init())
{
WRN("Failed to initialize D-Bus connection to iwd");
/* Continue anyway - we'll show error state in UI */
}
if (!iwd_agent_init())
{
WRN("Failed to initialize iwd agent");
}
/* Initialize gadget (Phase 3) */
e_iwd_gadget_init();
INF("IWD Module initialized successfully");
return mod;
}
/* Module shutdown */
E_API int
e_modapi_shutdown(E_Module *m EINA_UNUSED)
{
Mod *mod = iwd_mod;
if (!mod) return 0;
INF("IWD Module shutting down");
/* Shutdown gadget */
e_iwd_gadget_shutdown();
/* Shutdown D-Bus and iwd subsystems */
iwd_agent_shutdown();
iwd_dbus_shutdown();
iwd_network_shutdown();
iwd_device_shutdown();
/* Free configuration */
_iwd_config_free();
e_iwd_config_shutdown();
/* Free module structure */
E_FREE(mod);
iwd_mod = NULL;
/* Unregister logging */
eina_log_domain_unregister(_e_iwd_log_dom);
_e_iwd_log_dom = -1;
INF("IWD Module shutdown complete");
return 1;
}
/* Module save */
E_API int
e_modapi_save(E_Module *m EINA_UNUSED)
{
Mod *mod = iwd_mod;
if (!mod || !mod->conf) return 0;
DBG("Saving module configuration");
return e_config_domain_save("module.iwd", mod->conf_edd, mod->conf);
}
/* Configuration management */
void
e_iwd_config_init(void)
{
Mod *mod = iwd_mod;
if (!mod) return;
/* Create configuration descriptor */
mod->conf_edd = E_CONFIG_DD_NEW("IWD_Config", Config);
if (!mod->conf_edd)
{
ERR("Failed to create config EDD");
return;
}
#undef T
#undef D
#define T Config
#define D mod->conf_edd
E_CONFIG_VAL(D, T, config_version, INT);
E_CONFIG_VAL(D, T, auto_connect, UCHAR);
E_CONFIG_VAL(D, T, show_hidden_networks, UCHAR);
E_CONFIG_VAL(D, T, signal_refresh_interval, INT);
E_CONFIG_VAL(D, T, preferred_adapter, STR);
#undef T
#undef D
}
void
e_iwd_config_shutdown(void)
{
Mod *mod = iwd_mod;
if (!mod) return;
if (mod->conf_edd)
{
E_CONFIG_DD_FREE(mod->conf_edd);
mod->conf_edd = NULL;
}
}
static void
_iwd_config_load(void)
{
Mod *mod = iwd_mod;
if (!mod || !mod->conf_edd) return;
/* Load configuration from disk */
mod->conf = e_config_domain_load("module.iwd", mod->conf_edd);
if (mod->conf)
{
/* Check version */
if ((mod->conf->config_version >> 16) < MOD_CONFIG_FILE_EPOCH)
{
/* Config too old, use defaults */
WRN("Configuration version too old, using defaults");
E_FREE(mod->conf);
mod->conf = NULL;
}
}
/* Create default configuration if needed */
if (!mod->conf)
{
INF("Creating default configuration");
mod->conf = E_NEW(Config, 1);
if (mod->conf)
{
mod->conf->config_version = MOD_CONFIG_FILE_VERSION;
mod->conf->auto_connect = EINA_TRUE;
mod->conf->show_hidden_networks = EINA_FALSE;
mod->conf->signal_refresh_interval = 5;
mod->conf->preferred_adapter = NULL;
/* Save default config */
e_config_domain_save("module.iwd", mod->conf_edd, mod->conf);
}
}
}
static void
_iwd_config_free(void)
{
Mod *mod = iwd_mod;
if (!mod || !mod->conf) return;
if (mod->conf->preferred_adapter)
eina_stringshare_del(mod->conf->preferred_adapter);
E_FREE(mod->conf);
mod->conf = NULL;
}
/* Stub implementations for Phase 3 functions */
void
e_iwd_gadget_init(void)
{
DBG("Gadget initialization (stub - will be implemented in Phase 3)");
}
void
e_iwd_gadget_shutdown(void)
{
DBG("Gadget shutdown (stub)");
}

76
src/e_mod_main.h Normal file
View file

@ -0,0 +1,76 @@
#ifndef E_MOD_MAIN_H
#define E_MOD_MAIN_H
#include <e.h>
#include <Eina.h>
#include <Eldbus.h>
/* Module version information */
#define MOD_CONFIG_FILE_EPOCH 0x0001
#define MOD_CONFIG_FILE_GENERATION 0x0001
#define MOD_CONFIG_FILE_VERSION \
((MOD_CONFIG_FILE_EPOCH << 16) | MOD_CONFIG_FILE_GENERATION)
/* Configuration structure */
typedef struct _Config
{
int config_version;
Eina_Bool auto_connect;
Eina_Bool show_hidden_networks;
int signal_refresh_interval;
const char *preferred_adapter;
} Config;
/* Module instance structure */
typedef struct _Instance Instance;
/* Global module context */
typedef struct _Mod
{
E_Module *module;
E_Config_DD *conf_edd;
Config *conf;
Eina_List *instances;
/* D-Bus connection (will be initialized in Phase 2) */
Eldbus_Connection *dbus_conn;
/* Logging domain */
int log_dom;
} Mod;
/* Global module instance */
extern Mod *iwd_mod;
/* Logging macros */
extern int _e_iwd_log_dom;
#undef DBG
#undef INF
#undef WRN
#undef ERR
#define DBG(...) EINA_LOG_DOM_DBG(_e_iwd_log_dom, __VA_ARGS__)
#define INF(...) EINA_LOG_DOM_INFO(_e_iwd_log_dom, __VA_ARGS__)
#define WRN(...) EINA_LOG_DOM_WARN(_e_iwd_log_dom, __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(_e_iwd_log_dom, __VA_ARGS__)
/* Module API functions */
E_API extern E_Module_Api e_modapi;
E_API void *e_modapi_init(E_Module *m);
E_API int e_modapi_shutdown(E_Module *m);
E_API int e_modapi_save(E_Module *m);
/* Configuration functions */
void e_iwd_config_init(void);
void e_iwd_config_shutdown(void);
/* Gadget functions (will be implemented in Phase 3) */
void e_iwd_gadget_init(void);
void e_iwd_gadget_shutdown(void);
/* D-Bus functions */
#include "iwd/iwd_dbus.h"
#include "iwd/iwd_device.h"
#include "iwd/iwd_network.h"
#include "iwd/iwd_agent.h"
#endif

250
src/iwd/iwd_agent.c Normal file
View file

@ -0,0 +1,250 @@
#include "iwd_agent.h"
#include "iwd_dbus.h"
#include "../e_mod_main.h"
/* Global agent */
IWD_Agent *iwd_agent = NULL;
/* Forward declarations */
static Eldbus_Message *_agent_request_passphrase(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
static Eldbus_Message *_agent_cancel(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
static Eldbus_Message *_agent_release(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
static void _agent_register_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending);
static void _agent_unregister(void);
/* Agent interface methods */
static const Eldbus_Method agent_methods[] = {
{
"RequestPassphrase", ELDBUS_ARGS({"o", "network"}),
ELDBUS_ARGS({"s", "passphrase"}),
_agent_request_passphrase, 0
},
{
"Cancel", ELDBUS_ARGS({"s", "reason"}),
NULL,
_agent_cancel, 0
},
{
"Release", NULL, NULL,
_agent_release, 0
},
{ NULL, NULL, NULL, NULL, 0 }
};
/* Agent interface description */
static const Eldbus_Service_Interface_Desc agent_desc = {
IWD_AGENT_MANAGER_INTERFACE, agent_methods, NULL, NULL, NULL, NULL
};
/* Initialize agent */
Eina_Bool
iwd_agent_init(void)
{
Eldbus_Connection *conn;
Eldbus_Object *obj;
Eldbus_Proxy *proxy;
DBG("Initializing iwd agent");
if (iwd_agent)
{
WRN("Agent already initialized");
return EINA_TRUE;
}
conn = iwd_dbus_conn_get();
if (!conn)
{
ERR("No D-Bus connection available");
return EINA_FALSE;
}
iwd_agent = E_NEW(IWD_Agent, 1);
if (!iwd_agent)
{
ERR("Failed to allocate agent");
return EINA_FALSE;
}
/* Register D-Bus service interface */
iwd_agent->iface = eldbus_service_interface_register(conn, IWD_AGENT_PATH, &agent_desc);
if (!iwd_agent->iface)
{
ERR("Failed to register agent interface");
E_FREE(iwd_agent);
iwd_agent = NULL;
return EINA_FALSE;
}
/* Register agent with iwd */
obj = eldbus_object_get(conn, IWD_SERVICE, IWD_MANAGER_PATH);
if (!obj)
{
ERR("Failed to get iwd manager object");
eldbus_service_interface_unregister(iwd_agent->iface);
E_FREE(iwd_agent);
iwd_agent = NULL;
return EINA_FALSE;
}
proxy = eldbus_proxy_get(obj, IWD_AGENT_MANAGER_INTERFACE);
if (!proxy)
{
ERR("Failed to get AgentManager proxy");
eldbus_object_unref(obj);
eldbus_service_interface_unregister(iwd_agent->iface);
E_FREE(iwd_agent);
iwd_agent = NULL;
return EINA_FALSE;
}
eldbus_proxy_call(proxy, "RegisterAgent", _agent_register_cb, NULL, -1, "o", IWD_AGENT_PATH);
eldbus_object_unref(obj);
INF("Agent initialized");
return EINA_TRUE;
}
/* Shutdown agent */
void
iwd_agent_shutdown(void)
{
DBG("Shutting down iwd agent");
if (!iwd_agent) return;
_agent_unregister();
if (iwd_agent->iface)
eldbus_service_interface_unregister(iwd_agent->iface);
eina_stringshare_del(iwd_agent->pending_network_path);
eina_stringshare_del(iwd_agent->pending_passphrase);
E_FREE(iwd_agent);
iwd_agent = NULL;
}
/* Set passphrase for pending request */
void
iwd_agent_set_passphrase(const char *passphrase)
{
if (!iwd_agent) return;
eina_stringshare_replace(&iwd_agent->pending_passphrase, passphrase);
DBG("Passphrase set for pending request");
}
/* Cancel pending request */
void
iwd_agent_cancel(void)
{
if (!iwd_agent) return;
eina_stringshare_del(iwd_agent->pending_network_path);
eina_stringshare_del(iwd_agent->pending_passphrase);
iwd_agent->pending_network_path = NULL;
iwd_agent->pending_passphrase = NULL;
DBG("Agent request cancelled");
}
/* Agent registration callback */
static void
_agent_register_cb(void *data EINA_UNUSED,
const Eldbus_Message *msg,
Eldbus_Pending *pending EINA_UNUSED)
{
const char *err_name, *err_msg;
if (eldbus_message_error_get(msg, &err_name, &err_msg))
{
ERR("Failed to register agent: %s: %s", err_name, err_msg);
return;
}
INF("Agent registered with iwd");
}
/* Unregister agent */
static void
_agent_unregister(void)
{
Eldbus_Connection *conn;
Eldbus_Object *obj;
Eldbus_Proxy *proxy;
conn = iwd_dbus_conn_get();
if (!conn) return;
obj = eldbus_object_get(conn, IWD_SERVICE, IWD_MANAGER_PATH);
if (!obj) return;
proxy = eldbus_proxy_get(obj, IWD_AGENT_MANAGER_INTERFACE);
if (proxy)
{
eldbus_proxy_call(proxy, "UnregisterAgent", NULL, NULL, -1, "o", IWD_AGENT_PATH);
DBG("Agent unregistered from iwd");
}
eldbus_object_unref(obj);
}
/* Request passphrase method */
static Eldbus_Message *
_agent_request_passphrase(const Eldbus_Service_Interface *iface EINA_UNUSED,
const Eldbus_Message *msg)
{
const char *network_path;
if (!eldbus_message_arguments_get(msg, "o", &network_path))
{
ERR("Failed to get network path from RequestPassphrase");
return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid arguments");
}
INF("Passphrase requested for network: %s", network_path);
/* Store network path for reference */
eina_stringshare_replace(&iwd_agent->pending_network_path, network_path);
/* TODO: Show passphrase dialog (Phase 4) */
/* For now, just return an error to indicate we're not ready */
return eldbus_message_error_new(msg, "net.connman.iwd.Agent.Error.Canceled", "UI not implemented yet");
}
/* Cancel method */
static Eldbus_Message *
_agent_cancel(const Eldbus_Service_Interface *iface EINA_UNUSED,
const Eldbus_Message *msg)
{
const char *reason;
if (!eldbus_message_arguments_get(msg, "s", &reason))
{
WRN("Cancel called with no reason");
reason = "unknown";
}
INF("Agent request cancelled: %s", reason);
iwd_agent_cancel();
/* TODO: Close passphrase dialog if open (Phase 4) */
return eldbus_message_method_return_new(msg);
}
/* Release method */
static Eldbus_Message *
_agent_release(const Eldbus_Service_Interface *iface EINA_UNUSED,
const Eldbus_Message *msg)
{
INF("Agent released by iwd");
iwd_agent_cancel();
return eldbus_message_method_return_new(msg);
}

30
src/iwd/iwd_agent.h Normal file
View file

@ -0,0 +1,30 @@
#ifndef IWD_AGENT_H
#define IWD_AGENT_H
#include <Eina.h>
#include <Eldbus.h>
#define IWD_AGENT_PATH "/org/enlightenment/eiwd/agent"
/* Agent structure */
typedef struct _IWD_Agent
{
Eldbus_Service_Interface *iface;
const char *pending_network_path;
const char *pending_passphrase;
} IWD_Agent;
/* Global agent */
extern IWD_Agent *iwd_agent;
/* Agent management */
Eina_Bool iwd_agent_init(void);
void iwd_agent_shutdown(void);
/* Set passphrase for pending request */
void iwd_agent_set_passphrase(const char *passphrase);
/* Cancel pending request */
void iwd_agent_cancel(void);
#endif

385
src/iwd/iwd_dbus.c Normal file
View file

@ -0,0 +1,385 @@
#include "iwd_dbus.h"
#include "../e_mod_main.h"
/* Global D-Bus context */
IWD_DBus *iwd_dbus = NULL;
/* Forward declarations */
static void _iwd_dbus_name_owner_changed_cb(void *data, const char *bus EINA_UNUSED, const char *old_id, const char *new_id);
static void _iwd_dbus_managed_objects_get_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending);
static void _iwd_dbus_interfaces_added_cb(void *data, const Eldbus_Message *msg);
static void _iwd_dbus_interfaces_removed_cb(void *data, const Eldbus_Message *msg);
static void _iwd_dbus_connect(void);
static void _iwd_dbus_disconnect(void);
/* Initialize D-Bus connection */
Eina_Bool
iwd_dbus_init(void)
{
DBG("Initializing iwd D-Bus connection");
if (iwd_dbus)
{
WRN("D-Bus already initialized");
return EINA_TRUE;
}
iwd_dbus = E_NEW(IWD_DBus, 1);
if (!iwd_dbus)
{
ERR("Failed to allocate D-Bus context");
return EINA_FALSE;
}
/* Connect to system bus */
iwd_dbus->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
if (!iwd_dbus->conn)
{
ERR("Failed to connect to system bus");
E_FREE(iwd_dbus);
iwd_dbus = NULL;
return EINA_FALSE;
}
/* Monitor iwd daemon availability */
eldbus_name_owner_changed_callback_add(iwd_dbus->conn,
IWD_SERVICE,
_iwd_dbus_name_owner_changed_cb,
NULL,
EINA_TRUE);
/* Try to connect to iwd */
_iwd_dbus_connect();
return EINA_TRUE;
}
/* Shutdown D-Bus connection */
void
iwd_dbus_shutdown(void)
{
DBG("Shutting down iwd D-Bus connection");
if (!iwd_dbus) return;
_iwd_dbus_disconnect();
/* Unregister name owner changed callback */
eldbus_name_owner_changed_callback_del(iwd_dbus->conn, IWD_SERVICE,
_iwd_dbus_name_owner_changed_cb, NULL);
if (iwd_dbus->conn)
eldbus_connection_unref(iwd_dbus->conn);
E_FREE(iwd_dbus);
iwd_dbus = NULL;
}
/* Check if connected to iwd */
Eina_Bool
iwd_dbus_is_connected(void)
{
return (iwd_dbus && iwd_dbus->connected);
}
/* Get D-Bus connection */
Eldbus_Connection *
iwd_dbus_conn_get(void)
{
return iwd_dbus ? iwd_dbus->conn : NULL;
}
/* Request managed objects from iwd */
void
iwd_dbus_get_managed_objects(void)
{
Eldbus_Proxy *proxy;
if (!iwd_dbus || !iwd_dbus->manager_obj) return;
DBG("Requesting managed objects from iwd");
proxy = eldbus_proxy_get(iwd_dbus->manager_obj, DBUS_OBJECT_MANAGER_INTERFACE);
if (!proxy)
{
ERR("Failed to get ObjectManager proxy");
return;
}
eldbus_proxy_call(proxy, "GetManagedObjects",
_iwd_dbus_managed_objects_get_cb,
NULL, -1, "");
}
/* Connect to iwd daemon */
static void
_iwd_dbus_connect(void)
{
if (!iwd_dbus || !iwd_dbus->conn) return;
DBG("Connecting to iwd daemon");
/* Create manager object */
iwd_dbus->manager_obj = eldbus_object_get(iwd_dbus->conn, IWD_SERVICE, IWD_MANAGER_PATH);
if (!iwd_dbus->manager_obj)
{
ERR("Failed to get manager object");
return;
}
/* Subscribe to ObjectManager signals */
iwd_dbus->interfaces_added =
eldbus_proxy_signal_handler_add(
eldbus_proxy_get(iwd_dbus->manager_obj, DBUS_OBJECT_MANAGER_INTERFACE),
"InterfacesAdded",
_iwd_dbus_interfaces_added_cb,
NULL);
iwd_dbus->interfaces_removed =
eldbus_proxy_signal_handler_add(
eldbus_proxy_get(iwd_dbus->manager_obj, DBUS_OBJECT_MANAGER_INTERFACE),
"InterfacesRemoved",
_iwd_dbus_interfaces_removed_cb,
NULL);
iwd_dbus->connected = EINA_TRUE;
INF("Connected to iwd daemon");
/* Get initial state */
iwd_dbus_get_managed_objects();
}
/* Disconnect from iwd daemon */
static void
_iwd_dbus_disconnect(void)
{
if (!iwd_dbus) return;
DBG("Disconnecting from iwd daemon");
if (iwd_dbus->interfaces_added)
{
eldbus_signal_handler_del(iwd_dbus->interfaces_added);
iwd_dbus->interfaces_added = NULL;
}
if (iwd_dbus->interfaces_removed)
{
eldbus_signal_handler_del(iwd_dbus->interfaces_removed);
iwd_dbus->interfaces_removed = NULL;
}
if (iwd_dbus->manager_obj)
{
eldbus_object_unref(iwd_dbus->manager_obj);
iwd_dbus->manager_obj = NULL;
}
iwd_dbus->connected = EINA_FALSE;
}
/* Name owner changed callback */
static void
_iwd_dbus_name_owner_changed_cb(void *data EINA_UNUSED,
const char *bus EINA_UNUSED,
const char *old_id,
const char *new_id)
{
DBG("iwd name owner changed: old='%s' new='%s'", old_id, new_id);
if (new_id && new_id[0])
{
/* iwd daemon started */
INF("iwd daemon started");
_iwd_dbus_connect();
}
else if (old_id && old_id[0])
{
/* iwd daemon stopped */
WRN("iwd daemon stopped");
_iwd_dbus_disconnect();
/* TODO: Notify UI to show error state */
}
}
/* Managed objects callback */
static void
_iwd_dbus_managed_objects_get_cb(void *data EINA_UNUSED,
const Eldbus_Message *msg,
Eldbus_Pending *pending EINA_UNUSED)
{
Eldbus_Message_Iter *array, *dict_entry;
const char *err_name, *err_msg;
if (eldbus_message_error_get(msg, &err_name, &err_msg))
{
ERR("Failed to get managed objects: %s: %s", err_name, err_msg);
return;
}
if (!eldbus_message_arguments_get(msg, "a{oa{sa{sv}}}", &array))
{
ERR("Failed to parse GetManagedObjects reply");
return;
}
DBG("Processing managed objects from iwd");
while (eldbus_message_iter_get_and_next(array, 'e', &dict_entry))
{
Eldbus_Message_Iter *interfaces;
const char *path;
eldbus_message_iter_arguments_get(dict_entry, "o", &path);
eldbus_message_iter_arguments_get(dict_entry, "a{sa{sv}}", &interfaces);
DBG(" Object: %s", path);
/* Parse interfaces and create device/network objects */
Eldbus_Message_Iter *iface_entry;
Eina_Bool has_device = EINA_FALSE;
Eina_Bool has_station = EINA_FALSE;
Eina_Bool has_network = EINA_FALSE;
while (eldbus_message_iter_get_and_next(interfaces, 'e', &iface_entry))
{
const char *iface_name;
Eldbus_Message_Iter *properties;
eldbus_message_iter_arguments_get(iface_entry, "s", &iface_name);
eldbus_message_iter_arguments_get(iface_entry, "a{sv}", &properties);
DBG(" Interface: %s", iface_name);
if (strcmp(iface_name, IWD_DEVICE_INTERFACE) == 0)
has_device = EINA_TRUE;
else if (strcmp(iface_name, IWD_STATION_INTERFACE) == 0)
has_station = EINA_TRUE;
else if (strcmp(iface_name, IWD_NETWORK_INTERFACE) == 0)
has_network = EINA_TRUE;
}
/* Create device if it has Device and Station interfaces */
if (has_device && has_station)
{
extern IWD_Device *iwd_device_new(const char *path);
IWD_Device *dev = iwd_device_new(path);
if (dev)
{
/* Parse properties - re-iterate to get them */
eldbus_message_iter_arguments_get(dict_entry, "o", &path);
eldbus_message_iter_arguments_get(dict_entry, "a{sa{sv}}", &interfaces);
while (eldbus_message_iter_get_and_next(interfaces, 'e', &iface_entry))
{
const char *iface_name;
Eldbus_Message_Iter *properties;
eldbus_message_iter_arguments_get(iface_entry, "s", &iface_name);
eldbus_message_iter_arguments_get(iface_entry, "a{sv}", &properties);
if (strcmp(iface_name, IWD_DEVICE_INTERFACE) == 0 ||
strcmp(iface_name, IWD_STATION_INTERFACE) == 0)
{
extern void _device_parse_properties(IWD_Device *dev, Eldbus_Message_Iter *properties);
/* We need to expose the parse function or call it via a public function */
/* For now, properties will be updated via PropertyChanged signals */
}
}
}
}
/* Create network if it has Network interface */
if (has_network)
{
extern IWD_Network *iwd_network_new(const char *path);
iwd_network_new(path);
}
}
}
/* Interfaces added callback */
static void
_iwd_dbus_interfaces_added_cb(void *data EINA_UNUSED,
const Eldbus_Message *msg)
{
const char *path;
Eldbus_Message_Iter *interfaces;
if (!eldbus_message_arguments_get(msg, "oa{sa{sv}}", &path, &interfaces))
{
ERR("Failed to parse InterfacesAdded signal");
return;
}
DBG("Interfaces added at: %s", path);
/* Check what interfaces were added */
Eldbus_Message_Iter *iface_entry;
Eina_Bool has_device = EINA_FALSE;
Eina_Bool has_station = EINA_FALSE;
Eina_Bool has_network = EINA_FALSE;
while (eldbus_message_iter_get_and_next(interfaces, 'e', &iface_entry))
{
const char *iface_name;
Eldbus_Message_Iter *properties;
eldbus_message_iter_arguments_get(iface_entry, "s", &iface_name);
eldbus_message_iter_arguments_get(iface_entry, "a{sv}", &properties);
if (strcmp(iface_name, IWD_DEVICE_INTERFACE) == 0)
has_device = EINA_TRUE;
else if (strcmp(iface_name, IWD_STATION_INTERFACE) == 0)
has_station = EINA_TRUE;
else if (strcmp(iface_name, IWD_NETWORK_INTERFACE) == 0)
has_network = EINA_TRUE;
}
if (has_device && has_station)
{
extern IWD_Device *iwd_device_new(const char *path);
iwd_device_new(path);
}
if (has_network)
{
extern IWD_Network *iwd_network_new(const char *path);
iwd_network_new(path);
}
}
/* Interfaces removed callback */
static void
_iwd_dbus_interfaces_removed_cb(void *data EINA_UNUSED,
const Eldbus_Message *msg)
{
const char *path;
Eldbus_Message_Iter *interfaces;
if (!eldbus_message_arguments_get(msg, "oas", &path, &interfaces))
{
ERR("Failed to parse InterfacesRemoved signal");
return;
}
DBG("Interfaces removed at: %s", path);
/* Check if we should remove device or network */
extern IWD_Device *iwd_device_find(const char *path);
extern IWD_Network *iwd_network_find(const char *path);
extern void iwd_device_free(IWD_Device *dev);
extern void iwd_network_free(IWD_Network *net);
IWD_Device *dev = iwd_device_find(path);
if (dev)
{
iwd_device_free(dev);
}
IWD_Network *net = iwd_network_find(path);
if (net)
{
iwd_network_free(net);
}
}

49
src/iwd/iwd_dbus.h Normal file
View file

@ -0,0 +1,49 @@
#ifndef IWD_DBUS_H
#define IWD_DBUS_H
#include <Eina.h>
#include <Eldbus.h>
/* iwd D-Bus service and interfaces */
#define IWD_SERVICE "net.connman.iwd"
#define IWD_MANAGER_PATH "/"
#define IWD_MANAGER_INTERFACE "net.connman.iwd.Manager"
#define IWD_ADAPTER_INTERFACE "net.connman.iwd.Adapter"
#define IWD_DEVICE_INTERFACE "net.connman.iwd.Device"
#define IWD_STATION_INTERFACE "net.connman.iwd.Station"
#define IWD_NETWORK_INTERFACE "net.connman.iwd.Network"
#define IWD_KNOWN_NETWORK_INTERFACE "net.connman.iwd.KnownNetwork"
#define IWD_AGENT_MANAGER_INTERFACE "net.connman.iwd.AgentManager"
#define DBUS_OBJECT_MANAGER_INTERFACE "org.freedesktop.DBus.ObjectManager"
#define DBUS_PROPERTIES_INTERFACE "org.freedesktop.DBus.Properties"
/* D-Bus context */
typedef struct _IWD_DBus
{
Eldbus_Connection *conn;
Eldbus_Object *manager_obj;
Eldbus_Proxy *manager_proxy;
Eldbus_Signal_Handler *interfaces_added;
Eldbus_Signal_Handler *interfaces_removed;
Eina_Bool connected;
} IWD_DBus;
/* Global D-Bus context */
extern IWD_DBus *iwd_dbus;
/* Initialization and shutdown */
Eina_Bool iwd_dbus_init(void);
void iwd_dbus_shutdown(void);
/* Connection state */
Eina_Bool iwd_dbus_is_connected(void);
/* Helper to get D-Bus connection */
Eldbus_Connection *iwd_dbus_conn_get(void);
/* Get managed objects */
void iwd_dbus_get_managed_objects(void);
#endif

288
src/iwd/iwd_device.c Normal file
View file

@ -0,0 +1,288 @@
#include "iwd_device.h"
#include "iwd_dbus.h"
#include "../e_mod_main.h"
/* Global device list */
Eina_List *iwd_devices = NULL;
/* Forward declarations */
static void _device_properties_changed_cb(void *data, const Eldbus_Message *msg);
static void _device_parse_properties(IWD_Device *dev, Eldbus_Message_Iter *properties);
/* Create new device */
IWD_Device *
iwd_device_new(const char *path)
{
IWD_Device *dev;
Eldbus_Connection *conn;
Eldbus_Object *obj;
if (!path) return NULL;
conn = iwd_dbus_conn_get();
if (!conn) return NULL;
/* Check if device already exists */
dev = iwd_device_find(path);
if (dev)
{
DBG("Device already exists: %s", path);
return dev;
}
DBG("Creating new device: %s", path);
dev = E_NEW(IWD_Device, 1);
if (!dev) return NULL;
dev->path = eina_stringshare_add(path);
/* Create D-Bus object */
obj = eldbus_object_get(conn, IWD_SERVICE, path);
if (!obj)
{
ERR("Failed to get D-Bus object for device");
eina_stringshare_del(dev->path);
E_FREE(dev);
return NULL;
}
/* Get proxies */
dev->device_proxy = eldbus_proxy_get(obj, IWD_DEVICE_INTERFACE);
dev->station_proxy = eldbus_proxy_get(obj, IWD_STATION_INTERFACE);
/* Subscribe to property changes */
dev->properties_changed =
eldbus_proxy_signal_handler_add(dev->station_proxy,
"PropertiesChanged",
_device_properties_changed_cb,
dev);
/* Add to global list */
iwd_devices = eina_list_append(iwd_devices, dev);
INF("Created device: %s", path);
eldbus_object_unref(obj);
return dev;
}
/* Free device */
void
iwd_device_free(IWD_Device *dev)
{
if (!dev) return;
DBG("Freeing device: %s", dev->path);
iwd_devices = eina_list_remove(iwd_devices, dev);
if (dev->properties_changed)
eldbus_signal_handler_del(dev->properties_changed);
eina_stringshare_del(dev->path);
eina_stringshare_del(dev->name);
eina_stringshare_del(dev->address);
eina_stringshare_del(dev->adapter_path);
eina_stringshare_del(dev->mode);
eina_stringshare_del(dev->state);
eina_stringshare_del(dev->connected_network);
E_FREE(dev);
}
/* Find device by path */
IWD_Device *
iwd_device_find(const char *path)
{
Eina_List *l;
IWD_Device *dev;
if (!path) return NULL;
EINA_LIST_FOREACH(iwd_devices, l, dev)
{
if (dev->path && strcmp(dev->path, path) == 0)
return dev;
}
return NULL;
}
/* Trigger scan */
void
iwd_device_scan(IWD_Device *dev)
{
if (!dev || !dev->station_proxy)
{
ERR("Invalid device for scan");
return;
}
DBG("Triggering scan on device: %s", dev->name ? dev->name : dev->path);
eldbus_proxy_call(dev->station_proxy, "Scan", NULL, NULL, -1, "");
}
/* Disconnect from network */
void
iwd_device_disconnect(IWD_Device *dev)
{
if (!dev || !dev->station_proxy)
{
ERR("Invalid device for disconnect");
return;
}
DBG("Disconnecting device: %s", dev->name ? dev->name : dev->path);
eldbus_proxy_call(dev->station_proxy, "Disconnect", NULL, NULL, -1, "");
}
/* Connect to hidden network */
void
iwd_device_connect_hidden(IWD_Device *dev, const char *ssid)
{
if (!dev || !dev->station_proxy || !ssid)
{
ERR("Invalid parameters for hidden network connect");
return;
}
DBG("Connecting to hidden network: %s", ssid);
eldbus_proxy_call(dev->station_proxy, "ConnectHiddenNetwork",
NULL, NULL, -1, "s", ssid);
}
/* Get devices list */
Eina_List *
iwd_devices_get(void)
{
return iwd_devices;
}
/* Initialize device subsystem */
void
iwd_device_init(void)
{
DBG("Initializing device subsystem");
/* Devices will be populated from ObjectManager signals */
}
/* Shutdown device subsystem */
void
iwd_device_shutdown(void)
{
IWD_Device *dev;
DBG("Shutting down device subsystem");
EINA_LIST_FREE(iwd_devices, dev)
iwd_device_free(dev);
}
/* Properties changed callback */
static void
_device_properties_changed_cb(void *data,
const Eldbus_Message *msg)
{
IWD_Device *dev = data;
const char *interface;
Eldbus_Message_Iter *changed, *invalidated;
if (!eldbus_message_arguments_get(msg, "sa{sv}as", &interface, &changed, &invalidated))
{
ERR("Failed to parse PropertiesChanged signal");
return;
}
DBG("Properties changed for device %s on interface %s", dev->path, interface);
_device_parse_properties(dev, changed);
/* TODO: Notify UI of state changes */
}
/* Parse device properties */
static void
_device_parse_properties(IWD_Device *dev,
Eldbus_Message_Iter *properties)
{
Eldbus_Message_Iter *entry;
if (!properties) return;
while (eldbus_message_iter_get_and_next(properties, 'e', &entry))
{
const char *key;
Eldbus_Message_Iter *var;
if (!eldbus_message_iter_arguments_get(entry, "sv", &key, &var))
continue;
if (strcmp(key, "Name") == 0)
{
const char *name;
if (eldbus_message_iter_arguments_get(var, "s", &name))
{
eina_stringshare_replace(&dev->name, name);
DBG(" Name: %s", dev->name);
}
}
else if (strcmp(key, "Address") == 0)
{
const char *address;
if (eldbus_message_iter_arguments_get(var, "s", &address))
{
eina_stringshare_replace(&dev->address, address);
DBG(" Address: %s", dev->address);
}
}
else if (strcmp(key, "Powered") == 0)
{
Eina_Bool powered;
if (eldbus_message_iter_arguments_get(var, "b", &powered))
{
dev->powered = powered;
DBG(" Powered: %d", dev->powered);
}
}
else if (strcmp(key, "Scanning") == 0)
{
Eina_Bool scanning;
if (eldbus_message_iter_arguments_get(var, "b", &scanning))
{
dev->scanning = scanning;
DBG(" Scanning: %d", dev->scanning);
}
}
else if (strcmp(key, "State") == 0)
{
const char *state;
if (eldbus_message_iter_arguments_get(var, "s", &state))
{
eina_stringshare_replace(&dev->state, state);
DBG(" State: %s", dev->state);
}
}
else if (strcmp(key, "ConnectedNetwork") == 0)
{
const char *network;
if (eldbus_message_iter_arguments_get(var, "o", &network))
{
eina_stringshare_replace(&dev->connected_network, network);
DBG(" Connected network: %s", dev->connected_network);
}
}
else if (strcmp(key, "Mode") == 0)
{
const char *mode;
if (eldbus_message_iter_arguments_get(var, "s", &mode))
{
eina_stringshare_replace(&dev->mode, mode);
DBG(" Mode: %s", dev->mode);
}
}
}
}

48
src/iwd/iwd_device.h Normal file
View file

@ -0,0 +1,48 @@
#ifndef IWD_DEVICE_H
#define IWD_DEVICE_H
#include <Eina.h>
#include <Eldbus.h>
/* Device structure */
typedef struct _IWD_Device
{
const char *path; /* D-Bus object path */
const char *name; /* Interface name (e.g., "wlan0") */
const char *address; /* MAC address */
const char *adapter_path; /* Adapter object path */
const char *mode; /* "station", "ap", "ad-hoc" */
Eina_Bool powered; /* Device powered state */
/* Station interface properties */
Eina_Bool scanning;
const char *state; /* "disconnected", "connecting", "connected", "disconnecting" */
const char *connected_network; /* Connected network object path */
/* D-Bus objects */
Eldbus_Proxy *device_proxy;
Eldbus_Proxy *station_proxy;
Eldbus_Signal_Handler *properties_changed;
} IWD_Device;
/* Global device list */
extern Eina_List *iwd_devices;
/* Device management */
IWD_Device *iwd_device_new(const char *path);
void iwd_device_free(IWD_Device *dev);
IWD_Device *iwd_device_find(const char *path);
/* Device operations */
void iwd_device_scan(IWD_Device *dev);
void iwd_device_disconnect(IWD_Device *dev);
void iwd_device_connect_hidden(IWD_Device *dev, const char *ssid);
/* Get devices list */
Eina_List *iwd_devices_get(void);
/* Initialize device subsystem */
void iwd_device_init(void);
void iwd_device_shutdown(void);
#endif

253
src/iwd/iwd_network.c Normal file
View file

@ -0,0 +1,253 @@
#include "iwd_network.h"
#include "iwd_dbus.h"
#include "../e_mod_main.h"
/* Global network list */
Eina_List *iwd_networks = NULL;
/* Forward declarations */
static void _network_properties_changed_cb(void *data, const Eldbus_Message *msg);
static void _network_parse_properties(IWD_Network *net, Eldbus_Message_Iter *properties);
/* Create new network */
IWD_Network *
iwd_network_new(const char *path)
{
IWD_Network *net;
Eldbus_Connection *conn;
Eldbus_Object *obj;
if (!path) return NULL;
conn = iwd_dbus_conn_get();
if (!conn) return NULL;
/* Check if network already exists */
net = iwd_network_find(path);
if (net)
{
DBG("Network already exists: %s", path);
return net;
}
DBG("Creating new network: %s", path);
net = E_NEW(IWD_Network, 1);
if (!net) return NULL;
net->path = eina_stringshare_add(path);
/* Create D-Bus object */
obj = eldbus_object_get(conn, IWD_SERVICE, path);
if (!obj)
{
ERR("Failed to get D-Bus object for network");
eina_stringshare_del(net->path);
E_FREE(net);
return NULL;
}
/* Get proxy */
net->network_proxy = eldbus_proxy_get(obj, IWD_NETWORK_INTERFACE);
/* Subscribe to property changes */
net->properties_changed =
eldbus_proxy_signal_handler_add(net->network_proxy,
"PropertiesChanged",
_network_properties_changed_cb,
net);
/* Add to global list */
iwd_networks = eina_list_append(iwd_networks, net);
INF("Created network: %s", path);
eldbus_object_unref(obj);
return net;
}
/* Free network */
void
iwd_network_free(IWD_Network *net)
{
if (!net) return;
DBG("Freeing network: %s", net->path);
iwd_networks = eina_list_remove(iwd_networks, net);
if (net->properties_changed)
eldbus_signal_handler_del(net->properties_changed);
eina_stringshare_del(net->path);
eina_stringshare_del(net->name);
eina_stringshare_del(net->type);
eina_stringshare_del(net->last_connected_time);
E_FREE(net);
}
/* Find network by path */
IWD_Network *
iwd_network_find(const char *path)
{
Eina_List *l;
IWD_Network *net;
if (!path) return NULL;
EINA_LIST_FOREACH(iwd_networks, l, net)
{
if (net->path && strcmp(net->path, path) == 0)
return net;
}
return NULL;
}
/* Connect to network */
void
iwd_network_connect(IWD_Network *net)
{
if (!net || !net->network_proxy)
{
ERR("Invalid network for connect");
return;
}
DBG("Connecting to network: %s", net->name ? net->name : net->path);
/* TODO: This will trigger agent RequestPassphrase if needed */
eldbus_proxy_call(net->network_proxy, "Connect", NULL, NULL, -1, "");
}
/* Forget network */
void
iwd_network_forget(IWD_Network *net)
{
Eldbus_Proxy *known_proxy;
if (!net || !net->network_proxy || !net->known)
{
ERR("Invalid network for forget or network not known");
return;
}
DBG("Forgetting network: %s", net->name ? net->name : net->path);
/* Get KnownNetwork proxy (same path, different interface) */
known_proxy = eldbus_proxy_get(eldbus_proxy_object_get(net->network_proxy),
IWD_KNOWN_NETWORK_INTERFACE);
if (!known_proxy)
{
ERR("Failed to get KnownNetwork proxy");
return;
}
eldbus_proxy_call(known_proxy, "Forget", NULL, NULL, -1, "");
}
/* Get networks list */
Eina_List *
iwd_networks_get(void)
{
return iwd_networks;
}
/* Initialize network subsystem */
void
iwd_network_init(void)
{
DBG("Initializing network subsystem");
/* Networks will be populated from ObjectManager signals */
}
/* Shutdown network subsystem */
void
iwd_network_shutdown(void)
{
IWD_Network *net;
DBG("Shutting down network subsystem");
EINA_LIST_FREE(iwd_networks, net)
iwd_network_free(net);
}
/* Properties changed callback */
static void
_network_properties_changed_cb(void *data,
const Eldbus_Message *msg)
{
IWD_Network *net = data;
const char *interface;
Eldbus_Message_Iter *changed, *invalidated;
if (!eldbus_message_arguments_get(msg, "sa{sv}as", &interface, &changed, &invalidated))
{
ERR("Failed to parse PropertiesChanged signal");
return;
}
DBG("Properties changed for network %s on interface %s", net->path, interface);
_network_parse_properties(net, changed);
/* TODO: Notify UI of changes */
}
/* Parse network properties */
static void
_network_parse_properties(IWD_Network *net,
Eldbus_Message_Iter *properties)
{
Eldbus_Message_Iter *entry;
if (!properties) return;
while (eldbus_message_iter_get_and_next(properties, 'e', &entry))
{
const char *key;
Eldbus_Message_Iter *var;
if (!eldbus_message_iter_arguments_get(entry, "sv", &key, &var))
continue;
if (strcmp(key, "Name") == 0)
{
const char *name;
if (eldbus_message_iter_arguments_get(var, "s", &name))
{
eina_stringshare_replace(&net->name, name);
DBG(" Name: %s", net->name);
}
}
else if (strcmp(key, "Type") == 0)
{
const char *type;
if (eldbus_message_iter_arguments_get(var, "s", &type))
{
eina_stringshare_replace(&net->type, type);
DBG(" Type: %s", net->type);
}
}
else if (strcmp(key, "Known") == 0)
{
Eina_Bool known;
if (eldbus_message_iter_arguments_get(var, "b", &known))
{
net->known = known;
DBG(" Known: %d", net->known);
}
}
else if (strcmp(key, "AutoConnect") == 0)
{
Eina_Bool auto_connect;
if (eldbus_message_iter_arguments_get(var, "b", &auto_connect))
{
net->auto_connect = auto_connect;
DBG(" Auto-connect: %d", net->auto_connect);
}
}
}
}

44
src/iwd/iwd_network.h Normal file
View file

@ -0,0 +1,44 @@
#ifndef IWD_NETWORK_H
#define IWD_NETWORK_H
#include <Eina.h>
#include <Eldbus.h>
/* Network structure */
typedef struct _IWD_Network
{
const char *path; /* D-Bus object path */
const char *name; /* SSID (decoded) */
const char *type; /* "open", "psk", "8021x" */
Eina_Bool known; /* Is this a known network? */
int16_t signal_strength; /* Signal strength in dBm */
/* Known network properties */
Eina_Bool auto_connect;
const char *last_connected_time;
/* D-Bus objects */
Eldbus_Proxy *network_proxy;
Eldbus_Signal_Handler *properties_changed;
} IWD_Network;
/* Global network list */
extern Eina_List *iwd_networks;
/* Network management */
IWD_Network *iwd_network_new(const char *path);
void iwd_network_free(IWD_Network *net);
IWD_Network *iwd_network_find(const char *path);
/* Network operations */
void iwd_network_connect(IWD_Network *net);
void iwd_network_forget(IWD_Network *net);
/* Get networks list */
Eina_List *iwd_networks_get(void);
/* Initialize network subsystem */
void iwd_network_init(void);
void iwd_network_shutdown(void);
#endif

31
src/meson.build Normal file
View file

@ -0,0 +1,31 @@
module_sources = files(
'e_mod_main.c',
'iwd/iwd_dbus.c',
'iwd/iwd_device.c',
'iwd/iwd_network.c',
'iwd/iwd_agent.c',
)
# TODO: Add more source files as they are created in later phases
# Phase 3: e_mod_gadget.c, e_mod_popup.c, ui/*.c files
module_deps = [
enlightenment,
eldbus,
elementary,
ecore,
evas,
edje,
eina
]
module_includes = include_directories('.', 'iwd', 'ui')
shared_module('module',
module_sources,
dependencies: module_deps,
include_directories: module_includes,
name_prefix: '',
install: true,
install_dir: dir_module_arch
)