static void mc_setup_local_store(MailComponent *mc) { MailComponentPrivate *p = mc->priv; CamelURL *url; char *tmp; CamelException ex; int i; g_mutex_lock(p->lock); if (p->local_store != NULL) { g_mutex_unlock(p->lock); return; } camel_exception_init(&ex); url = camel_url_new("mbox:", NULL); tmp = g_build_filename (p->base_directory, "local", NULL); camel_url_set_path(url, tmp); g_free(tmp); tmp = camel_url_to_string(url, 0); p->local_store = (CamelStore *)camel_session_get_service(session, tmp, CAMEL_PROVIDER_STORE, &ex); g_free(tmp); if (p->local_store == NULL) goto fail; for (i=0;i<sizeof(mc_default_folders)/sizeof(mc_default_folders[0]);i++) { /* FIXME: should this uri be account relative? */ camel_url_set_fragment(url, mc_default_folders[i].name); mc_default_folders[i].uri = camel_url_to_string(url, 0); mc_default_folders[i].folder = camel_store_get_folder(p->local_store, mc_default_folders[i].name, CAMEL_STORE_FOLDER_CREATE, &ex); camel_exception_clear(&ex); } camel_url_free(url); g_mutex_unlock(p->lock); g_object_ref(mc); camel_object_ref(p->local_store); mail_async_event_emit(p->async_event, MAIL_ASYNC_GUI, (MailAsyncFunc)mc_add_local_store, p->local_store, _("On This Computer"), mc); return; fail: g_mutex_unlock(p->lock); g_warning("Could not setup local store/folder: %s", ex.desc); camel_url_free(url); camel_exception_clear(&ex); }
gint main (gint argc, gchar **argv) { CamelURL *base_url, *url; gchar *url_string; gint i; GError *error = NULL; camel_test_init (argc, argv); camel_test_start ("URL parsing"); camel_test_push ("base URL parsing"); base_url = camel_url_new (base, &error); if (!base_url) { camel_test_fail ( "Could not parse %s: %s\n", base, error->message); } camel_test_pull (); camel_test_push ("base URL unparsing"); url_string = camel_url_to_string (base_url, 0); if (strcmp (url_string, base) != 0) { camel_test_fail ("URL <%s> unparses to <%s>\n", base, url_string); } camel_test_pull (); g_free (url_string); for (i = 0; i < G_N_ELEMENTS (tests); i++) { camel_test_push ("<%s> + <%s> = <%s>?", base, tests[i].url_string, tests[i].result); url = camel_url_new_with_base (base_url, tests[i].url_string); if (!url) { camel_test_fail ("could not parse"); camel_test_pull (); continue; } url_string = camel_url_to_string (url, 0); if (strcmp (url_string, tests[i].result) != 0) camel_test_fail ("got <%s>!", url_string); g_free (url_string); camel_test_pull (); } camel_test_end (); return 0; }
static void update_url_account (EAccount *account, e_account_item_t item, const gchar *surl) { CamelURL *url; gchar *url_string; const gchar *target_url; if (!account) return; target_url = e_account_get_string (account, item); if (target_url && target_url[0] != '\0') url = camel_url_new (target_url, NULL); else return; camel_url_set_param (url, "owa_url", surl); camel_url_set_param (url, "account_uid", e_account_get_string (account, E_ACCOUNT_ID_ADDRESS)); url_string = camel_url_to_string (url, 0); e_account_set_string (account, item, url_string); g_free (url_string); camel_url_free (url); }
static void exchange_authtype_changed (GtkComboBox *dropdown, EConfig *config) { EMConfigTargetAccount *target = (EMConfigTargetAccount *)config->target; int id = gtk_combo_box_get_active(dropdown); GtkTreeModel *model; GtkTreeIter iter; CamelServiceAuthType *authtype; CamelURL *url_source, *url_transport; const char *source_url, *transport_url; char *source_url_string, *transport_url_string; source_url = e_account_get_string (target->account, E_ACCOUNT_SOURCE_URL); if (id == -1) return; url_source = camel_url_new (source_url, NULL); transport_url = e_account_get_string (target->account, E_ACCOUNT_TRANSPORT_URL); url_transport = camel_url_new (transport_url, NULL); model = gtk_combo_box_get_model(dropdown); if (gtk_tree_model_iter_nth_child(model, &iter, NULL, id)) { gtk_tree_model_get(model, &iter, 1, &authtype, -1); if (authtype) { camel_url_set_authmech(url_source, authtype->authproto); camel_url_set_authmech(url_transport, authtype->authproto); } else { camel_url_set_authmech(url_source, NULL); camel_url_set_authmech(url_transport, NULL); } source_url_string = camel_url_to_string(url_source, 0); transport_url_string = camel_url_to_string(url_transport, 0); e_account_set_string(target->account, E_ACCOUNT_SOURCE_URL, source_url_string); e_account_set_string(target->account, E_ACCOUNT_TRANSPORT_URL, transport_url_string); g_free(source_url_string); g_free(transport_url_string); } camel_url_free(url_source); camel_url_free(url_transport); }
static ESource * get_source (ESourceList *list) { CamelURL *url; gchar *url_string; GSList *p, *l; gchar **temp; gchar *uri; /* FIXME Wow... just... wow. If ever one needed proof that * URL-based accounts were a bad idea, here ya go. */ url = g_malloc0 (sizeof (CamelURL)); camel_settings_save_to_url (settings, url); url_string = camel_url_to_string (url, 0); temp = g_strsplit (url_string, ";", -1); g_free (url_string); camel_url_free (url); uri = temp[0]; l = e_source_list_peek_groups (list); for (p = l; p != NULL; p = p->next) { gchar *so_uri; GSList *r, *s; ESourceGroup *group = E_SOURCE_GROUP (p->data); s = e_source_group_peek_sources (group); for (r = s; r != NULL; r = r->next) { ESource *so = E_SOURCE (r->data); so_uri = e_source_get_uri (so); if (so_uri) { if (!strcmp (so_uri, uri)) { g_free (so_uri), so_uri = NULL; g_strfreev (temp); return E_SOURCE (r->data); } g_free (so_uri), so_uri = NULL; } } } g_strfreev (temp); return NULL; }
/*Build/populate CamelFolderInfo structure based on the imap_build_folder_info function*/ static CamelFolderInfo * groupwise_build_folder_info (CamelGroupwiseStore *gw_store, const gchar *parent_name, const gchar *folder_name) { CamelURL *url; const gchar *name; CamelFolderInfo *fi; CamelGroupwiseStorePrivate *priv = gw_store->priv; fi = camel_folder_info_new (); fi->unread = -1; fi->total = -1; if (parent_name) { if (strlen (parent_name) > 0) fi->full_name = g_strconcat(parent_name, "/", folder_name, NULL); else fi->full_name = g_strdup (folder_name); } else fi->full_name = g_strdup (folder_name); url = camel_url_new (priv->base_url,NULL); g_free (url->path); url->path = g_strdup_printf("/%s", fi->full_name); fi->uri = camel_url_to_string (url,CAMEL_URL_HIDE_ALL); camel_url_free (url); name = strrchr (fi->full_name,'/'); if (name == NULL) name = fi->full_name; else name++; if (!strcmp (folder_name, "Sent Items")) fi->flags |= CAMEL_FOLDER_TYPE_SENT; else if (!strcmp (folder_name, "Mailbox")) fi->flags |= CAMEL_FOLDER_TYPE_INBOX; else if (!strcmp (folder_name, "Trash")) fi->flags |= CAMEL_FOLDER_TYPE_TRASH; else if (!strcmp (folder_name, "Junk Mail")) fi->flags |= CAMEL_FOLDER_TYPE_JUNK; if (groupwise_is_system_folder (folder_name)) fi->flags |= CAMEL_FOLDER_SYSTEM; fi->name = g_strdup (name); return fi; }
static void owa_editor_entry_changed(GtkWidget *entry, EConfig *config) { const char *uri, *ssl = NULL; CamelURL *url, *owaurl = NULL; char *url_string; EMConfigTargetAccount *target = (EMConfigTargetAccount *)config->target; GtkWidget *button = g_object_get_data((GObject *)entry, "authenticate-button"); int active = FALSE; /* NB: we set the button active only if we have a parsable uri entered */ const char * target_url = e_account_get_string(target->account, E_ACCOUNT_SOURCE_URL); if (target_url && target_url[0] != '\0') url = camel_url_new(target_url, NULL); else url = NULL; uri = gtk_entry_get_text((GtkEntry *)entry); if (uri && uri[0]) { camel_url_set_param(url, "owa_url", uri); owaurl = camel_url_new(uri, NULL); if (owaurl) { active = TRUE; /* Reading the owa url and setting use_ssl paramemter */ if (!strcmp(owaurl->protocol, "https")) ssl = "always"; camel_url_free(owaurl); } } else { camel_url_set_param(url, "owa_url", NULL); } camel_url_set_param(url, "use_ssl", ssl); gtk_widget_set_sensitive(button, active); url_string = camel_url_to_string(url, 0); e_account_set_string(target->account, E_ACCOUNT_SOURCE_URL, url_string); g_free(url_string); camel_url_free (url); }
static char * url_set_path_and_get_string (CamelURL *url, const char *path) { char *url_str; char *tmp = NULL; if (!path || !path[0]) { return NULL; } if (path[0] != '/') { tmp = g_strconcat ("/", path, NULL); path = tmp; } camel_url_set_path (url, path); url_str = camel_url_to_string (url, 0); g_free (tmp); return url_str; }
/* FIXME: This should be a property on CamelFolder */ char * mail_tools_folder_to_url (CamelFolder *folder) { CamelURL *url; char *out; g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); url = camel_url_copy(((CamelService *)folder->parent_store)->url); if (((CamelService *)folder->parent_store)->provider->url_flags & CAMEL_URL_FRAGMENT_IS_PATH) { camel_url_set_fragment(url, folder->full_name); } else { char *name = g_alloca(strlen(folder->full_name)+2); sprintf(name, "/%s", folder->full_name); camel_url_set_path(url, name); } out = camel_url_to_string(url, CAMEL_URL_HIDE_ALL); camel_url_free(url); return out; }
static gboolean groupwise_store_construct (CamelService *service, CamelSession *session, CamelProvider *provider, CamelURL *url, GError **error) { CamelServiceClass *service_class; CamelGroupwiseStore *groupwise_store = CAMEL_GROUPWISE_STORE (service); CamelStore *store = CAMEL_STORE (service); const gchar *property_value; CamelGroupwiseStorePrivate *priv = groupwise_store->priv; gchar *path = NULL; d(printf ("\nin groupwise store constrcut\n")); /* Chain up to parent's construct() method. */ service_class = CAMEL_SERVICE_CLASS (camel_groupwise_store_parent_class); if (!service_class->construct (service, session, provider, url, error)) return FALSE; if (!(url->host || url->user)) { g_set_error ( error, CAMEL_SERVICE_ERROR, CAMEL_SERVICE_ERROR_INVALID, _("Host or user not available in url")); } /*storage path*/ priv->storage_path = camel_session_get_storage_path (session, service, error); if (!priv->storage_path) return FALSE; /*store summary*/ path = g_alloca (strlen (priv->storage_path) + 32); sprintf (path, "%s/.summary", priv->storage_path); groupwise_store->summary = camel_groupwise_store_summary_new (); camel_store_summary_set_filename ((CamelStoreSummary *)groupwise_store->summary, path); camel_store_summary_touch ((CamelStoreSummary *)groupwise_store->summary); camel_store_summary_load ((CamelStoreSummary *) groupwise_store->summary); /*host and user*/ priv->server_name = g_strdup (url->host); priv->user = g_strdup (url->user); /*base url*/ priv->base_url = camel_url_to_string (service->url, (CAMEL_URL_HIDE_PASSWORD | CAMEL_URL_HIDE_PARAMS | CAMEL_URL_HIDE_AUTH) ); /*soap port*/ property_value = camel_url_get_param (url, "soap_port"); if (property_value == NULL) priv->port = g_strdup ("7191"); else if (strlen (property_value) == 0) priv->port = g_strdup ("7191"); else priv->port = g_strdup (property_value); /*filter*/ if (camel_url_get_param (url, "filter")) store->flags |= CAMEL_STORE_FILTER_INBOX; /*Hash Table*/ priv->id_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); priv->name_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); priv->parent_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); /*ssl*/ priv->use_ssl = g_strdup (camel_url_get_param (url, "use_ssl")); store->flags &= ~CAMEL_STORE_VJUNK; store->flags &= ~CAMEL_STORE_VTRASH; return TRUE; }
/* used by editor and druid - same code */ GtkWidget * org_gnome_exchange_owa_url(EPlugin *epl, EConfigHookItemFactoryData *data) { EMConfigTargetAccount *target_account; const char *source_url; char *owa_url = NULL; GtkWidget *owa_entry; CamelURL *url; int row; GtkWidget *hbox, *label, *button; target_account = (EMConfigTargetAccount *)data->config->target; source_url = e_account_get_string (target_account->account, E_ACCOUNT_SOURCE_URL); if (source_url && source_url[0] != '\0') url = camel_url_new(source_url, NULL); else url = NULL; if (url == NULL || strcmp(url->protocol, "exchange") != 0) { if (url) camel_url_free(url); if (data->old && (label = g_object_get_data((GObject *)data->old, "authenticate-label"))) gtk_widget_destroy(label); /* TODO: we could remove 'owa-url' from the url, but that will lose it if we come back. Maybe a commit callback could do it */ return NULL; } if (data->old) { camel_url_free(url); return data->old; } owa_url = g_strdup (camel_url_get_param(url, "owa_url")); /* if the host is null, then user+other info is dropped silently, force it to be kept */ if (url->host == NULL) { char *uri; camel_url_set_host(url, ""); uri = camel_url_to_string(url, 0); e_account_set_string(target_account->account, E_ACCOUNT_SOURCE_URL, uri); g_free(uri); } row = ((GtkTable *)data->parent)->nrows; hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new_with_mnemonic(_("_OWA URL:")); gtk_widget_show(label); owa_entry = gtk_entry_new(); if (!owa_url) { if (url->host[0] != 0) { char *uri; /* url has hostname but not owa_url. * Account has been created using x-c-s or evo is upgraded to 2.2 * When invoked from druid, hostname will get set after validation, * so this condition will never be true during account creation. */ owa_url = construct_owa_url (url); camel_url_set_param (url, "owa_url", owa_url); uri = camel_url_to_string(url, 0); e_account_set_string(target_account->account, E_ACCOUNT_SOURCE_URL, uri); g_free(uri); } } camel_url_free (url); if (owa_url) gtk_entry_set_text(GTK_ENTRY (owa_entry), owa_url); gtk_label_set_mnemonic_widget((GtkLabel *)label, owa_entry); button = gtk_button_new_with_mnemonic (_("A_uthenticate")); gtk_widget_set_sensitive (button, owa_url && owa_url[0]); gtk_box_pack_start (GTK_BOX (hbox), owa_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show_all(hbox); gtk_table_attach (GTK_TABLE (data->parent), label, 0, 1, row, row+1, 0, 0, 0, 0); gtk_table_attach (GTK_TABLE (data->parent), hbox, 1, 2, row, row+1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); g_signal_connect (owa_entry, "changed", G_CALLBACK(owa_editor_entry_changed), data->config); g_object_set_data((GObject *)owa_entry, "authenticate-button", button); g_signal_connect (button, "clicked", G_CALLBACK(owa_authenticate_user), data->config); /* Track the authenticate label, so we can destroy it if e-config is to destroy the hbox */ g_object_set_data((GObject *)hbox, "authenticate-label", label); /* check for correctness of the input in the owa_entry */ owa_editor_entry_changed (owa_entry, data->config); g_free (owa_url); return hbox; }
static void owa_authenticate_user(GtkWidget *button, EConfig *config) { EMConfigTargetAccount *target_account = (EMConfigTargetAccount *)config->target; E2kAutoconfigResult result; CamelURL *url=NULL; gboolean remember_password; char *url_string, *key; const char *source_url, *id_name, *owa_url; char *at, *user; gboolean valid = FALSE; ExchangeParams *exchange_params; exchange_params = g_new0 (ExchangeParams, 1); exchange_params->host = NULL; exchange_params->ad_server = NULL; exchange_params->mailbox = NULL; exchange_params->owa_path = NULL; exchange_params->is_ntlm = TRUE; source_url = e_account_get_string (target_account->account, E_ACCOUNT_SOURCE_URL); if (source_url && source_url[0] != '\0') url = camel_url_new(source_url, NULL); if (url && url->user == NULL) { id_name = e_account_get_string (target_account->account, E_ACCOUNT_ID_ADDRESS); if (id_name) { at = strchr(id_name, '@'); user = g_alloca(at-id_name+1); memcpy(user, id_name, at-id_name); user[at-id_name] = 0; camel_url_set_user (url, user); } } /* validate_user() CALLS GTK!!! THIS IS TOTALLY UNNACCEPTABLE!!!!!!!! It must use camel_session_ask_password, and it should return an exception for any problem, which should then be shown using e-error */ owa_url = camel_url_get_param (url, "owa_url"); if (camel_url_get_param (url, "authmech")) exchange_params->is_ntlm = TRUE; else exchange_params->is_ntlm = FALSE; camel_url_set_authmech (url, exchange_params->is_ntlm ? "NTLM" : "Basic"); key = camel_url_to_string (url, CAMEL_URL_HIDE_PASSWORD | CAMEL_URL_HIDE_PARAMS); /* Supress the trailing slash */ key [strlen(key) -1] = 0; valid = e2k_validate_user (owa_url, key, &url->user, exchange_params, &remember_password, &result, GTK_WINDOW (gtk_widget_get_toplevel (button))); g_free (key); if (!valid && result != E2K_AUTOCONFIG_CANCELLED) print_error (owa_url, result); camel_url_set_host (url, valid ? exchange_params->host : ""); if (valid) camel_url_set_param (url, "save-passwd", remember_password? "true" : "false"); camel_url_set_param (url, "ad_server", valid ? exchange_params->ad_server: NULL); camel_url_set_param (url, "mailbox", valid ? exchange_params->mailbox : NULL); camel_url_set_param (url, "owa_path", valid ? exchange_params->owa_path : NULL); g_free (exchange_params->owa_path); g_free (exchange_params->mailbox); g_free (exchange_params->host); g_free (exchange_params->ad_server); g_free (exchange_params); if (valid) { url_string = camel_url_to_string (url, 0); e_account_set_string (target_account->account, E_ACCOUNT_SOURCE_URL, url_string); e_account_set_string (target_account->account, E_ACCOUNT_TRANSPORT_URL, url_string); e_account_set_bool (target_account->account, E_ACCOUNT_SOURCE_SAVE_PASSWD, remember_password); g_free (url_string); } camel_url_free (url); }
ECalComponent* kolab_cal_util_fb_new_ecalcomp_from_request (KolabUtilHttpJob *job, Kolab_conv_freebusy_type listtype, GError **err) { CamelURL *camel_url = NULL; gchar *url_string = NULL; gchar *servername = NULL; gboolean use_ssl = FALSE; gssize nbytes = 0; ECalComponent *ecalcomp = NULL; GError *tmp_err = NULL; /* preconditions */ g_assert (job != NULL); g_assert (job->buffer == NULL); g_return_val_if_fail (err == NULL || *err == NULL, NULL); url_string = camel_url_to_string (job->url, 0); g_assert (url_string != NULL); servername = g_strdup (job->url->host); use_ssl = kolab_util_http_protocol_is_ssl (url_string); g_free (url_string); url_string = kolabconv_cal_util_freebusy_new_fb_url (servername, job->url->user, use_ssl, listtype); g_assert (url_string != NULL); g_debug ("%s: \n\t\t\t\t%s", __func__, url_string); /* FIXME create a new extended CamelURL from url_string * * - merge the old and the new CamelURL * - pay attention to passwd,authmech,... set * on the original CamelURL * */ camel_url = camel_url_new (url_string, NULL); g_assert (camel_url != NULL); g_free (url_string); camel_url_set_user (camel_url, job->url->user); /* TODO authmech ? */ camel_url_set_port (camel_url, job->url->port); if (job->url->query) camel_url_set_query (camel_url, job->url->query); if (job->url->fragment) camel_url_set_fragment (camel_url, job->url->fragment); camel_url_free (job->url); job->url = camel_url; job->buffer = g_byte_array_new (); g_assert (job->buffer != NULL); /* issue HTTP GET request */ nbytes = kolab_util_http_get (job, &tmp_err); if (tmp_err != NULL) goto skip; job->nbytes = nbytes; /* save number of bytes read since buffer will be destroyed */ g_debug ("%s: read %d bytes", __func__, nbytes); /* create new ECalComponent */ ecalcomp = kolabconv_cal_util_freebusy_ecalcomp_new_from_ics ((gchar*)(job->buffer->data), nbytes, &tmp_err); skip: if ((ecalcomp == NULL) && (tmp_err != NULL)) g_propagate_error (err, tmp_err); g_byte_array_unref (job->buffer); job->buffer = NULL; g_free (servername); /* postconditions */ g_assert (job->buffer == NULL); return ecalcomp; }
void imap_headers_commit (EPlugin *efp, EConfigHookItemFactoryData *data) { EMConfigTargetAccount *target_account; EAccount *account; gboolean use_imap = g_getenv ("USE_IMAP") != NULL; target_account = (EMConfigTargetAccount *)data->config->target; account = target_account->account; if (g_str_has_prefix (account->source->url, "imap://") || (use_imap && g_str_has_prefix (account->source->url, "groupwise://"))) { EAccount *temp = NULL; EAccountList *accounts = mail_config_get_accounts (); CamelURL *url = NULL; CamelException ex; GtkTreeModel *model; GtkTreeIter iter; GString *str; gchar *header = NULL; str = g_string_new(""); temp = mail_config_get_account_by_source_url (account->source->url); url = camel_url_new (e_account_get_string(account, E_ACCOUNT_SOURCE_URL), &ex); model = gtk_tree_view_get_model (ui->custom_headers_tree); if (gtk_tree_model_get_iter_first(model, &iter)) { do { header = NULL; gtk_tree_model_get (model, &iter, 0, &header, -1); str = g_string_append (str, g_strstrip(header)); str = g_string_append (str, " "); g_free (header); } while (gtk_tree_model_iter_next(model, &iter)); } header = g_strstrip(g_strdup(str->str)); camel_url_set_param (url, "imap_custom_headers", header); g_free (header); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->all_headers))) { camel_url_set_param (url, "all_headers", "1"); camel_url_set_param (url, "basic_headers", NULL); } else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->basic_headers))) { camel_url_set_param (url, "basic_headers", "1"); camel_url_set_param (url, "all_headers", NULL); } else { camel_url_set_param (url, "all_headers", NULL); camel_url_set_param (url, "basic_headers", NULL); } e_account_set_string (temp, E_ACCOUNT_SOURCE_URL, camel_url_to_string (url, 0)); camel_url_free (url); g_string_free (str, TRUE); e_account_list_change (accounts, temp); e_account_list_save (accounts); } }
static CamelFolderInfo * scan_dir (CamelStore *store, CamelURL *url, GHashTable *visited, CamelFolderInfo *parent, const gchar *root, const gchar *name, guint32 flags, GError **error) { CamelFolderInfo *folders, *tail, *fi; GHashTable *folder_hash; const gchar *dent; GDir *dir; tail = folders = NULL; if (!(dir = g_dir_open (root, 0, NULL))) return NULL; folder_hash = g_hash_table_new (g_str_hash, g_str_equal); /* FIXME: it would be better if we queue'd up the recursive * scans till the end so that we can limit the number of * directory descriptors open at any given time... */ while ((dent = g_dir_read_name (dir))) { gchar *short_name, *full_name, *path, *ext; struct stat st; if (dent[0] == '.') continue; if (ignore_file (dent, FALSE)) continue; path = g_strdup_printf("%s/%s", root, dent); if (g_stat (path, &st) == -1) { g_free (path); continue; } #ifndef G_OS_WIN32 if (S_ISDIR (st.st_mode)) { struct _inode in = { st.st_dev, st.st_ino }; if (g_hash_table_lookup (visited, &in)) { g_free (path); continue; } } #endif short_name = g_strdup (dent); if ((ext = strrchr(short_name, '.')) && !strcmp(ext, ".sbd")) *ext = '\0'; if (name != NULL) full_name = g_strdup_printf("%s/%s", name, short_name); else full_name = g_strdup (short_name); if ((fi = g_hash_table_lookup (folder_hash, short_name)) != NULL) { g_free (short_name); g_free (full_name); if (S_ISDIR (st.st_mode)) { fi->flags =(fi->flags & ~CAMEL_FOLDER_NOCHILDREN) | CAMEL_FOLDER_CHILDREN; } else { fi->flags &= ~CAMEL_FOLDER_NOSELECT; } } else { fi = camel_folder_info_new (); fi->parent = parent; camel_url_set_fragment (url, full_name); fi->uri = camel_url_to_string (url, 0); fi->name = short_name; fi->full_name = full_name; fi->unread = -1; fi->total = -1; if (S_ISDIR (st.st_mode)) fi->flags = CAMEL_FOLDER_NOSELECT; else fi->flags = CAMEL_FOLDER_NOCHILDREN; if (tail == NULL) folders = fi; else tail->next = fi; tail = fi; g_hash_table_insert (folder_hash, fi->name, fi); } if (!S_ISDIR (st.st_mode)) { fill_fi (store, fi, flags); } else if ((flags & CAMEL_STORE_FOLDER_INFO_RECURSIVE)) { struct _inode in = { st.st_dev, st.st_ino }; if (g_hash_table_lookup (visited, &in) == NULL) { #ifndef G_OS_WIN32 struct _inode *inew = g_new (struct _inode, 1); *inew = in; g_hash_table_insert (visited, inew, inew); #endif if ((fi->child = scan_dir (store, url, visited, fi, path, fi->full_name, flags, error))) fi->flags |= CAMEL_FOLDER_CHILDREN; else fi->flags =(fi->flags & ~CAMEL_FOLDER_CHILDREN) | CAMEL_FOLDER_NOCHILDREN; } } g_free (path); } g_dir_close (dir); g_hash_table_destroy (folder_hash); return folders; }
/* The worker thread function with all the complex * logic in it! Big fat beast! Please watch your * children ... */ static void synch_worker (struct account_synch_msg *m) { ScalixAccountSynch *sxas; ScalixAccountSynchPrivate *priv; CamelException ex; CamelStore *store; CamelFolderInfo *ftree; CamelFolderInfo *sf; CamelSession *cs; const char *uri; gboolean res; char *sversion; char *markup; sxas = SCALIX_ACCOUNT_SYNCH (m->sxas); priv = SCALIX_ACCOUNT_SYNCH_GET_PRIVATE (sxas); uri = e_account_get_string (priv->account, E_ACCOUNT_SOURCE_URL); g_print ("SxAS: starting synch for %s\n", uri); signal_progress (sxas, 1, _("Trying to connect to server")); camel_exception_init (&ex); cs = scalix_camel_session_get_default (); camel_session_set_online (cs, TRUE); store = camel_session_get_store (cs, uri, &ex); if (store == NULL) { signal_error (sxas, _("Authentication failed. Check for correct hostname, username and password.")); return; } /* Must be online! */ camel_offline_store_set_network_state (CAMEL_OFFLINE_STORE (store), CAMEL_OFFLINE_STORE_NETWORK_AVAIL, &ex); camel_service_connect (CAMEL_SERVICE (store), &ex); if (camel_exception_is_set (&ex)) { signal_error (sxas, _("Error while trying to connect to server.")); return; } /* Always check for minimal required server version */ signal_progress (sxas, 10, _("Checking version of Scalix server")); g_print ("SxAS: Checking for minimal server version\n"); sversion = NULL; camel_object_get (store, NULL, CAMEL_SCALIX_STORE_SERVER_VERSION, &sversion, NULL); res = scalix_check_min_server_version (sversion); if (res == FALSE) { signal_error (sxas, _("Wrong version of Scalix server detected")); return; } m->sversion = g_strdup (sversion); g_print ("SxAS: sversion:%s\n", m->sversion); markup = g_markup_printf_escaped (MSG_SVER, sversion); signal_info (sxas, markup); g_free (markup); signal_progress (sxas, 20, _("Getting list of folders")); ftree = camel_store_get_folder_info (store, NULL, CAMEL_STORE_FOLDER_INFO_RECURSIVE | CAMEL_SCALIX_STORE_SHOW_SFOLDER, &ex); if (ftree == NULL) { camel_object_unref (store); signal_error (sxas, _("Could not obtain folder listening")); return; } /* Calendar */ signal_progress (sxas, 30, _("Loading calendar data...")); synch_data (sxas, ftree, CAMEL_SCALIX_FOLDER_CALENDAR, 30); m->esg_cals = create_group (priv->account, "Calendar"); sync_source_group (priv->account, m->esg_cals, CAMEL_SCALIX_FOLDER_CALENDAR, ftree); /* Contacts */ signal_progress (sxas, 60, _("Loading contacts...")); synch_data (sxas, ftree, CAMEL_SCALIX_FOLDER_CONTACT, 60); m->esg_cnts = create_group (priv->account, "Contacts"); sync_source_group (priv->account, m->esg_cnts, CAMEL_SCALIX_FOLDER_CONTACT, ftree); create_ldap_source (priv->account, m->esg_cnts); /* Sent Items and Drafts Folder */ if (priv->synch_dfolder) { char *url_str; CamelURL *url; url = camel_url_new (uri, NULL); signal_progress (sxas, 95, _("Synchronizing additional data")); sf = folder_tree_find_special (ftree, CAMEL_SCALIX_FOLDER_SENT); if (url && sf) { url_str = url_set_path_and_get_string (url, sf->full_name); e_account_set_string (priv->account, E_ACCOUNT_SENT_FOLDER_URI, url_str); g_free (url_str); } sf = folder_tree_find_special (ftree, CAMEL_SCALIX_FOLDER_DRAFTS); if (url && sf) { url_str = url_set_path_and_get_string (url, sf->full_name); e_account_set_string (priv->account, E_ACCOUNT_DRAFTS_FOLDER_URI, url_str); g_free (url_str); } if (url) { gboolean save_pw; camel_url_set_path (url, NULL); if (url->authmech == NULL) { camel_url_set_authmech (url, "PLAIN"); } url_str = camel_url_to_string (url, 0); e_account_set_string (priv->account, E_ACCOUNT_TRANSPORT_URL, url_str); save_pw = e_account_get_bool (priv->account, E_ACCOUNT_SOURCE_SAVE_PASSWD); e_account_set_bool (priv->account, E_ACCOUNT_TRANSPORT_SAVE_PASSWD, save_pw); } if (url) { camel_url_free (url); } } m->success = TRUE; g_print ("SxAS: DONE!\n"); camel_object_unref (store); signal_progress (sxas, 100, _("Done loading")); signal_info (sxas, _("Initial loading complete. Please click Forward.")); g_print ("SxAS: Freeing DONE\n"); return; }
static void groupwise_store_construct (CamelService *service, CamelSession *session, CamelProvider *provider, CamelURL *url, CamelException *ex) { CamelGroupwiseStore *groupwise_store = CAMEL_GROUPWISE_STORE (service); CamelStore *store = CAMEL_STORE (service); const char *property_value; CamelGroupwiseStorePrivate *priv = groupwise_store->priv; char *path = NULL; d(printf ("\nin groupwise store constrcut\n")); CAMEL_SERVICE_CLASS (parent_class)->construct (service, session, provider, url, ex); if (camel_exception_is_set (ex)) return; if (!(url->host || url->user)) { camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_INVALID, _("Host or user not available in url")); } /*XXX: The number 3 assigned to the list_loaded variable denotes * the number of times the get_folder_info is called during startup. * We are just trying to minimize the call. * This is a dirty hack. But it *WORKS* */ groupwise_store->list_loaded = 3; /*storage path*/ priv->storage_path = camel_session_get_storage_path (session, service, ex); if (!priv->storage_path) return; /*store summary*/ path = g_alloca (strlen (priv->storage_path) + 32); sprintf (path, "%s/.summary", priv->storage_path); groupwise_store->summary = camel_groupwise_store_summary_new (); camel_store_summary_set_filename ((CamelStoreSummary *)groupwise_store->summary, path); camel_store_summary_touch ((CamelStoreSummary *)groupwise_store->summary); camel_store_summary_load ((CamelStoreSummary *) groupwise_store->summary); /*host and user*/ priv->server_name = g_strdup (url->host); priv->user = g_strdup (url->user); /*base url*/ priv->base_url = camel_url_to_string (service->url, (CAMEL_URL_HIDE_PASSWORD | CAMEL_URL_HIDE_PARAMS | CAMEL_URL_HIDE_AUTH) ); /*soap port*/ property_value = camel_url_get_param (url, "soap_port"); if (property_value == NULL) priv->port = g_strdup ("7191"); else if(strlen(property_value) == 0) priv->port = g_strdup ("7191"); else priv->port = g_strdup (property_value); /*filter*/ if (camel_url_get_param (url, "filter")) store->flags |= CAMEL_STORE_FILTER_INBOX; /*Hash Table*/ priv->id_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); priv->name_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); priv->parent_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); /*ssl*/ priv->use_ssl = g_strdup (camel_url_get_param (url, "use_ssl")); store->flags &= ~CAMEL_STORE_VJUNK; store->flags &= ~CAMEL_STORE_VTRASH; }
/* ************************************************************************* */ static GNOME_Evolution_Addressbook_CallStatus e_book_backend_scalix_load_source (EBookBackend * backend, ESource * source, gboolean only_if_exists) { EBookBackendScalix *bs; EBookBackendScalixPrivate *priv; ScalixContainer *container; const char *prop_ssl; gchar *uri; bs = E_BOOK_BACKEND_SCALIX (backend); priv = E_BOOK_BACKEND_SCALIX_GET_PRIVATE (bs); if (priv->container != NULL) { /* Source already loaded! */ return GNOME_Evolution_Addressbook_Success; } uri = e_source_get_uri (source); if ((prop_ssl = e_source_get_property (source, "use_ssl"))) { CamelURL *url; url = camel_url_new (uri, NULL); camel_url_set_param (url, "use_ssl", prop_ssl); g_free (uri); uri = camel_url_to_string (url, 0); } container = scalix_container_open (uri); g_free (uri); if (container == NULL) { return GNOME_Evolution_Addressbook_OtherError; } e_book_backend_set_is_loaded (E_BOOK_BACKEND (backend), TRUE); e_book_backend_set_is_writable (E_BOOK_BACKEND (backend), TRUE); if (only_if_exists == FALSE) { GLOG_CAT_DEBUG (&slbook, "Only if exists == FALSE"); g_object_set (container, "only_if_exists", FALSE, "type", "Contacts", NULL); } priv->container = container; // go online here? if (priv->mode == GNOME_Evolution_Addressbook_MODE_REMOTE) { go_online (bs); } g_signal_connect (container, "object_added", G_CALLBACK (container_object_added_cb), (gpointer) backend); g_signal_connect (container, "object_removed", G_CALLBACK (container_object_removed_cb), (gpointer) backend); g_signal_connect (container, "object_changed", G_CALLBACK (container_object_changed_cb), (gpointer) backend); return GNOME_Evolution_Addressbook_Success; }