static char *
construct_owa_url (CamelURL *url)
{
const char *owa_path, *use_ssl = NULL;
const char *protocol = "http", *mailbox_name;
char *owa_url;
use_ssl = camel_url_get_param (url, "use_ssl");
if (use_ssl) {
if (!strcmp (use_ssl, "always"))
protocol = "https";
}
owa_path = camel_url_get_param (url, "owa_path");
if (!owa_path)
owa_path = "/exchange";
mailbox_name = camel_url_get_param (url, "mailbox");
if (mailbox_name)
owa_url = g_strdup_printf("%s://%s%s/%s", protocol, url->host, owa_path, mailbox_name);
else
owa_url = g_strdup_printf("%s://%s%s", protocol, url->host, owa_path );
return owa_url;
}
static void
handleuri_got_folder(char *uri, CamelFolder *folder, void *data)
{
CamelURL *url = data;
EMMessageBrowser *emmb;
if (folder != NULL) {
const char *reply = camel_url_get_param(url, "reply");
const char *forward = camel_url_get_param(url, "forward");
int mode;
if (reply) {
if (!strcmp(reply, "all"))
mode = REPLY_MODE_ALL;
else if (!strcmp(reply, "list"))
mode = REPLY_MODE_LIST;
else /* if "sender" or anything else */
mode = REPLY_MODE_SENDER;
em_utils_reply_to_message(folder, camel_url_get_param(url, "uid"), NULL, mode, NULL);
} else if (forward) {
GPtrArray *uids;
const char* uid;
uid = camel_url_get_param(url, "uid");
if (uid == NULL)
g_warning("Could not forward the message. UID is NULL.");
else {
uids = g_ptr_array_new();
g_ptr_array_add(uids, g_strdup(uid));
if (!strcmp(forward, "attached"))
em_utils_forward_attached(folder, uids, uri);
else if (!strcmp(forward, "inline"))
em_utils_forward_inline(folder, uids, uri);
else if (!strcmp(forward, "quoted"))
em_utils_forward_quoted(folder, uids, uri);
else { /* Just the default forward */
em_utils_forward_messages(folder, uids, uri);
}
}
} else {
emmb = (EMMessageBrowser *)em_message_browser_window_new();
/*message_list_set_threaded(((EMFolderView *)emmb)->list, emfv->list->threaded);*/
/* FIXME: session needs to be passed easier than this */
em_format_set_session((EMFormat *)((EMFolderView *)emmb)->preview, session);
em_folder_view_set_folder((EMFolderView *)emmb, folder, uri);
em_folder_view_set_message((EMFolderView *)emmb, camel_url_get_param(url, "uid"), FALSE);
gtk_widget_show(emmb->window);
}
} else {
g_warning("Couldn't open folder '%s'", uri);
}
camel_url_free(url);
}
/**
* camel_offline_store_set_network_state:
* @store: a #CamelOfflineStore object
* @state: the network state
* @ex: a #CamelException
*
* Set the network state to either #CAMEL_OFFLINE_STORE_NETWORK_AVAIL
* or #CAMEL_OFFLINE_STORE_NETWORK_UNAVAIL.
**/
void
camel_offline_store_set_network_state (CamelOfflineStore *store, int state, CamelException *ex)
{
CamelException lex;
CamelService *service = CAMEL_SERVICE (store);
gboolean network_state = camel_session_get_network_state (service->session);
if (store->state == state)
return;
camel_exception_init (&lex);
if (store->state == CAMEL_OFFLINE_STORE_NETWORK_AVAIL) {
/* network available -> network unavailable */
if (network_state) {
if (((CamelStore *) store)->folders) {
GPtrArray *folders;
CamelFolder *folder;
int i, sync;
sync = camel_url_get_param (((CamelService *) store)->url, "sync_offline") != NULL;
folders = camel_object_bag_list (((CamelStore *) store)->folders);
for (i = 0; i < folders->len; i++) {
folder = folders->pdata[i];
if (CAMEL_CHECK_TYPE (folder, CAMEL_OFFLINE_FOLDER_TYPE)
&& (sync || ((CamelOfflineFolder *) folder)->sync_offline)) {
camel_offline_folder_downsync ((CamelOfflineFolder *) folder, NULL, &lex);
camel_exception_clear (&lex);
}
camel_object_unref (folder);
}
g_ptr_array_free (folders, TRUE);
}
camel_store_sync (CAMEL_STORE (store), FALSE, &lex);
camel_exception_clear (&lex);
}
if (!camel_service_disconnect (CAMEL_SERVICE (store), network_state, ex))
return;
} else {
/* network unavailable -> network available */
if (!camel_service_connect (CAMEL_SERVICE (store), ex))
return;
}
store->state = state;
}
static void
offline_folder_changed (CamelFolder *folder, CamelFolderChangeInfo *changes, void *dummy)
{
CamelOfflineFolder *offline = (CamelOfflineFolder *) folder;
CamelService *service = (CamelService *) folder->parent_store;
if (changes->uid_added->len > 0 && (offline->sync_offline || camel_url_get_param (service->url, "sync_offline"))) {
CamelSession *session = service->session;
struct _offline_downsync_msg *m;
m = camel_session_thread_msg_new (session, &offline_downsync_ops, sizeof (*m));
m->changes = camel_folder_change_info_new ();
camel_folder_change_info_cat (m->changes, changes);
camel_object_ref (folder);
m->folder = folder;
camel_session_thread_queue (session, &m->msg, 0);
}
}
CamelFolder *
camel_spool_folder_new(CamelStore *parent_store, const char *full_name, guint32 flags, CamelException *ex)
{
CamelFolder *folder;
d(printf("Creating spool folder: %s in %s\n", full_name, camel_local_store_get_toplevel_dir((CamelLocalStore *)parent_store)));
folder = (CamelFolder *)camel_object_new(CAMEL_SPOOL_FOLDER_TYPE);
if (parent_store->flags & CAMEL_STORE_FILTER_INBOX
&& strcmp(full_name, "INBOX") == 0)
folder->folder_flags |= CAMEL_FOLDER_FILTER_RECENT;
flags &= ~CAMEL_STORE_FOLDER_BODY_INDEX;
folder = (CamelFolder *)camel_local_folder_construct((CamelLocalFolder *)folder, parent_store, full_name, flags, ex);
if (folder) {
if (camel_url_get_param(((CamelService *)parent_store)->url, "xstatus"))
camel_mbox_summary_xstatus((CamelMboxSummary *)folder->summary, TRUE);
}
return folder;
}
static void
impl_handleURI (PortableServer_Servant servant, const char *uri, CORBA_Environment *ev)
{
if (!strncmp (uri, "mailto:", 7)) {
if (!em_utils_check_user_can_send_mail(NULL))
return;
em_utils_compose_new_message_with_mailto (uri, NULL);
} else if (!strncmp(uri, "email:", 6)) {
CamelURL *url = camel_url_new(uri, NULL);
if (camel_url_get_param(url, "uid") != NULL) {
char *curi = em_uri_to_camel(uri);
mail_get_folder(curi, 0, handleuri_got_folder, url, mail_msg_unordered_push);
g_free(curi);
} else {
g_warning("email uri's must include a uid parameter");
camel_url_free(url);
}
}
}
/* 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);
}
GtkWidget *
org_gnome_imap_headers (EPlugin *epl, EConfigHookItemFactoryData *data)
{
EMConfigTargetAccount *target_account;
EAccount *account;
GtkWidget *vbox;
CamelURL *url = NULL;
CamelException ex;
char *gladefile;
GladeXML *gladexml;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeIter first, iter;
gboolean use_imap = g_getenv ("USE_IMAP") != NULL;
ui = g_new0 (EPImapFeaturesData, 1);
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://")))
return NULL;
gladefile = g_build_filename (EVOLUTION_GLADEDIR, "imap-headers.glade", NULL);
gladexml = glade_xml_new (gladefile, "vbox2", NULL);
g_free (gladefile);
vbox = glade_xml_get_widget (gladexml, "vbox2");
ui->all_headers = glade_xml_get_widget (gladexml, "allHeaders");
ui->basic_headers = glade_xml_get_widget (gladexml, "basicHeaders");
ui->mailing_list_headers = glade_xml_get_widget (gladexml, "mailingListHeaders");
ui->custom_headers_box = glade_xml_get_widget (gladexml, "custHeaderHbox");
ui->custom_headers_tree = GTK_TREE_VIEW(glade_xml_get_widget (gladexml, "custHeaderTree"));
ui->add_header = GTK_BUTTON(glade_xml_get_widget (gladexml, "addHeader"));
ui->remove_header = GTK_BUTTON(glade_xml_get_widget (gladexml, "removeHeader"));
ui->entry_header = GTK_ENTRY (glade_xml_get_widget (gladexml, "customHeaderEntry"));
url = camel_url_new (e_account_get_string(account, E_ACCOUNT_SOURCE_URL), &ex);
ui->store = gtk_tree_store_new (1, G_TYPE_STRING);
gtk_tree_view_set_model (ui->custom_headers_tree, GTK_TREE_MODEL(ui->store));
if (url) {
char *custom_headers;
custom_headers = g_strdup(camel_url_get_param (url, "imap_custom_headers"));
if (custom_headers) {
int i=0;
ui->custom_headers_array = g_strsplit (custom_headers, " ", -1);
while (ui->custom_headers_array[i] ) {
if (strlen(g_strstrip(ui->custom_headers_array[i]))) {
gtk_tree_store_append (ui->store, &iter, NULL);
gtk_tree_store_set (ui->store, &iter, 0, ui->custom_headers_array[i], -1);
}
i++;
}
g_strfreev (ui->custom_headers_array);
}
g_free (custom_headers);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ui->mailing_list_headers), TRUE);
if (camel_url_get_param (url, "all_headers")) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ui->all_headers), TRUE);
gtk_widget_set_sensitive (ui->custom_headers_box, FALSE);
} else if (camel_url_get_param (url, "basic_headers"))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ui->basic_headers), TRUE);
camel_url_free (url);
}
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Custom Headers"), renderer, "text", 0, NULL);
gtk_tree_view_append_column (ui->custom_headers_tree , column);
gtk_widget_set_sensitive (GTK_WIDGET (ui->add_header), FALSE);
if (gtk_tree_model_get_iter_first (gtk_tree_view_get_model (ui->custom_headers_tree), &first)==FALSE)
gtk_widget_set_sensitive (GTK_WIDGET (ui->remove_header), FALSE);
g_signal_connect (ui->all_headers, "toggled", G_CALLBACK (epif_fetch_all_headers_toggled), ui);
g_signal_connect (ui->add_header, "clicked", G_CALLBACK (epif_add_header), ui);
g_signal_connect (ui->remove_header, "clicked", G_CALLBACK (epif_remove_header_clicked), ui);
g_signal_connect (ui->entry_header, "changed", G_CALLBACK (epif_entry_changed), ui);
g_signal_connect (ui->entry_header, "activate", G_CALLBACK (epif_add_header), ui);
gtk_notebook_append_page ((GtkNotebook *)(data->parent), vbox, gtk_label_new(_("IMAP Headers")));
gtk_widget_show_all (vbox);
return GTK_WIDGET (vbox);
}
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;
}
static void
sync_source_group (EAccount * account,
ESourceGroup * group,
int folder_type, CamelFolderInfo * ftree)
{
GSList *fi_list;
GSList *def;
GSList *iter;
fi_list = folder_tree_flatten (ftree, folder_type, &def);
for (iter = fi_list; iter != NULL; iter = g_slist_next (iter)) {
ESource *source;
CamelURL *url;
CamelFolderInfo *info;
const char *fuid;
const char *pssl;
char *uid;
xmlNodePtr node;
info = (CamelFolderInfo *) iter->data;
url = camel_url_new (info->uri, NULL);
g_print ("FOLDER_URI: %s\n", info->uri);
if (url == NULL) {
camel_url_free (url);
continue;
}
/* the uid part */
fuid = camel_url_get_param (url, "uid");
if (fuid == NULL) {
g_warning ("No Folder UID\n");
camel_url_free (url);
continue;
}
uid = g_strdup_printf ("%s@%s", fuid, account->uid);
/* there is no such thing as e_source_set_uid
* so we have to cheat here a bit */
node = xmlNewNode (NULL, "source");
xmlSetProp (node, "uid", uid);
xmlSetProp (node, "name", info->name);
xmlSetProp (node, "relative_uri", info->full_name);
source = e_source_new_from_xml_node (node);
xmlFreeNode (node);
g_free (uid);
if (source == NULL) {
g_warning ("Invalid source, skipping");
camel_url_free (url);
/* FIXME free resources */
continue;
}
pssl = camel_url_get_param (url, "use_ssl");
if (pssl != NULL) {
e_source_set_property (source, "use_ssl", pssl);
}
if (info->flags & CAMEL_FOLDER_IS_DEFAULT) {
e_source_set_property (source, "default", "TRUE");
if (folder_type == CAMEL_SCALIX_FOLDER_CONTACT) {
e_source_set_property (source, "completion", "TRUE");
}
}
camel_url_free (url);
e_source_group_add_source (group, source, -1);
}
}
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;
}
