void options_file_save(GKeyFile *kf, const char *leafname)
{
char *pathname = options_file_filename_for_saving(leafname, NULL);
char *file_data;
gsize data_len;
GError *err = NULL;
if (!pathname)
return;
/* leafname may actually be a relative path, so make sure any directories
* in it exist */
if (strchr(leafname, G_DIR_SEPARATOR))
{
char *dirname = g_path_get_dirname(pathname);
options_file_mkdir_with_parents(dirname);
g_free(dirname);
}
file_data = g_key_file_to_data(kf, &data_len, &err);
if (err)
{
if (err && !STR_EMPTY(err->message))
{
dlg_critical(NULL, _("Unable to generate options file %s: %s"),
pathname, err->message);
}
else
{
dlg_critical(NULL, _("Unable to generate options file %s"),
pathname);
}
g_error_free(err);
}
else if (file_data)
{
if (!g_file_set_contents(pathname, file_data, data_len, &err))
{
if (err && !STR_EMPTY(err->message))
{
dlg_critical(NULL, _("Unable to save options file %s: %s"),
pathname, err->message);
}
else
{
dlg_critical(NULL, _("Unable to save options file %s"),
pathname);
}
if (err)
g_error_free(err);
}
}
g_free(pathname);
g_free(file_data);
}
/* --- PRIVATE FUNCTIONS ---------------------------------------------------- */
static void CallbackGroupMember(
_In_ CSV_HANDLE hOutfile,
_In_ CSV_HANDLE hDenyOutfile,
_Inout_ LPTSTR *tokens
) {
BOOL bResult = FALSE;
LPTSTR pMember = NULL;
LPTSTR next = NULL;
LPTSTR listMember = NULL;
UNREFERENCED_PARAMETER(hDenyOutfile);
if (STR_EMPTY(tokens[LdpListMember]))
return;
listMember = _tcsdup(tokens[LdpListMember]);
pMember = _tcstok_s(listMember, _T(";"), &next);
while (pMember) {
bResult = ControlWriteOutline(hOutfile, pMember, tokens[LdpListDn], CONTROL_MEMBER_KEYWORD);
if (!bResult) {
LOG(Err, _T("Cannot write outline for <%s>"), tokens[LdpListDn]);
}
pMember = _tcstok_s(NULL, _T(";"), &next);
}
free(listMember);
}
static void CallbackMakeAllNodes(
_In_ CSV_HANDLE hOutfile,
_In_ CSV_HANDLE hDenyOutfile,
_In_ LPTSTR *tokens
) {
BOOL bResult = FALSE;
CACHE_OBJECT_BY_DN cacheEntry = { 0 };
PCACHE_OBJECT_BY_DN inserted = NULL;
BOOL newElement = FALSE;
DWORD i = 0;
UNREFERENCED_PARAMETER(hDenyOutfile);
if (STR_EMPTY(tokens[RelDnMaster]) || STR_EMPTY(tokens[RelDnSlave]))
return;
for (i = 0; i < 2; i++) {
cacheEntry.dn = _tcsdup(tokens[i]);
if (!cacheEntry.dn)
FATAL(_T("Could not dup dn <%s>"), tokens[i]);
cacheEntry.objectClass = _tcsdup(_T("unknown"));
if (!cacheEntry.objectClass)
FATAL(_T("Could not dup objectclass for dn <%s>"), tokens[i]);
CacheEntryInsert(
ppCache,
(PVOID)&cacheEntry,
sizeof(CACHE_OBJECT_BY_DN),
&inserted,
&newElement
);
if (!inserted) {
LOG(Err, _T("cannot insert new object-by-dn cache entry <%s>"), tokens[i]);
}
else if (!newElement) {
LOG(Dbg, _T("object-by-dn cache entry is not new <%s>"), tokens[i]);
free(cacheEntry.dn);
free(cacheEntry.objectClass);
}
else {
LOG(Dbg, _T("successfully inserted new object-by-dn entry for <%d>, writing to file"), tokens[i]);
bResult = ControlWriteOutline(hOutfile, cacheEntry.dn, cacheEntry.objectClass, CONTROL_ALLNODES_KEYWORD);
}
}
}
/* --- PRIVATE FUNCTIONS ---------------------------------------------------- */
static void CallbackExchRoleEntry(
_In_ CSV_HANDLE hOutfile,
_In_ CSV_HANDLE hDenyOutfile,
_Inout_ LPTSTR *tokens
) {
UNREFERENCED_PARAMETER(hDenyOutfile);
BOOL bResult = FALSE;
LPTSTR roleEntry = NULL;
LPTSTR roleEntryName = NULL;
LPTSTR listMsExchRoleEntries = NULL;
LPTSTR nextEntry = NULL;
LPTSTR nextEntryField = NULL;
LPTSTR domainDN = NULL;
LPTSTR dn = NULL;
DWORD roleEntryIndex = 0;
size_t eTSDNlen = 0;
if (!exchangeTrustedSubsystemDN) {
dn = _tcsdup(tokens[LdpListDn]);
domainDN = _tcsstr(dn, _T("dc="));
eTSDNlen = _tcslen(ETS_PARTIAL_DN) + _tcslen(domainDN) + 1;
exchangeTrustedSubsystemDN = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,eTSDNlen * sizeof(TCHAR));
if (!exchangeTrustedSubsystemDN) {
LOG(Err, _T("Cannot allocate DN string"));
}
_tcsncat_s(exchangeTrustedSubsystemDN, eTSDNlen, ETS_PARTIAL_DN, _tcslen(ETS_PARTIAL_DN));
_tcsncat_s(exchangeTrustedSubsystemDN, eTSDNlen, domainDN, _tcslen(domainDN));
}
// Do we have role entries
if (STR_EMPTY(tokens[LdpListMsExchRoleEntries]))
return;
listMsExchRoleEntries = _tcsdup(tokens[LdpListMsExchRoleEntries]);
CharLower(listMsExchRoleEntries);
roleEntry = _tcstok_s(listMsExchRoleEntries, _T(";"), &nextEntry);
while (roleEntry) {
roleEntryName = _tcstok_s(roleEntry, _T(","), &nextEntryField);
roleEntryName = _tcstok_s(NULL, _T(","), &nextEntryField);
if (IsInSetOfStrings(roleEntryName, controlRoleEntryList, CONTROL_ROLE_ENTRY_COUNT, &roleEntryIndex)) {
bResult = ControlWriteOutline(hOutfile, tokens[LdpListDn], exchangeTrustedSubsystemDN, gc_RoleEntryKeyword[roleEntryIndex]);
if (!bResult) {
LOG(Err, _T("Cannot write outline for <%s>"), tokens[LdpListDn]);
}
}
nextEntryField = NULL;
roleEntry = _tcstok_s(NULL, _T(";"), &nextEntry);
}
free(listMsExchRoleEntries);
}
static void
home_widget_add_module_response (ClutterActor *dialog,
const gchar *module,
MnbHomeWidget *self)
{
if (!STR_EMPTY (module))
{
DEBUG ("Setting module '%s', chosen from dialog", module);
home_widget_set_module (self, module);
}
g_object_unref (dialog);
/* FIXME: why do I need this */
clutter_actor_queue_redraw (clutter_actor_get_stage (CLUTTER_ACTOR (self)));
}
static void
home_widget_set_module (MnbHomeWidget *self,
const gchar *module)
{
if (0 == g_strcmp0 (module, self->priv->module))
return;
DEBUG ("%s -> %s (%s)", self->priv->module, module,
self->priv->settings_path);
g_free (self->priv->module);
self->priv->module = g_strdup (module);
if (self->priv->app != NULL)
dawati_home_plugins_app_deinit (self->priv->app);
g_clear_object (&self->priv->app);
if (STR_EMPTY (self->priv->module))
{
DEBUG ("no module, going into edit mode (%s)",
self->priv->settings_path);
mnb_home_widget_set_edit_mode (self, TRUE);
}
else
{
DEBUG ("module = '%s' (%s)", self->priv->module,
self->priv->settings_path);
if (self->priv->engine == NULL)
self->priv->engine = mnb_home_plugins_engine_dup ();
self->priv->app =
mnb_home_plugins_engine_create_app (self->priv->engine,
self->priv->module, self->priv->settings_path);
if (self->priv->app != NULL)
dawati_home_plugins_app_init (self->priv->app);
}
/* reload the widget */
mnb_home_widget_set_edit_mode (self, self->priv->edit_mode);
g_object_notify (G_OBJECT (self), "module");
}
GKeyFile *options_file_open(const char *leafname, const char *group_name)
{
char *filename;
GKeyFile *kf = g_key_file_new();
GError *err = NULL;
char *first_group;
options_file_init_paths();
filename = options_file_build_filename(leafname, NULL);
if (!filename)
return kf;
if (!g_key_file_load_from_file(kf, filename,
G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS,
&err))
{
if (err && !STR_EMPTY(err->message))
dlg_critical(NULL, _("Can't read options file %s: %s"),
filename, err->message);
else
dlg_critical(NULL, _("Can't read options file %s"), filename);
if (err)
g_error_free(err);
g_free(filename);
return kf;
}
first_group = g_key_file_get_start_group(kf);
if (!first_group || strcmp(first_group, group_name))
{
dlg_critical(NULL, _("Options file %s does not start with group '%s'"),
filename, group_name);
g_key_file_free(kf);
kf = g_key_file_new();
}
g_free(first_group);
g_free(filename);
return kf;
}
void
mnb_home_widget_set_edit_mode (MnbHomeWidget *self,
gboolean edit_mode)
{
//if (edit_mode == self->priv->edit_mode)
// return;
DEBUG ("%d -> %d for widget %s", self->priv->edit_mode,
edit_mode, self->priv->settings_path);
self->priv->edit_mode = edit_mode;
//g_object_notify (G_OBJECT (self), "edit-mode");
/* FIXME: should hold refs to the actors rather than destroy/recreate them? */
mx_bin_set_child (MX_BIN (self), NULL);
/* FIXME: animate this */
if (edit_mode)
{
ClutterActor *table;
table = mx_table_new ();
mx_bin_set_child (MX_BIN (self), table);
if (!STR_EMPTY (self->priv->module))
{
ClutterActor *config, *remove;
remove = mx_button_new_with_label ("x");
mx_table_insert_actor_with_properties (MX_TABLE (table), remove, 0, 1,
"x-expand", FALSE,
"y-expand", FALSE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
g_signal_connect (remove, "clicked",
G_CALLBACK (home_widget_remove_module), self);
if (self->priv->app != NULL)
config = dawati_home_plugins_app_get_configuration (
self->priv->app);
else
config = mx_label_new_with_text (_("Plugin missing"));
if (CLUTTER_IS_ACTOR (config))
mx_table_insert_actor_with_properties (MX_TABLE (table), config, 1, 0,
"x-expand", TRUE,
"y-expand", TRUE,
"x-fill", TRUE,
"y-fill", TRUE,
NULL);
}
else /* STR_EMPTY (self->priv->module) */
{
ClutterActor *button;
button = mx_button_new_with_label ("+");
mx_table_insert_actor (MX_TABLE (table), button, 0, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (home_widget_add_module), self);
}
clutter_actor_show_all (table);
}
else /* !edit_mode */
{
ClutterActor *widget = NULL;
if (self->priv->app != NULL)
{
widget = dawati_home_plugins_app_get_widget (self->priv->app);
if (!CLUTTER_IS_ACTOR (widget))
/* FIXME: make this better */
{
widget = mx_label_new_with_text (_("Broken plugin"));
}
}
else if (!STR_EMPTY (self->priv->module))
{
widget = mx_label_new_with_text (_("Plugin missing"));
}
if (widget != NULL)
mx_bin_set_child (MX_BIN (self), widget);
}
}
/*
* Executes SQL statement zSql on zDatabase, using parameters zArgs and file name substitutions zFileArgs
* Result data is loaded onto pData, and pRowCnt and pColCnt will indicate number of loaded rows and
* number of columns in the row. Total number of items in pData will be nRowCnt * nColCnt
*/
static int
_runSql(char *zDatabase, char *zSrcSql, char *zArgs, char *zFileArgs, Array_t *pData, int *pColCnt,
char *zEntryFilePath,
char *zSubstFileNames)
{
int result;
sqlite3 *pDB = NULL;
sqlite3_stmt *pStmt = NULL;
sqlite3_stmt *pArgsStmt = NULL;
Array_t sqlArgs;
char *zError = NULL;
char *zFullFilePath = NULL;
sqlite3_stmt *pSubstStmt = NULL;
char *zFileContent = NULL;
char *zSchemaSql = NULL;
char *zSql = strCopy(zSrcSql, -1);
/*
* Only first 16 substitute parameters will be processed. This is related to the fact that in C there
* is no non-hacking way to dynamically build variadic arguments. So, to support list of values we just
* limit maximum number of substitute strings to reasonably high number (16)
*/
const char *zz[16];
memset(&zz, 0, sizeof(zz));
Array_init(&sqlArgs, sizeof(SqlArg_t), (void *) _freeSqlArg);
*pColCnt = 0;
// Array_init(pData, sizeof(sqlite3_value *), (void *) _freeSqliteValue);
/*
* Open database (use :memory: if not defined)
*/
if (zDatabase == NULL || strlen(zDatabase) == 0)
{
zDatabase = ":memory:";
}
CHECK_CALL(sqlite3_open_v2(zDatabase, &pDB,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_SHAREDCACHE,
NULL));
CHECK_CALL(sqlite3_enable_load_extension(pDB, 1));
// load extension library
CHECK_CALL(sqlite3_load_extension(pDB, "../../bin/libFlexilite", NULL, &zError));
// load and run db schema
CHECK_CALL(file_load_utf8("../../sql/dbschema.sql", &zSchemaSql));
CHECK_CALL(sqlite3_exec(pDB, (const char *) zSchemaSql, NULL, NULL, &zError));
/*
* Substitute strings
*/
if (!STR_EMPTY(zSubstFileNames))
{
CHECK_STMT_PREPARE(pDB, "select key, value from json_each(:1);", &pSubstStmt);
CHECK_CALL(sqlite3_bind_text(pSubstStmt, 1, zSubstFileNames, -1, NULL));
int nSubst = 0;
while ((result = sqlite3_step(pSubstStmt)) == SQLITE_ROW)
{
if (nSubst >= 16)
{
result = SQLITE_ERROR;
zError = "Number of substitute strings must not exceed 16";
goto ONERROR;
}
sqlite3_free(zFullFilePath);
zFullFilePath = NULL;
Path_join(&zFullFilePath, zEntryFilePath, (char *) sqlite3_column_text(pSubstStmt, 1));
CHECK_CALL(file_load_utf8(zFullFilePath, &zFileContent));
zz[nSubst++] = zFileContent;
zFileContent = NULL; // Memory will be freed by zz
}
if (result != SQLITE_DONE)
goto ONERROR;
char *zTemp = zSql;
zSql = sqlite3_mprintf(zTemp, zz[0], zz[1], zz[2], zz[3], zz[4], zz[5], zz[6], zz[7], zz[8],
zz[9], zz[10], zz[11], zz[12], zz[13], zz[14], zz[15]);
sqlite3_free(zTemp);
}
// TODO use flexi('init')
CHECK_STMT_PREPARE(pDB, zSql, &pStmt);
// Check if we have arguments JSON. Prepare arguments
if (!STR_EMPTY(zArgs))
{
CHECK_STMT_PREPARE(pDB, "select value, type from json_each(:1);", &pArgsStmt);
CHECK_CALL(sqlite3_bind_text(pArgsStmt, 1, zArgs, -1, NULL));
int nArgCnt = 0;
while ((result = sqlite3_step(pArgsStmt)) == SQLITE_ROW)
{
SqlArg_t item;
memset(&item, 0, sizeof(item));
item.pValue = sqlite3_value_dup(sqlite3_column_value(pArgsStmt, 0));
Array_setNth(&sqlArgs, sqlArgs.iCnt, &item);
nArgCnt++;
}
if (result != SQLITE_DONE)
goto ONERROR;
/*
* Process file args
*/
CHECK_CALL(sqlite3_reset(pArgsStmt));
CHECK_CALL(sqlite3_bind_text(pArgsStmt, 1, zFileArgs, -1, NULL));
while ((result = sqlite3_step(pArgsStmt)) == SQLITE_ROW)
{
int argNo = sqlite3_column_int(pArgsStmt, 0);
if (argNo >= 1 && argNo <= nArgCnt)
{
sqlite3_free(zFullFilePath);
zFullFilePath = NULL;
SqlArg_t *arg = Array_getNth(&sqlArgs, (u32) argNo - 1);
Path_join(&zFullFilePath, zEntryFilePath, (char *) sqlite3_value_text(arg->pValue));
CHECK_CALL(file_load_utf8(zFullFilePath, &arg->zText));
}
}
if (result != SQLITE_DONE)
goto ONERROR;
Array_each(&sqlArgs, (void *) _bindSqlArg, pStmt);
}
while ((result = sqlite3_step(pStmt)) == SQLITE_ROW)
{
if (*pColCnt == 0)
*pColCnt = sqlite3_column_count(pStmt);
int iCol;
for (iCol = 0; iCol < *pColCnt; iCol++)
{
sqlite3_value *pVal = sqlite3_value_dup(sqlite3_column_value(pStmt, iCol));
Array_setNth(pData, pData->iCnt, &pVal);
}
}
if (result != SQLITE_DONE)
goto ONERROR;
result = SQLITE_OK;
goto EXIT;
ONERROR:
Array_clear(pData);
if (pDB && zError == NULL)
{
zError = (char *) sqlite3_errmsg(pDB);
}
if (zError != NULL)
printf("Error: %s\n", zError);
EXIT:
sqlite3_free(zSchemaSql);
sqlite3_finalize(pStmt);
sqlite3_finalize(pArgsStmt);
sqlite3_finalize(pSubstStmt);
if (pDB != NULL)
{
result = sqlite3_close(pDB);
if (result != SQLITE_OK)
{
printf("DB Close Error %d. %s\n", result, sqlite3_errmsg(pDB));
}
}
Array_clear(&sqlArgs);
sqlite3_free(zFullFilePath);
sqlite3_free(zSql);
for (int i = 0; i < ARRAY_LEN(zz); i++)
sqlite3_free((void *) zz[i]);
if (zFileContent != NULL)
sqlite3_free(zFileContent);
return result;
}
/* --- PRIVATE FUNCTIONS ---------------------------------------------------- */
static void CallbackBuildDnCache(
_In_ CSV_HANDLE hOutfile,
_In_ CSV_HANDLE hDenyOutfile,
_In_ LPTSTR *tokens
) {
BOOL bResult = FALSE;
CACHE_OBJECT_BY_DN cacheEntry = { 0 };
CACHE_OBJECT_BY_DN mailCacheEntry = { 0 };
PCACHE_OBJECT_BY_DN inserted = NULL;
BOOL newElement = FALSE;
LPTSTR objectClass = NULL;
UNREFERENCED_PARAMETER(hDenyOutfile);
if (STR_EMPTY(tokens[LdpListDn]) || STR_EMPTY(tokens[LdpListObjectClass]))
return;
cacheEntry.dn = _tcsdup(tokens[LdpListDn]);
if (!cacheEntry.dn)
FATAL(_T("Could not dup dn <%s>"), tokens[LdpListDn]);
cacheEntry.objectClass = _tcsdup(tokens[LdpListObjectClass]);
if (!cacheEntry.objectClass)
FATAL(_T("Could not dup objectClass <%s>"), tokens[LdpListObjectClass]);
CacheEntryInsert(
ppCache,
(PVOID)&cacheEntry,
sizeof(CACHE_OBJECT_BY_DN),
&inserted,
&newElement
);
if (!inserted) {
LOG(Err, _T("cannot insert new object-by-dn cache entry <%s>"), tokens[LdpListDn]);
}
else if (!newElement) {
LOG(Dbg, _T("object-by-dn cache entry is not new <%s>"), tokens[LdpListDn]);
free(cacheEntry.dn);
free(cacheEntry.objectClass);
}
else {
objectClass = _tcsrchr(tokens[LdpListObjectClass], _T(';')) + 1;
bResult = ControlWriteOutline(hOutfile, tokens[LdpListDn], objectClass, CONTROL_ALLNODES_KEYWORD);
if (!bResult)
LOG(Err, _T("Cannot write outline for <%s>"), tokens[LdpListDn]);
}
// Writing Mail attributes as object of type email
if (STR_EMPTY(tokens[LdpListMail]))
return;
mailCacheEntry.dn = _tcsdup(tokens[LdpListMail]);
if (!mailCacheEntry.dn)
FATAL(_T("Could not dup dn <%s>"), tokens[LdpListMail]);
mailCacheEntry.objectClass = _tcsdup(_T("email"));
if (!mailCacheEntry.objectClass)
FATAL(_T("Could not dup objectClass <%s>"), _T("email"));
CacheEntryInsert(
ppCache,
(PVOID)&mailCacheEntry,
sizeof(CACHE_OBJECT_BY_DN),
&inserted,
&newElement
);
if (!inserted) {
LOG(Err, _T("cannot insert new object-by-dn cache entry <%s>"), tokens[LdpListMail]);
}
else if (!newElement) {
LOG(Dbg, _T("object-by-dn cache entry is not new <%s>"), tokens[LdpListMail]);
free(mailCacheEntry.dn);
free(mailCacheEntry.objectClass);
}
else {
bResult = ControlWriteOutline(hOutfile, tokens[LdpListMail], _T("email"), CONTROL_ALLNODES_KEYWORD);
if (!bResult)
LOG(Err, _T("Cannot write outline for <%s>"), tokens[LdpListMail]);
}
}
