int
main(int argc, char *argv[])
{
const gchar* connection_string = "HOST=localhost;USER=murrayc;PASSWORD=yourpasswordhere;DATABASE=template1";
GdaClient *client = 0;
GdaConnection *con = 0;
gda_init ("glom-gda-test", NULL, argc, argv);
/* 3. Create a gda client */
client = gda_client_new ();
/* 4. Open the connection */
con = gda_client_open_connection_from_string (client, "PostgreSQL", connection_string, 0);
if (!GDA_IS_CONNECTION (con)) {
g_print ("** ERROR: could not open connection.\n");
/* This cannot work because it needs a working connection: get_errors (con); */
return 0;
}
gboolean created = gda_connection_create_database(con, "glomtest");
if(!created) {
g_print("** Error: gda_connection_create_database failed.\n");
get_errors(con);
}
gda_connection_close (con);
g_object_unref (G_OBJECT (client));
g_print ("** Connection successfully opened, database created, and connection closed.\n");
return 0;
}
/* Test database status: database exists, correct tables, correct version */
static GdaConnection *
sql_get_tested_connection (const gchar *dsn_name,
const gchar *host,
const gchar *db_name,
GdaClient *client,
PlannerPlugin *plugin)
{
GdaConnection *conn = NULL;
gboolean success;
gchar *str;
GError *error;
conn = gda_client_open_connection (client, dsn_name, NULL, NULL, 0, &error);
if (conn == NULL) {
if (!create_database (dsn_name, host, db_name, plugin)) {
str = g_strdup_printf (_("Connection to database '%s@%s' failed."),
db_name, host);
show_error_dialog (plugin, str);
conn = NULL;
} else {
conn = gda_client_open_connection (client, dsn_name, NULL, NULL, 0, &error);
}
}
if (conn != NULL) {
success = sql_execute_command (conn, "SET TIME ZONE 'UTC'");
if (!success) {
g_warning ("SET TIME ZONE command failed: %s.",
sql_get_last_error (conn));
goto out;
}
if (!check_database_tables (conn, plugin)) {
str = g_strdup_printf (_("Test to tables in database '%s' failed."),
db_name);
show_error_dialog (plugin, str);
g_free (str);
goto out;
}
}
/* g_object_unref (client); */
return conn;
out:
if (conn) {
gda_connection_close (conn);
}
return NULL;
}
int
main (int argc, char *argv[])
{
gda_init ();
GdaConnection *cnc;
/* open connections */
cnc = open_connection ();
create_table (cnc);
display_products_contents (cnc);
gda_connection_close (cnc);
return 0;
}
static void
sim_database_impl_finalize (GObject *gobject)
{
SimDatabase *database = SIM_DATABASE (gobject);
if (database->_priv->name)
g_free (database->_priv->name);
if (database->_priv->provider)
g_free (database->_priv->provider);
if (database->_priv->dsn)
g_free (database->_priv->dsn);
gda_connection_close (database->_priv->conn);
g_static_rec_mutex_free (database->_priv->mutex);
g_free (database->_priv);
G_OBJECT_CLASS (parent_class)->finalize (gobject);
}
/*
* Actually closes the connection from Libgda's point of view
*/
void
_gda_web_change_connection_to_closed (GdaConnection *cnc, WebConnectionData *cdata)
{
cdata->forced_closing = TRUE;
gda_connection_close (cnc, NULL);
}
/*
* Creates an SQLite .db file from the definitions in @sqlfile
*/
gboolean
create_sqlite_db (const gchar *dir, const gchar *dbname, const gchar *sqlfile, GError **error)
{
GdaBatch *batch;
GdaSqlParser *parser;
GdaServerProvider *prov;
GdaConnection *cnc;
/* create batch */
prov = gda_config_get_provider ("SQLite", NULL);
if (!prov) {
g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "%s",
"Cannot find the SQLite provider");
return FALSE;
}
parser = gda_server_provider_create_parser (prov, NULL);
if (!parser)
parser = gda_sql_parser_new ();
batch = gda_sql_parser_parse_file_as_batch (parser, sqlfile, error);
g_object_unref (parser);
if (!batch)
return FALSE;
/* clean any previous DB file */
gchar *fname, *tmp;
tmp = g_strdup_printf ("%s.db", dbname);
fname = g_build_filename (dir, tmp, NULL);
g_free (tmp);
g_unlink (fname);
g_free (fname);
/* open a connection */
gchar *cnc_string;
gchar *edir, *edbname;
edir = gda_rfc1738_encode (dir);
edbname = gda_rfc1738_encode (dbname);
cnc_string = g_strdup_printf ("DB_DIR=%s;DB_NAME=%s", edir, edbname);
g_free (edir);
g_free (edbname);
cnc = gda_connection_open_from_string ("SQLite", cnc_string, NULL,
GDA_CONNECTION_OPTIONS_NONE, error);
g_free (cnc_string);
if (!cnc) {
g_object_unref (batch);
return FALSE;
}
/* execute batch */
GSList *list;
const GSList *stmt_list;
gboolean retval = TRUE;
list = gda_connection_batch_execute (cnc, batch, NULL, GDA_STATEMENT_MODEL_RANDOM_ACCESS, error);
stmt_list = gda_batch_get_statements (batch);
if (g_slist_length (list) != g_slist_length ((GSList *) stmt_list))
retval = FALSE;
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
g_assert (gda_connection_close (cnc, NULL));
g_object_unref (cnc);
g_object_unref (batch);
return retval;
}
static void
dsn_test_cb (G_GNUC_UNUSED GSimpleAction *action, GVariant *state, gpointer data)
{
GdauiDsnEditor *editor;
editor = GDAUI_DSN_EDITOR (data);
GtkWidget *test_dialog = NULL;
GdauiLogin* login = NULL;
GdaConnection *cnc = NULL;
gboolean auth_needed = gdaui_dsn_editor_need_authentication (editor);
GtkWindow *parent = NULL;
parent = (GtkWindow*) gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW);
const gchar *dsn;
dsn = editor->priv->name;
if (auth_needed) {
gchar *title;
title = g_strdup_printf (_("Login for %s"), dsn);
test_dialog = gdaui_login_dialog_new (title, parent);
g_free (title);
login = gdaui_login_dialog_get_login_widget (GDAUI_LOGIN_DIALOG (test_dialog));
g_object_set (G_OBJECT (login), "dsn", dsn, NULL);
}
if (!auth_needed || gdaui_login_dialog_run (GDAUI_LOGIN_DIALOG (test_dialog))) {
if (test_dialog)
parent = GTK_WINDOW (test_dialog);
GtkWidget *msgdialog;
GError *error = NULL;
const GdaDsnInfo *cinfo = NULL;
if (login)
cinfo = gdaui_login_get_connection_information (login);
cnc = gda_connection_open_from_dsn (dsn,
cinfo ? cinfo->auth_string : NULL,
GDA_CONNECTION_OPTIONS_NONE, &error);
if (cnc) {
msgdialog = gtk_message_dialog_new_with_markup (parent,
GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"<b>%s</b>",
_("Connection successfully opened!"));
gda_connection_close (cnc, NULL);
}
else {
msgdialog = gtk_message_dialog_new_with_markup (parent,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
"<b>%s:</b>\n%s",
_("Could not open connection"),
error->message ? error->message : _("No detail"));
if (error)
g_error_free (error);
}
gtk_dialog_run (GTK_DIALOG (msgdialog));
gtk_widget_destroy (msgdialog);
}
if (test_dialog)
gtk_widget_destroy (test_dialog);
}
void oseaserver_command_close_connection ()
{
if (connection)
gda_connection_close (connection);
return;
}
/*
* Test 5: open, close and open again, also tests signal's emission
*/
static guint
test5 (void)
{
g_print ("============= %s started =============\n", __FUNCTION__);
GdaConnection *cnc;
GError *error = NULL;
cnc = gda_connection_new_from_string ("SQLite", "DB_NAME=test-cnc-opendb", NULL,
GDA_CONNECTION_OPTIONS_AUTO_META_DATA, &error);
if (!cnc) {
g_print ("gda_connection_new_from_string() failed: %s\n", error && error->message ? error->message : "No detail");
return 1;
}
guint nsignals = 0;
g_signal_connect (cnc, "status-changed",
G_CALLBACK (t5_status_changed_cb), &nsignals);
guint counter = 0;
setup_main_context (cnc, &counter);
/* open */
if (! gda_connection_open (cnc, &error)) {
g_print ("gda_connection_open() 1 failed: %s\n", error && error->message ? error->message : "No detail");
return 1;
}
if (counter == 0) {
g_print ("gda_connection_open() 1 failed: did not make GMainContext 'run'\n");
return 1;
}
else
g_print ("Counter incremented to %u\n", counter);
/* open */
counter = 0;
if (! gda_connection_close (cnc, &error)) {
g_print ("gda_connection_close() failed: %s\n", error && error->message ? error->message : "No detail");
return 1;
}
if (counter == 0) {
g_print ("gda_connection_close() failed: did not make GMainContext 'run'\n");
return 1;
}
else
g_print ("Counter incremented to %u\n", counter);
/* open */
counter = 0;
if (! gda_connection_open (cnc, &error)) {
g_print ("gda_connection_open() 2 failed: %s\n", error && error->message ? error->message : "No detail");
return 1;
}
if (counter == 0) {
g_print ("gda_connection_open() 2 failed: did not make GMainContext 'run'\n");
return 1;
}
else
g_print ("Counter incremented to %u\n", counter);
g_object_unref (cnc);
if (nsignals != 6) {
g_print ("Expected %d signals and got %d\n", 6, nsignals);
return 1;
}
return 0;
}
/* Try to create the database */
static gboolean
create_database (const gchar *dsn_name,
const gchar *host,
const gchar *db_name,
PlannerPlugin *plugin)
{
GtkWidget *dialog;
GtkWindow *window;
guint result;
gboolean retval;
GdaConnection *conn;
GdaClient *client;
GdaDataSourceInfo *dsn;
gchar *cnc_string_orig;
/* FIXME: In postgresql we use template1 as the connection database */
gchar *init_database = "template1";
gchar *query;
GError *error;
dsn = gda_config_find_data_source (dsn_name);
cnc_string_orig = dsn->cnc_string;
retval = FALSE;
window = GTK_WINDOW (plugin->main_window);
/* Use same data but changing the database */
dsn->cnc_string = g_strdup_printf (CONNECTION_FORMAT_STRING, host, init_database);
gda_config_save_data_source_info (dsn);
client = gda_client_new ();
conn = gda_client_open_connection (client, dsn_name, NULL, NULL, 0, &error);
if (conn == NULL) {
g_warning ("Can't connect to database server in order to check/create the database: %s", cnc_string_orig);
} else {
dialog = gtk_message_dialog_new (window,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
_("Database %s is not setup for Planner. "
"Do you want to do that?"),
db_name);
result = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (result == GTK_RESPONSE_YES) {
query = g_strdup_printf ("CREATE DATABASE %s WITH ENCODING = 'UTF8'",
db_name);
sql_execute_command (conn, query);
g_free (query);
retval = TRUE;
} else {
retval = FALSE;
}
gda_connection_close (conn);
g_object_unref (client);
}
g_free (dsn->cnc_string);
dsn->cnc_string = cnc_string_orig;
gda_config_save_data_source_info (dsn);
return retval;
}
static void
sql_plugin_save (GtkAction *action,
gpointer user_data)
{
GdaClient *client;
GdaConnection *conn;
PlannerPlugin *plugin = user_data;
MrpProject *project;
GObject *object;
gchar *server = NULL;
gchar *port = NULL;
gchar *database = NULL;
gchar *login = NULL;
gchar *password = NULL;
gchar *uri = NULL;
const gchar *uri_plan = NULL;
GError *error = NULL;
gchar *db_txt;
const gchar *dsn_name = "planner-auto";
const gchar *provider = "PostgreSQL";
project = planner_window_get_project (plugin->main_window);
if (!sql_plugin_retrieve_db_values (plugin,
_("Save to Database"),
&server,
&port,
&database,
&login,
&password)) {
return;
}
db_txt = g_strdup_printf (CONNECTION_FORMAT_STRING,server,database);
gda_config_save_data_source (dsn_name,
provider,
db_txt,
"planner project", login, password, FALSE);
g_free (db_txt);
client = gda_client_new ();
conn = sql_get_tested_connection (dsn_name, server, database, client, plugin);
if (conn == NULL) {
g_object_unref (client);
return;
}
gda_connection_close (conn);
g_object_unref (client);
/* This code is prepared for getting support for selecting a project to
* save over. Needs finishing though. Pass project id -1 for now (always
* create a new project).
*/
uri_plan = mrp_project_get_uri (project);
/* First time project */
if (uri_plan == NULL) {
uri = create_sql_uri (server, port, database, login, password, -1);
if (!mrp_project_save_as (project, uri, FALSE, &error)) {
show_error_dialog (plugin, error->message);
g_clear_error (&error);
goto fail;
}
g_free (uri);
}
/* Project was in database */
else if (strncmp (uri_plan, "sql://", 6) == 0) {
if (!mrp_project_save (project, FALSE, &error)) {
show_error_dialog (plugin, error->message);
g_clear_error (&error);
goto fail;
}
}
/* Project wasn't in database */
else {
uri = create_sql_uri (server, port, database, login, password, -1);
if (!mrp_project_save_as (project, uri, FALSE, &error)) {
show_error_dialog (plugin, error->message);
g_clear_error (&error);
goto fail;
}
g_free (uri);
}
object = G_OBJECT (plugin->main_window);
g_object_set_data_full (object, SERVER, server, g_free);
g_object_set_data_full (object, DATABASE, database, g_free);
g_object_set_data_full (object, LOGIN, login, g_free);
g_object_set_data_full (object, PASSWORD, password, g_free);
return;
fail:
g_free (server);
g_free (port);
g_free (database);
g_free (login);
g_free (password);
g_free (uri);
}
int
main (int argc, char **argv)
{
GError *error = NULL;
GOptionContext *context;
GdaConnection *cnc;
gchar *auth_string = NULL;
gchar *blob_data;
/* command line parsing */
context = g_option_context_new ("Tests opening a connection");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_warning ("Can't parse arguments: %s", error->message);
exit (1);
}
g_option_context_free (context);
if (direct && dsn) {
g_print ("DSN and connection string are exclusive\n");
exit (1);
}
if (!direct && !dsn) {
g_print ("You must specify a connection to open either as a DSN or a connection string\n");
exit (1);
}
if (direct && !prov) {
g_print ("You must specify a provider when using a connection string\n");
exit (1);
}
gda_init ();
/* open connection */
if (user) {
if (pass)
auth_string = g_strdup_printf ("USERNAME=%s;PASSWORD=%s", user, pass);
else
auth_string = g_strdup_printf ("USERNAME=%s", user);
}
if (dsn) {
GdaDsnInfo *info = NULL;
info = gda_config_get_dsn_info (dsn);
if (!info)
g_error (_("DSN '%s' is not declared"), dsn);
else {
cnc = gda_connection_open_from_dsn (info->name, auth_string ? auth_string : info->auth_string,
0, &error);
if (!cnc) {
g_warning (_("Can't open connection to DSN %s: %s\n"), info->name,
error && error->message ? error->message : "???");
exit (1);
}
prov = info->provider;
}
}
else {
cnc = gda_connection_open_from_string (prov, direct, auth_string, 0, &error);
if (!cnc) {
g_warning (_("Can't open specified connection: %s\n"),
error && error->message ? error->message : "???");
exit (1);
}
}
g_free (auth_string);
g_print (_("Connection successfully opened!\n"));
parser = gda_connection_create_parser (cnc);
gda_connection_begin_transaction (cnc, NULL, GDA_TRANSACTION_ISOLATION_UNKNOWN, NULL);
/*
* clear all blobs
*/
if (!clear_blobs (cnc, &error))
g_error ("Blobs clear error: %s", error && error->message ? error->message : "No detail");
/* insert a blob */
blob_data = "Blob Data 1";
if (!insert_blob (cnc, 1, blob_data, strlen (blob_data), &error))
g_error ("Blob insert error: %s", error && error->message ? error->message : "No detail");
else if (error) {
g_print ("Msg: %s\n", error->message);
g_error_free (error);
error = NULL;
}
/* insert a blob */
blob_data = "Blob Data 2";
if (!insert_blob (cnc, 2, blob_data, strlen (blob_data), &error))
g_error ("Blob insert error: %s", error && error->message ? error->message : "No detail");
else if (error) {
g_print ("Msg: %s\n", error->message);
g_error_free (error);
error = NULL;
}
if (!display_blobs (cnc, &error))
g_error ("Blobs display error: %s", error && error->message ? error->message : "No detail");
/* update blob */
blob_data = "New blob 1 contents is now this one...";
if (!update_blob (cnc, 1, blob_data, strlen (blob_data), &error))
g_error ("Blob update error: %s", error && error->message ? error->message : "No detail");
else if (error) {
g_print ("Msg: %s\n", error->message);
g_error_free (error);
error = NULL;
}
if (!display_blobs (cnc, &error))
g_error ("Blobs display error: %s", error && error->message ? error->message : "No detail");
/* update blob */
blob_data = "After several blobs updated";
if (!update_multiple_blobs (cnc, blob_data, strlen (blob_data), &error))
g_error ("Multiple blob update error: %s", error && error->message ? error->message : "No detail");
else if (error) {
g_print ("Msg: %s\n", error->message);
g_error_free (error);
error = NULL;
}
if (!display_blobs (cnc, &error))
g_error ("Blobs display error: %s", error && error->message ? error->message : "No detail");
/* SQL Postgres:
create table blobs (id serial not null primary key, name varchar (50), data oid);
SQL Oracle:
CREATE TABLE blobs (id number primary key, name varchar2 (50), data BLOB);
*/
gda_connection_commit_transaction (cnc, NULL, NULL);
if (! gda_connection_close (cnc, &error))
g_error ("Can't close connection: %s", error && error->message ? error->message : "No detail");
return 0;
}
int
main (int argc, char *argv[])
{
gda_init ();
GdaConnection *cnc;
GError *error = NULL;
GdaStatement *stmt;
GdaDataModel *model;
gchar *str;
GValue *name;
/* open connection */
cnc = open_connection ();
/* begin transaction */
if (! gda_connection_begin_transaction (cnc, NULL, GDA_TRANSACTION_ISOLATION_UNKNOWN,
&error)) {
g_print ("Could not begin transaction: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
/* execute SELECT */
stmt = gda_sql_parser_parse_string (parser, "SELECT id, name FROM customers ORDER BY id", NULL, NULL);
g_assert (stmt);
model = gda_connection_statement_execute_select (cnc, stmt, NULL, &error);
g_object_unref (stmt);
if (!model) {
g_print ("Could not execute SELECT statement: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("** Data model is:\n");
gda_data_model_dump (model, stdout);
/*
* make sure the mete data is up to date
*/
g_print ("Computing meta data, this may take a while; in real applications, this should be cached to avoid waiting\n");
if (! gda_connection_update_meta_store (cnc, NULL, &error)) {
g_print ("Could not fetch meta data: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
/*
* Make the data model compute the modification statements which
* will actually be executed when the data model is modified
*/
if (! gda_data_select_compute_modification_statements (GDA_DATA_SELECT (model), &error)) {
g_print ("Could not compute modification statements: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_object_get (G_OBJECT (model), "update-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed UPDATE: %s\n", str);
g_free (str);
g_object_unref (stmt);
g_object_get (G_OBJECT (model), "delete-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed DELETE: %s\n", str);
g_free (str);
g_object_unref (stmt);
g_object_get (G_OBJECT (model), "insert-stmt", &stmt, NULL);
str = gda_statement_to_sql (stmt, NULL, NULL);
g_print ("Computed INSERT: %s\n", str);
g_free (str);
g_object_unref (stmt);
/*
* remove row 0 (1st row)
*/
g_print ("\n\n** Removing row 0\n");
if (! gda_data_model_remove_row (model, 0, &error)) {
g_print ("Could not remove row 0: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/*
* add a row: the row's values is a list of GValue pointers
* (or NULL pointers where the default value should be inserted
*/
GList *list;
g_print ("\n\n** Adding a row\n");
list = g_list_append (NULL, NULL);
g_value_set_string ((name = gda_value_new (G_TYPE_STRING)), "Hiro");
list = g_list_append (list, name);
if (gda_data_model_append_values (model, list, &error) == -1) {
g_print ("Could not add a row: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
gda_value_free (name);
g_list_free (list);
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/*
* alter row 2
*/
g_print ("\n\n** Modifying row 2\n");
g_value_set_string ((name = gda_value_new (G_TYPE_STRING)), "Tom");
if (! gda_data_model_set_value_at (model, 1, 2, name, &error)) {
g_print ("Could not modify row 2: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
gda_value_free (name);
g_print ("** Data model is now:\n");
gda_data_model_dump (model, stdout);
g_print ("** Table's contents is now:\n");
display_customers (cnc);
/* rollback transaction */
gda_connection_rollback_transaction (cnc, NULL, NULL);
gda_connection_close (cnc);
return 0;
}
/*
* Cleans up a connection.
*
* If @destroy_db is TRUE, then the database is destroyed, except if <upper_case_provider_name>_DONT_REMOVE_DB
* is set.
*
* WARNING: the @cnc connection destroyed closed by this function
*/
gboolean
test_cnc_clean_connection (GdaConnection *cnc, GError **error)
{
gchar *prov_id;
gboolean retval = TRUE;
gchar *str, *upname;
gboolean destroy_db;
prov_id = g_strdup (gda_connection_get_provider_name (cnc));
upname = prov_name_upcase (prov_id);
str = g_strdup_printf ("%s_DONT_REMOVE_DB", upname);
if (getenv (str))
destroy_db = FALSE;
else
destroy_db = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cnc), "db_created"));
g_free (str);
if (destroy_db) {
GdaServerOperation *op;
gchar *dbname;
const gchar *db_params;
GdaQuarkList *db_quark_list = NULL;
dbname = (gchar *) g_object_get_data (G_OBJECT (cnc), "dbname");
g_assert (dbname);
dbname = g_strdup (dbname);
g_assert (gda_connection_close (cnc, NULL));
g_object_unref (cnc);
#ifdef CHECK_EXTRA_INFO
g_print ("Waiting a bit for the server to register the disconnection...\n");
#endif
sleep (1);
str = g_strdup_printf ("%s_DBCREATE_PARAMS", upname);
db_params = getenv (str);
g_free (str);
g_assert (db_params);
op = gda_server_operation_prepare_drop_database (prov_id, dbname, NULL);
g_free (dbname);
db_quark_list = gda_quark_list_new_from_string (db_params);
gda_quark_list_foreach (db_quark_list, (GHFunc) db_drop_quark_foreach_func, op);
gda_quark_list_free (db_quark_list);
if (!gda_server_operation_perform_drop_database (op, NULL, error))
retval = FALSE;
g_object_unref (op);
}
else {
TO_IMPLEMENT;
g_assert (gda_connection_close (cnc, NULL));
g_object_unref (cnc);
}
g_free (upname);
g_free (prov_id);
return retval;
}
