~ubuntu-branches/ubuntu/quantal/gconf/quantal

 

/* Don't allow special characters in configuration source addresses.

 * The important one here is not to allow ';' because we use that

 * internally as a list delimiter. See GCONF_DATABASE_LIST_DELIM

 */

static const char invalid_chars[] = 

#ifndef G_OS_WIN32

  /* Space is common in user names (and thus home directories) on Windows */

  " "

#endif

  "\t\r\n\"$&<>,+=#!()'|{}[]?~`;%\\";

 

static gboolean

gconf_address_valid (const char  *address,

                     char      **why_invalid)

{

  const char *s;

 

  g_return_val_if_fail (address != NULL, FALSE);

 

  if (why_invalid)

    *why_invalid = NULL;

 

  s = address;

  while (*s)

    {

      const char *inv = invalid_chars;

 

      while (*inv)

        {

          if (*inv == *s)

            {

              if (why_invalid)

                *why_invalid = g_strdup_printf(_("`%c' is an invalid character in a configuration storage address"), *s);

              return FALSE;

            }

          ++inv;

        }

 

      ++s;

    }

 

  return TRUE;

}

 

#ifdef G_OS_WIN32

          return _gconf_win32_replace_prefix (start);

#else

#endif

  if (g_file_test(retval, G_FILE_TEST_EXISTS))

      if (g_file_test(retval, G_FILE_TEST_EXISTS))

static gboolean

gconf_backend_verify_vtable (GConfBackendVTable  *vtable,

                             GConfBackendVTable  *vtable_copy,

                             const char          *backend_name,                     

                             GError             **err)

{

  int i;

  struct

  {

    char  *name;

    gsize  offset;

  } required_vtable_functions[] = {

    { "shutdown",        G_STRUCT_OFFSET(GConfBackendVTable, shutdown)        },

    { "resolve_address", G_STRUCT_OFFSET(GConfBackendVTable, resolve_address) },

    { "query_value",     G_STRUCT_OFFSET(GConfBackendVTable, query_value)     },

    { "query_metainfo",  G_STRUCT_OFFSET(GConfBackendVTable, query_metainfo)  },

    { "set_value",       G_STRUCT_OFFSET(GConfBackendVTable, set_value)       },

    { "all_entries",     G_STRUCT_OFFSET(GConfBackendVTable, all_entries)     },

    { "all_subdirs",     G_STRUCT_OFFSET(GConfBackendVTable, all_subdirs)     },

    { "unset_value",     G_STRUCT_OFFSET(GConfBackendVTable, unset_value)     },

    { "dir_exists",      G_STRUCT_OFFSET(GConfBackendVTable, dir_exists)      },

    { "remove_dir",      G_STRUCT_OFFSET(GConfBackendVTable, remove_dir)      },

    { "set_schema",      G_STRUCT_OFFSET(GConfBackendVTable, set_schema)      },

    { "sync_all",        G_STRUCT_OFFSET(GConfBackendVTable, sync_all)        },

    { "destroy_source",  G_STRUCT_OFFSET(GConfBackendVTable, destroy_source)  },

    { "blow_away_locks", G_STRUCT_OFFSET(GConfBackendVTable, blow_away_locks) }

  };

 

  if (!vtable)

    {

      gconf_set_error(err,

                      GCONF_ERROR_FAILED, _("Backend `%s' failed return a vtable\n"),

                      backend_name);

      return FALSE;

    }

 

  /* Create a copy in case vtable size doesn't match */

  memcpy(vtable_copy, vtable, MIN(vtable->vtable_size, sizeof(GConfBackendVTable)));

 

  vtable_copy->vtable_size = sizeof(GConfBackendVTable);

 

  for (i = 0; i < G_N_ELEMENTS(required_vtable_functions); i++)

    {

      if (G_STRUCT_MEMBER_P(vtable_copy, required_vtable_functions[i].offset) == NULL)

        {

          gconf_set_error(err,

                          GCONF_ERROR_FAILED, _("Backend `%s' missing required vtable member `%s'\n"),

                          backend_name,

                          required_vtable_functions[i].name);

          return FALSE;

        }

    }

 

  return TRUE;

}

 

  gchar* why_invalid;

 

  why_invalid = NULL;

  if (!gconf_address_valid (address, &why_invalid))

    {

      g_assert (why_invalid != NULL);

      gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS, _("Bad address `%s': %s"),

                       address, why_invalid);

      g_free (why_invalid);

      return NULL;

    }

 

          module = g_module_open(file, G_MODULE_BIND_LAZY);

                              name, g_module_error());

              gconf_set_error(err,

                              GCONF_ERROR_FAILED, _("Error initializing module `%s': %s\n"),

                              name, g_module_error());

              g_module_close(module);

          if (!gconf_backend_verify_vtable((*get_vtable)(), &backend->vtable, name, err))

            {

              g_module_close(module);

              g_free(name);

              g_free(backend);

              return NULL;

            }

      (*backend->vtable.shutdown)(&error);

  retval = (*backend->vtable.resolve_address)(address, err);

void

gconf_blow_away_locks (const gchar* address)

{

  GConfBackend* backend;

 

  backend = gconf_get_backend (address, NULL);

 

  if (backend != NULL)

    {

      (*backend->vtable.blow_away_locks) (address);

    }

}