abort ();
}
-
}
done:
if (e_flag_is_set (closure->running))
return GNOME_Evolution_Addressbook_Success;
}
-
static EBookBackendSyncStatus
e_book_backend_file_get_supported_fields (EBookBackendSync *backend,
EDataBook *book,
g_warning ("libdb error: %s", buf2);
}
-
static GNOME_Evolution_Addressbook_CallStatus
e_book_backend_file_load_source (EBookBackend *backend,
ESource *source,
sync_class->get_supported_fields_sync = e_book_backend_file_get_supported_fields;
sync_class->get_required_fields_sync = e_book_backend_file_get_required_fields;
-
object_class->dispose = e_book_backend_file_dispose;
object_class->finalize = e_book_backend_file_finalize;
return FALSE;
}
-
static void
google_book_cache_destroy (GoogleBook *book)
{
g_signal_emit (book, google_book_signals [AUTH_REQUIRED], 0);
}
-
static void
google_book_class_init (GoogleBookClass *klass)
{
return rv;
}
-
EContact*
google_book_get_contact (GoogleBook *book,
const gchar *uid,
return types;
}
-
static EVCardAttribute*
attribute_from_gdata_entry_email_address (GDataEntryEmailAddress *email)
{
}
}
-
static void
set_emails_in_gw_item (EGwItem *item, gpointer data)
{
g_object_unref (temp_item);
}
-
/* In groupwise there is no way to put arbitrary members into a group. There's no
* mechanism for a group to contain members that are not already present in a system
* or personal addressbook as a contact, and so they cant be saved and will be lost.
if (status != E_GW_CONNECTION_STATUS_OK)
return FALSE;
-
for (; gw_items != NULL; gw_items = g_list_next(gw_items)) {
contact_num++;
contact = e_contact_new ();
return NULL;
}*/
-
/*FIXME using cursors for address book seems to be crashing server
till it gets fixed we will use get items. cursor implementation is below */
struct stat buf;
time_t mod_time;
-
if (!ebgw)
return FALSE;
if (sync_required)
ebgw->priv->file_db->sync(ebgw->priv->file_db, 0);
-
if (book_view) {
e_data_book_view_notify_complete (book_view,
GNOME_Evolution_Addressbook_Success);
printf("book_name:%s\n", priv->book_name);
}
-
switch (ebgw->priv->mode) {
case GNOME_Evolution_Addressbook_MODE_LOCAL:
/* load summary file for offline use */
const gchar *use_ssl;
const gchar *offline;
-
if (enable_debug)
printf("\ne_book_backend_groupwise_load_source.. \n");
ebgw = E_BOOK_BACKEND_GROUPWISE (backend);
e_book_backend_groupwise_class_init (EBookBackendGroupwiseClass *klass)
{
-
GObjectClass *object_class = G_OBJECT_CLASS (klass);
EBookBackendClass *parent_class;
#endif /* ! __E_BOOK_BACKEND_GROUPWISE_H__ */
-
-
#include "openldap-extract.h"
#endif
-
#endif
#include <sys/time.h>
}
}
-
#ifndef SUNLDAP
static void
get_ldap_library_info (void)
(PFN_ldap_start_tls_s) GetProcAddress (GetModuleHandle ("wldap32.dll"), "ldap_start_tls_s");
if (!pldap_start_tls_s)
(PFN_ldap_start_tls_s) GetProcAddress (GetModuleHandle ("wldap32.dll"), "ldap_start_tls_sA");
-
+
if (!pldap_start_tls_s)
ldap_error = LDAP_NOT_SUPPORTED;
else
}
}
-
typedef struct {
LDAPOp op;
gchar *id;
gint modify_contact_msgid;
EDataBookView *book_view;
-
switch (bl->priv->mode) {
case GNOME_Evolution_Addressbook_MODE_LOCAL :
}
}
-
typedef struct {
LDAPOp op;
} LDAPGetContactOp;
}
}
-
typedef struct {
LDAPOp op;
GList *contacts;
g_free (contact_list_op);
}
-
static void
e_book_backend_ldap_get_contact_list (EBookBackend *backend,
EDataBook *book,
return TRUE;
}
-
static void
member_populate (EContact *contact, gchar **values)
{
return contact_addr;
}
-
-
static void
address_populate(EContact * card, gchar **values, EContactField field, EContactField other_field)
{
photo1 = e_contact_get(ecard1, E_CONTACT_PHOTO);
photo2 = e_contact_get(ecard2, E_CONTACT_PHOTO);
-
if (photo1 && photo2) {
if (photo1->type == photo2->type && photo1->type == E_CONTACT_PHOTO_TYPE_INLINED) {
equal = ((photo1->data.inlined.length == photo2->data.inlined.length)
{
GList *fields = NULL;
-
/*FIMEME we should look at mandatory attributs in the schema
and return all those fields here */
fields = g_list_append (fields, (gchar *)e_contact_field_name (E_CONTACT_FILE_AS));
fields = g_list_append (fields, (gchar *)e_contact_field_name (E_CONTACT_FULL_NAME));
fields = g_list_append (fields, (gchar *)e_contact_field_name (E_CONTACT_FAMILY_NAME));
-
e_data_book_respond_get_required_fields (book,
opid,
GNOME_Evolution_Addressbook_Success,
g_list_free (fields);
}
-
static void
e_book_backend_ldap_get_supported_fields (EBookBackend *backend,
EDataBook *book,
gchar **oc_at_oids_may; /* OPTIONAL */
} LDAPObjectClass;
-
static void
vfree(gpointer *vec)
{
}
}
-
typedef struct {
EBookBackendVCF *bvcf;
gboolean search_needed;
return NULL;
}
-
static void
e_book_backend_vcf_start_book_view (EBookBackend *backend,
EDataBookView *book_view)
"apt", "apartment", "suite", NULL
};
-
-
static gboolean
e_address_western_is_line_blank (gchar *line)
{
return blank;
}
-
-
/* In the array of lines, `lines', we will erase the line at line_num, and
shift the remaining lines, up to line number num_lines, up one position. */
}
}
-
static void
e_address_western_remove_blank_lines (gchar *lines[], gint *linecntr)
{
}
}
-
static gboolean
e_address_western_is_po_box (gchar *line)
{
/* In which phase of processing are we? */
enum State { FIRSTCHAR, SECONDCHAR, WHITESPACE } state;
-
/* If the first two letters of the line are `p' and `o', and these
are in turn followed by whitespace before another letter, then I
will deem the line a representation of a PO Box address. */
return g_strndup (line, index);
}
-
/* Whatever resides between the comma and the start of the
postal code is deemed to be the region. */
#endif /* ! __E_ADDRESS_WESTERN_H__ */
-
g_signal_emit (listener, e_book_listener_signals [RESPONSE], 0, &response);
}
-
static void
impl_BookListener_respond_get_supported_fields (PortableServer_Servant servant,
const CORBA_long opid,
gchar *vcard;
};
-
EBookListener *e_book_listener_new (void);
GType e_book_listener_get_type (void);
void e_book_listener_stop (EBookListener *listener);
break;
}
-
g_string_append (str, ")");
g_string_free (encoded, TRUE);
E_BOOK_ERROR_NO_SPACE
} EBookStatus;
-
typedef enum {
E_BOOK_VIEW_STATUS_OK,
E_BOOK_VIEW_STATUS_TIME_LIMIT_EXCEEDED,
*/
void (*response) (EBookViewListener *listener, EBookViewListenerResponse *response);
-
/* Padding for future expansion */
void (*_ebook_reserved0) (void);
void (*_ebook_reserved1) (void);
resp->message);
}
-
static void
e_book_view_handle_response (EBookViewListener *listener, EBookViewListenerResponse *resp, EBookView *book_view)
{
e_book_op_free (op);
}
-
static gboolean
do_add_contact (gboolean sync,
EBook *book,
}
}
-
/**
* e_book_commit_contact:
* @book: an #EBook
return FALSE;
}
-
CORBA_exception_free (&ev);
if (sync) {
return FALSE;
}
-
CORBA_exception_free (&ev);
if (sync) {
return FALSE;
}
-
CORBA_exception_free (&ev);
if (sync) {
return FALSE;
}
-
static void
e_book_response_get_contacts (EBook *book,
guint32 opid,
return FALSE;
-
}
static void
\f
-
/* Set a flag for operation from the operation hash table */
static void
find_key_value (gpointer key, gpointer value, gpointer data)
return FALSE;
}
-
/*
* Create our local BookListener interface.
*/
return e_book_set_default_source (source, error);
}
-
/**
* e_book_set_default_source:
* @source: An #ESource pointer
typedef void (*EBookBookViewCallback) (EBook *book, EBookStatus status, EBookView *book_view, gpointer closure);
typedef void (*EBookEListCallback) (EBook *book, EBookStatus status, EList *list, gpointer closure);
-
struct _EBook {
GObject parent;
/*< private >*/
EBookEListCallback cb,
gpointer closure);
-
/* User authentication. */
gboolean e_book_authenticate_user (EBook *book,
const gchar *user,
return type_id;
}
-
/**
* e_contact_address_free:
* @address: an #EContactAddress
E_CONTACT_IS_LIST, /* boolean field */
E_CONTACT_LIST_SHOW_ADDRESSES, /* boolean field */
-
E_CONTACT_BIRTH_DATE, /* structured field (EContactDate) */
E_CONTACT_ANNIVERSARY, /* structured field (EContactDate) */
EContactName *e_contact_name_copy (EContactName *n);
void e_contact_name_free (EContactName *name);
-
GType e_contact_photo_get_type (void);
void e_contact_photo_free (EContactPhoto *photo);
GType e_contact_address_get_type (void);
void e_contact_address_free (EContactAddress *address);
-
const gchar * e_contact_field_name (EContactField field_id);
const gchar * e_contact_pretty_name (EContactField field_id);
const gchar * e_contact_vcard_attribute (EContactField field_id);
GType e_destination_get_type (void);
-
EDestination *e_destination_new (void);
EDestination *e_destination_copy (const EDestination *dest);
g_free (name->full);
name->full = newfull;
-
g_free (prefix);
g_free (firstmidnick);
g_free (last);
return vcard_type;
}
-
-
/* Skip newline characters and return the next character.
* This function takes care of folding lines, skipping
* newline characters if found, taking care of equal characters
return p;
}
-
/* skip forward until we hit the CRLF, or \0 */
static void
skip_to_next_line (gchar **p)
/* mostly for debugging */
void e_vcard_dump_structure (EVCard *evc);
-
/* attributes */
EVCardAttribute *e_vcard_attribute_new (const gchar *attr_group, const gchar *attr_name);
void e_vcard_attribute_free (EVCardAttribute *attr);
}
}
-
static void
e_book_backend_cache_finalize (GObject *object)
{
priv->uri = NULL;
}
-
g_free (priv);
cache->priv = NULL;
}
}
-
GType
e_book_backend_cache_get_type (void)
{
}
-
return contact;
}
g_return_val_if_fail (E_IS_BOOK_BACKEND_CACHE (cache), FALSE);
-
priv = cache->priv;
uid = e_contact_get_const (contact, E_CONTACT_UID);
priv = cache->priv;
-
if (!e_file_cache_get_object (E_FILE_CACHE (cache), uid)) {
return FALSE;
}
retval = e_file_cache_remove_object (E_FILE_CACHE (cache), uid);
-
return retval;
}
return NULL;
}
-
lcache = l = e_file_cache_get_objects (E_FILE_CACHE (cache));
for (; l != NULL; l = g_slist_next (l)) {
gchar *e_book_backend_cache_get_time (EBookBackendCache *cache);
GPtrArray* e_book_backend_cache_search (EBookBackendCache *cache, const gchar *query);
-
-
-
G_END_DECLS
#endif
const gchar * e_book_backend_factory_get_protocol (EBookBackendFactory *factory);
EBookBackend* e_book_backend_factory_new_backend (EBookBackendFactory *factory);
-
/* use this macro for simple, 1 factory modules */
#define E_BOOK_BACKEND_FACTORY_SIMPLE(p,t,f) \
typedef struct { \
return compare_im (contact, str, compare, E_CONTACT_IM_GADUGADU);
}
-
static gboolean
compare_im_jabber (EContact *contact, const gchar *str,
gchar *(*compare)(const gchar *, const gchar *))
g_object_unref (views);
}
-
static void
view_notify_update (EDataBookView *view, gpointer contact)
{
e_book_backend_foreach_view (backend, view_notify_update, contact);
}
-
static void
view_notify_remove (EDataBookView *view, gpointer id)
{
e_book_backend_foreach_view (backend, view_notify_remove, (gpointer)id);
}
-
static void
view_notify_complete (EDataBookView *view, gpointer unused)
{
GType e_book_backend_get_type (void);
-
/* protected functions for subclasses */
void e_book_backend_set_is_loaded (EBookBackend *backend,
gboolean is_loaded);
{
EDataBookFactoryPrivate *priv = factory->priv;
-
g_mutex_lock (priv->map_mutex);
priv->mode = mode;
g_hash_table_foreach (priv->active_server_map, set_backend_online_status, GINT_TO_POINTER (priv->mode));
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
epv = &klass->epv;
epv->getBook = impl_GNOME_Evolution_Addressbook_BookFactory_getBook;
POA_GNOME_Evolution_Addressbook_BookView__epv epv;
};
-
EDataBookView *e_data_book_view_new (EBookBackend *backend,
GNOME_Evolution_Addressbook_BookViewListener listener,
const gchar *card_query,
e_data_book_respond_get_book_view (book, opid, GNOME_Evolution_Addressbook_Success, view);
}
-
static void
impl_GNOME_Evolution_Addressbook_Book_getChanges (PortableServer_Servant servant,
const CORBA_long opid,
return ret_val;
}
-
static void
impl_GNOME_Evolution_Addressbook_Book_getRequiredFields (PortableServer_Servant servant,
const CORBA_long opid,
return e_book_backend_cancel_operation (e_data_book_get_backend (book), book);
}
-
/**
* e_data_book_get_backend:
* @book: an #EDataBook
g_list_foreach (card_list, (GFunc)g_free, NULL);
g_list_free (card_list);
-
GNOME_Evolution_Addressbook_BookListener_notifyContactListRequested (book->priv->listener,
opid,
status,
void (*_pas_reserved4) (void);
};
-
EDataBook *e_data_book_new (EBookBackend *backend,
ESource *source,
GNOME_Evolution_Addressbook_BookListener listener);
e_book_free_change_list (changes);
-
if (!e_book_remove (book, &error)) {
printf ("failed to remove book; %s\n", error->message);
exit(0);
}
}
-
static gchar *
icomp_x_prop_get (icalcomponent *comp, const gchar *key)
{
g_free (state_string);
}*/
-
static gchar *
ecalcomp_gen_href (ECalComponent *comp)
{
return result;
}
-
static ECalBackendSyncStatus
caldav_server_get_object (ECalBackendCalDAV *cbdav, CalDAVObject *object)
{
} else if (uid && ccl) {
/* all components cover by this uid are up-to-date */
GSList *p;
-
+
for (p = ccl->slist; p; p = p->next) {
g_object_unref (p->data);
}
return GNOME_Evolution_Calendar_Success;
}
-
static ECalBackendSyncStatus
caldav_get_cal_address (ECalBackendSync *backend,
EDataCal *cal,
return GNOME_Evolution_Calendar_Success;
}
-
-
static ECalBackendSyncStatus
caldav_get_ldap_attribute (ECalBackendSync *backend,
EDataCal *cal,
e_cal_backend_sync_set_lock (E_CAL_BACKEND_SYNC (cbdav), FALSE);
}
-
static void
e_cal_backend_caldav_class_init (ECalBackendCalDAVClass *class)
{
G_BEGIN_DECLS
-
#define E_TYPE_CAL_BACKEND_CALDAV (e_cal_backend_caldav_get_type ())
#define E_CAL_BACKEND_CALDAV(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TYPE_CAL_BACKEND_CALDAV, ECalBackendCalDAV))
#define E_CAL_BACKEND_CALDAV_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_CAL_BACKEND_CALDAV, ECalBackendCalDAVClass))
GType e_cal_backend_caldav_get_type (void);
-
G_END_DECLS
#endif /* E_CAL_BACKEND_CALDAV_H */
backend_class->internal_get_timezone = e_cal_backend_contacts_internal_get_timezone;
}
-
/**
* e_cal_backend_contacts_get_type:
* @void:
comp = e_cal_component_new_from_string (old_obj_str);
id = e_cal_component_get_id (comp);
-
e_cal_backend_notify_object_removed (context->backend, id, old_obj_str, NULL);
e_cal_component_free_id (id);
priv = cbfile->priv;
-
/* FIXME Will this always work? */
unescaped_uri = g_uri_unescape_string (priv->path, "");
filename = g_strdup_printf ("%s-%s.db", unescaped_uri, change_id);
tzdata->found = FALSE;
}
-
/* This function is largely duplicated in
* ../groupwise/e-cal-backend-groupwise.c
*/
backend_class->internal_get_timezone = e_cal_backend_file_internal_get_timezone;
}
-
/**
* e_cal_backend_file_get_type:
* @void:
* Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <libecal/e-cal-component.h>
#include <libecal/e-cal-time-util.h>
-
#include <libical/ical.h>
#include <libsoup/soup-misc.h>
e_cal_backend_notify_view_done (E_CAL_BACKEND(cbgo), GNOME_Evolution_Calendar_Success);
}
-
/**
*
* e_cal_backend_google_utils_create_cache:
return GINT_TO_POINTER (GNOME_Evolution_Calendar_Success);
}
-
/**
* e_cal_backend_google_utils_update:
*
return comp;
}
-
/**
*
* e_go_item_from_cal_component:
return item->entry;
}
-
/**
*
* e_go_item_set_entry:
return NULL;
}
-
/***************************************************************** Utility Functions *********************************************/
static gint
g_slist_free (entries_list);
}
-
static void
utils_update_deletion (ECalBackendGoogle *cbgo, ECalBackendCache *cache, GSList *cache_keys)
{
#include <libedataserver/e-xml-hash-utils.h>
#include <libedataserver/e-proxy.h>
-
#include <libedata-cal/e-cal-backend-util.h>
#include <libedata-cal/e-cal-backend-sexp.h>
return GNOME_Evolution_Calendar_Success;
}
-
static ECalBackendSyncStatus
e_cal_backend_google_remove (ECalBackendSync *backend, EDataCal *cal)
{
return GNOME_Evolution_Calendar_Success;
}
-
static gboolean
e_cal_backend_google_is_loaded (ECalBackend *backend)
{
return priv->cache ? TRUE : FALSE;
}
-
static ECalBackendSyncStatus
e_cal_backend_google_add_timezone (ECalBackendSync *backend, EDataCal *cal, const gchar *tzobj)
{
return GNOME_Evolution_Calendar_Success;
}
-
static void
e_cal_backend_google_set_mode (ECalBackend *backend, CalMode mode)
{
return GNOME_Evolution_Calendar_Success;
}
-
/* Returns the email address of the person who opened the calendar */
static ECalBackendSyncStatus
e_cal_backend_google_get_cal_address (ECalBackendSync *backend, EDataCal *cal, gchar **address)
return GNOME_Evolution_Calendar_Success;
}
-
static ECalBackendSyncStatus
e_cal_backend_google_remove_object (ECalBackendSync *backend, EDataCal *cal,
const gchar *uid, const gchar *rid,
return GNOME_Evolution_Calendar_Success;
}
-
static ECalBackendSyncStatus
e_cal_backend_google_get_static_capabilities (ECalBackendSync *backend, EDataCal *cal, gchar **capabilities)
{
priv->cache = NULL;
}
-
if (priv->default_zone) {
icaltimezone_free (priv->default_zone, 1);
priv->default_zone = NULL;
return e_cal_backend_google_type;
}
-
/***************************************** Helper Functions ****************************************************/
/**
g_return_val_if_fail (cbgo != NULL, NULL);
g_return_val_if_fail (E_IS_CAL_BACKEND_GOOGLE(cbgo), NULL);
-
priv = cbgo->priv;
return priv->cache;
}
return priv->password;
}
-
gchar *
e_cal_backend_google_get_local_attachments_store (ECalBackendGoogle *cbgo)
{
gint count = 0;
icaltimezone *dzone, *utc;
-
dzone = e_cal_backend_groupwise_get_default_zone (cbgw);
utc = icaltimezone_get_utc_timezone ();
icaltimezone *default_zone, *utc;
struct icaltimetype itt_utc;
-
e_cal_component_get_exdate_list (comp, &exdate_list);
default_zone = e_cal_backend_groupwise_get_default_zone (cbgw);
utc = icaltimezone_get_utc_timezone ();
cal_obj_uid_list_free (l);
}
-
-
/* end date */
e_cal_component_get_dtend (comp, &dt);
if (dt.value) {
/* GW server ID */
e_gw_item_set_id (item, e_cal_component_get_gw_id (comp));
-
/* UID */
e_cal_component_get_uid (comp, &uid);
e_gw_item_set_icalid (item, uid);
e_cal_component_free_text_list (slist);
}
-
/* start date */
e_cal_component_get_dtstart (comp, &dt);
if (dt.value) {
e_gw_item_set_classification (item, NULL);
}
-
set_attendees_to_item (item, comp, default_zone, FALSE, NULL);
/* check if recurrences exist and update the item */
g_object_unref (gconf);
}
-
static gchar *
get_cn_from_display_name (gchar *display_name)
{
icalcomponent_add_property (e_cal_component_get_icalcomponent (comp), icalprop);
}
-
if (e_gw_item_get_reply_request (item)) {
gchar *reply_within;
const gchar *mess = e_gw_item_get_message (item);
else
attendee->status = ICAL_PARTSTAT_NEEDSACTION;
-
attendee_list = g_slist_append (attendee_list, attendee);
}
e_cal_component_set_dtend (comp, &dt);
}
-
/* alarms*/
/* we negate the value as GW supports only "before" the start of event alarms */
alarm_duration = 0 - e_gw_item_get_trigger (item);
const gchar *email_id;
ECalComponentAttendee *attendee = NULL, *tmp;
-
e_cal_component_get_attendee_list (comp, &attendee_list);
for (l = attendee_list; l; l = g_slist_next (l)) {
tmp = (ECalComponentAttendee *) (l->data);
soup_soap_message_end_element (msg);
-
utc = icaltimezone_get_utc_timezone ();
icaltime = icaltime_from_timet_with_zone (start, FALSE, utc);
start_date = icaltime_as_ical_string_r (icaltime);
SET_DELTA(message);
SET_DELTA(classification);
-
SET_DELTA(start_date);
set_categories_changes (item, cache_item);
/*FIXME recipient_list modifications need go here after server starts
}
}
-
static void
add_return_value (EGwSendOptionsReturnNotify track, ESource *source, const gchar *notify)
{
#define GW_EVENT_TYPE_ID "@4:"
#define GW_TODO_TYPE_ID "@3:"
-
/* Default reminder */
#define CALENDAR_CONFIG_PREFIX "/apps/evolution/calendar"
#define CALENDAR_CONFIG_DEFAULT_REMINDER CALENDAR_CONFIG_PREFIX "/other/use_default_reminder"
gboolean e_cal_backend_groupwise_store_settings (GwSettings *hold);
gboolean e_cal_backend_groupwise_utils_check_delegate (ECalComponent *comp, const gchar *email);
-
/*
* Component related utility functions
*/
const gchar *attempts;
const gchar *position;
-
EGwFilter *filter;
gint time_interval;
icaltimetype temp;
ECalComponent *comp = NULL;
icalcomponent *icalcomp = NULL;
-
comp = e_cal_backend_cache_get_component (cache, (const gchar *) ls->data, NULL);
if (!comp)
sanitize_component (E_CAL_BACKEND_SYNC (cbgw), comp, (gchar *) e_gw_item_get_id (item));
e_cal_backend_cache_put_component (priv->cache, comp);
-
if (kind == icalcomponent_isa (e_cal_component_get_icalcomponent (comp))) {
tmp = e_cal_component_get_as_string (comp);
e_cal_backend_notify_object_created (E_CAL_BACKEND (cbgw), tmp);
return TRUE;
}
-
static gboolean
start_fetch_deltas (gpointer data)
{
return GNOME_Evolution_Calendar_AuthenticationFailed;
}
-
cbgw->priv->read_only = TRUE;
if (kind == ICAL_VEVENT_COMPONENT && (permissions & E_GW_PROXY_APPOINTMENT_WRITE) )
return GNOME_Evolution_Calendar_OtherError;
}
-
} else {
e_cal_backend_notify_error (E_CAL_BACKEND (cbgw), _("Authentication failed"));
return GNOME_Evolution_Calendar_AuthenticationFailed;
return GNOME_Evolution_Calendar_Success;
}
-
static void
in_offline (ECalBackendGroupwise *cbgw) {
ECalBackendGroupwisePrivate *priv;
priv->cnc = NULL;
}
-
}
/* Open handler for the file backend */
break;
}
-
*old_object = e_cal_component_get_as_string (cache_comp);
g_object_unref (cache_comp);
g_object_unref (comp);
gboolean found = FALSE;
icalcomponent *icalcomp = e_cal_component_get_icalcomponent (comp);
-
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_ATTENDEE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_ATTENDEE_PROPERTY)) {
return GNOME_Evolution_Calendar_ObjectNotFound;
}
-
switch (priv->mode) {
case CAL_MODE_ANY :
case CAL_MODE_REMOTE :
return status;
}
-
/* Object initialization function for the file backend */
static void
e_cal_backend_groupwise_init (ECalBackendGroupwise *cbgw, ECalBackendGroupwiseClass *class)
backend_class->internal_get_timezone = e_cal_backend_groupwise_internal_get_timezone;
}
-
/**
* e_cal_backend_groupwise_get_type:
* @void:
priv->default_zone = NULL;
}
-
if (priv->soup_session) {
soup_session_abort (priv->soup_session);
g_object_unref (priv->soup_session);
if (priv->mode == CAL_MODE_LOCAL)
return GNOME_Evolution_Calendar_Success;
-
g_idle_add ((GSourceFunc) begin_retrieval_cb, cbhttp);
return GNOME_Evolution_Calendar_Success;
if (!tz_comp)
return GNOME_Evolution_Calendar_InvalidObject;
-
zone = icaltimezone_new ();
icaltimezone_set_component (zone, tz_comp);
e_data_cal_view_notify_done (query, GNOME_Evolution_Calendar_Success);
}
-
static icaltimezone *
resolve_tzid (const gchar *tzid, gpointer user_data)
{
return icalcomponent_get_timezone (vcalendar_comp, tzid);
}
-
static gboolean
free_busy_instance (ECalComponent *comp,
time_t instance_start,
return vfb;
}
-
-
/* Get_free_busy handler for the file backend */
static ECalBackendSyncStatus
e_cal_backend_http_get_free_busy (ECalBackendSync *backend, EDataCal *cal, GList *users,
icalcomponent *vfb;
gchar *calobj;
-
cbhttp = E_CAL_BACKEND_HTTP (backend);
priv = cbhttp->priv;
backend_class->internal_get_timezone = e_cal_backend_http_internal_get_timezone;
}
-
/**
* e_cal_backend_http_get_type:
* @void:
backend_class->internal_get_timezone = e_cal_backend_weather_internal_get_timezone;
}
-
/**
* e_cal_backend_weather_get_type:
* @void:
g_free(fulltzid);
}
-
/*
* If the strings are identical, then the
* VTIMEZONE definitions are identical. If
/* Extension property for alarm components so that we can reference them by UID */
#define EVOLUTION_ALARM_UID_PROPERTY "X-EVOLUTION-ALARM-UID"
-
struct attendee {
icalproperty *prop;
icalparameter *cutype_param;
*list = g_slist_append (*list, period);
}
-
/* Scans an icalrecurtype property */
static void
scan_recur_id (ECalComponent *comp, struct recur_id *recur_id, icalproperty *prop)
*al = g_slist_reverse (*al);
}
-
static void
set_attachment_list (icalcomponent *icalcomp,
GSList **attachment_list,
*attachment_list = g_slist_reverse (*attachment_list);
}
-
/**
* e_cal_component_get_attachment_list:
* @comp: A calendar component object.
}
}
-
/**
* e_cal_component_get_categories_list:
* @comp: A calendar component object.
t);
}
-
/**
* e_cal_component_get_created:
* @comp: A calendar component object.
}
}
-
/* This tries to get the DTSTART + DURATION for a VEVENT or VTODO. In a
VEVENT this is used for the DTEND if no DTEND exists, In a VTOTO it is
used for the DUE date if DUE doesn't exist. */
duration.minutes, duration.seconds);
}
-
/**
* e_cal_component_get_dtend:
* @comp: A calendar component object.
priv->organizer.language_param = NULL;
}
-
}
-
/**
* e_cal_component_has_organizer:
* @comp: A calendar component object.
icalcomponent_add_property (priv->icalcomp, priv->percent);
}
-
}
gint
priv = comp->priv;
g_return_if_fail (priv->icalcomp != NULL);
-
if (transp == E_CAL_COMPONENT_TRANSP_NONE) {
if (priv->transparency) {
icalcomponent_remove_property (priv->icalcomp, priv->transparency);
*al = g_slist_reverse (*al);
}
-
/* Sets a text list value */
static void
set_attendee_list (icalcomponent *icalcomp,
g_hash_table_foreach_remove (priv->alarm_uid_hash, for_each_remove_all_alarms, comp);
}
-
/* Scans an icalproperty from a calendar component and adds its mapping to our
* own alarm structure.
*/
return FALSE;
}
-
/**
* e_cal_component_alarm_get_icalcomponent
* @alarm: An alarm.
return FALSE;
}
-
/**
* e_cal_component_event_dates_match:
* @comp1: A calendar component object.
return retval;
}
-
gboolean e_cal_component_has_attachments (ECalComponent *comp);
gint e_cal_component_get_num_attachments (ECalComponent *comp);
-
gboolean e_cal_component_event_dates_match (ECalComponent *comp1, ECalComponent *comp2);
-
/* Functions to free returned values */
void e_cal_component_free_categories_list (GSList *categ_list);
#include "e-cal-recur.h"
#include "e-cal-time-util.h"
-
/*
* Introduction to The Recurrence Generation Functions:
*
/* WKST property - the week start day: 0 = Monday to 6 = Sunday. */
gint week_start_day;
-
/* NOTE: I've used GList's here, but it doesn't matter if we use
other data structures like arrays. The code should be easy to
change. So long as it is easy to see if the modifier is set. */
CalObjFilterFn bysecond_filter;
};
-
/* This is used to specify which parts of the CalObjTime to compare in
cal_obj_time_compare(). */
typedef enum {
static gint e_cal_recur_ical_weekday_to_weekday (enum icalrecurrencetype_weekday day);
static void e_cal_recur_free (ECalRecurrence *r);
-
static gboolean cal_object_get_rdate_end (CalObjTime *occ,
GArray *rdate_periods,
icaltimezone *zone);
ECalRecurVTable *vtable,
CalObjTime *occ);
-
static ECalRecurVTable* cal_obj_get_vtable (icalrecurrencetype_frequency recur_type);
static void cal_obj_initialize_recur_data (RecurData *recur_data,
ECalRecurrence *recur,
static GArray* cal_obj_bysetpos_filter (ECalRecurrence *recur,
GArray *occs);
-
static gboolean cal_obj_yearly_find_start_position (CalObjTime *event_start,
CalObjTime *event_end,
RecurData *recur_data,
static gint cal_obj_date_only_compare_func (gconstpointer arg1,
gconstpointer arg2);
-
-
static gboolean e_cal_recur_ensure_end_dates (ECalComponent *comp,
gboolean refresh,
ECalRecurResolveTimezoneFn tz_cb,
static void e_cal_recur_set_rule_end_date (icalproperty *prop,
time_t end_date);
-
#ifdef CAL_OBJ_DEBUG
static gchar * cal_obj_time_to_string (CalObjTime *cotime);
#endif
-
static ECalRecurVTable cal_obj_yearly_vtable = {
cal_obj_yearly_find_start_position,
cal_obj_yearly_find_next_position,
default_timezone);
}
-
/*
* Calls the given callback function for each occurrence of the given
* recurrence rule between the given start and end times. If the rule is NULL
return r;
}
-
static gint
e_cal_recur_ical_weekday_to_weekday (enum icalrecurrencetype_weekday day)
{
return weekday;
}
-
/**
* e_cal_recur_free:
* @r: A #ECalRecurrence structure.
g_array_append_val (ex_occs, cotime);
}
-
/* Sort all the arrays. */
cal_obj_sort_occurrences (occs);
cal_obj_sort_occurrences (ex_occs);
return cb_status && !finished;
}
-
/* This looks up the occurrence time in the sorted rdate_periods array, and
tries to compute the end time of the occurrence. If no end time or duration
is set it returns FALSE and the default duration will be used. */
return TRUE;
}
-
static void
cal_object_compute_duration (CalObjTime *start,
CalObjTime *end,
}
}
-
/* Returns an unsorted GArray of CalObjTime's resulting from expanding the
given recurrence rule within the given interval. Note that it doesn't
clip the generated occurrences to the interval, i.e. if the interval
return all_occs;
}
-
static GArray*
cal_obj_generate_set_yearly (RecurData *recur_data,
ECalRecurVTable *vtable,
return occs;
}
-
static GArray*
cal_obj_generate_set_monthly (RecurData *recur_data,
ECalRecurVTable *vtable,
return occs;
}
-
static GArray*
cal_obj_generate_set_default (RecurData *recur_data,
ECalRecurVTable *vtable,
return occs;
}
-
-
/* Returns the function table corresponding to the recurrence frequency. */
static ECalRecurVTable* cal_obj_get_vtable (icalrecurrencetype_frequency recur_type)
{
return vtable;
}
-
/* This creates a number of fast lookup tables used when filtering with the
modifier properties BYMONTH, BYYEARDAY etc. */
static void
}
}
-
static void
cal_obj_sort_occurrences (GArray *occs)
{
cal_obj_time_compare_func);
}
-
static void
cal_obj_remove_duplicates_and_invalid_dates (GArray *occs)
{
g_array_set_size (occs, j);
}
-
/* Removes the exceptions from the ex_occs array from the occurrences in the
occs array, and removes any duplicates. Both arrays are sorted. */
static void
g_array_set_size (occs, j);
}
-
-
static GArray*
cal_obj_bysetpos_filter (ECalRecurrence *recur,
GArray *occs)
return new_occs;
}
-
-
-
/* Finds the first year from the event_start, counting in multiples of the
recurrence interval, that intersects the given interval. It returns TRUE
if there is no intersection. */
return FALSE;
}
-
static gboolean
cal_obj_yearly_find_next_position (CalObjTime *cotime,
CalObjTime *event_end,
return FALSE;
}
-
-
static gboolean
cal_obj_monthly_find_start_position (CalObjTime *event_start,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_monthly_find_next_position (CalObjTime *cotime,
CalObjTime *event_end,
return FALSE;
}
-
-
static gboolean
cal_obj_weekly_find_start_position (CalObjTime *event_start,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_weekly_find_next_position (CalObjTime *cotime,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_daily_find_start_position (CalObjTime *event_start,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_daily_find_next_position (CalObjTime *cotime,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_hourly_find_start_position (CalObjTime *event_start,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_hourly_find_next_position (CalObjTime *cotime,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_minutely_find_start_position (CalObjTime *event_start,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_minutely_find_next_position (CalObjTime *cotime,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_secondly_find_start_position (CalObjTime *event_start,
CalObjTime *event_end,
return FALSE;
}
-
static gboolean
cal_obj_secondly_find_next_position (CalObjTime *cotime,
CalObjTime *event_end,
return FALSE;
}
-
-
-
-
/* If the BYMONTH rule is specified it expands each occurrence in occs, by
using each of the months in the bymonth list. */
static GArray*
return new_occs;
}
-
/* If the BYMONTH rule is specified it filters out all occurrences in occs
which do not match one of the months in the bymonth list. */
static GArray*
return new_occs;
}
-
-
static GArray*
cal_obj_byweekno_expand (RecurData *recur_data,
GArray *occs)
return new_occs;
}
-
#if 0
/* This isn't used at present. */
static GArray*
}
#endif
-
static GArray*
cal_obj_byyearday_expand (RecurData *recur_data,
GArray *occs)
return new_occs;
}
-
/* Note: occs must not contain invalid dates, e.g. 31st September. */
static GArray*
cal_obj_byyearday_filter (RecurData *recur_data,
return new_occs;
}
-
-
static GArray*
cal_obj_bymonthday_expand (RecurData *recur_data,
GArray *occs)
return new_occs;
}
-
static GArray*
cal_obj_bymonthday_filter (RecurData *recur_data,
GArray *occs)
return new_occs;
}
-
-
static GArray*
cal_obj_byday_expand_yearly (RecurData *recur_data,
GArray *occs)
return new_occs;
}
-
static GArray*
cal_obj_byday_expand_monthly (RecurData *recur_data,
GArray *occs)
return new_occs;
}
-
/* Note: occs must not contain invalid dates, e.g. 31st September. */
static GArray*
cal_obj_byday_expand_weekly (RecurData *recur_data,
return new_occs;
}
-
/* Note: occs must not contain invalid dates, e.g. 31st September. */
static GArray*
cal_obj_byday_filter (RecurData *recur_data,
return new_occs;
}
-
-
/* If the BYHOUR rule is specified it expands each occurrence in occs, by
using each of the hours in the byhour list. */
static GArray*
return new_occs;
}
-
/* If the BYHOUR rule is specified it filters out all occurrences in occs
which do not match one of the hours in the byhour list. */
static GArray*
return new_occs;
}
-
-
/* If the BYMINUTE rule is specified it expands each occurrence in occs, by
using each of the minutes in the byminute list. */
static GArray*
return new_occs;
}
-
/* If the BYMINUTE rule is specified it filters out all occurrences in occs
which do not match one of the minutes in the byminute list. */
static GArray*
return new_occs;
}
-
-
/* If the BYSECOND rule is specified it expands each occurrence in occs, by
using each of the seconds in the bysecond list. */
static GArray*
return new_occs;
}
-
/* If the BYSECOND rule is specified it filters out all occurrences in occs
which do not match one of the seconds in the bysecond list. */
static GArray*
return new_occs;
}
-
-
-
-
/* Adds a positive or negative number of months to the given CalObjTime,
updating the year appropriately so we end up with a valid month.
Note that the day may be invalid, e.g. 30th Feb. */
}
}
-
/* Adds a positive or negative number of days to the given CalObjTime,
updating the month and year appropriately so we end up with a valid day. */
static void
}
}
-
/* Adds a positive or negative number of hours to the given CalObjTime,
updating the day, month & year appropriately so we end up with a valid
time. */
}
}
-
/* Adds a positive or negative number of minutes to the given CalObjTime,
updating the rest of the CalObjTime appropriately. */
static void
}
}
-
/* Adds a positive or negative number of seconds to the given CalObjTime,
updating the rest of the CalObjTime appropriately. */
static void
}
}
-
/* Compares 2 CalObjTimes. Returns -1 if the cotime1 is before cotime2, 0 if
they are the same, or 1 if cotime1 is after cotime2. The comparison type
specifies which parts of the times we are interested in, e.g. if CALOBJ_DAY
return 0;
}
-
/* This is the same as the above function, but without the comparison type.
It is used for qsort(). */
static gint
return retval;
}
-
static gint
cal_obj_date_only_compare_func (gconstpointer arg1,
gconstpointer arg2)
return 0;
}
-
/* Returns the weekday of the given CalObjTime, from 0 (Mon) - 6 (Sun). */
static gint
cal_obj_time_weekday (CalObjTime *cotime)
return weekday;
}
-
/* Returns the weekday of the given CalObjTime, from 0 - 6. The week start
day is Monday by default, but can be set in the recurrence rule. */
static gint
return offset;
}
-
/* Returns the day of the year of the given CalObjTime, from 1 - 366. */
static gint
cal_obj_time_day_of_year (CalObjTime *cotime)
return g_date_get_day_of_year (&date);
}
-
/* Finds the first week in the given CalObjTime's year, using the same weekday
as the event start day (i.e. from the RecurData).
The first week of the year is the first week starting from the specified
cal_obj_time_add_days (cotime, offset);
}
-
static void
cal_object_time_from_time (CalObjTime *cotime,
time_t t,
cotime->flags = FALSE;
}
-
/* Debugging function to convert a CalObjTime to a string. It uses a static
buffer so beware. */
#ifdef CAL_OBJ_DEBUG
}
#endif
-
/* This recalculates the end dates for recurrence & exception rules which use
the COUNT property. If refresh is TRUE it will recalculate all enddates
for rules which use COUNT. If refresh is FALSE, it will only calculate
return changed;
}
-
typedef struct _ECalRecurEnsureEndDateData ECalRecurEnsureEndDateData;
struct _ECalRecurEnsureEndDateData {
gint count;
time_t end_date;
};
-
static gboolean
e_cal_recur_ensure_rule_end_date (ECalComponent *comp,
icalproperty *prop,
return TRUE;
}
-
static gboolean
e_cal_recur_ensure_rule_end_date_cb (ECalComponent *comp,
time_t instance_start,
return TRUE;
}
-
/* If default_timezone is set, the saved ENDDATE parameter is assumed to be
in that timezone. This is used when the DTSTART is a DATE or floating
value, since the RRULE end date will change depending on the timezone that
return -1;
}
-
static void
e_cal_recur_set_rule_end_date (icalproperty *prop,
time_t end_date)
return NULL;
}
-
static gboolean
files_are_identical_inode (struct stat *a_stat,
struct stat *b_stat,
return (a_stat->st_ino == b_stat->st_ino);
}
-
/* Determine if /etc/localtime is a hard link to some file, by looking at
* the inodes */
static gchar *
#define SATURDAY 6 /* Offset value; 1 Jan 1 was a Saturday */
#define ISODATE_LENGTH 17 /* 4+2+2+1+2+2+2+1 + 1 */
-
/* Number of days in a month, using 0 (Jan) to 11 (Dec). For leap years,
add 1 to February (month 1). */
static const gint days_in_month[12] = {
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
-
-
/**************************************************************************
* time_t manipulation functions.
*
return mktime (&tm);
}
-
/**************************************************************************
* time_t manipulation functions, using timezones in libical.
*
* time_t values wherever possible.
**************************************************************************/
-
/**
* time_add_day_with_zone:
* @time: A time_t value.
return icaltime_as_timet_with_zone (tt, zone);
}
-
/**
* time_add_week_with_zone:
* @time: A time_t value.
return time_add_day_with_zone (time, weeks * 7, zone);
}
-
/**
* time_add_month_with_zone:
* @time: A time_t value.
return icaltime_as_timet_with_zone (tt, zone);
}
-
/**
* time_year_begin_with_zone:
* @time: A time_t value.
return icaltime_as_timet_with_zone (tt, zone);
}
-
/**
* time_month_begin_with_zone:
* @time: A time_t value.
return icaltime_as_timet_with_zone (tt, zone);
}
-
/**
* time_week_begin_with_zone:
* @time: A time_t value.
return icaltime_as_timet_with_zone (tt, zone);
}
-
/**
* time_day_begin_with_zone:
* @time: A time_t value.
return icaltime_as_timet_with_zone (tt, zone);
}
-
/**
* time_day_end_with_zone:
* @time: A time_t value.
g_date_set_dmy (date, tt.day, tt.month, tt.year);
}
-
/**************************************************************************
* General time functions.
**************************************************************************/
-
/**
* time_days_in_month:
* @year: The year.
return days;
}
-
/**
* time_day_of_year:
* @day: The day.
return day;
}
-
/**
* time_day_of_week:
* @day: The day.
return THURSDAY;
}
-
/**
* time_is_leap_year:
* @year: The year.
return (!(year % 4) && (year % 100)) || !(year % 400);
}
-
/**
* time_leap_years_up_to:
* @year: The year.
+ ((year > 1600) ? ((year - 1600) / 400) : 0));
}
-
/**
* isodate_from_time_t:
* @t: A time value.
#ifndef TIMEUTIL_H
#define TIMEUTIL_H
-
#include <time.h>
#include <libical/ical.h>
#include <glib.h>
gchar *isodate_from_time_t (time_t t);
time_t time_from_isodate (const gchar *str);
-
/**************************************************************************
* time_t manipulation functions.
*
time_t time_day_begin (time_t t);
time_t time_day_end (time_t t);
-
/**************************************************************************
* time_t manipulation functions, using timezones in libical.
*
return n;
}
-
/**
* e_cal_util_priority_to_string:
* @priority: Priority value.
return retval;
}
-
/**
* e_cal_util_priority_from_string:
* @string: A string representing the PRIORITY value.
return FALSE;
}
-
-
/* now match the timezones */
if (!(!c1_dtstart.zone && !c2_dtstart.zone) ||
(c1_dtstart.zone && c2_dtstart.zone &&
#include "e-cal-view-private.h"
#include "e-cal.h"
-
static gboolean
open_calendar (ECal *ecal, gboolean only_if_exists, GError **error, ECalendarStatus *status, gboolean needs_auth);
return cal_mode_enum_type;
}
-
-
static GNOME_Evolution_Calendar_CalObjType
convert_type (ECalSourceType type)
{
query = "repo_ids.has ('IDL:GNOME/Evolution/DataServer/CalFactory:" API_VERSION "')";
-
servers = bonobo_activation_query (query, NULL, NULL);
e_uri_free (uri);
return e_cal_type;
}
-
static gboolean
fetch_corba_cal (ECal *ecal, ESource *source, ECalSourceType type)
{
g_static_mutex_unlock (&e_cal_lock);
}
-
/* TODO - For now, the policy of where each backend serializes its
* attachment data is hardcoded below. Should this end up as a
* gconf key set during the account creation and fetched
g_free (key);
}
-
CORBA_exception_init (&ev);
priv->load_state = E_CAL_LOAD_LOADING;
g_mutex_unlock (ecal->priv->mutex);
-
CORBA_exception_init (&ev);
GNOME_Evolution_Calendar_Cal_remove (priv->cal, &ev);
g_mutex_unlock (ecal->priv->mutex);
-
CORBA_exception_init (&ev);
GNOME_Evolution_Calendar_Cal_isReadOnly (priv->cal, &ev);
ECalendarStatus status;
ECalendarOp *our_op;
-
if (!(ecal && E_IS_CAL (ecal)))
E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_INVALID_ARG, error);
priv = ecal->priv;
g_mutex_unlock (ecal->priv->mutex);
-
CORBA_exception_init (&ev);
GNOME_Evolution_Calendar_Cal_getCalAddress (priv->cal, &ev);
g_mutex_unlock (ecal->priv->mutex);
-
CORBA_exception_init (&ev);
GNOME_Evolution_Calendar_Cal_getAlarmEmailAddress (priv->cal, &ev);
g_mutex_unlock (ecal->priv->mutex);
-
CORBA_exception_init (&ev);
GNOME_Evolution_Calendar_Cal_getLdapAttribute (priv->cal, &ev);
g_mutex_unlock (ecal->priv->mutex);
-
CORBA_exception_init (&ev);
GNOME_Evolution_Calendar_Cal_getStaticCapabilities (priv->cal, &ev);
ECalendarOp *our_op;
ECalendarStatus status;
-
e_return_error_if_fail (ecal && E_IS_CAL (ecal), E_CALENDAR_STATUS_INVALID_ARG);
e_return_error_if_fail (query, E_CALENDAR_STATUS_INVALID_ARG);
g_free (value);
}
-
/* This simply frees the hash values. */
static void
free_timezone_string (gpointer key, gpointer value, gpointer data)
g_free (value);
}
-
/* This converts the VEVENT/VTODO to a string. If include_all_timezones is
TRUE, it includes all the VTIMEZONE components needed for the VEVENT/VTODO.
If not, it only includes builtin timezones that may not be on the server.
g_mutex_unlock (ecal->priv->mutex);
-
CORBA_exception_init (&ev);
GNOME_Evolution_Calendar_Cal_removeObject (priv->cal, uid, rid ? rid : "", mod, &ev);
GList *e_cal_backend_cache_get_components (ECalBackendCache *cache);
GSList *e_cal_backend_cache_get_components_by_uid (ECalBackendCache *cache, const gchar *uid);
-
-
const icaltimezone *e_cal_backend_cache_get_timezone (ECalBackendCache *cache, const gchar *tzid);
gboolean e_cal_backend_cache_put_timezone (ECalBackendCache *cache, const icaltimezone *zone);
gboolean e_cal_backend_cache_remove_timezone (ECalBackendCache *cache, const gchar *tzid);
ECalComponent *comp,
ECalBackend *backend);
-
/* Default implementations of time functions for use by subclasses */
ESExpResult *e_cal_backend_sexp_func_time_now (ESExp *esexp, gint argc, ESExpResult **argv, gpointer data);
ESExpResult *e_cal_backend_sexp_func_time_day_begin (ESExp *esexp, gint argc, ESExpResult **argv, gpointer data);
ESExpResult *e_cal_backend_sexp_func_time_day_end (ESExp *esexp, gint argc, ESExpResult **argv, gpointer data);
-
G_END_DECLS
#endif /* __E_CAL_BACKEND_SEXP_H__ */
ECalBackendSyncStatus (*get_attachment_list_sync) (ECalBackendSync *backend, EDataCal *cal, const gchar *uid, const gchar *rid, GSList **attachments);
-
ECalBackendSyncStatus (*get_timezone_sync) (ECalBackendSync *backend, EDataCal *cal, const gchar *tzid, gchar **object);
ECalBackendSyncStatus (*add_timezone_sync) (ECalBackendSync *backend, EDataCal *cal, const gchar *tzobj);
ECalBackendSyncStatus (*set_default_timezone_sync) (ECalBackendSync *backend, EDataCal *cal, const gchar *tzid);
return result;
}
-
/**
* e_cal_backend_set_mode:
* @backend: A calendar backend
g_object_unref (iter);
}
-
void
e_cal_backend_notify_objects_added (ECalBackend *backend, EDataCalView *query, const GList *objects)
{
return NULL;
}
-
factory = g_hash_table_lookup (kinds, GINT_TO_POINTER (kind));
return factory;
return ret_cal;
}
-
/**
* e_data_cal_factory_new:
* @void:
g_mutex_unlock (priv->backends_mutex);
}
-
/* Object initialization function for the calendar factory */
static void
e_data_cal_factory_init (EDataCalFactory *factory, EDataCalFactoryClass *klass)
ECalBackendSExp *sexp;
};
-
\f
static void e_data_cal_view_class_init (EDataCalViewClass *class);
e_data_cal_notify_query (cal, GNOME_Evolution_Calendar_Success, query);
}
-
/* Cal::getTimezone method */
static void
impl_Cal_getTimezone (PortableServer_Servant servant,
e_cal_component_set_dtend (comp, &dt);
e_cal_component_set_transparency (comp, E_CAL_COMPONENT_TRANSP_OPAQUE);
-
e_cal_component_commit_sequence (comp);
icalcomp = e_cal_component_get_icalcomponent (comp);
if (!e_cal_create_object (client, icalcomp, uid, &error)) {
return NULL;
}
-
static gchar *
test_get_default_object (ECal *client)
{
return error->message;
}
-
/* XXX The string pasted below is *really* ugly. Alternatively, it could be
* read from a file at run-time. Not sure if it is an elegant solution when
* multiple clients try to load the same file during stress testing.
printf ("\n\nTime Zones : \n%s *** %s", icaltimezone_get_display_name (zone), icaltimezone_get_tzid (zone));
printf ("\n\nTime Zones : \n%s", icaltimezone_get_location (zone));
-
return NULL;
}
mu_run_test (test_query (client, "(contains? \"summary\" \"Kansas\")", 1));
mu_run_test (test_query (client, "(contains? \"any\" \"gibberish\")", 0));
-
mu_run_test (test_get_default_object (client));
mu_run_test (test_get_object (client));
mu_run_test (test_get_free_busy (client));
if (results != 0)
cl_printf (*client, "***Failures********%s\n", results);
-
cl_printf (*client, "dump of the test calendar data");
list_uids (*client);
g_free (cal_uri);
#include "camel-address.h"
-
static void camel_address_class_init (CamelAddressClass *klass);
static void camel_address_init (CamelAddress *obj);
static void camel_address_finalize (CamelObject *obj);
return new;
}
-
/**
* camel_address_new_clone:
* @addr: a #CamelAddress object
return new;
}
-
/**
* camel_address_length:
* @addr: a #CamelAddress object
return addr->addresses->len;
}
-
/**
* camel_address_decode:
* @addr: a #CamelAddress object
return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->decode(addr, raw);
}
-
/**
* camel_address_encode:
* @addr: a #CamelAddress object
return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->encode(addr);
}
-
/**
* camel_address_unformat:
* @addr: a #CamelAddress object
return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->unformat(addr, raw);
}
-
/**
* camel_address_format:
* @addr: a #CamelAddress object
return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->format(addr);
}
-
/**
* camel_address_cat:
* @dest: destination #CamelAddress object
return CAMEL_ADDRESS_CLASS(CAMEL_OBJECT_GET_CLASS(dest))->cat(dest, source);
}
-
/**
* camel_address_copy:
* @dest: destination #CamelAddress object
return camel_address_cat(dest, source);
}
-
/**
* camel_address_remove:
* @addr: a #CamelAddress object
guint deleted:1;
};
-
#define CAMEL_BLOCK_FILE_LOCK(kf, lock) (pthread_mutex_lock(&(kf)->priv->lock))
#define CAMEL_BLOCK_FILE_TRYLOCK(kf, lock) (pthread_mutex_trylock(&(kf)->priv->lock))
#define CAMEL_BLOCK_FILE_UNLOCK(kf, lock) (pthread_mutex_unlock(&(kf)->priv->lock))
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static const gchar *cert_get_string (CamelCertDB *certdb, CamelCert *cert, gint string);
static void cert_set_string (CamelCertDB *certdb, CamelCert *cert, gint string, const gchar *value);
-
static CamelObjectClass *parent_class = NULL;
-
CamelType
camel_certdb_get_type (void)
{
return type;
}
-
static void
camel_certdb_class_init (CamelCertDBClass *klass)
{
g_free (p);
}
-
CamelCertDB *
camel_certdb_new (void)
{
return (CamelCertDB *) camel_object_new (camel_certdb_get_type ());
}
-
static CamelCertDB *default_certdb = NULL;
static pthread_mutex_t default_certdb_lock = PTHREAD_MUTEX_INITIALIZER;
-
void
camel_certdb_set_default (CamelCertDB *certdb)
{
pthread_mutex_unlock (&default_certdb_lock);
}
-
CamelCertDB *
camel_certdb_get_default (void)
{
return certdb;
}
-
void
camel_certdb_set_filename (CamelCertDB *certdb, const gchar *filename)
{
CAMEL_CERTDB_UNLOCK (certdb, db_lock);
}
-
static gint
certdb_header_load (CamelCertDB *certdb, FILE *istream)
{
CAMEL_CERTDB_UNLOCK (certdb, ref_lock);
}
-
static gboolean
cert_remove (gpointer key, gpointer value, gpointer user_data)
{
CAMEL_CERTDB_UNLOCK (certdb, db_lock);
}
-
static const gchar *
cert_get_string (CamelCertDB *certdb, CamelCert *cert, gint string)
{
}
}
-
const gchar *
camel_cert_get_string (CamelCertDB *certdb, CamelCert *cert, gint string)
{
}
}
-
void
camel_cert_set_string (CamelCertDB *certdb, CamelCert *cert, gint string, const gchar *value)
{
CAMEL_CERTDB_GET_CLASS (certdb)->cert_set_string (certdb, cert, string, value);
}
-
CamelCertTrust
camel_cert_get_trust (CamelCertDB *certdb, CamelCert *cert)
{
return cert->trust;
}
-
void
camel_cert_set_trust (CamelCertDB *certdb, CamelCert *cert, CamelCertTrust trust)
{
*
*/
-
#ifndef __CAMEL_CERTDB_H__
#define __CAMEL_CERTDB_H__
void (*cert_set_string) (CamelCertDB *certdb, CamelCert *cert, gint string, const gchar *value);
};
-
CamelType camel_certdb_get_type (void);
CamelCertDB *camel_certdb_new (void);
void camel_certdb_clear (CamelCertDB *certdb);
-
const gchar *camel_cert_get_string (CamelCertDB *certdb, CamelCert *cert, gint string);
void camel_cert_set_string (CamelCertDB *certdb, CamelCert *cert, gint string, const gchar *value);
* USA
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return camel_charset_best_name (&charset);
}
-
/**
* camel_charset_iso_to_windows:
* @isocharset: a canonicalised ISO charset
return stream;
}
-
/**
* camel_data_cache_get_filename:
* @cdc: A #CamelDataCache
* USA
*/
-
#ifndef CAMEL_DATA_CACHE_H
#define CAMEL_DATA_CACHE_H 1
* USA
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return type;
}
-
/**
* camel_data_wrapper_new:
*
return ret;
}
-
/**
* camel_data_wrapper_write_to_stream:
* @data_wrapper: a #CamelDataWrapper object
return CDW_CLASS (data_wrapper)->write_to_stream (data_wrapper, stream);
}
-
static gssize
decode_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream)
{
return ret;
}
-
/**
* camel_data_wrapper_decode_to_stream:
* @data_wrapper: a #CamelDataWrapper object
return CDW_CLASS (data_wrapper)->decode_to_stream (data_wrapper, stream);
}
-
static gint
construct_from_stream (CamelDataWrapper *data_wrapper, CamelStream *stream)
{
return 0;
}
-
/**
* camel_data_wrapper_construct_from_stream:
* @data_wrapper: a #CamelDataWrapper object
return CDW_CLASS (data_wrapper)->construct_from_stream (data_wrapper, stream);
}
-
static void
set_mime_type (CamelDataWrapper *data_wrapper, const gchar *mime_type)
{
data_wrapper->mime_type = camel_content_type_decode (mime_type);
}
-
/**
* camel_data_wrapper_set_mime_type:
* @data_wrapper: a #CamelDataWrapper object
return camel_content_type_simple (data_wrapper->mime_type);
}
-
/**
* camel_data_wrapper_get_mime_type:
* @data_wrapper: a #CamelDataWrapper object
return CDW_CLASS (data_wrapper)->get_mime_type (data_wrapper);
}
-
static CamelContentType *
get_mime_type_field (CamelDataWrapper *data_wrapper)
{
return data_wrapper->mime_type;
}
-
/**
* camel_data_wrapper_get_mime_type_field:
* @data_wrapper: a #CamelDataWrapper object
data_wrapper->mime_type = mime_type;
}
-
/**
* camel_data_wrapper_set_mime_type_field:
* @data_wrapper: a #CamelDataWrapper object
CDW_CLASS (data_wrapper)->set_mime_type_field (data_wrapper, mime_type);
}
-
static gboolean
is_offline (CamelDataWrapper *data_wrapper)
{
return data_wrapper->offline;
}
-
/**
* camel_data_wrapper_is_offline:
* @data_wrapper: a #CamelDataWrapper object
*
*/
-
#ifndef CAMEL_DATA_WRAPPER_H
#define CAMEL_DATA_WRAPPER_H 1
#define STARTTS(stmt) if (camel_debug("dbtimets")) { g_print ("\n===========\nDB SQL operation [%s] started\n", stmt); if (!cdb->priv->timer) { cdb->priv->timer = g_timer_new (); } else { g_timer_reset(cdb->priv->timer);} }
#define ENDTS if (camel_debug("dbtimets")) { g_timer_stop (cdb->priv->timer); g_print ("DB Operation ended. Time Taken : %f\n###########\n", g_timer_elapsed (cdb->priv->timer, NULL)); }
-
struct _CamelDBPrivate {
GTimer *timer;
gchar *file_name;
ret = sqlite3_exec(db, stmt, 0, 0, &errmsg);
}
-
if (ret != SQLITE_OK) {
d(g_print ("Error in SQL EXEC statement: %s [%s].\n", stmt, errmsg));
if (ex)
return NULL;
}
-
-
cdb = g_new (CamelDB, 1);
cdb->db = db;
cdb->lock = g_mutex_new ();
camel_db_command (cdb, "PRAGMA temp_store = memory", NULL);
}
-
sqlite3_busy_timeout (cdb->db, CAMEL_DB_SLEEP_INTERVAL);
return cdb;
return ret;
}
-
gint
camel_db_begin_transaction (CamelDB *cdb, CamelException *ex)
{
if (ret)
goto end;
-
while (qry_list) {
query = qry_list->data;
ret = cdb_sql_exec (cdb->db, query, ex);
return ret;
}
-
gint
camel_db_count_total_message_info (CamelDB *cdb, const gchar *table_name, guint32 *count, CamelException *ex)
{
sqlite3_free (table_creation_query);
-
safe_index = g_strdup_printf("VINDEX-%s", folder_name);
table_creation_query = sqlite3_mprintf ("CREATE INDEX IF NOT EXISTS %Q ON %Q (vuid)", safe_index, folder_name);
ret = camel_db_command (db, table_creation_query, ex);
sqlite3_free (table_query);
-
return camel_db_create_vfolder (db, folder_name, ex);
}
data.uids = uids;
data.flags = flags;
-
sel_query = sqlite3_mprintf("SELECT uid,flags FROM %Q%s%s%s%s", folder_name, sort_by ? " order by " : "", sort_by ? sort_by: "", (sort_by && collate) ? " collate " : "", (sort_by && collate) ? collate : "");
ret = camel_db_select (db, sel_query, read_uids_flags_callback, &data, ex);
#if 0
gint i;
-
for (i = 0; i < ncol; ++i) {
if (!strcmp (name [i], "vuid"))
g_ptr_array_add (array, (gchar *) (camel_pstring_strdup(cols [i]+8)));
return ret;
}
-
gint
camel_db_create_folders_table (CamelDB *cdb, CamelException *ex)
{
return ((camel_db_command (cdb, query, ex)));
}
-
-
static gint
camel_db_create_message_info_table (CamelDB *cdb, const gchar *folder_name, CamelException *ex)
{
del_query = sqlite3_mprintf ("DELETE FROM folders WHERE folder_name = %Q", record->folder_name);
-
#if 0
gchar *upd_query;
#define CAMEL_DB_RELEASE_SQLITE_MEMORY if(!g_getenv("CAMEL_SQLITE_FREE_CACHE")) sqlite3_release_memory(CAMEL_DB_FREE_CACHE_SIZE);
#define CAMEL_DB_USE_SHARED_CACHE if(g_getenv("CAMEL_SQLITE_SHARED_CACHE")) sqlite3_enable_shared_cache(TRUE);
-
/* The extensive DB format, supporting basic searching and sorting
uid, - Message UID
flags, - Camel Message info flags
gchar *bdata;
} CamelFIRecord;
-
-
-
typedef struct _CamelDB CamelDB;
typedef gint (*CamelDBSelectCB) (gpointer data, gint ncol, gchar **colvalues, gchar **colnames);
-
CamelDB * camel_db_open (const gchar *path, CamelException *ex);
CamelDB * camel_db_clone (CamelDB *cdb, CamelException *ex);
void camel_db_close (CamelDB *cdb);
#define I386_DR_LOCAL_ENABLE(i) \
dr_control_mirror |= (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (i)))
-
#define set_dr(regnum, val) \
__asm__("movl %0,%%db" #regnum \
: /* no output */ \
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static CamelStoreClass *parent_class = NULL;
-
CamelType
camel_digest_store_get_type (void)
{
return CAMEL_OBJECT_CLASS (parent_class)->getv (object, ex, args);
}
-
/**
* camel_digest_store_new:
* @url:
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static void camel_digest_summary_init (CamelDigestSummary *obj);
static void camel_digest_summary_finalise (CamelObject *obj);
-
static CamelFolderSummaryClass *parent_class = NULL;
-
CamelType
camel_digest_summary_get_type(void)
{
}
-
CamelFolderSummary *
camel_digest_summary_new (void)
{
};
-
CamelType camel_digest_summary_get_type (void);
CamelFolderSummary *camel_digest_summary_new (void);
return camel_disco_diary_type;
}
-
static gint
diary_encode_uids (CamelDiscoDiary *diary, GPtrArray *uids)
{
} CamelDiscoDiaryClass;
-
/* public methods */
CamelDiscoDiary *camel_disco_diary_new (CamelDiscoStore *store,
const gchar *filename,
}
}
-
/**
* camel_disco_folder_expunge_uids:
* @folder: a (disconnectable) folder
disco_expunge_uids (folder, uids, ex);
}
-
static void
disco_cache_message (CamelDiscoFolder *disco_folder, const gchar *uid,
CamelException *ex)
CDF_CLASS (disco_folder)->cache_message (disco_folder, uid, ex);
}
-
static void
disco_prepare_for_offline (CamelDiscoFolder *disco_folder,
const gchar *expression,
const gchar *new_uid);
} CamelDiscoFolderClass;
-
/* public methods */
void camel_disco_folder_expunge_uids (CamelFolder *folder, GPtrArray *uids,
CamelException *ex);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return NULL;
}
-
/**
* camel_disco_store_status:
* @store: a disconnectable store
return CDS_CLASS (store)->can_work_offline (store);
}
-
/**
* camel_disco_store_check_online:
* @store: a disconnectable store
CamelDiscoDiary *diary;
};
-
typedef struct {
CamelStoreClass parent_class;
CamelException *);
gboolean (*can_work_offline) (CamelDiscoStore *);
-
gboolean (*connect_online) (CamelService *,
CamelException *);
gboolean (*connect_offline) (CamelService *,
} CamelDiscoStoreClass;
-
/* Standard Camel function */
CamelType camel_disco_store_get_type (void);
CamelException *ex);
gboolean camel_disco_store_can_work_offline (CamelDiscoStore *store);
-
/* Convenience functions */
gboolean camel_disco_store_check_online (CamelDiscoStore *store, CamelException *ex);
void camel_disco_store_prepare_for_offline(CamelDiscoStore *store, CamelException *ex);
/* dont turn this off */
#define w(x) x
-
/**
* camel_exception_new: allocate a new exception object.
*
ex->id = CAMEL_EXCEPTION_NONE;
}
-
/**
* camel_exception_clear:
* @ex: a #CamelException
* USA
*/
-
-
#ifndef CAMEL_EXCEPTION_H
#define CAMEL_EXCEPTION_H 1
void camel_exception_free (CamelException *ex);
void camel_exception_init (CamelException *ex);
-
/* exception content manipulation */
void camel_exception_clear (CamelException *ex);
void camel_exception_set (CamelException *ex,
void camel_exception_xfer (CamelException *ex_dst,
CamelException *ex_src);
-
/* exception content retrieval */
ExceptionId camel_exception_get_id (CamelException *ex);
const gchar * camel_exception_get_description (CamelException *ex);
* USA
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return fputc (value | 0x80, out);
}
-
/**
* camel_file_util_decode_uint32:
* @in: file to read from
return 0;
}
-
/**
* camel_file_util_encode_fixed_int32:
* @out: file to output to
return 0;
}
-
/**
* camel_file_util_decode_fixed_int32:
* @in: file to read from
return 0; \
}
-
/**
* camel_file_util_encode_time_t:
* @out: file to output to
**/
CFU_ENCODE_T(off_t)
-
/**
* camel_file_util_decode_off_t:
* @in: file to read from
**/
CFU_ENCODE_T(gsize)
-
/**
* camel_file_util_decode_gsize:
* @in: file to read from
**/
CFU_DECODE_T(gsize)
-
/**
* camel_file_util_encode_string:
* @out: file to output to
return -1;
}
-
/**
* camel_file_util_decode_string:
* @in: file to read from
return -1;
}
-
/**
* camel_file_util_decode_fixed_string:
* @in: file to read from
return camel_url_encode(name, unsafe_chars);
}
-
/* FIXME: poll() might be more efficient and more portable? */
/**
return nread;
}
-
/**
* camel_write:
* @fd: file descriptor
#endif
}
-
/**
* camel_file_util_savename:
* @filename: a pathname
* USA
*/
-
#ifndef CAMEL_FILE_UTILS_H
#define CAMEL_FILE_UTILS_H 1
gint camel_file_util_encode_fixed_string (FILE *out, const gchar *str, gsize len);
gint camel_file_util_decode_fixed_string (FILE *in, gchar **str, gsize len);
-
gchar *camel_file_util_safe_filename (const gchar *name);
/* Code that intends to be portable to Win32 should use camel_read()
}
}
-
#if 0
void
camel_filter_driver_set_global (CamelFilterDriver *d, const gchar *name, const gchar *value)
}
#endif
-
static void
camel_filter_driver_log (CamelFilterDriver *driver, enum filter_log_t status, const gchar *desc, ...)
{
}
}
-
struct _run_only_once {
CamelFilterDriver *driver;
CamelException *ex;
return TRUE;
}
-
/**
* camel_filter_driver_flush:
* @driver:
g_hash_table_foreach_remove (p->only_once, (GHRFunc) run_only_once, &data);
}
-
static gint
decode_flags_from_xev(const gchar *xev, CamelMessageInfoBase *mi)
{
return ret;
}
-
/**
* camel_filter_driver_filter_folder:
* @driver: CamelFilterDriver
return status;
}
-
struct _get_message {
struct _CamelFilterDriverPrivate *p;
const gchar *source_url;
};
-
static CamelMimeMessage *
get_message_cb (gpointer data, CamelException *ex)
{
{ "junk-test", (ESExpFunc *) junk_test, 0 },
};
-
static CamelMimeMessage *
camel_filter_search_get_message (FilterMessageSearch *fms, struct _ESExp *sexp)
{
return check_header (f, argc, argv, fms, CAMEL_SEARCH_MATCH_CONTAINS);
}
-
static ESExpResult *
header_matches (struct _ESExp *f, gint argc, struct _ESExpResult **argv, FilterMessageSearch *fms)
{
camel_folder_summary_reload_from_db (search->folder->summary, search->priv->ex);
}
-
for (i=0;i<v->len;i++) {
const gchar *uid;
#define GLOBAL_INFO_LOCK(i) pthread_mutex_lock(&info_lock)
#define GLOBAL_INFO_UNLOCK(i) pthread_mutex_unlock(&info_lock)
-
/* this should probably be conditional on it existing */
#define USE_BSEARCH
static gint summary_meta_header_save(CamelFolderSummary *, FILE *);
#endif
-
static CamelMessageInfo * message_info_new_from_header(CamelFolderSummary *, struct _camel_header_raw *);
static CamelMessageInfo * message_info_new_from_parser(CamelFolderSummary *, CamelMimeParser *);
static CamelMessageInfo * message_info_new_from_message(CamelFolderSummary *s, CamelMimeMessage *msg);
return type;
}
-
/**
* camel_folder_summary_new:
* @folder: parent #CamelFolder object
return new;
}
-
/**
* camel_folder_summary_set_filename:
* @summary: a #CamelFolderSummary object
CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
-
/**
* camel_folder_summary_set_index:
* @summary: a #CamelFolderSummary object
camel_object_ref((CamelObject *)index);
}
-
/**
* camel_folder_summary_set_build_content:
* @summary: a #CamelFolderSummary object
s->build_content = state;
}
-
/**
* camel_folder_summary_count:
* @summary: a #CamelFolderSummary object
return s->uids->len;
}
-
/**
* camel_folder_summary_index:
* @summary: a #CamelFolderSummary object
for (i=0;i<s->uids->len;i++)
res->pdata[i] = (gpointer) camel_pstring_strdup ((gchar *)g_ptr_array_index(s->uids, i));
-
CAMEL_SUMMARY_UNLOCK(s, summary_lock);
return res;
data.double_ref = TRUE;
data.add = FALSE;
-
ret = camel_db_read_message_info_record_with_uid (cdb, folder_name, uid, &data, camel_read_mir_callback, &ex);
if (ret != 0) {
camel_exception_clear (&ex);
} else
info->refcount++;
-
CAMEL_SUMMARY_UNLOCK(s, ref_lock);
CAMEL_SUMMARY_UNLOCK(s, summary_lock);
return info;
}
-
/**
* camel_folder_summary_uid:
* @summary: a #CamelFolderSummary object
{
guint32 uid;
-
CAMEL_SUMMARY_LOCK(s, summary_lock);
uid = s->nextuid++;
return uid;
}
-
/**
* camel_folder_summary_set_uid:
* @summary: a #CamelFolderSummary object
CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
-
/**
* camel_folder_summary_next_uid_string:
* @summary: a #CamelFolderSummary object
return ci;
}
-
/* loads the content descriptions, recursively */
static CamelMessageContentInfo *
perform_content_info_load(CamelFolderSummary *s, FILE *in)
return FALSE;
}
-
struct _folder_summary_free_msg {
CamelSessionThreadMsg msg;
CamelFolderSummary *summary;
return;
}
-
-
static void remove_cache_end (CamelSession *session, CamelSessionThreadMsg *msg)
{
struct _folder_summary_free_msg *m = (struct _folder_summary_free_msg *)msg;
}
CAMEL_SUMMARY_UNLOCK (s, summary_lock);
-
info = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_from_db (s, mir);
if (info) {
}
-
gint
camel_folder_summary_migrate_infos(CamelFolderSummary *s)
{
g_hash_table_insert (s->loaded_infos, (gpointer) mi->uid, mi);
}
-
if (fclose (in) != 0)
return -1;
}
-
/* saves the content descriptions, recursively */
static gint
perform_content_info_save_to_db (CamelFolderSummary *s, CamelMessageContentInfo *ci, CamelMIRecord *record)
return ret;
}
-
/**
* camel_folder_summary_save:
* @summary: a #CamelFolderSummary object
FILE *in;
FILE *in_meta;
-
if (s->summary_path == NULL ||
s->meta_summary->path == NULL)
return 0;
return 1;
}
-
/**
* camel_folder_summary_add:
* @summary: a #CamelFolderSummary object
if (info == NULL)
return;
-
if (summary_assign_uid(s, info) == 0)
return;
CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
-
void
camel_folder_summary_insert (CamelFolderSummary *s, CamelMessageInfo *info, gboolean load)
{
CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
-
static void
update_summary (CamelFolderSummary *summary, CamelMessageInfoBase *info)
{
return info;
}
-
/**
* camel_folder_summary_add_from_parser:
* @summary: a #CamelFolderSummary object
return info;
}
-
/**
* camel_folder_summary_add_from_message:
* @summary: a #CamelFolderSummary object
return info;
}
-
/**
* camel_folder_summary_info_new_from_header:
* @summary: a #CamelFolderSummary object
return ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_new_from_header(s, h);
}
-
/**
* camel_folder_summary_info_new_from_parser:
* @summary: a #CamelFolderSummary object
return info;
}
-
/**
* camel_folder_summary_info_new_from_message:
* @summary: a #CamelFodlerSummary object
return info;
}
-
/**
* camel_folder_summary_content_info_free:
* @summary: a #CamelFolderSummary object
}
}
-
/**
* camel_folder_summary_touch:
* @summary: a #CamelFolderSummary object
camel_db_clear_folder_summary (cdb, folder_name, NULL);
}
-
/* This function returns 0 on success. So the caller should not bother,
deleting the uid from db when the return value is non-zero */
static gint
g_hash_table_remove (s->loaded_infos, camel_message_info_uid(info));
ret = summary_remove_uid (s, camel_message_info_uid(info));
-
s->flags |= CAMEL_SUMMARY_DIRTY;
s->meta_summary->msg_expunged = TRUE;
CAMEL_SUMMARY_UNLOCK(s, summary_lock);
camel_message_info_free(info);
}
-
/**
* camel_folder_summary_remove_uid:
* @summary: a #CamelFolderSummary object
CAMEL_SUMMARY_UNLOCK(s, ref_lock);
CAMEL_SUMMARY_UNLOCK(s, summary_lock);
-
}
}
camel_folder_summary_remove_uid (s, uid);
}
-
/**
* camel_folder_summary_remove_range:
* @summary: a #CamelFolderSummary object
return 0;
}
-
/**
* camel_folder_summary_decode_token:
* @in: input FILE pointer
return str;
}
-
/**
* camel_folder_summary_content_info_new:
* @summary: a #CamelFolderSummary object
return ferror(out);
}
-
static CamelMIRecord *
message_info_to_db (CamelFolderSummary *s, CamelMessageInfo *info)
{
record->usertags = tmp->str;
g_string_free (tmp, FALSE);
-
return record;
}
-
static gint
message_info_save(CamelFolderSummary *s, FILE *out, CamelMessageInfo *info)
{
if (mi->headers)
camel_header_param_list_free (mi->headers);
-
if (s)
#ifndef ALWAYS_ALLOC
e_memchunk_free(s->message_info_chunks, mi);
return FALSE;
}
-
/**
* camel_flag_set:
* @list: the address of a #CamelFlag list
return value;
}
-
/**
* camel_flag_list_size:
* @list: the address of a #CamelFlag list
return count;
}
-
/**
* camel_flag_list_free:
* @list: the address of a #CamelFlag list
*list = NULL;
}
-
/**
* camel_flag_list_copy:
* @to: the address of the #CamelFlag list to copy to
return changed;
}
-
/**
* camel_tag_get:
* @list: the address of a #CamelTag list
return NULL;
}
-
/**
* camel_tag_set:
* @list: the address of a #CamelTag list
return FALSE;
}
-
/**
* camel_tag_list_size:
* @list: the address of a #CamelTag list
camel_tag_set(to, key, NULL);
}
-
/**
* camel_tag_list_copy:
* @to: the address of the #CamelTag list to copy to
return changed;
}
-
/**
* camel_tag_list_free:
* @list: the address of a #CamelTag list
{ NULL, 0 }
};
-
/**
* camel_system_flag:
* @name: name of a system flag
return 0;
}
-
/**
* camel_system_flag_get:
* @flags: bitwise system flags
return flags & camel_system_flag (name);
}
-
/**
* camel_message_info_new:
* @summary: a #CamelFolderSummary object or %NULL
info = g_slice_alloc0 (sizeof(CamelMessageInfoBase));
#endif
-
}
info->refcount = 1;
return info;
}
-
/**
* camel_message_info_ref:
* @info: a #CamelMessageInfo
}
}
-
/**
* camel_message_info_new_from_header:
* @summary: a #CamelFolderSummary object or %NULL
return message_info_new_from_header(NULL, header);
}
-
/**
* camel_message_info_free:
* @info: a #CamelMessageInfo
return (CamelMessageInfo *)to;
}
-
/**
* camel_message_info_clone:
* @info: a #CamelMessageInfo
return camel_tag_get(&((CamelMessageInfoBase *)mi)->user_tags, id);
}
-
/**
* camel_message_info_ptr:
* @mi: a #CamelMessageInfo
return info_ptr(mi, id);
}
-
/**
* camel_message_info_uint32:
* @mi: a #CamelMessageInfo
return info_uint32(mi, id);
}
-
/**
* camel_message_info_time:
* @mi: a #CamelMessageInfo
return info_time(mi, id);
}
-
/**
* camel_message_info_user_flag:
* @mi: a #CamelMessageInfo
return info_user_flag(mi, id);
}
-
/**
* camel_message_info_user_tag:
* @mi: a #CamelMessageInfo
camel_folder_change_info_free(changes);
}
-
-
d(printf("%d %d %d %d %d\n", mi->summary->unread_count, mi->summary->deleted_count, mi->summary->junk_count, mi->summary->junk_not_deleted_count, mi->summary->visible_count));
return TRUE;
}
return res;
}
-
/**
* camel_message_info_set_user_flag:
* @mi: a #CamelMessageInfo
return res;
}
-
/**
* camel_message_info_set_user_tag:
* @mi: a #CamelMessageInfo
/*camel_content_info_dump(mi->content, 0);*/
}
-
static void
camel_folder_summary_class_init (CamelFolderSummaryClass *klass)
{
return _PRIVATE(summary)->need_preview;
}
-
/* Deprecated */
void camel_folder_summary_set_filename(CamelFolderSummary *summary, const gchar *filename);
-
void camel_folder_summary_set_index(CamelFolderSummary *summary, CamelIndex *index);
void camel_folder_summary_set_build_content(CamelFolderSummary *summary, gboolean state);
static gint folder_getv(CamelObject *object, CamelException *ex, CamelArgGetV *args);
static void folder_free(CamelObject *o, guint32 tag, gpointer val);
-
static void append_message (CamelFolder *folder, CamelMimeMessage *message,
const CamelMessageInfo *info, gchar **appended_uid,
CamelException *ex);
}
}
-
static void
folder_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
{
camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))));
}
-
/**
* camel_folder_sync:
* @folder: a #CamelFolder object
CAMEL_FOLDER_REC_UNLOCK(folder, lock);
}
-
static void
refresh_info (CamelFolder *folder, CamelException *ex)
{
/* No op */
}
-
/**
* camel_folder_refresh_info:
* @folder: a #CamelFolder object
return folder->name;
}
-
/**
* camel_folder_get_name:
* @folder: a #CamelFolder object
return CF_CLASS (folder)->get_name (folder);
}
-
static const gchar *
get_full_name (CamelFolder *folder)
{
return folder->full_name;
}
-
/**
* camel_folder_get_full_name:
* @folder: a #CamelFolder object
return CF_CLASS (folder)->get_full_name (folder);
}
-
static CamelStore *
get_parent_store (CamelFolder * folder)
{
return folder->parent_store;
}
-
/**
* camel_folder_get_parent_store:
* @folder: a #CamelFolder object
return CF_CLASS (folder)->get_parent_store (folder);
}
-
static void
expunge (CamelFolder *folder, CamelException *ex)
{
camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))));
}
-
/**
* camel_folder_expunge:
* @folder: a #CamelFolder object
return camel_folder_summary_count(folder->summary);
}
-
/**
* camel_folder_get_message_count:
* @folder: a #CamelFolder object
return ret;
}
-
/**
* camel_folder_get_unread_message_count:
* @folder: a #CamelFolder object
return count;
}
-
/**
* camel_folder_get_deleted_message_count:
* @folder: a #CamelFolder object
CAMEL_FOLDER_REC_UNLOCK(folder, lock);
}
-
static guint32
get_permanent_flags (CamelFolder *folder)
{
return folder->permanent_flags;
}
-
/**
* camel_folder_get_permanent_flags:
* @folder: a #CamelFolder object
return flags;
}
-
/**
* camel_folder_get_message_flags:
* @folder: a #CamelFolder object
return res;
}
-
/**
* camel_folder_set_message_flags:
* @folder: a #CamelFolder object
return ret;
}
-
/**
* camel_folder_get_message_user_flag:
* @folder: a #CamelFolder object
camel_message_info_free(info);
}
-
/**
* camel_folder_set_message_user_flag:
* @folder: a #CamelFolder object
return ret;
}
-
/**
* camel_folder_get_message_user_tag:
* @folder: a #CamelFolder object
camel_message_info_free(info);
}
-
/**
* camel_folder_set_message_user_tag:
* @folder: a #CamelFolder object
return camel_folder_summary_uid(folder->summary, uid);
}
-
/**
* camel_folder_get_message_info:
* @folder: a #CamelFolder object
camel_message_info_free(info);
}
-
/**
* camel_folder_free_message_info:
* @folder: a #CamelFolder object
camel_message_info_ref(info);
}
-
/**
* camel_folder_ref_message_info:
* @folder: a #CamelFolder object
CF_CLASS (folder)->ref_message_info(folder, info);
}
-
/* TODO: is this function required anyway? */
/**
* camel_folder_has_summary_capability:
return folder->folder_flags & CAMEL_FOLDER_HAS_SUMMARY_CAPABILITY;
}
-
/* UIDs stuff */
static CamelMimeMessage *
return NULL;
}
-
/**
* camel_folder_get_message:
* @folder: a #CamelFolder object
return camel_folder_summary_array (folder->summary);
}
-
/**
* camel_folder_get_uids:
* @folder: a #CamelFolder object
g_ptr_array_free(array, TRUE);
}
-
/**
* camel_folder_free_uids:
* @folder: a #CamelFolder object
CF_CLASS (folder)->free_uids (folder, array);
}
-
/**
* Default: return the uids we are given.
*/
g_qsort_with_data (uids->pdata, uids->len, sizeof (gpointer), cmp_array_uids, folder);
}
-
/**
* camel_folder_sort_uids:
* @folder: a #CamelFolder object
CF_CLASS (folder)->sort_uids (folder, uids);
}
-
static GPtrArray *
get_summary(CamelFolder *folder)
{
return camel_folder_summary_array(folder->summary);
}
-
/**
* camel_folder_get_summary:
* @folder: a #CamelFolder object
g_ptr_array_free (summary, TRUE);
}
-
/**
* camel_folder_free_summary:
* @folder: a #CamelFolder object
CF_CLASS(folder)->free_summary(folder, array);
}
-
/**
* camel_folder_has_search_capability:
* @folder: a #CamelFolder object
return NULL;
}
-
/**
* camel_folder_search_by_expression:
* @folder: a #CamelFolder object
return 0;
}
-
/**
* camel_folder_count_by_expression:
* @folder: a #CamelFolder object
return NULL;
}
-
/**
* camel_folder_search_by_uids:
* @folder: a #CamelFolder object
g_ptr_array_free (result, TRUE);
}
-
/**
* camel_folder_search_free:
* @folder: a #CamelFolder object
CF_CLASS (folder)->search_free (folder, result);
}
-
static void
transfer_message_to (CamelFolder *source, const gchar *uid, CamelFolder *dest,
gchar **transferred_uid, gboolean delete_original,
camel_exception_clear(&local);
}
-
/**
* camel_folder_transfer_messages_to:
* @source: the source #CamelFolder object
camel_folder_summary_clear (folder->summary);
}
-
/**
* camel_folder_delete:
* @folder: a #CamelFolder object
folder->name = g_strdup(tmp?tmp+1:new);
}
-
/**
* camel_folder_rename:
* @folder: a #CamelFolder object
CAMEL_FOLDER_UNLOCK(folder, change_lock);
}
-
/**
* camel_folder_freeze:
* @folder: a #CamelFolder
return folder->priv->frozen != 0;
}
-
/**
* camel_folder_is_frozen:
* @folder: a #CamelFolder object
struct _EMemPool *uid_pool; /* pool used to store copies of uid strings */
};
-
/* Event hooks that block emission when frozen */
static gboolean
folder_changed (CamelObject *obj, gpointer event_data)
return TRUE;
}
-
/**
* camel_folder_free_nop:
* @folder: a #CamelFolder object
;
}
-
/**
* camel_folder_free_shallow:
* @folder: a #CamelFolder object
g_ptr_array_free (array, TRUE);
}
-
/**
* camel_folder_free_deep:
* @folder: a #CamelFolder object
g_ptr_array_free (array, TRUE);
}
-
/**
* camel_folder_change_info_new:
*
return info;
}
-
/**
* camel_folder_change_info_add_source:
* @info: a #CamelFolderChangeInfo
g_hash_table_insert(p->uid_source, e_mempool_strdup(p->uid_pool, uid), GINT_TO_POINTER (1));
}
-
/**
* camel_folder_change_info_add_source_list:
* @info: a #CamelFolderChangeInfo
}
}
-
/**
* camel_folder_change_info_add_update:
* @info: a #CamelFolderChangeInfo
}
}
-
/**
* camel_folder_change_info_add_update_list:
* @info: a #CamelFolderChangeInfo
g_hash_table_insert(p->uid_stored, key, info->uid_removed);
}
-
/**
* camel_folder_change_info_build_diff:
* @info: a #CamelFolderChangeInfo
add(info, source->pdata[i]);
}
-
/**
* camel_folder_change_info_cat:
* @info: a #CamelFolderChangeInfo to append to
g_hash_table_insert(p->uid_stored, olduid, info->uid_added);
}
-
/**
* camel_folder_change_info_remove_uid:
* @info: a #CamelFolderChangeInfo
g_hash_table_insert(p->uid_stored, olduid, info->uid_removed);
}
-
/**
* camel_folder_change_info_change_uid:
* @info: a #CamelFolderChangeInfo
g_hash_table_insert(p->uid_stored, olduid, info->uid_changed);
}
-
/**
* camel_folder_change_info_recent_uid:
* @info: a #CamelFolderChangeInfo
return (info->uid_added->len || info->uid_removed->len || info->uid_changed->len || info->uid_recent->len);
}
-
/**
* camel_folder_change_info_clear:
* @info: a #CamelFolderChangeInfo
e_mempool_flush(p->uid_pool, TRUE);
}
-
/**
* camel_folder_change_info_free:
* @info: a #CamelFolderChangeInfo
/* Standard Camel function */
CamelType camel_folder_get_type (void);
-
/* public methods */
void camel_folder_construct (CamelFolder *folder,
CamelStore *parent_store,
CamelStore * camel_folder_get_parent_store (CamelFolder *folder);
-
/* delete operations */
void camel_folder_expunge (CamelFolder *folder,
CamelException *ex);
-
/* folder name operations */
const gchar * camel_folder_get_name (CamelFolder *folder);
const gchar * camel_folder_get_full_name (CamelFolder *folder);
-
/* various properties accessors */
guint32 camel_folder_get_permanent_flags (CamelFolder *folder);
const gchar *value);
#endif /* CAMEL_DISABLE_DEPRECATED */
-
-
/* message manipulation */
void camel_folder_append_message (CamelFolder *folder,
CamelMimeMessage *message,
gchar **appended_uid,
CamelException *ex);
-
/* summary related operations */
gboolean camel_folder_has_summary_capability (CamelFolder *folder);
-
gint camel_folder_get_message_count (CamelFolder *folder);
#ifndef CAMEL_DISABLE_DEPRECATED
return cipher;
}
-
/**
* camel_gpg_context_set_always_trust:
* @ctx: gpg context
ctx->always_trust = always_trust;
}
-
static const gchar *
gpg_hash_to_id (CamelCipherContext *context, CamelCipherHash hash)
{
return CAMEL_CIPHER_HASH_DEFAULT;
}
-
enum _GpgCtxMode {
GPG_CTX_MODE_SIGN,
GPG_CTX_MODE_VERIFY,
{
return gpg->complete && gpg->seen_eof1 && gpg->seen_eof2;}
-
#if 0
static gboolean
gpg_ctx_op_exited (struct _GpgCtx *gpg)
#endif
}
-
-
static gint
gpg_sign (CamelCipherContext *context, const gchar *userid, CamelCipherHash hash, CamelMimePart *ipart, CamelMimePart *opart, CamelException *ex)
{
return res;
}
-
static gchar *
swrite (CamelMimePart *sigpart)
{
*
*/
-
#ifndef __CAMEL_GPG_CONTEXT_H__
#define __CAMEL_GPG_CONTEXT_H__
};
-
CamelType camel_gpg_context_get_type (void);
CamelCipherContext *camel_gpg_context_new (CamelSession *session);
return new;
}
-
void camel_html_parser_set_data(CamelHTMLParser *hp, const gchar *start, gint len, gint last)
{
CamelHTMLParserPrivate *p = hp->priv;
{ 8659, "dArr", /* downwards double arrow, U+21D3 ISOamsa */ },
{ 8660, "hArr", /* left right double arrow, U+21D4 ISOamsa */ },
-
{ 8704, "forall",/* for all, U+2200 ISOtech */ },
{ 8706, "part", /* partial differential, U+2202 ISOtech */ },
{ 8707, "exist",/* there exists, U+2203 ISOtech */ },
*
*/
-
#ifndef __CAMEL_HTTP_STREAM_H__
#define __CAMEL_HTTP_STREAM_H__
/*CAMEL_HTTP_METHOD_CONNECT*/
} CamelHttpMethod;
-
typedef struct _CamelHttpStreamClass CamelHttpStreamClass;
struct _CamelHttpStream {
{ NULL, NULL }
};
-
-
/* Another copy of this trivial list implementation
Why? This stuff gets called a lot (potentially), should run fast,
and g_list's are f@@#$ed up to make this a hassle */
return n;
}
-
static const gchar *
e_strdown (gchar *str)
{
return str;
}
-
static void
locale_parse_lang (const gchar *locale)
{
return locale_charset;
}
-
const gchar *
camel_iconv_locale_language (void)
{
*
*/
-
#ifndef __CAMEL_ICONV_H__
#define __CAMEL_ICONV_H__
g_ptr_array_remove_index(a->addresses, index);
}
-
/**
* camel_internet_address_new:
*
return new;
}
-
/**
* camel_internet_address_add:
* @addr: a #CamelInternetAddress object
return index;
}
-
/**
* camel_internet_address_get:
* @addr: a #CamelInternetAddress object
return TRUE;
}
-
/**
* camel_internet_address_find_name:
* @addr: a #CamelInternetAddress object
return -1;
}
-
/**
* camel_internet_address_find_address:
* @addr: a #CamelInternetAddress object
g_string_append(out, addr);
}
-
/**
* camel_internet_address_encode_address:
* @len: the length of the line the address is being appended to
return ret;
}
-
/**
* camel_internet_address_format_address:
* @name: a name, quotes may be stripped from it
continue;
}
-
len = read_n(STDIN_FILENO, &msg, sizeof(msg));
if (len == 0)
break;
* USA
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
camel_object_unref (medium->content);
}
-
CamelType
camel_medium_get_type (void)
{
g_warning("No %s::add_header implemented, adding %s", camel_type_to_name(CAMEL_OBJECT_GET_TYPE(medium)), name);
}
-
/**
* camel_medium_add_header:
* @medium: a #CamelMedium object
g_warning("No %s::set_header implemented, setting %s", camel_type_to_name(CAMEL_OBJECT_GET_TYPE(medium)), name);
}
-
/**
* camel_medium_set_header:
* @medium: a #CamelMedium object
g_warning("No %s::remove_header implemented, removing %s", camel_type_to_name(CAMEL_OBJECT_GET_TYPE(medium)), name);
}
-
/**
* camel_medium_remove_header:
* @medium: a #CamelMedium
CM_CLASS(medium)->remove_header(medium, name);
}
-
static gconstpointer
get_header(CamelMedium *medium, const gchar *name)
{
return NULL;
}
-
/**
* camel_medium_get_header:
* @medium: a #CamelMedium object
return CM_CLASS (medium)->get_header (medium, name);
}
-
static GArray *
get_headers(CamelMedium *medium)
{
CM_CLASS (medium)->free_headers (medium, headers);
}
-
static CamelDataWrapper *
get_content_object(CamelMedium *medium)
{
return medium->content;
}
-
/**
* camel_medium_get_content_object:
* @medium: a #CamelMedium object
return CM_CLASS (medium)->get_content_object (medium);
}
-
static void
set_content_object (CamelMedium *medium, CamelDataWrapper *content)
{
medium->content = content;
}
-
/**
* camel_medium_set_content_object:
* @medium: a #CamelMedium object
* USA
*/
-
#ifndef CAMEL_MEDIUM_H
#define CAMEL_MEDIUM_H 1
obj->save = 0;
}
-
CamelType
camel_mime_filter_basic_get_type (void)
{
*outprespace = prespace;
}
-
/**
* camel_mime_filter_basic_new:
*
return new;
}
-
/**
* camel_mime_filter_basic_new_type:
* @type: a #CamelMimeFilterBasicType type
* Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return new;
}
-
/**
* camel_mime_filter_bestenc_get_best_encoding:
* @filter: a #CamelMimeFilterBestenc object
}
-
/**
* camel_mime_filter_bestenc_get_best_charset:
* @filter: a #CamelMimeFilterBestenc object
return camel_charset_best_name(&filter->charset);
}
-
/**
* camel_mime_filter_bestenc_set_flags:
* @filter: a #CamelMimeFilterBestenc object
CamelType camel_mime_filter_bestenc_get_type (void);
CamelMimeFilterBestenc *camel_mime_filter_bestenc_new (guint flags);
-
CamelTransferEncoding camel_mime_filter_bestenc_get_best_encoding(CamelMimeFilterBestenc *filter, CamelBestencEncoding required);
const gchar * camel_mime_filter_bestenc_get_best_charset(CamelMimeFilterBestenc *filter);
void camel_mime_filter_bestenc_set_flags(CamelMimeFilterBestenc *filter, guint flags);
gsize *outprespace);
static void reset (CamelMimeFilter *f);
-
static void
camel_mime_filter_canon_class_init (CamelMimeFilterCanonClass *klass)
{
/* no-op */
}
-
/**
* camel_mime_filter_canon_new:
* @flags: bitwise flags defining the behaviour of the filter
* Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
obj->ic = (iconv_t)-1;
}
-
/**
* camel_mime_filter_charset_new:
*
return CAMEL_MIME_FILTER_CHARSET (camel_object_new (camel_mime_filter_charset_get_type ()));
}
-
/**
* camel_mime_filter_charset_new_convert:
* @from_charset: charset to convert from
gsize *outprespace);
static void reset (CamelMimeFilter *f);
-
static void
camel_mime_filter_crlf_class_init (CamelMimeFilterCRLFClass *klass)
{
crlf->saw_dot = FALSE;
}
-
/**
* camel_mime_filter_crlf_new:
* @direction: encode vs decode
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_MIME_FILTER_CRLF_H
#define _CAMEL_MIME_FILTER_CRLF_H
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static GHashTable *enriched_hash = NULL;
-
static void camel_mime_filter_enriched_class_init (CamelMimeFilterEnrichedClass *klass);
static void camel_mime_filter_enriched_init (CamelMimeFilterEnriched *filter);
static void camel_mime_filter_enriched_finalize (CamelObject *obj);
gchar **out, gsize *outlen, gsize *outprespace);
static void filter_reset (CamelMimeFilter *filter);
-
static CamelMimeFilterClass *parent_class = NULL;
-
CamelType
camel_mime_filter_enriched_get_type (void)
{
filter->nofill = 0;
}
-
#if 0
static gboolean
enriched_tag_needs_param (const gchar *tag)
enriched->nofill = 0;
}
-
/**
* camel_mime_filter_enriched_new:
* @flags: bitwise set of flags to specify filter behaviour
return CAMEL_MIME_FILTER (new);
}
-
/**
* camel_enriched_to_html:
* @in: input textual string
*
*/
-
#ifndef __CAMEL_MIME_FILTER_ENRICHED_H__
#define __CAMEL_MIME_FILTER_ENRICHED_H__
* Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
;
}
-
/**
* camel_mime_filter_from_new:
*
g_tk_init(&argc, &argv);
-
f = camel_mime_filter_from_new();
buffer = "This is a test\nFrom Someone\nTo someone. From Someone else, From\n From blah\nFromblah\nBye! \nFrom ";
camel_mime_filter_complete(f, buffer, len, prespace, &buffer, &len, &prespace);
printf("complete = '%.*s'\n", len, buffer);
-
return 0;
}
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_MIME_FILTER_FROM_H
#define _CAMEL_MIME_FILTER_FROM_H
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "camel-mime-filter-gzip.h"
-
/* rfc1952 */
enum {
gchar **out, gsize *outlen, gsize *outprespace);
static void filter_reset (CamelMimeFilter *filter);
-
static CamelMimeFilterClass *parent_class = NULL;
-
CamelType
camel_mime_filter_gzip_get_type (void)
{
return type;
}
-
static void
camel_mime_filter_gzip_class_init (CamelMimeFilterGZipClass *klass)
{
g_free (priv);
}
-
static void
gzip_filter (CamelMimeFilter *filter, const gchar *in, gsize len, gsize prespace,
gchar **out, gsize *outlen, gsize *outprespace, gint flush)
priv->isize = 0;
}
-
/**
* camel_mime_filter_gzip_new:
* @mode: zip or unzip
*
*/
-
#ifndef __CAMEL_MIME_FILTER_GZIP_H__
#define __CAMEL_MIME_FILTER_GZIP_H__
};
-
CamelType camel_mime_filter_gzip_get_type (void);
CamelMimeFilter *camel_mime_filter_gzip_new (CamelMimeFilterGZipMode mode, gint level);
{ "h1", "\n" }, { "h2", "\n" }, { "h3", "\n" }, { "h4", "\n" }, { "h5", "\n" }, { "h6", "\n" },
};
-
static struct {
gchar *element;
gchar *remap;
};
#endif
-
/* ********************************************************************** */
-
CamelType
camel_mime_filter_html_get_type (void)
{
filter_class->complete = complete;
}
-
/**
* camel_mime_filter_html_new:
*
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_MIME_FILTER_HTML_H
#define _CAMEL_MIME_FILTER_HTML_H
return new;
}
-
/**
* camel_mime_filter_index_new_index:
* @index: a #CamelIndex object
/* Set the match name for any indexed words */
-
/**
* camel_mime_filter_index_set_name:
* @filter: a #CamelMimeFilterIndex object
camel_object_ref (name);
}
-
/**
* camel_mime_filter_index_set_index:
* @filter: a #CamelMimeFilterIndex object
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_MIME_FILTER_INDEX_H
#define _CAMEL_MIME_FILTER_INDEX_H
* Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "camel-mime-filter-linewrap.h"
-
static void filter (CamelMimeFilter *f, const gchar *in, gsize len, gsize prespace,
gchar **out, gsize *outlen, gsize *outprespace);
static void complete (CamelMimeFilter *f, const gchar *in, gsize len,
gsize *outprespace);
static void reset (CamelMimeFilter *f);
-
static void
camel_mime_filter_linewrap_class_init (CamelMimeFilterLinewrapClass *klass)
{
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
filter_class->complete = filter_complete;
}
-
/**
* camel_mime_filter_progress_new:
* @operation: a #CamelOperation
*
*/
-
#ifndef __CAMEL_MIME_FILTER_PROGRESS_H__
#define __CAMEL_MIME_FILTER_PROGRESS_H__
};
-
CamelType camel_mime_filter_progress_get_type (void);
CamelMimeFilter *camel_mime_filter_progress_new (CamelOperation *operation, gsize total);
*
*/
-
#ifndef HAVE_CONFIG_H
#include <config.h>
#endif
gsize *outprespace);
static void reset (CamelMimeFilter *f);
-
static void
camel_mime_filter_save_class_init (CamelMimeFilterSaveClass *klass)
{
/* no-op */
}
-
/**
* camel_mime_filter_save_new:
*
return (CamelMimeFilter *) save;
}
-
/**
* camel_mime_filter_save_new_with_stream:
* @stream: a #CamelStream object
*
*/
-
#ifndef __CAMEL_MIME_FILTER_SAVE_H__
#define __CAMEL_MIME_FILTER_SAVE_H__
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static CamelMimeFilterClass *camel_mime_filter_tohtml_parent;
-
CamelType
camel_mime_filter_tohtml_get_type (void)
{
filter->pre_open = FALSE;
}
-
static gchar *
check_size (CamelMimeFilter *filter, gchar *outptr, gchar **outend, gsize len)
{
filter_class->complete = filter_complete;
}
-
/**
* camel_mime_filter_tohtml_new:
* @flags: bitwise flags defining the behaviour
return CAMEL_MIME_FILTER (new);
}
-
/**
* camel_text_to_html:
* @in: input text
*
*/
-
#ifndef __CAMEL_MIME_FILTER_TOHTML_H__
#define __CAMEL_MIME_FILTER_TOHTML_H__
CamelMimeFilterClass parent_class;
};
-
CamelType camel_mime_filter_tohtml_get_type (void);
CamelMimeFilter *camel_mime_filter_tohtml_new (guint32 flags, guint32 colour);
-
/* utility functions to replace e_text_to_html */
gchar *camel_text_to_html (const gchar *in, guint32 flags, guint32 colour);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
filter_class->complete = filter_complete;
}
-
/**
* camel_mime_filter_windows_new:
* @claimed_charset: ISO charset name
return CAMEL_MIME_FILTER (new);
}
-
/**
* camel_mime_filter_windows_is_windows_charset:
* @filter: a #CamelMimeFilterWindows object
return filter->is_windows;
}
-
/**
* camel_mime_filter_windows_real_charset:
* @filter: a #CamelMimeFilterWindows object
*
*/
-
#ifndef __CAMEL_MIME_FILTER_WINDOWS_H__
#define __CAMEL_MIME_FILTER_WINDOWS_H__
};
-
CamelType camel_mime_filter_windows_get_type (void);
CamelMimeFilter *camel_mime_filter_windows_new (const gchar *claimed_charset);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
gchar **out, gsize *outlen, gsize *outprespace);
static void filter_reset (CamelMimeFilter *filter);
-
static CamelMimeFilterClass *parent_class = NULL;
-
CamelType
camel_mime_filter_yenc_get_type (void)
{
return type;
}
-
static void
camel_mime_filter_yenc_class_init (CamelMimeFilterYencClass *klass)
{
filter->crc = CAMEL_MIME_YENCODE_CRC_INIT;
}
-
/* here we do all of the basic yEnc filtering */
static void
filter_filter (CamelMimeFilter *filter, const gchar *in, gsize len, gsize prespace,
yenc->crc = CAMEL_MIME_YENCODE_CRC_INIT;
}
-
/**
* camel_mime_filter_yenc_new:
* @direction: encode direction
return (CamelMimeFilter *) new;
}
-
/**
* camel_mime_filter_yenc_set_state:
* @yenc: a #CamelMimeFilterYenc object
yenc->state = state;
}
-
/**
* camel_mime_filter_yenc_set_crc:
* @yenc: a #CamelMimeFilterYenc object
yenc->crc = crc;
}
-
#if 0
/* FIXME: once we parse out the yenc part id, we can re-enable this interface */
/**
return CAMEL_MIME_YENCODE_CRC_FINAL (yenc->pcrc);
}
-
/**
* camel_mime_filter_yenc_get_crc:
* @yenc: a #CamelMimeFiletrYenc object
return CAMEL_MIME_YENCODE_CRC_FINAL (yenc->crc);
}
-
static const gint yenc_crc_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
#define YENC_NEWLINE_ESCAPE (CAMEL_MIME_YDECODE_STATE_EOLN | CAMEL_MIME_YDECODE_STATE_ESCAPE)
-
/**
* camel_ydecode_step:
* @in: input buffer
return outptr - out;
}
-
/**
* camel_yencode_step:
* @in: input buffer
return outptr - out;
}
-
/**
* camel_yencode_close:
* @in: input buffer
*
*/
-
#ifndef __CAMEL_MIME_FILTER_YENC_H__
#define __CAMEL_MIME_FILTER_YENC_H__
};
-
CamelType camel_mime_filter_yenc_get_type (void);
CamelMimeFilter *camel_mime_filter_yenc_new (CamelMimeFilterYencDirection direction);
guint32 camel_mime_filter_yenc_get_pcrc (CamelMimeFilterYenc *yenc);
guint32 camel_mime_filter_yenc_get_crc (CamelMimeFilterYenc *yenc);
-
gsize camel_ydecode_step (const guchar *in, gsize inlen, guchar *out,
gint *state, guint32 *pcrc, guint32 *crc);
gsize camel_yencode_step (const guchar *in, gsize inlen, guchar *out,
/* default - do nothing */
}
-
/**
* camel_mime_filter_new:
*
}
-
/**
* camel_mime_filter_filter:
* @filter: a #CamelMimeFilter object
g_error("Filter function unplmenented in class");
}
-
/**
* camel_mime_filter_complete:
* @filter: a #CamelMimeFilter object
filter_run(filter, in, len, prespace, out, outlen, outprespace, FCLASS(filter)->complete);
}
-
/**
* camel_mime_filter_reset:
* @filter: a #CamelMimeFilter object
filter->backlen = 0;
}
-
/**
* camel_mime_filter_backup:
* @filter: a #camelMimeFilter object
memcpy(filter->backbuf, data, length);
}
-
/**
* camel_mime_filter_set_size:
* @filter: a #camelMimeFilter object
camel_object_unref (value);
}
-
/**
* camel_mime_message_new:
*
/* **** Date: */
-
/**
* camel_mime_message_set_date:
* @message: a #CamelMimeMessage object
g_free (datestr);
}
-
/**
* camel_mime_message_get_date:
* @message: a #CamelMimeMessage object
return msg->date;
}
-
/**
* camel_mime_message_get_date_received:
* @message: a #CamelMimeMessage object
g_free (id);
}
-
/**
* camel_mime_message_get_message_id:
* @message: a #CamelMimeMessage object
/* **** Reply-To: */
-
/**
* camel_mime_message_set_reply_to:
* @message: a #CamelMimeMessage object
g_free (addr);
}
-
/**
* camel_mime_message_get_reply_to:
* @message: a #CamelMimeMessage object
g_free (text);
}
-
/**
* camel_mime_message_get_subject:
* @message: a #CamelMimeMessage object
g_free(addr);
}
-
/**
* camel_mime_message_get_from:
* @message: a #CamelMimeMessage object
g_free(text);
}
-
/**
* camel_mime_message_get_recipients:
* @message: a #CamelMimeMessage object
return g_hash_table_lookup (mime_message->recipients, type);
}
-
void
camel_mime_message_set_source (CamelMimeMessage *mime_message, const gchar *src)
{
return !(*has8bit);
}
-
/**
* camel_mime_message_has_8bit_parts:
* @message: a #CamelMimeMessage object
return TRUE;
}
-
/**
* camel_mime_message_set_best_encoding:
* @message: a #CamelMimeMessage object
camel_mime_message_foreach_part (msg, best_encoding, &data);
}
-
/**
* camel_mime_message_encode_8bit_parts:
* @message: a #CamelMimeMessage object
camel_mime_message_set_best_encoding (mime_message, CAMEL_BESTENC_GET_ENCODING, CAMEL_BESTENC_7BIT);
}
-
struct _check_content_id {
CamelMimePart *part;
const gchar *content_id;
return !found;
}
-
/**
* camel_mime_message_get_part_by_content_id:
* @message: a #CamelMimeMessage object
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
-
/**
* camel_mime_message_build_mbox_from:
* @message: a #CamelMimeMessage object
* USA
*/
-
#ifndef CAMEL_MIME_MESSAGE_H
#define CAMEL_MIME_MESSAGE_H 1
} CamelMimeMessageClass;
-
-
/* Standard Camel function */
CamelType camel_mime_message_get_type (void);
-
/* public methods */
CamelMimeMessage *camel_mime_message_new (void);
void camel_mime_message_set_date (CamelMimeMessage *message,
const gchar *identity);
const gchar *camel_mime_message_get_source (CamelMimeMessage *message);
-
/* utility functions */
gboolean camel_mime_message_has_8bit_parts (CamelMimeMessage *message);
void camel_mime_message_set_best_encoding (CamelMimeMessage *message,
return new;
}
-
/**
* camel_mime_parser_filter_add:
* @m:
return part;
}
-
static void
folder_scan_close(struct _header_scan_state *s)
{
g_free(s);
}
-
static struct _header_scan_state *
folder_scan_init(void)
{
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_MIME_PARSER_H
#define _CAMEL_MIME_PARSER_H
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* camel-mime-part-utils : Utility for mime parsing and so on */
-
/*
*
* Author :
* USA
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
HEADER_CONTENT_TYPE
} CamelHeaderType;
-
static GHashTable *header_name_table;
static GHashTable *header_formatted_table;
/*static gint write_fold(CamelStream *stream, struct _camel_header_raw *h);*/
static gssize write_raw(CamelStream *stream, struct _camel_header_raw *h);
-
/* loads in a hash table the set of header names we */
/* recognize and associate them with a unique enum */
/* identifier (see CamelHeaderType above) */
mime_part->encoding = CAMEL_TRANSFER_ENCODING_DEFAULT;
}
-
static void
camel_mime_part_finalize (CamelObject *object)
{
camel_header_raw_clear(&mime_part->headers);
}
-
-
CamelType
camel_mime_part_get_type (void)
{
return type;
}
-
/* **** */
static gboolean
g_free (text);
}
-
/**
* camel_mime_part_get_description:
* @mime_part: a #CamelMimePart object
mime_part->disposition = NULL;
}
-
/**
* camel_mime_part_set_disposition:
* @mime_part: a #CamelMimePart object
g_free(text);
}
-
/**
* camel_mime_part_get_disposition:
* @mime_part: a #CamelMimePart object
return NULL;
}
-
/* **** Content-Disposition: filename="xxx" */
/**
g_free (str);
}
-
/**
* camel_mime_part_get_filename:
* @mime_part: a #CamelMimePart object
return camel_content_type_param (((CamelDataWrapper *) mime_part)->mime_type, "name");
}
-
/* **** Content-ID: */
/**
g_free (cid);
}
-
/**
* camel_mime_part_get_content_id:
* @mime_part: a #CamelMimePart object
camel_medium_set_header (CAMEL_MEDIUM (mime_part), "Content-MD5", md5);
}
-
/**
* camel_mime_part_get_content_MD5:
* @mime_part: a #CamelMimePart object
/* **** Content-Location: */
-
/**
* camel_mime_part_set_content_location:
* @mime_part: a #CamelMimePart object
camel_medium_set_header (CAMEL_MEDIUM (mime_part), "Content-Location", location);
}
-
/**
* camel_mime_part_get_content_location:
* @mime_part: a #CamelMimePart object
/* **** Content-Transfer-Encoding: */
-
/**
* camel_mime_part_set_encoding:
* @mime_part: a #CamelMimePart object
"Content-Transfer-Encoding", text);
}
-
/**
* camel_mime_part_get_encoding:
* @mime_part: a #CamelMimePart object
/* FIXME: do something with this stuff ... */
-
/**
* camel_mime_part_set_content_languages:
* @mime_part: a #CamelMimePart object
/* FIXME: translate to a header and set it */
}
-
/**
* camel_mime_part_get_content_languages:
* @mime_part: a #CamelMimePart object
return mime_part->content_languages;
}
-
/* **** */
/* **** Content-Type: */
"Content-Type", content_type);
}
-
/**
* camel_mime_part_get_content_type:
* @mime_part: a #CamelMimePart object
* USA
*/
-
#ifndef CAMEL_MIME_PART_H
#define CAMEL_MIME_PART_H 1
return bytes;
}
-
/**
* camel_base64_encode_step:
* @in: input stream
return g_base64_encode_step (in, len, break_lines, (gchar *) out, state, save);
}
-
/**
* camel_base64_decode_step: decode a chunk of base64 encoded data
* @in: input stream
return g_base64_decode_step ((gchar *) in, len, out, state, save);
}
-
/**
* camel_base64_encode_simple:
* @data: binary stream of data to encode
return g_base64_encode ((const guchar *) data, len);
}
-
/**
* camel_base64_decode_simple:
* @data: data to decode
return outptr - out;
}
-
/**
* camel_uuencode_step:
* @in: input stream
return outptr - out;
}
-
/**
* camel_uudecode_step:
* @in: input stream
return outptr - out;
}
-
/**
* camel_quoted_encode_close:
* @in: input stream
return outptr-out;
}
-
/**
* camel_quoted_encode_step:
* @in: input stream
return (outptr - out);
}
-
static void
header_decode_lwsp(const gchar **in)
{
return decoded;
}
-
/**
* camel_header_decode_string:
* @in: input header value string
return header_decode_text (in, FALSE, default_charset);
}
-
/**
* camel_header_format_ctext:
* @in: input header value string
camel_iconv_close (ic);
}
-
/* TODO: Should this worry about quotes?? */
/**
* camel_header_encode_string:
return outstr;
}
-
/* these are all internal parser functions */
static gchar *
}
}
-
/**
* camel_header_token_decode:
* @in: input string
return decoded;
}
-
/**
* camel_header_param:
* @params: parameters
return NULL;
}
-
/**
* camel_header_set_param:
* @paramsp: poinetr to a list of params
return pn;
}
-
/**
* camel_content_type_param:
* @content_type: a #CamelContentType
return camel_header_param (t->params, name);
}
-
/**
* camel_content_type_set_param:
* @content_type: a #CamelContentType
camel_header_set_param (&t->params, name, value);
}
-
/**
* camel_content_type_is:
* @content_type: A content type specifier, or %NULL.
|| !strcmp("*", subtype))));
}
-
/**
* camel_header_param_list_free:
* @params: a list of params
}
}
-
/**
* camel_content_type_new:
* @type: the major type of the new content-type
return t;
}
-
/**
* camel_content_type_ref:
* @content_type: a #CamelContentType
ct->refcount++;
}
-
/**
* camel_content_type_unref:
* @content_type: a #CamelContentType
return msgid;
}
-
/**
* camel_header_msgid_decode:
* @in: input string
return header_msgid_decode_internal(&in);
}
-
/**
* camel_header_contentid_decode:
* @in: input string
return ret;
}
-
/* date parser macros */
#define NUMERIC_CHARS "1234567890"
#define WEEKDAY_CHARS "SundayMondayTuesdayWednesdayThursdayFridaySaturday"
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
-
/**
* camel_header_format_date:
* @date: time_t date representation
return t;
}
-
#define date_token_mask(t) (((struct _date_token *) t)->mask)
#define is_numeric(t) ((date_token_mask (t) & DATE_TOKEN_NON_NUMERIC) == 0)
#define is_weekday(t) ((date_token_mask (t) & DATE_TOKEN_NON_WEEKDAY) == 0)
return t;
}
-
/**
* camel_header_decode_date:
* @str: input date string
return msgid;
}
-
static struct {
const gchar *name;
const gchar *pattern;
}
}
-
void
camel_header_address_list_append(struct _camel_header_address **l, struct _camel_header_address *h)
{
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_MIME_UTILS_H
#define _CAMEL_MIME_UTILS_H
_("Error copying mail temp file: %s"),
g_strerror (errno));
-
camel_object_unref((CamelObject *)mp);
camel_object_unref((CamelObject *)ffrom);
* USA
*/
-
#ifndef CAMEL_MOVEMAIL_H
#define CAMEL_MOVEMAIL_H 1
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static void set_mime_type_field (CamelDataWrapper *data_wrapper, CamelContentType *mime_type);
-
static CamelMultipartClass *parent_class = NULL;
-
CamelType
camel_multipart_encrypted_get_type (void)
{
return type;
}
-
static void
camel_multipart_encrypted_class_init (CamelMultipartEncryptedClass *klass)
{
((CamelDataWrapperClass *) parent_class)->set_mime_type_field (data_wrapper, mime_type);
}
-
/**
* camel_multipart_encrypted_new:
*
*
*/
-
#ifndef __CAMEL_MULTIPART_ENCRYPTED_H__
#define __CAMEL_MULTIPART_ENCRYPTED_H__
return total;
}
-
/**
* camel_multipart_signed_get_content_stream:
* @mps: a #CamlMultipartSigned object
static CamelDataWrapperClass *parent_class = NULL;
-
-
/* Returns the class for a CamelMultipart */
#define CMP_CLASS(so) CAMEL_MULTIPART_CLASS (CAMEL_OBJECT_GET_CLASS(so))
/* Returns the class for a CamelDataWrapper */
#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (CAMEL_OBJECT_GET_CLASS(so))
-
static void
camel_multipart_class_init (CamelMultipartClass *camel_multipart_class)
{
g_free (multipart->postface);
}
-
CamelType
camel_multipart_get_type (void)
{
return camel_multipart_type;
}
-
/**
* camel_multipart_new:
*
return multipart;
}
-
static void
add_part (CamelMultipart *multipart, CamelMimePart *part)
{
camel_object_ref (part);
}
-
/**
* camel_multipart_add_part:
* @multipart: a #CamelMultipart object
CMP_CLASS (multipart)->add_part (multipart, part);
}
-
static void
add_part_at (CamelMultipart *multipart, CamelMimePart *part, guint index)
{
CMP_CLASS (multipart)->add_part_at (multipart, part, index);
}
-
static void
remove_part (CamelMultipart *multipart, CamelMimePart *part)
{
CMP_CLASS (multipart)->remove_part (multipart, part);
}
-
static CamelMimePart *
remove_part_at (CamelMultipart *multipart, guint index)
{
return CMP_CLASS (multipart)->remove_part_at (multipart, index);
}
-
static CamelMimePart *
get_part (CamelMultipart *multipart, guint index)
{
return CMP_CLASS (multipart)->get_part (multipart, index);
}
-
static guint
get_number (CamelMultipart *multipart)
{
return CMP_CLASS (multipart)->get_number (multipart);
}
-
static void
set_boundary (CamelMultipart *multipart, const gchar *boundary)
{
CMP_CLASS (multipart)->set_boundary (multipart, boundary);
}
-
static const gchar *
get_boundary (CamelMultipart *multipart)
{
return 0;
}
-
/**
* camel_multipart_construct_from_parser:
* @multipart: a #CamelMultipart object
* USA
*/
-
#ifndef CAMEL_MULTIPART_H
#define CAMEL_MULTIPART_H 1
/* Standard Camel function */
CamelType camel_multipart_get_type (void);
-
/* public methods */
CamelMultipart * camel_multipart_new (void);
void camel_multipart_add_part (CamelMultipart *multipart,
} \
} G_STMT_END
-
#ifdef ENABLE_IPv6
/* some helpful utils for IPv6 lookups */
#define IPv6_BUFLEN_MIN (sizeof (gchar *) * 3)
#include "camel-news-address.h"
-
static void camel_news_address_class_init (CamelNewsAddressClass *klass);
static CamelAddressClass *camel_news_address_parent;
camel_news_address_parent = CAMEL_ADDRESS_CLASS (camel_type_get_global_classfuncs (camel_address_get_type ()));
}
-
CamelType
camel_news_address_get_type (void)
{
#define camel_object_unget_hooks(o) \
(g_static_rec_mutex_unlock(&CAMEL_OBJECT(o)->hooks->lock))
-
/* ********************************************************************** */
/* type-lock must be recursive, for atomically creating classes */
return res;
}
-
static void
cobject_class_init(CamelObjectClass *klass)
{
g_free(klass);
}
-
/* CamelInterface base methods */
G_GNUC_NORETURN static void
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
{ CAMEL_OFFLINE_FOLDER_SYNC_OFFLINE, "sync_offline", N_("Copy folder content locally for offline operation") },
};
-
CamelType
camel_offline_folder_get_type (void)
{
return type;
}
-
static void
camel_offline_folder_class_init (CamelOfflineFolderClass *klass)
{
klass->downsync = offline_folder_downsync;
}
-
struct _offline_downsync_msg {
CamelSessionThreadMsg msg;
camel_operation_end (NULL);
}
-
/**
* camel_offline_folder_downsync:
* @offline: a #CamelOfflineFolder object
*
*/
-
#ifndef __CAMEL_OFFLINE_FOLDER_H__
#define __CAMEL_OFFLINE_FOLDER_H__
void (* downsync) (CamelOfflineFolder *folder, const gchar *expression, CamelException *ex);
};
-
CamelType camel_offline_folder_get_type (void);
void camel_offline_folder_downsync (CamelOfflineFolder *offline, const gchar *expression, CamelException *ex);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static void camel_offline_journal_init (CamelOfflineJournal *journal, CamelOfflineJournalClass *klass);
static void camel_offline_journal_finalize (CamelObject *object);
-
static CamelObjectClass *parent_class = NULL;
-
CamelType
camel_offline_journal_get_type (void)
{
}
}
-
/**
* camel_offline_journal_set_filename:
* @journal: a #CamelOfflineJournal object
journal->filename = g_strdup (filename);
}
-
/**
* camel_offline_journal_write:
* @journal: a #CamelOfflineJournal object
return -1;
}
-
/**
* camel_offline_journal_replay:
* @journal: a #CamelOfflineJournal object
*
*/
-
#ifndef __CAMEL_OFFLINE_JOURNAL_H__
#define __CAMEL_OFFLINE_JOURNAL_H__
gint (* entry_play) (CamelOfflineJournal *journal, CamelDListNode *entry, CamelException *ex);
};
-
CamelType camel_offline_journal_get_type (void);
void camel_offline_journal_construct (CamelOfflineJournal *journal, struct _CamelFolder *folder, const gchar *filename);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "camel-offline-store.h"
#include "camel-session.h"
-
static void camel_offline_store_class_init (CamelOfflineStoreClass *klass);
static void camel_offline_store_init (CamelOfflineStore *store, CamelOfflineStoreClass *klass);
static void camel_offline_store_finalize (CamelObject *object);
CamelProvider *provider, CamelURL *url,
CamelException *ex);
-
static CamelStoreClass *parent_class = NULL;
-
CamelType
camel_offline_store_get_type (void)
{
return type;
}
-
static void
camel_offline_store_class_init (CamelOfflineStoreClass *klass)
{
;
}
-
static void
offline_store_construct (CamelService *service, CamelSession *session,
CamelProvider *provider, CamelURL *url,
*
*/
-
#ifndef __CAMEL_OFFLINE_STORE_H__
#define __CAMEL_OFFLINE_STORE_H__
void (* set_network_state) (CamelOfflineStore *store, gint state, CamelException *ex);
};
-
CamelType camel_offline_store_get_type (void);
-
void camel_offline_store_set_network_state (CamelOfflineStore *store, gint state, CamelException *ex);
gint camel_offline_store_get_network_state (CamelOfflineStore *store, CamelException *ex);
#define LOCK() pthread_mutex_lock(&operation_lock)
#define UNLOCK() pthread_mutex_unlock(&operation_lock)
-
static guint stamp (void);
static CamelDList operation_list = CAMEL_DLIST_INITIALISER(operation_list);
static pthread_key_t operation_key;
* Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/* key index debug */
#define k(x) /*(printf("%s(%d):%s: ", __FILE__, __LINE__, __PRETTY_FUNCTION__),(x))*/
-
struct _CamelPartitionTablePrivate {
pthread_mutex_t lock; /* for locking partition */
};
#define CAMEL_PARTITION_TABLE_LOCK(kf, lock) (pthread_mutex_lock(&(kf)->priv->lock))
#define CAMEL_PARTITION_TABLE_UNLOCK(kf, lock) (pthread_mutex_unlock(&(kf)->priv->lock))
-
static void
camel_partition_table_class_init(CamelPartitionTableClass *klass)
{
/* ********************************************************************** */
-
struct _CamelKeyTablePrivate {
pthread_mutex_t lock; /* for locking key */
};
#define CAMEL_KEY_TABLE_LOCK(kf, lock) (pthread_mutex_lock(&(kf)->priv->lock))
#define CAMEL_KEY_TABLE_UNLOCK(kf, lock) (pthread_mutex_unlock(&(kf)->priv->lock))
-
static void
camel_key_table_class_init(CamelKeyTableClass *klass)
{
return type;
}
-
CamelKeyTable *
camel_key_table_new(CamelBlockFile *bs, camel_block_t root)
{
}
#endif
-
camel_block_file_touch_block(ki->blocks, last);
camel_block_file_unref_block(ki->blocks, last);
#define CAMEL_FOLDER_REC_UNLOCK(f, l) \
(g_static_rec_mutex_unlock(&((CamelFolder *) (f))->priv->l))
-
struct _CamelStorePrivate {
GStaticRecMutex folder_lock; /* for locking folder operations */
};
#define CAMEL_STORE_UNLOCK(f, l) \
(g_static_rec_mutex_unlock(&((CamelStore *) (f))->priv->l))
-
struct _CamelTransportPrivate {
GMutex *send_lock; /* for locking send operations */
};
#define CAMEL_TRANSPORT_UNLOCK(f, l) \
(g_mutex_unlock(((CamelTransport *) (f))->priv->l))
-
struct _CamelServicePrivate {
GStaticRecMutex connect_lock; /* for locking connection operations */
GStaticMutex connect_op_lock; /* for locking the connection_op */
#define CAMEL_SERVICE_REC_TRYLOCK(f, l) \
(g_static_rec_mutex_trylock(&((CamelService *) (f))->priv->l))
-
struct _CamelSessionPrivate {
GMutex *lock; /* for locking everything basically */
GMutex *thread_lock; /* locking threads */
#define CAMEL_SESSION_UNLOCK(f, l) \
(g_mutex_unlock(((CamelSession *) (f))->priv->l))
-
/* most of this stuff really is private, but the lock can be used by subordinate classes */
struct _CamelFolderSummaryPrivate {
GHashTable *filter_charset; /* CamelMimeFilterCharset's indexed by source charset */
#define CAMEL_SUMMARY_UNLOCK(f, l) \
(g_mutex_unlock(((CamelFolderSummary *) (f))->priv->l))
-
struct _CamelStoreSummaryPrivate {
GMutex *summary_lock; /* for the summary hashtable/array */
GMutex *io_lock; /* load/save lock, for access to saved_count, etc */
#define CAMEL_STORE_SUMMARY_UNLOCK(f, l) \
(g_mutex_unlock(((CamelStoreSummary *) (f))->priv->l))
-
struct _CamelVeeFolderPrivate {
gboolean destroyed;
GList *folders; /* lock using subfolder_lock before changing/accessing */
#define CAMEL_VEE_FOLDER_UNLOCK(f, l) \
(g_mutex_unlock(((CamelVeeFolder *) (f))->priv->l))
-
struct _CamelDataWrapperPrivate {
pthread_mutex_t stream_lock;
};
#define CAMEL_DATA_WRAPPER_UNLOCK(dw, l) \
(pthread_mutex_unlock(&((CamelDataWrapper *) (dw))->priv->l))
-
/* most of this stuff really is private, but the lock can be used by subordinate classes */
struct _CamelCertDBPrivate {
GMutex *db_lock; /* for the db hashtable/array */
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "camel-process.h"
-
pid_t
camel_process_fork (const gchar *path, gchar **argv, gint *infd, gint *outfd, gint *errfd, CamelException *ex)
{
return pid;
}
-
gint
camel_process_wait (pid_t pid)
{
{
GList *list = NULL;
-
/* provider_table can be NULL, so initialize it */
if (G_UNLIKELY (provider_table == NULL))
camel_provider_init ();
return provider;
}
-
/**
* camel_provider_auto_detect:
* @provider: camel provider
* USA
*/
-
#ifndef CAMEL_PROVIDER_H
#define CAMEL_PROVIDER_H 1
#define CAMEL_PROVIDER_HAS_LICENSE (1 << 6)
#define CAMEL_PROVIDER_DISABLE_SENT_FOLDER (1 << 7)
-
/* Flags for url_flags. "ALLOW" means the config dialog will let the
* user configure it. "NEED" implies "ALLOW" but means the user must
* configure it. Service code can assume that any url part for which
#define CAMEL_URL_FRAGMENT_IS_PATH (1 << 30) /* url uses fragment for folder name path, not path */
#define CAMEL_URL_PATH_IS_ABSOLUTE (1 << 31)
-
#define CAMEL_PROVIDER_IS_STORE_AND_TRANSPORT(prov) (prov->object_types[CAMEL_PROVIDER_STORE] && prov->object_types[CAMEL_PROVIDER_TRANSPORT])
/* Generic extra config stuff */
/* This is defined by each module, not by camel-provider.c. */
void camel_provider_module_init(void);
-
gint camel_provider_auto_detect (CamelProvider *provider, CamelURL *url,
GHashTable **auto_detected, CamelException *ex);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
g_free (sasl->trace_info);
}
-
CamelType
camel_sasl_anonymous_get_type (void)
{
return type;
}
-
/**
* camel_sasl_anonymous_new:
* @type: trace type
CamelSaslAnonTraceType type;
} CamelSaslAnonymous;
-
typedef struct _CamelSaslAnonymousClass {
CamelSaslClass parent_class;
} CamelSaslAnonymousClass;
-
/* Standard Camel function */
CamelType camel_sasl_anonymous_get_type (void);
} CamelSaslCramMd5;
-
typedef struct _CamelSaslCramMd5Class {
CamelSaslClass parent_class;
} CamelSaslCramMd5Class;
-
/* Standard Camel function */
CamelType camel_sasl_cram_md5_get_type (void);
g_free (sasl->priv);
}
-
CamelType
camel_sasl_digest_md5_get_type (void)
{
} CamelSaslDigestMd5;
-
typedef struct _CamelSaslDigestMd5Class {
CamelSaslClass parent_class;
} CamelSaslDigestMd5Class;
-
/* Standard Camel function */
CamelType camel_sasl_digest_md5_get_type (void);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
gss_name_t target;
};
-
static GByteArray *gssapi_challenge (CamelSasl *sasl, GByteArray *token, CamelException *ex);
-
static CamelSaslClass *parent_class = NULL;
-
static void
camel_sasl_gssapi_class_init (CamelSaslGssapiClass *klass)
{
g_free (gssapi->priv);
}
-
CamelType
camel_sasl_gssapi_get_type (void)
{
*
*/
-
#ifndef __CAMEL_SASL_GSSAPI_H__
#define __CAMEL_SASL_GSSAPI_H__
}
}
-
CamelType
camel_sasl_kerberos4_get_type (void)
{
} CamelSaslKerberos4;
-
typedef struct _CamelSaslKerberos4Class {
CamelSaslClass parent_class;
} CamelSaslKerberos4Class;
-
/* Standard Camel function */
CamelType camel_sasl_kerberos4_get_type (void);
g_free (sasl->priv);
}
-
CamelType
camel_sasl_login_get_type (void)
{
} CamelSaslLogin;
-
typedef struct _CamelSaslLoginClass {
CamelSaslClass parent_class;
} CamelSaslLoginClass;
-
/* Standard Camel function */
CamelType camel_sasl_login_get_type (void);
static void setup_schedule (const guchar *key_56, DES_KS ks);
-
-
#define LM_PASSWORD_MAGIC "\x4B\x47\x53\x21\x40\x23\x24\x25" \
"\x4B\x47\x53\x21\x40\x23\x24\x25" \
"\x00\x00\x00\x00\x00"
des (ks, results + 16);
}
-
/*
* MD4 encoder. (The one everyone else uses is not GPL-compatible;
* this is a reimplementation from spec.) This doesn't need to be
digest[15] = (D >> 24) & 0xFF;
}
-
/* Public domain DES implementation from Phil Karn */
static guint32 Spbox[8][64] = {
{ 0x01010400, 0x00000000, 0x00010000, 0x01010404,
/* End of DES-defined tables */
-
/* bit 0 is left-most in byte */
static gint bytebit[] = {
0200,0100,040,020,010,04,02,01
};
-
/* Generate key schedule for encryption or decryption
* depending on the value of "decrypt"
*/
} CamelSaslNTLM;
-
typedef struct _CamelSaslNTLMClass {
CamelSaslClass parent_class;
} CamelSaslNTLMClass;
-
/* Standard Camel function */
CamelType camel_sasl_ntlm_get_type (void);
} CamelSaslPlain;
-
typedef struct _CamelSaslPlainClass {
CamelSaslClass parent_class;
} CamelSaslPlainClass;
-
/* Standard Camel function */
CamelType camel_sasl_plain_get_type (void);
} CamelSaslPOPB4SMTP;
-
typedef struct _CamelSaslPOPB4SMTPClass {
CamelSaslClass parent_class;
} CamelSaslPOPB4SMTPClass;
-
/* Standard Camel function */
CamelType camel_sasl_popb4smtp_get_type (void);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "camel-sasl.h"
#include "camel-service.h"
-
#define w(x)
static CamelObjectClass *parent_class = NULL;
return type;
}
-
static GByteArray *
sasl_challenge (CamelSasl *sasl, GByteArray *token, CamelException *ex)
{
return sasl->authenticated;
}
-
/**
* camel_sasl_new:
* @service_name: the SASL service name
gboolean authenticated;
} CamelSasl;
-
typedef struct _CamelSaslClass {
CamelObjectClass parent_class;
} CamelSaslClass;
-
/* Standard Camel function */
CamelType camel_sasl_get_type (void);
}
-
static ESExpResult *
match_threads(struct _ESExp *f, gint argc, struct _ESExpTerm **argv, gpointer data)
{
return check_header(f, argc, argv, data, CAMEL_SEARCH_MATCH_ENDS);
}
-
static ESExpResult *
header_exists (struct _ESExp *f, gint argc, struct _ESExpResult **argv, gpointer data)
{
return r;
}
-
static ESExpResult *
user_flag(struct _ESExp *f, gint argc, struct _ESExpResult **argv, gpointer data)
{
/* { "uid", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, uid), 1 }, */
};
-
gchar *
camel_sexp_to_sql_sexp (const gchar *sql)
{
#ifdef TEST_MAIN
/*
-
(and (match-all (and (not (system-flag "deleted")) (not (system-flag "junk"))))
(and (or
}
#endif
-
gint len = 2;
Node *pnode;
-
n1=NULL; n2=NULL; n3=NULL;
tmp = operands;
n1 = operands->data;
else
dyn_lvl = n3->level;
-
if (n3->prefix && g_ascii_strcasecmp (opnode->token, "=") == 0) {
/* see if '=' was a last operator. if so take care of it */
free_node(opnode);
dyn_lvl = opnode->level;
}
-
}
if (n3->prefix && ((g_ascii_strcasecmp (opnode->token, ">") == 0) || (g_ascii_strcasecmp (opnode->token, ">") == 0) )) {
/* see if '=' was a last operator. if so take care of it */
n3->ignore_lhs = 0;
}
-
}
/* Handle if 'not' was a last sysnode, if so take care of it */
}
}
-
}
tmp = operands;
d(g_node_dump (all));
d(printf("\n\n\n"));
-
res=NULL;
tmp = all;
op=NULL; n1=NULL;
#ifdef TEST_MAIN
/*
-
(and (match-all (and (not (system-flag "deleted")) (not (system-flag "junk"))))
(and (or
return camel_seekable_stream_type;
}
-
static off_t
seek (CamelSeekableStream *stream, off_t offset,
CamelStreamSeekPolicy policy)
return CSS_CLASS (stream)->seek (stream, offset, policy);
}
-
static off_t
stream_tell (CamelSeekableStream *stream)
{
CAMEL_STREAM_SET);
}
-
-
-
-
-
* USA
*/
-
#ifndef CAMEL_SEEKABLE_STREAM_H
#define CAMEL_SEEKABLE_STREAM_H 1
camel_object_unref (seekable_substream->parent_stream);
}
-
CamelType
camel_seekable_substream_get_type (void)
{
* USA
*/
-
#ifndef CAMEL_SEEKABLE_SUBSTREAM_H
#define CAMEL_SEEKABLE_SUBSTREAM_H 1
* USA
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static gint service_setv (CamelObject *object, CamelException *ex, CamelArgV *args);
static gint service_getv (CamelObject *object, CamelException *ex, CamelArgGetV *args);
-
static void
camel_service_class_init (CamelServiceClass *camel_service_class)
{
g_free (service->priv);
}
-
-
CamelType
camel_service_get_type (void)
{
return type;
}
-
static gint
service_setv (CamelObject *object, CamelException *ex, CamelArgV *args)
{
CSERV_CLASS (service)->construct (service, session, provider, url, ex);
}
-
static gboolean
service_connect (CamelService *service, CamelException *ex)
{
return TRUE;
}
-
/**
* camel_service_connect:
* @service: a #CamelService object
return TRUE;
}
-
/**
* camel_service_disconnect:
* @service: a #CamelService object
return camel_url_to_string (service->url, CAMEL_URL_HIDE_PASSWORD);
}
-
static gchar *
get_name (CamelService *service, gboolean brief)
{
return g_strdup ("???");
}
-
/**
* camel_service_get_name:
* @service: a #CamelService object
return CSERV_CLASS (service)->get_name (service, brief);
}
-
static gchar *
get_path (CamelService *service)
{
return CSERV_CLASS (service)->get_path (service);
}
-
/**
* camel_service_get_session:
* @service: a #CamelService object
return service->session;
}
-
/**
* camel_service_get_provider:
* @service: a #CamelService object
return NULL;
}
-
/**
* camel_service_query_auth_types:
* @service: a #CamelService object
return svc;
}
-
static gchar *
get_storage_path (CamelSession *session, CamelService *service, CamelException *ex)
{
return CS_CLASS (session)->get_storage_path (session, service, ex);
}
-
/**
* camel_session_get_password:
* @session: a #CamelSession object
return CS_CLASS (session)->get_password (session, service, domain, prompt, item, flags, ex);
}
-
/**
* camel_session_forget_password:
* @session: a #CamelSession object
CS_CLASS (session)->forget_password (session, service, domain, item, ex);
}
-
/**
* camel_session_alert_user:
* @session: a #CamelSession object
return session->online;
}
-
/**
* camel_session_set_online:
* @session: a #CamelSession object
* USA
*/
-
#ifndef CAMEL_SESSION_H
#define CAMEL_SESSION_H 1
CamelException *ex);
} CamelSessionClass;
-
/* public methods */
/* Standard Camel function */
CamelType camel_session_get_type (void);
-
void camel_session_construct (CamelSession *session,
const gchar *storage_path);
return type;
}
-
/**
* camel_store_summary_new:
*
CamelStoreSummary *new = CAMEL_STORE_SUMMARY ( camel_object_new (camel_store_summary_get_type ())); return new;
}
-
/**
* camel_store_summary_set_filename:
* @summary: a #CamelStoreSummary
CAMEL_STORE_SUMMARY_UNLOCK(s, summary_lock);
}
-
/**
* camel_store_summary_set_uri_base:
* @summary: a #CamelStoreSummary object
CAMEL_STORE_SUMMARY_UNLOCK(s, summary_lock);
}
-
/**
* camel_store_summary_count:
* @summary: a #CamelStoreSummary object
return s->folders->len;
}
-
/**
* camel_store_summary_index:
* @summary: a #CamelStoreSummary object
return info;
}
-
/**
* camel_store_summary_array:
* @summary: a #CamelStoreSummary object
return res;
}
-
/**
* camel_store_summary_array_free:
* @summary: a #CamelStoreSummary object
g_ptr_array_free(array, TRUE);
}
-
/**
* camel_store_summary_path:
* @summary: a #CamelStoreSummary object
return -1;
}
-
/**
* camel_store_summary_save:
* @summary: a #CamelStoreSummary object
return 0;
}
-
/**
* camel_store_summary_header_load:
* @summary: a #CamelStoreSummary object
return ret;
}
-
/**
* camel_store_summary_add:
* @summary: a #CamelStoreSummary object
CAMEL_STORE_SUMMARY_UNLOCK(s, summary_lock);
}
-
/**
* camel_store_summary_add_from_path:
* @summary: a #CamelStoreSummary object
return info;
}
-
/**
* camel_store_summary_info_new_from_path:
* @summary: a #CamelStoreSummary object
return ((CamelStoreSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->store_info_new(s, path);
}
-
/**
* camel_store_summary_info_free:
* @summary: a #CamelStoreSummary object
((CamelStoreSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->store_info_free(s, info);
}
-
/**
* camel_store_summary_info_ref:
* @summary: a #CamelStoreSummary object
CAMEL_STORE_SUMMARY_UNLOCK(s, ref_lock);
}
-
/**
* camel_store_summary_touch:
* @summary: a #CamelStoreSummary object
CAMEL_STORE_SUMMARY_UNLOCK(s, summary_lock);
}
-
/**
* camel_store_summary_clear:
* @summary: a #CamelStoreSummary object
CAMEL_STORE_SUMMARY_UNLOCK(s, summary_lock);
}
-
/**
* camel_store_summary_remove:
* @summary: a #CamelStoreSummary object
camel_store_summary_info_free(s, info);
}
-
/**
* camel_store_summary_remove_path:
* @summary: a #CamelStoreSummary object
}
}
-
/**
* camel_store_summary_remove_index:
* @summary: a #CamelStoreSummary object
return camel_file_util_encode_fixed_int32(out, camel_store_summary_count(s));
}
-
/**
* camel_store_summary_info_new:
* @summary: a #CamelStoreSummary object
return info;
}
-
/**
* camel_store_info_string:
* @summary: a #CamelStoreSummary object
return ((CamelStoreSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->store_info_string(s, info, type);
}
-
/**
* camel_store_info_set_string:
* @summary: a #CamelStoreSummary object
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_STORE_SUMMARY_H
#define _CAMEL_STORE_SUMMARY_H
g_free (store->priv);
}
-
CamelType
camel_store_get_type (void)
{
g_free(old_name);
}
-
static CamelFolder *
get_inbox (CamelStore *store, CamelException *ex)
{
return info;
}
-
/**
* camel_folder_info_clone:
* @fi: a #CamelFolderInfo
return folder_info_clone_rec(fi, NULL);
}
-
/**
* camel_store_supports_subscriptions:
* @store: a #CamelStore object
camel_type_to_name (CAMEL_OBJECT_GET_TYPE (store))));
}
-
/**
* camel_store_unsubscribe_folder:
* @store: a #CamelStore object
CS_CLASS (store)->noop (store, ex);
}
-
/**
* camel_store_folder_uri_equal:
* @store: a #CamelStore object
g_free(sbf->linebuf);
}
-
CamelType
camel_stream_buffer_get_type (void)
{
return camel_stream_buffer_type;
}
-
static void
set_vbuf(CamelStreamBuffer *sbf, gchar *buf, CamelStreamBufferMode mode, gint size)
{
init_vbuf(sbuf, s, mode, NULL, BUF_SIZE);
}
-
/**
* camel_stream_buffer_new:
* @stream: a #CamelStream object to buffer
* USA
*/
-
#ifndef CAMEL_STREAM_BUFFER_H
#define CAMEL_STREAM_BUFFER_H 1
guint flags; /* internal flags */
};
-
typedef struct {
CamelStreamClass parent_class;
} CamelStreamBufferClass;
-
/* Standard Camel function */
CamelType camel_stream_buffer_get_type (void);
-
/* public methods */
CamelStream *camel_stream_buffer_new (CamelStream *stream,
CamelStreamBufferMode mode);
* Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_STREAM_FILTER_H
#define _CAMEL_STREAM_FILTER_H
close (stream_fs->fd);
}
-
CamelType
camel_stream_fs_get_type (void)
{
return stream;
}
-
static gssize
stream_read (CamelStream *stream, gchar *buffer, gsize n)
{
* USA
*/
-
#ifndef CAMEL_STREAM_FS_H
#define CAMEL_STREAM_FS_H 1
return camel_stream_mem_type;
}
-
/**
* camel_stream_mem_new:
*
return camel_stream_mem_new_with_byte_array (g_byte_array_new ());
}
-
/**
* camel_stream_mem_new_with_buffer:
* @buffer: a memory buffer to use as the stream data
return camel_stream_mem_new_with_byte_array (ba);
}
-
/**
* camel_stream_mem_new_with_byte_array:
* @buffer: a #GByteArray to use as the stream data
return CAMEL_STREAM (stream_mem);
}
-
/**
* camel_stream_mem_set_secure:
* @mem: a #CamelStreamMem object
/* setup a mem-locked buffer etc? blah blah, well not yet anyway */
}
-
/* note: with these functions the caller is the 'owner' of the buffer */
/**
mem->buffer = buffer;
}
-
/**
* camel_stream_mem_set_buffer:
* @mem: a #CamelStreamMem object
mem->owner = TRUE;
}
-
static void
camel_stream_mem_finalize (CamelObject *object)
{
* USA
*/
-
#ifndef CAMEL_STREAM_MEM_H
#define CAMEL_STREAM_MEM_H 1
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_STREAM_NULL_H
#define _CAMEL_STREAM_NULL_H
stream->childpid = 0;
}
-
CamelType
camel_stream_process_get_type (void)
{
return (CamelStream *) camel_object_new (camel_stream_process_get_type ());
}
-
static gssize
stream_read (CamelStream *stream, gchar *buffer, gsize n)
{
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_STREAM_NULL_H
#define _CAMEL_STREAM_NULL_H
g_object_unref (stream_vfs->stream);
}
-
CamelType
camel_stream_vfs_get_type (void)
{
* USA
*/
-
#ifndef CAMEL_STREAM_VFS_H
#define CAMEL_STREAM_VFS_H 1
* USA
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return camel_stream_type;
}
-
/**
* camel_stream_read:
* @stream: a #CamelStream object.
return (CS_CLASS (stream)->read) (stream, buffer, n);
}
-
/**
* camel_stream_write:
* @stream: a #CamelStream object
return CS_CLASS (stream)->write (stream, buffer, n);
}
-
/**
* camel_stream_flush:
* @stream: a #CamelStream object
return CS_CLASS (stream)->flush (stream);
}
-
/**
* camel_stream_close:
* @stream: a #CamelStream object
return CS_CLASS (stream)->close (stream);
}
-
/**
* camel_stream_eos:
* @stream: a #CamelStream object
return CS_CLASS (stream)->eos (stream);
}
-
/**
* camel_stream_reset:
* @stream: a #CamelStream object
return camel_stream_write (stream, string, strlen (string));
}
-
/**
* camel_stream_printf:
* @stream: a #CamelStream object
return ret;
}
-
/**
* camel_stream_write_to_stream:
* @stream: source #CamelStream object
* USA
*/
-
#ifndef CAMEL_STREAM_H
#define CAMEL_STREAM_H 1
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return h;
}
-
static void
free_string (gpointer string, gpointer user_data)
{
return NULL;
}
-
const gchar *
camel_strdown (gchar *str)
{
return camel_pstring_add ((gchar *) s, FALSE);
}
-
/**
* camel_pstring_free:
* @s: String to free.
*
*/
-
#ifndef __CAMEL_STRING_UTILS_H__
#define __CAMEL_STRING_UTILS_H__
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
g_free (stream->priv);
}
-
CamelType
camel_tcp_stream_ssl_get_type (void)
{
return type;
}
-
/**
* camel_tcp_stream_ssl_new:
* @service: camel service
return CAMEL_STREAM (stream);
}
-
/**
* camel_tcp_stream_ssl_new_raw:
* @service: camel service
return CAMEL_STREAM (stream);
}
-
static gint
ssl_errno (SSL *ssl, gint ret)
{
}
}
-
/**
* camel_tcp_stream_ssl_enable_ssl:
* @stream: ssl stream
return 0;
}
-
static gssize
stream_read (CamelStream *stream, gchar *buffer, gsize n)
{
return 0;
}
-
static void
close_ssl_connection (SSL *ssl)
{
return 0;
}
-
static gint
get_sockopt_level (const CamelSockOptData *data)
{
SOCKET_CLOSE (stream->sockfd);
}
-
CamelType
camel_tcp_stream_raw_get_type (void)
{
#endif /* SIMULATE_FLAKY_NETWORK */
-
-
/**
* camel_tcp_stream_raw_new:
*
*
*/
-
#ifndef CAMEL_TCP_STREAM_RAW_H
#define CAMEL_TCP_STREAM_RAW_H
g_free (stream->priv);
}
-
CamelType
camel_tcp_stream_ssl_get_type (void)
{
return type;
}
-
/**
* camel_tcp_stream_ssl_new:
* @session: an active #CamelSession object
return CAMEL_STREAM (stream);
}
-
/**
* camel_tcp_stream_ssl_new_raw:
* @session: an active #CamelSession object
return CAMEL_STREAM (stream);
}
-
static void
set_errno (gint code)
{
}
}
-
/**
* camel_tcp_stream_ssl_enable_ssl:
* @ssl: a #CamelTcpStreamSSL object
return 0;
}
-
static gssize
stream_read (CamelStream *stream, gchar *buffer, gsize n)
{
g_free (path);
}
-
#if 0
/* used by the mozilla-like code below */
static gchar *
*
*/
-
#ifndef CAMEL_TCP_STREAM_SSL_H
#define CAMEL_TCP_STREAM_SSL_H
return type;
}
-
static gint
tcp_connect (CamelTcpStream *stream, struct addrinfo *host)
{
*
*/
-
#ifndef CAMEL_TCP_STREAM_H
#define CAMEL_TCP_STREAM_H
#include "camel-private.h"
#include "camel-text-index.h"
-
#define w(x)
#define io(x)
#define d(x) /*(printf("%s(%d):%s: ", __FILE__, __LINE__, __PRETTY_FUNCTION__),(x))*/
while ((len = read(fd, buf, 1024)) == 1024) {
id = total;
-
-
type = g_hash_table_lookup(map, id);
switch(type) {
case 0:
} break;
}
-
printf("--raw--\n");
len = 1024;
idx = (CamelIndex *)camel_text_index_new("textindex", O_CREAT|O_RDWR|O_TRUNC);
-
#if 1
camel_index_compress(idx);
static gint transport_setv (CamelObject *object, CamelException *ex, CamelArgV *args);
static gint transport_getv (CamelObject *object, CamelException *ex, CamelArgGetV *args);
-
static void
camel_transport_class_init (CamelTransportClass *camel_transport_class)
{
return type;
}
-
static gint
transport_setv (CamelObject *object, CamelException *ex, CamelArgV *args)
{
return CAMEL_OBJECT_CLASS (parent_class)->getv (object, ex, args);
}
-
/**
* camel_transport_send_to:
* @transport: a #CamelTransport object
* USA
*/
-
#ifndef CAMEL_TRANSPORT_H
#define CAMEL_TRANSPORT_H 1
struct _CamelTransportPrivate *priv;
};
-
-
typedef struct {
CamelServiceClass parent_class;
CamelException *ex);
} CamelTransportClass;
-
/* public methods */
gboolean camel_transport_send_to (CamelTransport *transport,
CamelMimeMessage *message,
EMemChunk *state_chunks;
};
-
static inline gunichar
trie_utf8_getc (const guchar **in, gsize inlen)
{
g_free (trie);
}
-
-
static struct _trie_match *
g (struct _trie_state *s, gunichar c)
{
return q;
}
-
#if d(!)0
static void
dump_trie (struct _trie_state *s, gint depth)
}
#endif
-
/*
* final = empty set
* FOR p = 1 TO #pat
gboolean save;
};
-
/**
* camel_uid_cache_new:
* @filename: path to load the cache from
return cache;
}
-
static void
maybe_write_uid (gpointer key, gpointer value, gpointer data)
{
}
}
-
/**
* camel_uid_cache_save:
* @cache: a CamelUIDCache
return FALSE;
}
-
static void
free_uid (gpointer key, gpointer value, gpointer data)
{
g_free (value);
}
-
/**
* camel_uid_cache_destroy:
* @cache: a CamelUIDCache
g_free (cache);
}
-
/**
* camel_uid_cache_get_new_uids:
* @cache: a CamelUIDCache
return new_uids;
}
-
/**
* camel_uid_cache_save_uid:
* @cache: a CamelUIDCache
}
}
-
/**
* camel_uid_cache_free_uids:
* @uids: an array returned from camel_uid_cache_get_new_uids()
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
CamelTrie *trie;
};
-
CamelUrlScanner *
camel_url_scanner_new (void)
{
return scanner;
}
-
void
camel_url_scanner_free (CamelUrlScanner *scanner)
{
g_free (scanner);
}
-
void
camel_url_scanner_add (CamelUrlScanner *scanner, urlpattern_t *pattern)
{
g_ptr_array_add (scanner->patterns, pattern);
}
-
gboolean
camel_url_scanner_scan (CamelUrlScanner *scanner, const gchar *in, gsize inlen, urlmatch_t *match)
{
return FALSE;
}
-
static guchar url_scanner_table[256] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 1, 1, 9, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
#define is_domain(x) ((url_scanner_table[(guchar)(x)] & IS_DOMAIN) != 0)
#define is_urlsafe(x) ((url_scanner_table[(guchar)(x)] & (IS_ALPHA|IS_DIGIT|IS_URLSAFE)) != 0)
-
static const struct {
const gchar open;
const gchar close;
return '\0';
}
-
gboolean
camel_url_addrspec_start (const gchar *in, const gchar *pos, const gchar *inend, urlmatch_t *match)
{
while (inptr > pos && strchr (",.:;?!-|}])\"", inptr[-1]))
inptr--;
-
match->um_eo = (inptr - in);
return TRUE;
}
-
-
#ifdef BUILD_TABLE
#include <stdio.h>
/* got these from rfc1738 */
#define CHARS_URLSAFE "$-_.+!*'(),{}|\\^~[]`#%\";/?:@&="
-
static void
table_init_bits (guint mask, const guchar *vals)
{
*
*/
-
#ifndef __CAMEL_URL_SCANNER_H__
#define __CAMEL_URL_SCANNER_H__
}
}
-
#define DEFINE_CAMEL_URL_SET(part) \
void \
camel_url_set_##part (CamelURL *url, const gchar *part) \
url->part = g_strdup (part); \
}
-
/**
* camel_url_set_protocol:
* @url: a #CamelURL
**/
DEFINE_CAMEL_URL_SET (protocol)
-
/**
* camel_url_set_user:
* @url: a #CamelURL
**/
DEFINE_CAMEL_URL_SET (user)
-
/**
* camel_url_set_authmech:
* @url: a #CamelURL
**/
DEFINE_CAMEL_URL_SET (authmech)
-
/**
* camel_url_set_passwd:
* @url: a #CamelURL
**/
DEFINE_CAMEL_URL_SET (passwd)
-
/**
* camel_url_set_host:
* @url: a #CamelURL
**/
DEFINE_CAMEL_URL_SET (host)
-
/**
* camel_url_set_path:
* @url: a #CamelURL
**/
DEFINE_CAMEL_URL_SET (path)
-
/**
* camel_url_set_query:
* @url: a #CamelURL
**/
DEFINE_CAMEL_URL_SET (query)
-
/**
* camel_url_set_fragment:
* @url: a #CamelURL
**/
DEFINE_CAMEL_URL_SET (fragment)
-
/**
* camel_url_set_port:
* @url: a #CamelURL
url->port = port;
}
-
/**
* camel_url_set_param:
* @url: a #CamelURL
g_datalist_remove_data(&url->params, name);
}
-
/**
* camel_url_get_param:
* @url: a #CamelURL
} while (*s++);
}
-
guint
camel_url_hash (gconstpointer v)
{
&& u1->port == u2->port;
}
-
/**
* camel_url_copy:
* @in: a #CamelURL to copy
* USA
*/
-
#ifndef CAMEL_URL_H
#define CAMEL_URL_H 1
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return;
}
-
camel_object_unhook_event((CamelObject *)sub, "folder_changed", (CamelObjectEventHookFunc) folder_changed, vf);
camel_object_unhook_event((CamelObject *)sub, "deleted", (CamelObjectEventHookFunc) subfolder_deleted, vf);
camel_object_unhook_event((CamelObject *)sub, "renamed", (CamelObjectEventHookFunc) folder_renamed, vf);
-
p->folders = g_list_remove(p->folders, sub);
/* undo the freeze state that we have imposed on this source folder */
} else
camel_exception_clear (ex);
-
/* auto update vfolders shouldn't need a rebuild */
/* if ((vf->flags & CAMEL_STORE_VEE_FOLDER_AUTO) == 0 */
/* && camel_vee_folder_rebuild_folder(vf, f, ex) == -1) */
node = g_list_next(node);
}
-
g_free(expr);
g_hash_table_destroy(searched);
node = g_list_next(node);
}
-
g_free(expr);
g_hash_table_destroy(searched);
}
}
-
/* build query contents for a single folder */
static gint
vee_rebuild_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex)
return 0;
}
-
/* Hold all these with summary lock and unmatched summary lock held */
static void
folder_changed_add_uid(CamelFolder *sub, const gchar *uid, const gchar hash[8], CamelVeeFolder *vf, gboolean use_db)
camel_vee_folder_hash_folder(sub, hash);
-
/* Lookup anything before we lock anything, to avoid deadlock with build_folder */
/* Find newly added that match */
if (matches_changed || matches_added || changes->uid_removed->len||present)
camel_db_begin_transaction (folder->parent_store->cdb_w, NULL);
-
dd(printf("Vfolder '%s' subfolder changed '%s'\n", folder->full_name, sub->full_name));
dd(printf(" changed %u added %u removed %u\n", changes->uid_changed->len, changes->uid_added->len, changes->uid_removed->len));
s->junk_not_deleted_count = 0;
}
-
g_free(vf->expression);
if (query)
vf->expression = g_strdup(query);
guint32 tag;
gint unread = -1, deleted = 0, junked = 0, visible = 0, count = -1, junked_not_deleted = -1;
-
for (i=0;i<args->argc;i++) {
CamelArgGet *arg = &args->argv[i];
camel_object_hook_event((CamelObject *)sub, "folder_changed", (CamelObjectEventHookFunc) folder_changed, vf);
}
-
static void
vee_folder_stop_folder(CamelVeeFolder *vf, CamelFolder *sub)
{
return;
}
-
camel_object_unhook_event((CamelObject *)sub, "folder_changed", (CamelObjectEventHookFunc) folder_changed, vf);
camel_object_unhook_event((CamelObject *)sub, "deleted", (CamelObjectEventHookFunc) subfolder_deleted, vf);
camel_object_unhook_event((CamelObject *)sub, "renamed", (CamelObjectEventHookFunc) folder_renamed, vf);
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_VEE_FOLDER_H
#define _CAMEL_VEE_FOLDER_H
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_VEE_STORE_H
#define _CAMEL_VEE_STORE_H
if (hacked_unread_folder)
camel_vee_folder_mask_event_folder_changed ((CamelVeeFolder *)mi->summary->folder, rmi->summary->folder);
-
+
res = camel_message_info_set_user_flag(rmi, name, value);
if (hacked_unread_folder)
camel_vee_folder_unmask_event_folder_changed ((CamelVeeFolder *)mi->summary->folder, rmi->summary->folder);
-
+
camel_message_info_free (rmi);
}
return type;
}
-
/**
* camel_vee_summary_new:
* @parent: Folder its attached to.
*
*/
-
#ifndef _CAMEL_VTRASH_FOLDER_H
#define _CAMEL_VTRASH_FOLDER_H
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
* USA
*/
-
#ifndef CAMEL_H
#define CAMEL_H 1
#include <stdio.h>
#include <sqlite3.h>
-
sqlite3 *db;
static gint
* USA
*/
-
/* This file is broken and suffers from multiple author syndrome.
This needs to be rewritten with a lot of functions cleaned up.
return camel_data_cache_get_filename (gw_folder->cache, "cache", uid, ex);
}
-
/* Get a message from cache if available otherwise get it from server */
static CamelMimeMessage *
groupwise_folder_get_message( CamelFolder *folder, const gchar *uid, CamelException *ex )
CAMEL_SERVICE_REC_UNLOCK (gw_store, connect_lock);
}
-
-
if (unread_items) {
CAMEL_SERVICE_REC_LOCK (gw_store, connect_lock);
status = e_gw_connection_mark_unread (cnc, unread_items);
gchar *summary_file, *state_file, *journal_file;
gchar *short_name;
-
folder = CAMEL_FOLDER (camel_object_new(camel_groupwise_folder_get_type ()) );
gw_folder = CAMEL_GROUPWISE_FOLDER(folder);
is_proxy = TRUE;
}
-
/*Get the New Items*/
if (!is_proxy) {
const gchar *source;
goto end3;
}
-
if (gw_store->current_folder != folder)
groupwise_store_set_current_folder (gw_store, folder);
g_object_unref (container);
-
if (list)
gw_update_cache (folder, list, ex, FALSE);
update_summary_string (folder, new_sync_time, ex);
}
-
CAMEL_SERVICE_REC_UNLOCK (gw_store, connect_lock);
is_locked = FALSE;
guint8 *digest;
gchar *msgid;
-
if (!message_id)
return;
mi->info.flags |= status_flags;
-
priority = e_gw_item_get_priority (item);
if (priority && !(g_ascii_strcasecmp (priority,"High"))) {
mi->info.flags |= CAMEL_MESSAGE_FLAGGED;
} /* if attach_list */
-
msg = camel_mime_message_new ();
if (has_mime_822 && body) {
temp_stream = camel_stream_mem_new_with_buffer (body, body_len);
}/* if attach_list */
/********************/
-
/* this is broken for translations. someone should care to fix these hacks. nobody except groupwise users are affected though */
if (e_gw_item_get_priority (item))
camel_medium_add_header ( CAMEL_MEDIUM (msg), "Priority", e_gw_item_get_priority(item));
return;
}
-
cnc = cnc_lookup (priv);
index = 0;
while (index < uids->len) {
wrapper = NULL;
}
-
/* A User may mark a message as Unread and then immediately move it to
some other folder. The following piece of code take care of such scenario.
}
}
-
if (destination_is_trash) {
e_gw_connection_remove_item (cnc, source_container_id, (const gchar *) uids->pdata[index]);
camel_folder_summary_remove_uid (source->summary, uids->pdata[index]);
gboolean delete = FALSE;
GList *deleted_items, *deleted_head;
-
deleted_items = deleted_head = NULL;
cnc = cnc_lookup (priv);
if (!cnc)
CamelGroupwiseFolder *gw_folder = CAMEL_GROUPWISE_FOLDER (object);
CamelFolder *folder = CAMEL_FOLDER (object);
-
folder->permanent_flags = CAMEL_MESSAGE_ANSWERED | CAMEL_MESSAGE_DELETED |
CAMEL_MESSAGE_DRAFT | CAMEL_MESSAGE_FLAGGED | CAMEL_MESSAGE_SEEN;
{
static CamelType camel_groupwise_folder_type = CAMEL_INVALID_TYPE;
-
if (camel_groupwise_folder_type == CAMEL_INVALID_TYPE) {
camel_groupwise_folder_type =
camel_type_register (camel_offline_folder_get_type (),
gstr = g_string_append (gstr, "END:VTODO\n");
gstr = g_string_append (gstr, "END:VCALENDAR\n");
-
*str = g_strdup (gstr->str);
*len = gstr->len;
* USA
*/
-
#ifndef CAMEL_GROUPWISE_FOLDER_H
#define CAMEL_GROUPWISE_FOLDER_H 1
guint need_refresh:1;
guint read_only:1;
-
};
struct _CamelGroupwiseFolderClass {
} ;
-
/* Standard Camel function */
CamelType camel_groupwise_folder_get_type (void);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define d(x)
-
static void camel_groupwise_journal_class_init (CamelGroupwiseJournalClass *klass);
static void camel_groupwise_journal_init (CamelGroupwiseJournal *journal, CamelGroupwiseJournalClass *klass);
static void camel_groupwise_journal_finalize (CamelObject *object);
static gint groupwise_entry_write (CamelOfflineJournal *journal, CamelDListNode *entry, FILE *out);
static gint groupwise_entry_play (CamelOfflineJournal *journal, CamelDListNode *entry, CamelException *ex);
-
static CamelOfflineJournalClass *parent_class = NULL;
-
CamelType
camel_groupwise_journal_get_type (void)
{
}
}
-
-
CamelOfflineJournal *
camel_groupwise_journal_new (CamelGroupwiseFolder *folder, const gchar *filename)
{
*
*/
-
#ifndef __CAMEL_GROUPWISE_JOURNAL_H__
#define __CAMEL_GROUPWISE_JOURNAL_H__
};
-
CamelType camel_groupwise_journal_get_type (void);
CamelOfflineJournal *camel_groupwise_journal_new (struct _CamelGroupwiseFolder *folder, const gchar *filename);
static gint check_equal (gchar *s1, gchar *s2);
static gint groupwise_url_equal (gconstpointer a, gconstpointer b);
-
CamelProviderConfEntry groupwise_conf_entries[] = {
/* override the labels/defaults of the standard settings */
{ CAMEL_PROVIDER_CONF_END }
};
-
static CamelProvider groupwise_provider = {
"groupwise",
N_("Novell GroupWise"),
camel_provider_register (&groupwise_provider);
}
-
static void
add_hash (guint *hash, gchar *s)
{
* Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static CamelStoreSummaryClass *camel_groupwise_store_summary_parent;
-
static void
camel_groupwise_store_summary_class_init (CamelGroupwiseStoreSummaryClass *klass)
{
ssklass->store_info_string = store_info_string;
ssklass->store_info_set_string = store_info_set_string;
-
}
static void
s->version = CAMEL_GW_STORE_SUMMARY_VERSION;
}
-
static void
camel_groupwise_store_summary_finalise (CamelObject *obj)
{
}
-
CamelType
camel_groupwise_store_summary_get_type (void)
{
return type;
}
-
CamelGroupwiseStoreSummary *
camel_groupwise_store_summary_new (void)
{
return new;
}
-
CamelGroupwiseStoreInfo *
camel_groupwise_store_summary_full_name(CamelGroupwiseStoreSummary *s, const gchar *full_name)
{
return ns;
}
-
-
static gint
summary_header_load(CamelStoreSummary *s, FILE *in)
{
return 0;
}
-
static gint
summary_header_save(CamelStoreSummary *s, FILE *out)
{
if (summary->namespace && namespace_save(s, out, summary->namespace) == -1)
return -1;
-
return 0;
}
return 0;
}
-
static void
store_info_free(CamelStoreSummary *s, CamelStoreInfo *mi)
{
camel_groupwise_store_summary_parent->store_info_free(s, mi);
}
-
-
-
-
static const gchar *
store_info_string(CamelStoreSummary *s, const CamelStoreInfo *mi, gint type)
{
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_GW_STORE_SUMMARY_H
#define _CAMEL_GW_STORE_SUMMARY_H
static void groupwise_folders_sync (CamelGroupwiseStore *store, CamelException *ex);
static gint match_path(const gchar *path, const gchar *name);
-
-
static void
groupwise_store_construct (CamelService *service, CamelSession *session,
CamelProvider *provider, CamelURL *url,
uri = g_strconcat ("http://", priv->server_name, ":", priv->port, "/soap", NULL);
service->url->passwd = NULL;
-
while (!authenticated) {
if (!service->url->passwd && !(store->flags & CAMEL_STORE_PROXY)) {
return FALSE;
}
-
service->status = CAMEL_SERVICE_CONNECTED;
((CamelOfflineStore *) store)->state = CAMEL_OFFLINE_STORE_NETWORK_AVAIL;
if (groupwise_is_system_folder (folder_name))
fi->flags |= CAMEL_FOLDER_SYSTEM;
-
fi->name = g_strdup(name);
return fi;
}
container_id = g_strdup (g_hash_table_lookup (priv->name_hash, folder_name));
-
storage_path = g_strdup_printf("%s/folders", priv->storage_path);
folder_dir = e_path_to_physical (storage_path, folder_name);
g_free(storage_path);
return g_hash_table_lookup (priv->id_hash, container_id);
}
-
EGwConnection *
cnc_lookup (CamelGroupwiseStorePrivate *priv)
{
camel_store_class->can_refresh_folder = groupwise_can_refresh_folder;
}
-
/*This frees the private structure*/
static void
camel_groupwise_store_finalize (CamelObject *object)
* USA
*/
-
#ifndef CAMEL_GROUPWISE_STORE_H
#define CAMEL_GROUPWISE_STORE_H 1
guint list_loaded;
};
-
struct _CamelGroupwiseStoreClass {
CamelOfflineStoreClass parent_class;
};
-
/* Standard Camel function */
CamelType camel_groupwise_store_get_type (void);
gchar * groupwise_get_name(CamelService *service, gboolean brief);
static void camel_groupwise_summary_class_init (CamelGroupwiseSummaryClass *klass);
static void camel_groupwise_summary_init (CamelGroupwiseSummary *obj);
-
/*End of Prototypes*/
-
static CamelFolderSummaryClass *camel_groupwise_summary_parent;
-
CamelType
camel_groupwise_summary_get_type (void)
{
}
-
static void
camel_groupwise_summary_init (CamelGroupwiseSummary *obj)
{
s->meta_summary->uid_len = 2048;
}
-
/**
* camel_groupwise_summary_new:
* @filename: the file to store the summary in.
return 0;
}
-
-
-
-
static CamelFIRecord *
summary_header_to_db (CamelFolderSummary *s, CamelException *ex)
{
CamelMessageInfo *info;
CamelGroupwiseMessageInfo *gw_info;
-
info = camel_groupwise_summary_parent->message_info_load(s,in);
if (info) {
gw_info = (CamelGroupwiseMessageInfo*) info;
return camel_folder_summary_content_info_new (s);
}
-
static CamelMessageContentInfo *
gw_content_info_load (CamelFolderSummary *s, FILE *in)
{
mi->flags |= CAMEL_GW_MESSAGE_JUNK | CAMEL_MESSAGE_JUNK | CAMEL_MESSAGE_JUNK_LEARN;
}
-
if (mi->summary && mi->summary->folder && mi->uid) {
CamelFolderChangeInfo *changes = camel_folder_change_info_new();
return TRUE;
}
-
void
camel_gw_summary_add_offline (CamelFolderSummary *summary, const gchar *uid, CamelMimeMessage *message, const CamelMessageInfo *info)
{
guint32 server_flags;
} ;
-
struct _CamelGroupwiseMessageContentInfo {
CamelMessageContentInfo info;
} ;
-
struct _CamelGroupwiseSummary {
CamelFolderSummary parent;
gint32 validity;
} ;
-
struct _CamelGroupwiseSummaryClass {
CamelFolderSummaryClass parent_class;
} ;
-
CamelType camel_groupwise_summary_get_type (void);
CamelFolderSummary *camel_groupwise_summary_new (struct _CamelFolder *folder, const gchar *filename);
static void groupwise_transport_construct (CamelService *service, CamelSession *session,
CamelProvider *provider, CamelURL *url, CamelException *ex);
-
static CamelTransportClass *parent_class = NULL;
-
-
static void
camel_groupwise_transport_class_init (CamelGroupwiseTransportClass *camel_groupwise_transport_class)
{
}
}
-
static gboolean
groupwise_transport_connect (CamelService *service, CamelException *ex)
{
}
-
static gboolean
groupwise_send_to (CamelTransport *transport,
CamelMimeMessage *message,
g_free (id);
}
-
/*Send item*/
status = e_gw_connection_send_item (cnc, item, &sent_item_list);
if (status != E_GW_CONNECTION_STATUS_OK) {
* USA
*/
-
#ifndef CAMEL_GROUPWISE_TRANSPORT_H
#define CAMEL_GROUPWISE_TRANSPORT_H 1
} CamelGroupwiseTransport;
-
typedef struct {
CamelTransportClass parent_class;
} CamelGroupwiseTransportClass;
-
/* Standard Camel function */
CamelType camel_groupwise_transport_get_type (void);
return ppath;
}
-
static gboolean
find_folders_recursive (const gchar *physical_path, const gchar *path,
EPathFindFoldersCallback callback, gpointer data)
return find_folders_recursive (prefix, "", callback, data);
}
-
/**
* e_path_rmdir:
* @prefix: a prefix to prepend to the path, or %NULL
guint32 bits;
} flags_diff_t;
-
/* FIXME: deprecated
This is used exclusively for the legacy imap cache code. DO NOT use this in any new code */
gint e_path_rmdir (const gchar *prefix, const gchar *vpath);
-
EGwItem *camel_groupwise_util_item_from_message (EGwConnection *cnc, CamelMimeMessage *message, CamelAddress *from);
void do_flags_diff (flags_diff_t *diff, guint32 old, guint32 _new);
static gint check_equal (gchar *s1, gchar *s2);
static gint hula_url_equal (gconstpointer a, gconstpointer b);
-
static CamelProviderConfEntry hula_conf_entries[] = {
/* override the labels/defaults of the standard settings */
{ CAMEL_PROVIDER_CONF_SECTION_START, "mailcheck", NULL,
* relevancy - harish*/
};
-
static CamelProvider hula_provider = {
"hula",
N_("Hula"),
hula_provider.object_types[CAMEL_PROVIDER_STORE] = imap_provider->object_types [CAMEL_PROVIDER_STORE];
-
camel_provider_register (&hula_provider);
}
-
static void
add_hash (guint *hash, gchar *s)
{
return NULL;
}
-
/**
* camel_imap_response_free:
* @store: the CamelImapStore the response is from
* USA
*/
-
#ifndef CAMEL_IMAP_COMMAND_H
#define CAMEL_IMAP_COMMAND_H 1
changed = TRUE;
}
-
/* Do not merge custom flags when server doesn't support it.
Because server always reports NULL, which means none, which
will remove user's flags from local machine, which is bad.
seq = i + 1;
-
#if 0
/* FIXME: Srini: I don't think this will be called any longer. */
/* Free remaining memory. */
camel_imap_response_free (store, response);
}
-
static void
imap_transfer_offline (CamelFolder *source, GPtrArray *uids,
CamelFolder *dest, GPtrArray **transferred_uids,
* if we don't have UIDPLUS, we won't know their real UIDs,
* so we'll have to append them rather than copying. */
-
realuids = g_ptr_array_new ();
i = 0;
}
}
-
CamelStream *
camel_imap_folder_fetch_data (CamelImapFolder *imap_folder, const gchar *uid,
const gchar *section_text, gboolean cache_only,
* USA
*/
-
#ifndef CAMEL_IMAP_FOLDER_H
#define CAMEL_IMAP_FOLDER_H 1
};
-
/* public methods */
CamelFolder *camel_imap_folder_new (CamelStore *parent,
const gchar *folder_name,
static CamelOfflineJournalClass *parent_class = NULL;
-
CamelType
camel_imap_journal_get_type (void)
{
{
CamelIMAPJournalEntry *entry;
-
d(g_print ("DEBUG: Loading to the journal \n"));
entry = g_malloc0 (sizeof (CamelIMAPJournalEntry));
};
-
CamelType camel_imap_journal_get_type (void);
CamelOfflineJournal *camel_imap_journal_new (struct _CamelImapFolder *folder, const gchar *filename);
gint found;
};
-
CamelType
camel_imap_message_cache_get_type (void)
{
return cache;
}
-
/**
* camel_imap_message_cache_delete:
* @path: directory to use for storage
g_hash_table_insert (cache->parts, key, NULL);
}
-
static CamelStream *
insert_setup (CamelImapMessageCache *cache, const gchar *uid, const gchar *part_spec,
gchar **path, gchar **key, CamelException *ex)
g_ptr_array_free (uids, TRUE);
}
-
/**
* camel_imap_message_cache_copy:
* @source: the source message cache
}
}
-
static void
_match_part(gpointer part_name, gpointer user_data)
{
* USA
*/
-
#ifndef CAMEL_IMAP_MESSAGE_CACHE_H
#define CAMEL_IMAP_MESSAGE_CACHE_H 1
guint32 max_uid;
};
-
typedef struct {
CamelFolderClass parent_class;
} CamelImapMessageCacheClass;
-
/* public methods */
CamelImapMessageCache *camel_imap_message_cache_new (const gchar *path,
CamelFolderSummary *summary,
GArray *matches;
};
-
static void free_match(CamelImapSearch *is, struct _match_record *mr);
static ESExpResult *imap_body_contains (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFolderSearch *s);
return new;
}
-
static void
hash_match(gchar hash[17], gint argc, struct _ESExpResult **argv)
{
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_IMAP_STORE_SUMMARY_H
#define _CAMEL_IMAP_STORE_SUMMARY_H
{
CamelImapStore *store = CAMEL_IMAP_STORE (service);
-
if (CAMEL_OFFLINE_STORE (store)->state == CAMEL_OFFLINE_STORE_NETWORK_AVAIL && clean) {
CamelImapResponse *response;
return FALSE;
}
-
gssize
camel_imap_store_readline (CamelImapStore *store, gchar **dest, CamelException *ex)
{
* USA
*/
-
#ifndef CAMEL_IMAP_STORE_H
#define CAMEL_IMAP_STORE_H 1
} CamelImapStoreClass;
-
/* Standard Camel function */
CamelType camel_imap_store_get_type (void);
-
gboolean camel_imap_store_connected (CamelImapStore *store, CamelException *ex);
gssize camel_imap_store_readline (CamelImapStore *store, gchar **dest, CamelException *ex);
static gint content_info_to_db (CamelFolderSummary *s, CamelMessageContentInfo *info, CamelMIRecord *mir);
static CamelMessageContentInfo * content_info_from_db (CamelFolderSummary *s, CamelMIRecord *mir);
-
static void camel_imap_summary_class_init (CamelImapSummaryClass *klass);
static void camel_imap_summary_init (CamelImapSummary *obj);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return word;
}
-
static void
imap_namespace_destroy (struct _namespace *namespace)
{
return TRUE;
}
-
/**
* imap_parse_folder_name:
* @store:
return 0;
}
-
static CamelMessageContentInfo *
imap_body_decode (const gchar **in, CamelMessageContentInfo *ci, CamelFolder *folder, GPtrArray *cis)
{
return NULL;
}
-
/**
* imap_parse_body:
* @body_p: pointer to the start of an IMAP "body"
g_ptr_array_free (children, TRUE);
}
-
/**
* imap_quote_string:
* @str: the string to quote, which must not contain CR or LF
return quoted;
}
-
static inline gulong
get_summary_uid_numeric (CamelFolderSummary *summary, gint index)
{
#define CAMEL_IMAP_WRAPPER_LOCK(f, l) (g_mutex_lock(((CamelImapWrapper *)f)->priv->l))
#define CAMEL_IMAP_WRAPPER_UNLOCK(f, l) (g_mutex_unlock(((CamelImapWrapper *)f)->priv->l))
-
static CamelDataWrapperClass *parent_class = NULL;
/* Returns the class for a CamelDataWrapper */
return type;
}
-
static void
imap_wrapper_hydrate (CamelImapWrapper *imap_wrapper, CamelStream *stream)
{
imap_wrapper->part = NULL;
}
-
static gssize
write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream)
{
return parent_class->write_to_stream (data_wrapper, stream);
}
-
CamelDataWrapper *
camel_imap_wrapper_new (CamelImapFolder *imap_folder,
CamelContentType *type, CamelTransferEncoding encoding,
* USA
*/
-
#ifndef CAMEL_IMAP_WRAPPER_H
#define CAMEL_IMAP_WRAPPER_H 1
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define d(x) (camel_debug ("imap4:command") ? (x) : 0)
-
enum {
IMAP4_STRING_ATOM,
IMAP4_STRING_QSTRING,
}
}
-
static gint
imap4_literal_write_to_stream (CamelIMAP4Literal *literal, CamelStream *stream)
{
return -1;
}
-
static void
unexpected_token (camel_imap4_token_t *token)
{
return -1;
}
-
void
camel_imap4_command_reset (CamelIMAP4Command *ic)
{
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_COMMAND_H__
#define __CAMEL_IMAP4_COMMAND_H__
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define d(x)
-
static void camel_imap4_engine_class_init (CamelIMAP4EngineClass *klass);
static void camel_imap4_engine_init (CamelIMAP4Engine *engine, CamelIMAP4EngineClass *klass);
static void camel_imap4_engine_finalize (CamelObject *object);
static gint parse_xgwextensions (CamelIMAP4Engine *engine, CamelIMAP4Command *ic, guint32 index,
camel_imap4_token_t *token, CamelException *ex);
-
static CamelObjectClass *parent_class = NULL;
-
CamelType
camel_imap4_engine_get_type (void)
{
}
}
-
/**
* camel_imap4_engine_new:
* @service: service
return engine;
}
-
/**
* camel_imap4_engine_take_stream:
* @engine: imap4 engine
return -1;
}
-
/**
* camel_imap4_engine_disconnect:
* @engine: IMAP4 engine
}
}
-
/**
* camel_imap4_engine_capability:
* @engine: IMAP4 engine
return retval;
}
-
/**
* camel_imap4_engine_namespace:
* @engine: IMAP4 engine
return 0;
}
-
/**
* camel_imap4_engine_select_folder:
* @engine: IMAP4 engine
return retval;
}
-
static struct {
const gchar *name;
guint32 flag;
return -1;
}
-
/*
* resp-text-code = "ALERT" /
* "BADCHARSET" [SP "(" astring *(SP astring) ")" ] /
{ NULL, CAMEL_IMAP4_RESP_CODE_UNKNOWN, 0 }
};
-
/**
* camel_imap4_engine_parse_resp_code:
* @engine: IMAP4 engine
return -1;
}
-
/**
* camel_imap4_engine_handle_untagged_1:
* @engine: IMAP4 engine
return code;
}
-
/**
* camel_imap4_engine_handle_untagged:
* @engine: IMAP4 engine
engine->state = CAMEL_IMAP4_ENGINE_DISCONNECTED;
}
-
static gint
imap4_process_command (CamelIMAP4Engine *engine, CamelIMAP4Command *ic)
{
return 0;
}
-
static void
engine_prequeue_folder_select (CamelIMAP4Engine *engine)
{
camel_imap4_command_unref (ic);
}
-
static gint
engine_state_change (CamelIMAP4Engine *engine, CamelIMAP4Command *ic)
{
return retval;
}
-
/**
* camel_imap4_engine_iterate:
* @engine: IMAP4 engine
return retval;
}
-
/**
* camel_imap4_engine_queue:
* @engine: IMAP4 engine
return ic;
}
-
/**
* camel_imap4_engine_prequeue:
* @engine: IMAP4 engine
return ic;
}
-
/**
* camel_imap4_engine_dequeue:
* @engine: IMAP4 engine
camel_imap4_command_unref (ic);
}
-
/**
* camel_imap4_engine_next_token:
* @engine: IMAP4 engine
return 0;
}
-
/**
* camel_imap4_engine_eat_line:
* @engine: IMAP4 engine
return 0;
}
-
/**
* camel_imap4_engine_line:
* @engine: IMAP4 engine
return 0;
}
-
/**
* camel_imap4_engine_literal:
* @engine: IMAP4 engine
return 0;
}
-
/**
* camel_imap4_engine_nstring:
* @engine: IMAP4 engine
return 0;
}
-
/**
* camel_imap4_resp_code_free:
* @rcode: RESP-CODE
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_ENGINE_H__
#define __CAMEL_IMAP4_ENGINE_H__
guchar tagprefix;
};
-
CamelType camel_imap4_engine_get_type (void);
CamelIMAP4Engine *camel_imap4_engine_new (CamelService *service, CamelIMAP4ReconnectFunc reconnect);
gint camel_imap4_engine_iterate (CamelIMAP4Engine *engine);
-
/* untagged response utility functions */
gint camel_imap4_engine_handle_untagged_1 (CamelIMAP4Engine *engine, struct _camel_imap4_token_t *token, CamelException *ex);
void camel_imap4_engine_handle_untagged (CamelIMAP4Engine *engine, CamelException *ex);
gint camel_imap4_engine_nstring (CamelIMAP4Engine *engine, guchar **nstring, CamelException *ex);
gint camel_imap4_engine_eat_line (CamelIMAP4Engine *engine, CamelException *ex);
-
/* response code stuff */
gint camel_imap4_engine_parse_resp_code (CamelIMAP4Engine *engine, CamelException *ex);
void camel_imap4_resp_code_free (CamelIMAP4RespCode *rcode);
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static CamelOfflineFolderClass *parent_class = NULL;
-
static GSList *imap4_folder_props = NULL;
static CamelProperty imap4_prop_list[] = {
{ CAMEL_IMAP4_FOLDER_EXPIRE_AGE, "expire-age", N_("Expire cached messages older than X seconds") },
};
-
CamelType
camel_imap4_folder_get_type (void)
{
return ((CamelObjectClass *) parent_class)->setv (object, ex, args);
}
-
static gchar *
imap4_get_summary_filename (const gchar *path)
{
return path;
}
-
CamelFolder *
camel_imap4_folder_new (CamelStore *store, const gchar *full_name, CamelException *ex)
{
return folder->utf7_name;
}
-
static struct {
const gchar *name;
guint32 flag;
{ "\\Seen", CAMEL_MESSAGE_SEEN },
};
-
static gint
imap4_sync_flag (CamelFolder *folder, GPtrArray *infos, gchar onoff, const gchar *flag, CamelException *ex)
{
CAMEL_SERVICE_REC_UNLOCK (folder->parent_store, connect_lock);
}
-
static gint
info_uid_sort (const CamelMessageInfo **info0, const CamelMessageInfo **info1)
{
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_FOLDER_H__
#define __CAMEL_IMAP4_FOLDER_H__
};
-
CamelType camel_imap4_folder_get_type (void);
CamelFolder *camel_imap4_folder_new (CamelStore *store, const gchar *full_name, CamelException *ex);
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define d(x)
-
static void camel_imap4_journal_class_init (CamelIMAP4JournalClass *klass);
static void camel_imap4_journal_init (CamelIMAP4Journal *journal, CamelIMAP4JournalClass *klass);
static void camel_imap4_journal_finalize (CamelObject *object);
static gint imap4_entry_write (CamelOfflineJournal *journal, CamelDListNode *entry, FILE *out);
static gint imap4_entry_play (CamelOfflineJournal *journal, CamelDListNode *entry, CamelException *ex);
-
static CamelOfflineJournalClass *parent_class = NULL;
-
CamelType
camel_imap4_journal_get_type (void)
{
}
}
-
-
CamelOfflineJournal *
camel_imap4_journal_new (CamelIMAP4Folder *folder, const gchar *filename)
{
return journal;
}
-
void
camel_imap4_journal_readd_failed (CamelIMAP4Journal *journal)
{
g_ptr_array_set_size (journal->failed, 0);
}
-
void
camel_imap4_journal_append (CamelIMAP4Journal *imap4_journal, CamelMimeMessage *message,
const CamelMessageInfo *mi, gchar **appended_uid, CamelException *ex)
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_JOURNAL_H__
#define __CAMEL_IMAP4_JOURNAL_H__
};
-
CamelType camel_imap4_journal_get_type (void);
CamelOfflineJournal *camel_imap4_journal_new (struct _CamelIMAP4Folder *folder, const gchar *filename);
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
TRUE
};
-
static void
add_hash (guint *hash, gchar *s)
{
&& u1->port == u2->port;
}
-
void
camel_provider_module_init (void)
{
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static ESExpResult *imap4_body_contains (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFolderSearch *search);
-
static CamelFolderSearchClass *parent_class = NULL;
-
CamelType
camel_imap4_search_get_type (void)
{
;
}
-
CamelFolderSearch *
camel_imap4_search_new (CamelIMAP4Engine *engine, const gchar *cachedir)
{
return (CamelFolderSearch *) search;
}
-
static gint
untagged_search (CamelIMAP4Engine *engine, CamelIMAP4Command *ic, guint32 index, camel_imap4_token_t *token, CamelException *ex)
{
goto done;
}
-
if (ic->result == CAMEL_IMAP4_RESULT_NO && utf8_search && (engine->capa & CAMEL_IMAP4_CAPABILITY_utf8_search)) {
gint j;
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_SEARCH_H__
#define __CAMEL_IMAP4_SEARCH_H__
};
-
CamelType camel_imap4_search_get_type (void);
CamelFolderSearch *camel_imap4_search_new (struct _CamelIMAP4Engine *engine, const gchar *cachedir);
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
};
-
static void
imap4_init_bits (unsigned short bit, unsigned short bitcopy, gint remove, guchar *vals)
{
}
}
-
void
camel_imap4_specials_init (void)
{
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_SPECIALS_H__
#define __CAMEL_IMAP4_SPECIALS_H__
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "camel-imap4-store-summary.h"
#include "camel-imap4-utils.h"
-
#define CAMEL_IMAP4_STORE_SUMMARY_VERSION_0 (0)
#define CAMEL_IMAP4_STORE_SUMMARY_VERSION (0)
static gint store_info_save (CamelStoreSummary *s, FILE *out, CamelStoreInfo *info);
static void store_info_free (CamelStoreSummary *s, CamelStoreInfo *info);
-
static CamelStoreSummaryClass *parent_class = NULL;
-
CamelType
camel_imap4_store_summary_get_type (void)
{
return type;
}
-
static void
camel_imap4_store_summary_class_init (CamelIMAP4StoreSummaryClass *klass)
{
camel_imap4_namespace_list_free (s->namespaces);
}
-
static CamelIMAP4NamespaceList *
load_namespaces (FILE *in)
{
parent_class->store_info_free (s, info);
}
-
/**
* camel_imap4_store_summary_new:
*
return (CamelIMAP4StoreSummary *) camel_object_new (camel_imap4_store_summary_get_type ());
}
-
void
camel_imap4_store_summary_set_capabilities (CamelIMAP4StoreSummary *s, guint32 capa)
{
s->capa = capa;
}
-
void
camel_imap4_store_summary_set_namespaces (CamelIMAP4StoreSummary *s, const CamelIMAP4NamespaceList *ns)
{
s->namespaces = camel_imap4_namespace_list_copy (ns);
}
-
void
camel_imap4_store_summary_note_info (CamelIMAP4StoreSummary *s, CamelFolderInfo *fi)
{
/* FIXME: should this be recursive? */
}
-
void
camel_imap4_store_summary_unnote_info (CamelIMAP4StoreSummary *s, CamelFolderInfo *fi)
{
camel_store_summary_remove_path (ss, fi->full_name);
}
-
static CamelFolderInfo *
store_info_to_folder_info (CamelStoreSummary *s, CamelStoreInfo *si)
{
return fi;
}
-
CamelFolderInfo *
camel_imap4_store_summary_get_folder_info (CamelIMAP4StoreSummary *s, const gchar *top, guint32 flags)
{
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP_STORE_SUMMARY_H__
#define __CAMEL_IMAP_STORE_SUMMARY_H__
CAMEL_IMAP4_STORE_INFO_LAST,
};
-
struct _CamelFolderInfo;
-
struct _CamelIMAP4StoreInfo {
CamelStoreInfo info;
};
CamelStoreSummaryClass summary_class;
};
-
CamelType camel_imap4_store_summary_get_type (void);
CamelIMAP4StoreSummary *camel_imap4_store_summary_new (void);
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static gboolean imap4_folder_subscribed (CamelStore *store, const gchar *folder_name);
static void imap4_noop (CamelStore *store, CamelException *ex);
-
static CamelOfflineStoreClass *parent_class = NULL;
-
CamelType
camel_imap4_store_get_type (void)
{
g_free (store->storage_path);
}
-
static void
imap4_construct (CamelService *service, CamelSession *session, CamelProvider *provider, CamelURL *url, CamelException *ex)
{
return folder;
}
-
static gboolean
imap4_folder_can_contain_folders (CamelStore *store, const gchar *folder_name, CamelException *ex)
{
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_STORE_H__
#define __CAMEL_IMAP4_STORE_H__
};
-
CamelType camel_imap4_store_get_type (void);
G_END_DECLS
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
static gint stream_close (CamelStream *stream);
static gboolean stream_eos (CamelStream *stream);
-
static CamelStreamClass *parent_class = NULL;
-
CamelType
camel_imap4_stream_get_type (void)
{
g_free (imap4->tokenbuf);
}
-
static gssize
imap4_fill (CamelIMAP4Stream *imap4)
{
return FALSE;
}
-
/**
* camel_imap4_stream_new:
* @stream: tcp stream
return (CamelStream *) imap4;
}
-
-
#define token_save(imap4, start, len) G_STMT_START { \
if (imap4->tokenleft <= len) { \
guint tlen, toff; \
imap4->literal = 0; \
} G_STMT_END
-
/**
* camel_imap4_stream_next_token:
* @stream: imap4 stream
return 0;
}
-
/**
* camel_imap4_stream_unget_token:
* @stream: imap4 stream
return 0;
}
-
/**
* camel_imap4_stream_line:
* @stream: imap4 stream
return 1;
}
-
/**
* camel_imap4_stream_literal:
* @stream: IMAP stream
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_STREAM_H__
#define __CAMEL_IMAP4_STREAM_H__
/* Virtual methods */
};
-
/* Standard Camel function */
CamelType camel_imap4_stream_get_type (void);
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <errno.h>
#include <ctype.h>
-
#include <glib/gi18n-lib.h>
#include <libedataserver/md5-utils.h>
static CamelFolderSummaryClass *parent_class = NULL;
-
CamelType
camel_imap4_summary_get_type (void)
{
return type;
}
-
static void
camel_imap4_summary_class_init (CamelIMAP4SummaryClass *klass)
{
{
}
-
CamelFolderSummary *
camel_imap4_summary_new (CamelFolder *folder)
{
return fputc (0, out);
}
-
void
camel_imap4_summary_set_exists (CamelFolderSummary *summary, guint32 exists)
{
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_SUMMARY_H__
#define __CAMEL_IMAP4_SUMMARY_H__
};
-
CamelType camel_imap4_summary_get_type (void);
CamelFolderSummary *camel_imap4_summary_new (CamelFolder *folder);
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define d(x)
-
CamelFolderInfo *
camel_imap4_build_folder_info_tree (GPtrArray *array, const gchar *top)
{
diff->bits = new & diff->changed;
}
-
guint32
camel_imap4_flags_merge (flags_diff_t *diff, guint32 flags)
{
return (flags & ~diff->changed) | diff->bits;
}
-
/**
* camel_imap4_merge_flags:
* @original: original server flags
return camel_imap4_flags_merge (&diff, server);
}
-
void
camel_imap4_namespace_clear (CamelIMAP4Namespace **ns)
{
g_free (nsl);
}
-
gchar
camel_imap4_get_path_delim (CamelIMAP4StoreSummary *s, const gchar *full_name)
{
return '/';
}
-
struct _uidset_range {
struct _uidset_range *next;
guint32 first, last;
return (i - cur);
}
-
void
camel_imap4_utils_set_unexpected_token_error (CamelException *ex, CamelIMAP4Engine *engine, camel_imap4_token_t *token)
{
g_string_free (errmsg, TRUE);
}
-
static struct {
const gchar *name;
guint32 flag;
return 0;
}
-
static struct {
const gchar *name;
guint32 flag;
return -1;
}
-
static struct {
const gchar *name;
gint type;
{ "UNSEEN", CAMEL_IMAP4_STATUS_UNSEEN },
};
-
void
camel_imap4_status_free (camel_imap4_status_t *status)
{
g_free (status);
}
-
gint
camel_imap4_untagged_status (CamelIMAP4Engine *engine, CamelIMAP4Command *ic, guint32 index, camel_imap4_token_t *token, CamelException *ex)
{
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-
#ifndef __CAMEL_IMAP4_UTILS_H__
#define __CAMEL_IMAP4_UTILS_H__
guint32 camel_imap4_flags_merge (flags_diff_t *diff, guint32 flags);
guint32 camel_imap4_merge_flags (guint32 original, guint32 local, guint32 server);
-
struct _CamelFolderInfo;
struct _CamelIMAP4Engine;
struct _CamelIMAP4Command;
gint camel_imap4_untagged_list (struct _CamelIMAP4Engine *engine, struct _CamelIMAP4Command *ic,
guint32 index, struct _camel_imap4_token_t *token, CamelException *ex);
-
enum {
CAMEL_IMAP4_STATUS_UNKNOWN,
CAMEL_IMAP4_STATUS_MESSAGES,
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return camel_imapp_engine_skip(ie);
}
-
/* This code is for the separate thread per server idea */
typedef enum {
{ "STARTTLS", IMAP_CAPABILITY_STARTTLS },
};
-
/*
capability_data ::= "CAPABILITY" SPACE [1#capability SPACE] "IMAP4rev1"
[SPACE 1#capability]
return 1;
}
-
/* Do work if there's any to do */
gint
camel_imapp_engine_iterate(CamelIMAPPEngine *imap, CamelIMAPPCommand *icwait)
gint zero;
gchar *s;
gint d;
- glong gint l;
+ gglong l;
guint32 f;
CamelStream *S;
CamelDataWrapper *D;
case 'd': /* int/unsigned */
case 'u':
if (llong) {
- l = va_arg(ap, glong gint);
- c(printf("got glong gint '%d'\n", (gint)l));
+ l = va_arg(ap, gglong);
+ c(printf("got gglong '%d'\n", (gint)l));
memcpy(buffer, start, p-start);
buffer[p-start] = 0;
camel_stream_printf((CamelStream *)ic->mem, buffer, l);
camel_stream_write((CamelStream *)ic->mem, ps, p-ps-1);
}
-
static gpointer
cie_worker(gpointer data)
{
}
}
-
/* here temporarily while its experimental */
-
#ifdef ENABLE_THREADS
#include <pthread.h>
return msg;
}
-
/* Algorithm for selecting a folder:
- If uidvalidity == old uidvalidity
* Boston, MA 02110-1301, USA.
*/
-
#ifndef _CAMEL_IMAPP_STORE_SUMMARY_H
#define _CAMEL_IMAPP_STORE_SUMMARY_H
/* leave this stuff out for now */
-
static struct {
gchar *value;
gint mode;
* USA
*/
-
#ifndef CAMEL_IMAPP_STORE_H
#define CAMEL_IMAPP_STORE_H 1
#endif /* CAMEL_IMAPP_STORE_H */
-
return (CamelStream *)is;
}
-
/*
From rfc2060
return summary;
}
-
static gint
summary_header_load(CamelFolderSummary *s, FILE *in)
{
return 0;
}
-
static CamelMessageInfo *
message_info_load(CamelFolderSummary *s, FILE *in)
{
media_text ::= <"> "TEXT" <"> SPACE media_subtype
;; Defined in [MIME-IMT]
-
-
( "type" "subtype" body_fields [envelope body body_fld_lines]
[body_fld_lines]
-
-
(("TEXT" "PLAIN" ("CHARSET"
"US-ASCII") NIL NIL "7BIT" 1152 23)("TEXT" "PLAIN"
("CHARSET" "US-ASCII" "NAME" "cc.diff")
}
}
-
/* ********************************************************************** */
/* utility functions */
void (*unlock)(CamelLocalFolder *);
};
-
/* public methods */
/* flags are taken from CAMEL_STORE_FOLDER_* flags */
CamelLocalFolder *camel_local_folder_construct(CamelLocalFolder *lf, CamelStore *parent_store,
*
*/
-
#ifndef CAMEL_LOCAL_PRIVATE_H
#define CAMEL_LOCAL_PRIVATE_H 1
#endif /* CAMEL_LOCAL_STORE_H */
-
return 0;
}
-
static gint
summary_header_from_db (CamelFolderSummary *s, CamelFIRecord *fir)
{
return 0;
}
-
static gint
summary_header_load(CamelFolderSummary *s, FILE *in)
{
return g_strdup_printf("%s/cur/%s", lf->folder_path, camel_maildir_info_filename(mdi));
}
-
static CamelMimeMessage *
maildir_get_message(CamelFolder * folder, const gchar * uid, CamelException * ex)
{
return mi;
}
-
static void
message_info_free(CamelFolderSummary *s, CamelMessageInfo *mi)
{
((CamelFolderSummaryClass *) parent_class)->message_info_free(s, mi);
}
-
static gchar *maildir_summary_next_uid_string(CamelFolderSummary *s)
{
CamelMaildirSummary *mds = (CamelMaildirSummary *)s;
frompos = info->frompos;
camel_message_info_free((CamelMessageInfo *)info);
-
filename = g_strdup_printf ("%s%s!%" PRId64, lf->folder_path, G_DIR_SEPARATOR_S, (gint64) frompos);
fail:
#endif /* CAMEL_MBOX_STORE_H */
-
static CamelMessageInfo * message_info_from_db(CamelFolderSummary *s, CamelMIRecord *record);
static CamelMIRecord * message_info_to_db(CamelFolderSummary *s, CamelMessageInfo *info);
-
static gint summary_header_load (CamelFolderSummary *, FILE *);
static gint summary_header_save (CamelFolderSummary *, FILE *);
return 0;
}
-
static gint
summary_header_load(CamelFolderSummary *s, FILE *in)
{
return mir;
}
-
static gint
message_info_save(CamelFolderSummary *s, FILE *out, CamelMessageInfo *mi)
{
/* Sync only the changes */
-
summary = camel_folder_summary_get_changed ((CamelFolderSummary *)mbs);
for (i=0; i<summary->len; i++) {
CamelMboxMessageInfo *info = (CamelMboxMessageInfo *)camel_folder_summary_uid(s, summary->pdata[i]);
if (quick && expunge) {
guint32 dcount =0;
-
if (camel_db_count_deleted_message_info (s->folder->parent_store->cdb_w, s->folder->full_name, &dcount, ex) == -1)
return -1;
if (dcount)
quick = FALSE;
}
-
/* yuck i hate this logic, but its to simplify the 'all ok, update summary' and failover cases */
ret = -1;
if (quick) {
return g_strdup_printf("%s/%s", lf->folder_path, uid);
}
-
static CamelMimeMessage *mh_get_message(CamelFolder * folder, const gchar * uid, CamelException * ex)
{
CamelLocalFolder *lf = (CamelLocalFolder *)folder;
camel_message_info_free(info);
}
-
static gint
mh_summary_check(CamelLocalSummary *cls, CamelFolderChangeInfo *changeinfo, CamelException *ex)
{
* USA
*/
-
#ifndef CAMEL_SPOOL_STORE_H
#define CAMEL_SPOOL_STORE_H 1
camel_spool_store_t type;
} CamelSpoolStore;
-
-
typedef struct {
CamelMboxStoreClass parent_class;
} CamelSpoolStoreClass;
-
/* public methods */
/* Standard Camel function */
#endif /* CAMEL_SPOOL_STORE_H */
-
if (camel_mbox_summary_sync_mbox((CamelMboxSummary *)cls, flags, changeinfo, fd, fdout, ex) == -1)
goto error;
-
/* sync out content */
if (fsync(fdout) == -1) {
g_warning("Cannot sync temporary folder: %s", g_strerror (errno));
goto error;
}
-
/* now copy content back */
buffer = g_malloc(8192);
size = 1;
* USA
*/
-
#ifndef CAMEL_NNTP_AUTH_H
#define CAMEL_NNTP_AUTH_H 1
return NULL;
}
-
static void
nntp_folder_cache_message (CamelDiscoFolder *disco_folder, const gchar *uid, CamelException *ex)
{
* USA
*/
-
#ifndef CAMEL_NNTP_FOLDER_H
#define CAMEL_NNTP_FOLDER_H 1
return NULL;
}
-
list = g_new0 (CamelNNTPGroupList, 1);
list->store = store;
sscanf (buf, "%lu", &time);
GMutex *lock;
};
-
static NewsrcGroup *
camel_nntp_newsrc_group_add (CamelNNTPNewsrc *newsrc, const gchar *group_name, gboolean subscribed)
{
return count;
}
-
static void
camel_nntp_newsrc_group_mark_range_read(CamelNNTPNewsrc *newsrc, NewsrcGroup *group, glong low, glong high)
{
#define CAMEL_NNTP_STORE_LOCK(f, l) (e_mutex_lock(((CamelNNTPStore *)f)->priv->l))
#define CAMEL_NNTP_STORE_UNLOCK(f, l) (e_mutex_unlock(((CamelNNTPStore *)f)->priv->l))
-
struct _CamelNNTPFolderPrivate {
GMutex *search_lock; /* for locking the search object */
GMutex *cache_lock; /* for locking the cache object */
/* currently, this is just a straigt s/imap/nntp from the IMAP file*/
-
#ifndef _CAMEL_NNTP_STORE_SUMMARY_H
#define _CAMEL_NNTP_STORE_SUMMARY_H
CamelProvider *provider, CamelURL *url,
CamelException *ex);
-
static gboolean
nntp_can_work_offline(CamelDiscoStore *store)
{
* USA
*/
-
#ifndef CAMEL_NNTP_STORE_H
#define CAMEL_NNTP_STORE_H 1
#endif /* CAMEL_NNTP_STORE_H */
-
CamelStream *camel_nntp_stream_new (CamelStream *source);
-
void camel_nntp_stream_set_mode (CamelNNTPStream *is, camel_nntp_stream_mode_t mode);
gint camel_nntp_stream_line (CamelNNTPStream *is, guchar **data, guint *len);
CamelNNTPSummary *cns = CAMEL_NNTP_SUMMARY(s);
gchar *part;
-
if (camel_nntp_summary_parent->summary_header_from_db (s, mir) == -1)
return -1;
return 0;
}
-
static CamelFIRecord *
summary_header_to_db (CamelFolderSummary *s, CamelException *ex)
{
return;
}
-
if (nntp_store->extensions & CAMEL_NNTP_EXT_OVER) {
get_XOVER_headers (nntp_store, folder, first_message, last_message, ex);
}
* USA
*/
-
#ifndef CAMEL_NNTP_UTILS_H
#define CAMEL_NNTP_UTILS_H 1
return pe;
}
-
/**
* camel_pop3_engine_reget_capabilities:
* @engine: pop3 engine
get_capabilities (engine);
}
-
/* TODO: read implementation too?
etc? */
static struct {
camel_store_class->can_refresh_folder = pop3_can_refresh_folder;
}
-
-
static void
camel_pop3_store_init (gpointer object, gpointer klass)
{
* USA
*/
-
#ifndef CAMEL_POP3_STORE_H
#define CAMEL_POP3_STORE_H 1
guint delete_after;
} CamelPOP3Store;
-
-
typedef struct {
CamelStoreClass parent_class;
} CamelPOP3StoreClass;
-
/* public methods */
void camel_pop3_store_expunge (CamelPOP3Store *store, CamelException *ex);
#endif /* CAMEL_POP3_STORE_H */
-
/* This is *identical* to the camel-nntp-stream, so should probably
work out a way to merge them */
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
CamelStream *camel_pop3_stream_new (CamelStream *source);
-
void camel_pop3_stream_set_mode (CamelPOP3Stream *is, camel_pop3_stream_mode_t mode);
gint camel_pop3_stream_line (CamelPOP3Stream *is, guchar **data, guint *len);
camel_provider_register(&sendmail_provider);
}
-
-
CamelAddress *from, CamelAddress *recipients,
CamelException *ex);
-
static void
camel_sendmail_transport_class_init (CamelSendmailTransportClass *camel_sendmail_transport_class)
{
return camel_sendmail_transport_type;
}
-
static gboolean
sendmail_send_to (CamelTransport *transport, CamelMimeMessage *message,
CamelAddress *from, CamelAddress *recipients,
* USA
*/
-
#ifndef CAMEL_SENDMAIL_TRANSPORT_H
#define CAMEL_SENDMAIL_TRANSPORT_H 1
} CamelSendmailTransport;
-
typedef struct {
CamelTransportClass parent_class;
} CamelSendmailTransportClass;
-
/* Standard Camel function */
CamelType camel_sendmail_transport_get_type (void);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
* USA
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
}
pull();
-
for (i=0;i<ARRAY_LEN(mailboxes);i++) {
check_unref(mailboxes[i].folder, 1);
}
return info;
}
-
void camel_test_init(gint argc, gchar **argv)
{
struct stat st;
va_end(ap);
}
-
void camel_test_failv(const gchar *why, va_list ap)
{
gchar *text;
fflush(stdout);
}
-
-
-
/* compare strings, ignore whitespace though */
gint string_equal(const gchar *a, const gchar *b)
{
camel_exception_free(ex);
}
-
/* todo: cross-check everything with folder_info checks as well */
/* this should probably take a folder instead of a session ... */
void
Retrieve message, compare content.
-
Operations:
writing/loading from different types of streams
reading/writing different content
*
*/
-
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <camel/camel-stream-fs.h>
#include <camel/camel-stream-mem.h>
-
#if 0
static void
dump_mime_struct (CamelMimePart *mime_part, gint depth)
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
-
#include <config.h>
#include <stdio.h>
-
#include <config.h>
#include <ctype.h>
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
"as well as test 8bit chars and other fun stuff? 8bit chars: Dra¾en Kaèar\n\nOkay, I guess that covers"
"the basics at least...\n";
-
#define CAMEL_PGP_SESSION_TYPE (camel_pgp_session_get_type ())
#define CAMEL_PGP_SESSION(obj) (CAMEL_CHECK_CAST((obj), CAMEL_PGP_SESSION_TYPE, CamelPgpSession))
#define CAMEL_PGP_SESSION_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_PGP_SESSION_TYPE, CamelPgpSessionClass))
#define CAMEL_PGP_IS_SESSION(o) (CAMEL_CHECK_TYPE((o), CAMEL_PGP_SESSION_TYPE))
-
typedef struct _CamelPgpSession {
CamelSession parent_object;
} CamelPgpSessionClass;
-
static gchar *get_password (CamelSession *session, const gchar *prompt,
guint32 flags,
CamelService *service, const gchar *item,
return session;
}
-
gint main (gint argc, gchar **argv)
{
CamelSession *session;
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define CAMEL_PGP_SESSION_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_PGP_SESSION_TYPE, CamelPgpSessionClass))
#define CAMEL_PGP_IS_SESSION(o) (CAMEL_CHECK_TYPE((o), CAMEL_PGP_SESSION_TYPE))
-
typedef struct _CamelPgpSession {
CamelSession parent_object;
} CamelPgpSessionClass;
-
static gchar *get_password (CamelSession *session, const gchar *prompt,
guint32 flags,
CamelService *service, const gchar *item,
return session;
}
-
gint main (gint argc, gchar **argv)
{
CamelSession *session;
#include "camel-test.h"
-
#define CAMEL_TEST_SESSION_TYPE (camel_test_session_get_type ())
#define CAMEL_TEST_SESSION(obj) (CAMEL_CHECK_CAST((obj), CAMEL_TEST_SESSION_TYPE, CamelTestSession))
#define CAMEL_TEST_SESSION_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_TEST_SESSION_TYPE, CamelTestSessionClass))
#define CAMEL_TEST_IS_SESSION(o) (CAMEL_CHECK_TYPE((o), CAMEL_TEST_SESSION_TYPE))
-
typedef struct _CamelTestSession {
CamelSession parent_object;
} CamelTestSessionClass;
-
static gchar *get_password (CamelSession *session, const gchar *prompt,
guint32 flags, CamelService *service,
const gchar *item, CamelException *ex);
return session;
}
-
gint main (gint argc, gchar **argv)
{
CamelSession *session;
void (*account_removed) (EAccountList *, EAccount *);
} EAccountListClass;
-
GType e_account_list_get_type (void);
EAccountList *e_account_list_new (GConfClient *gconf);
return account;
}
-
static gboolean
xml_set_bool (xmlNodePtr node, const gchar *name, gboolean *val)
{
return changed;
}
-
/**
* e_account_import:
* @dest: destination account object
g_signal_emit(dest, signals[CHANGED], 0, -1);
}
-
/**
* e_account_to_xml:
* @account: an #EAccount
return tmp;
}
-
/**
* e_account_uid_from_xml:
* @xml: an XML account description
void (*changed)(EAccount *, gint field);
} EAccountClass;
-
GType e_account_get_type (void);
EAccount *e_account_new (void);
gchar *e_account_to_xml (EAccount *account);
-
gchar *e_account_uid_from_xml (const gchar *xml);
const gchar *e_account_get_string (EAccount *,
return NULL;
}
-
static gunichar
stripped_char (gunichar ch)
{
{ NULL, NULL }
};
-
-
/* Another copy of this trivial list implementation
Why? This stuff gets called a lot (potentially), should run fast,
and g_list's are f@@#$ed up to make this a hassle */
return n;
}
-
static const gchar *
e_strdown (gchar *str)
{
return str;
}
-
static void
locale_parse_lang (const gchar *locale)
{
return locale_charset;
}
-
const gchar *
e_iconv_locale_language (void)
{
#include "e-list-iterator.h"
#include "e-list.h"
-
static void e_list_iterator_invalidate (EIterator *iterator);
static gboolean e_list_iterator_is_valid (EIterator *iterator);
static void e_list_iterator_set (EIterator *iterator,
}
}
-
/*
string array classes
*/
g_free(strv);
}
-
-
/* string pool stuff */
/* TODO:
}
}
-
static void
e_proxy_class_init (EProxyClass *klass)
{
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
}
static void
Execute a sequence. The last function return is the return type.
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define r(x) /* run debug */
#define d(x) /* general debug */
-
static struct _ESExpTerm * parse_list(ESExp *f, gint gotbrace);
static struct _ESExpTerm * parse_value(ESExp *f);
return e_sexp_result_new(f, ESEXP_RES_UNDEFINED);
}
-
/* this must only be called from inside term evaluation callbacks! */
struct _ESExpResult *
e_sexp_term_eval(struct _ESExp *f, struct _ESExpTerm *t)
return parse_value (f);
}
-
static struct _ESExpTerm *
parse_value(ESExp *f)
{
} value;
};
-
-
struct _ESExp {
#ifdef E_SEXP_IS_G_OBJECT
GObject parent_object;
void e_sexp_input_text (ESExp *f, const gchar *text, gint len);
void e_sexp_input_file (ESExp *f, gint fd);
-
gint e_sexp_parse (ESExp *f);
ESExpResult *e_sexp_eval (ESExp *f);
GHashTable *properties;
};
-
/* Signals. */
enum {
};
static guint signals[LAST_SIGNAL] = { 0 };
-
/* Callbacks. */
static void
g_signal_emit (group, signals[CHANGED], 0);
}
-
/* GObject methods. */
G_DEFINE_TYPE (ESourceGroup, e_source_group, G_TYPE_OBJECT)
(* G_OBJECT_CLASS (e_source_group_parent_class)->finalize) (object);
}
-
/* Initialization. */
static void
g_return_val_if_fail (E_IS_SOURCE_GROUP (group), FALSE);
g_return_val_if_fail (xml != NULL, FALSE);
-
xmldoc = xmlParseDoc (XC xml);
success = e_source_group_update_from_xmldoc (group, xmldoc, changed_return);
return FALSE;
}
-
gchar *
e_source_group_to_xml (ESourceGroup *group)
{
#define E_IS_SOURCE_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_SOURCE_GROUP))
#define E_IS_SOURCE_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_TYPE_SOURCE_GROUP))
-
typedef struct _ESourceGroup ESourceGroup;
typedef struct _ESourceGroupPrivate ESourceGroupPrivate;
typedef struct _ESourceGroupClass ESourceGroupClass;
void (* source_added) (ESourceGroup *source_list, ESource *source);
};
-
GType e_source_group_get_type (void);
ESourceGroup *e_source_group_new (const gchar *name,
gint sync_idle_id;
};
-
/* Signals. */
enum {
};
static guint signals[LAST_SIGNAL] = { 0 };
-
/* Forward declarations. */
static gboolean sync_idle_callback (ESourceList *list);
GConfEntry *entry,
ESourceList *list);
-
/* Utility functions. */
static void
g_signal_emit (list, signals[CHANGED], 0);
}
-
/* Callbacks. */
static gboolean
load_from_gconf (list);
}
-
/* GObject methods. */
G_DEFINE_TYPE (ESourceList, e_source_list, G_TYPE_OBJECT)
(* G_OBJECT_CLASS (e_source_list_parent_class)->finalize) (object);
}
-
/* Initialization. */
static void
return FALSE;
}
-
gboolean
e_source_list_sync (ESourceList *list,
GError **error)
}
}
-
/* If there is mismatch, free the conf_list and return FALSE */
if (!conf_to_list) {
for (p = conf_list; p != NULL; p = p->next) {
#define E_IS_SOURCE_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_SOURCE_LIST))
#define E_IS_SOURCE_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_TYPE_SOURCE_LIST))
-
typedef struct _ESourceList ESourceList;
typedef struct _ESourceListPrivate ESourceListPrivate;
typedef struct _ESourceListClass ESourceListClass;
void (* group_added) (ESourceList *source_list, ESourceGroup *group);
};
-
GType e_source_list_get_type (void);
ESourceList *e_source_list_new (void);
#define ES_CLASS(obj) E_SOURCE_CLASS (G_OBJECT_GET_CLASS (obj))
-
/* Private members. */
struct _ESourcePrivate {
GHashTable *properties;
};
-
/* Signals. */
enum {
};
static guint signals[LAST_SIGNAL] = { 0 };
-
/* Callbacks. */
static void
g_signal_emit (source, signals[CHANGED], 0);
}
-
/* GObject methods. */
G_DEFINE_TYPE (ESource, e_source, G_TYPE_OBJECT)
(* G_OBJECT_CLASS (e_source_parent_class)->dispose) (object);
}
-
/* Initialization. */
static void
return source->priv->readonly;
}
-
#ifndef EDS_DISABLE_DEPRECATED
/**
* e_source_get_color:
return e_source_build_absolute_uri (source);
}
-
static void
property_dump_cb (const xmlChar *key, const xmlChar *value, xmlNodePtr root)
{
xmlSetProp (node, (xmlChar*)"value", value);
}
-
static xmlNodePtr
dump_common_to_xml_node (ESource *source,
xmlNodePtr parent_node)
return node;
}
-
void
e_source_dump_to_xml_node (ESource *source,
xmlNodePtr parent_node)
dump_common_to_xml_node (source, parent_node);
}
-
gchar *
e_source_to_standalone_xml (ESource *source)
{
return source;
}
-
const gchar *
e_source_get_property (ESource *source,
const gchar *property)
g_signal_emit (source, signals[CHANGED], 0);
}
-
void
e_source_foreach_property (ESource *source, GHFunc func, gpointer data)
{
g_hash_table_foreach (priv->properties, func, data);
}
-
static void
copy_property (const gchar *key, const gchar *value, ESource *new_source)
{
e_source_set_property (new_source, key, value);
}
-
ESource *
e_source_copy (ESource *source)
{
#define E_IS_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_SOURCE))
#define E_IS_SOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_TYPE_SOURCE))
-
typedef struct _ESource ESource;
typedef struct _ESourcePrivate ESourcePrivate;
typedef struct _ESourceClass ESourceClass;
void (* changed) (ESource *source);
};
-
GType e_source_get_type (void);
ESource *e_source_new (const gchar *name,
# include "../locale/localeinfo.h"
#endif
-
#ifndef __P
# if defined __GNUC__ || (defined __STDC__ && __STDC__)
# define __P(args) args
# endif /* GCC. */
#endif /* Not __P. */
-
#if ! HAVE_LOCALTIME_R && ! defined localtime_r
# ifdef _LIBC
# define localtime_r __localtime_r
# endif /* ! _LIBC */
#endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
-
#define match_char(ch1, ch2) if (ch1 != ch2) return NULL
#if defined _LIBC && defined __GNUC__ && __GNUC__ >= 2
# define match_string(cs1, s2) \
&& (rp = __strptime_internal (rp, (new_fmt), tm, \
decided, era_cnt LOCALE_ARG)) != NULL)
-
#ifdef _LIBC
/* This is defined in locale/C-time.c in the GNU libc. */
extern const struct locale_data _nl_C_LC_TIME attribute_hidden;
# define ISSPACE(Ch) isspace (Ch)
#endif
-
-
-
#ifndef __isleap
/* Nonzero if YEAR is a leap year (every 4 years,
except every 100th isn't, and every 400th is). */
+ (tm->tm_mday - 1));
}
-
#ifdef _LIBC
gchar *
internal_function
return empty;
}
-
/* Takes a number of format strings for strptime() and attempts to parse a
* string with them.
*/
/* strptime format of a weekday and a date. */
format[num_formats++] = _("%a %m/%d/%Y");
-
/*
* Now try all the above formats again, but without the weekday.
*/
return parse_with_strptime (value, result, format, num_formats);
}
-
/**
* e_time_format_date_and_time:
* @date_tm: The #tm to convert to a string.
buffer[0] = '\0';
}
-
/**
* e_time_format_time:
* @date_tm: The #tm to convert to a string.
buffer[0] = '\0';
}
-
/**
* e_mktime_utc:
* @tm: The #tm to convert to a calendar time representation.
}
#ifdef G_OS_WIN32
-static int _e_string_replace(gchar **str, const gchar *old, const gchar *new)
+static gint _e_string_replace(gchar **str, const gchar *old, const gchar *new)
{
GRegex *my_regex = g_regex_new(old, 0, 0, NULL);
gchar *buf = *str;
res = g_strdup (nl_langinfo (D_FMT) );
#elif defined(G_OS_WIN32)
#define GET_LOCALE_INFO(str, len) GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SLONGDATE, str, len)
- int format_string_length = GET_LOCALE_INFO(NULL, 0);
+ gint format_string_length = GET_LOCALE_INFO(NULL, 0);
if (format_string_length > 0)
{
gsize format_bytes_read, format_bytes_written;
_e_string_replace(&res, "\\byy\\b", "%y"); /* yy -> %y*/
_e_string_replace(&res, "\\byyyy\\b", "%Y"); /* yyyy -> %Y */
_e_string_replace(&res, "\\byyyyy\\b", "%Y"); /* yyyyy -> %Y */
- }
+ }
#undef GET_LOCALE_INFO
/**TODO** implement this for other systems
*/
ETimeParseStatus e_time_parse_date (const gchar *value,
struct tm *result);
-
/* have same behavior like those functions above with two_digit_year set to NULL */
ETimeParseStatus e_time_parse_date_and_time_ex (const gchar *value,
struct tm *result,
gchar *buffer,
gint buffer_size);
-
/* Like mktime(3), but assumes UTC instead of local timezone. */
time_t e_mktime_utc (struct tm *tm);
*
*/
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
EMemChunk *state_chunks;
};
-
static inline gunichar
trie_utf8_getc (const guchar **in, gsize inlen)
{
g_free (trie);
}
-
-
static struct _trie_match *
g (struct _trie_state *s, gunichar c)
{
return q;
}
-
#if 0
static void
dump_trie (struct _trie_state *s, gint depth)
}
#endif
-
/*
* final = empty set
* FOR p = 1 TO #pat
return hash;
}
-
struct save_data {
EXmlHashType type;
xmlDoc *doc;
g_hash_table_destroy (hash);
}
-
/**
* EXmlHash:
*
void e_xml_destroy_hash (GHashTable *hash);
-
-
/**
* EXmlHashStatus:
* @E_XMLHASH_STATUS_SAME: The compared values are the same.
* Modified October 1995 by Erik Troan for RPM
*/
-
#include <stdio.h>
#include <string.h>
#include "md5-utils.h"
-
static void md5_transform (guint32 buf[4], const guint32 in[16]);
-
#if G_BYTE_ORDER == G_BIG_ENDIAN
/*
* Note: this code is not required on little-endian machines.
ctx->bits[1] = 0;
}
-
-
/**
* md5_update: add a buffer to md5 hash computation
* @ctx: context object used for md5 computaion
memcpy (ctx->in, buf, len);
}
-
-
-
-
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
memcpy (digest, ctx->buf, 16);
}
-
-
-
/* The four core functions - F1 is optimized somewhat */
/* #define F1(x, y, z) (x & y | ~x & z) */
buf[3] += d;
}
-
-
-
/**
* md5_get_digest: get the md5 hash of a buffer
* @buffer: byte buffer
memcpy (digest, local_digest, length);
}
-
/**
* md5_get_digest_from_file: get the md5 hash of a file
* @filename: file name
* Modified October 1995 by Erik Troan for RPM
*/
-
#ifndef MD5_UTILS_H
#define MD5_UTILS_H
guchar in[64];
} MD5Context;
-
void md5_get_digest (const gchar *buffer, gint buffer_size, guchar digest[16]);
/* use this one when speed is needed */
static ESourceList *list = NULL;
static gint idle_dump_id = 0;
-
/* Options. */
static gboolean listen = FALSE;
dump_group (E_SOURCE_GROUP (p->data));
}
-
static gint
idle_dump_callback (gpointer unused_data)
{
idle_dump_id = g_idle_add (idle_dump_callback, NULL);
}
-
static void
source_changed_callback (ESource *source)
{
dump_on_idle ();
}
-
static void
connect_source (ESource *source)
{
g_object_unref (source);
}
-
static void
source_added_callback (ESourceGroup *group,
ESource *source)
dump_on_idle ();
}
-
static gint
on_idle_do_stuff (gpointer unused_data)
{
return FALSE;
}
-
gint
main (gint argc, gchar **argv)
{
#ifndef _E_CELL_RENDERER_COLOR_H_
#define _E_CELL_RENDERER_COLOR_H_
-
#include <glib.h>
#include <gtk/gtk.h>
#define E_NAME_SELECTOR_DIALOG_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), E_TYPE_NAME_SELECTOR_DIALOG, ENameSelectorDialogPrivate))
-
static void
e_name_selector_dialog_get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
/* TODO: Remember last used source */
-
/* Set up dialog defaults */
gtk_dialog_add_buttons (GTK_DIALOG (name_selector_dialog),
return;
}
-
priv = E_NAME_SELECTOR_DIALOG_GET_PRIVATE (name_selector_dialog);
section = &g_array_index (name_selector_dialog->sections, Section, priv->destination_index);
void e_name_selector_dialog_set_destination_index (ENameSelectorDialog *name_selector_dialog,
guint index);
-
G_END_DECLS
#endif /* E_NAME_SELECTOR_DIALOG_H */
list->rows = e_destination_store_get_destination_count (((ENameSelectorEntry *) list)->destination_store);
enl_popup_size (list);
-
}
static void
return TRUE;
-
}
static gboolean
continue;
}
-
if (ep_keyring_validate (uri->user, uri->host, uri->protocol, found->attributes)) {
msg->password = g_strdup (found->secret);
break;
1, 2, 3, 4, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
}
-
msg->noreply = noreply;
g_signal_connect (password_dialog, "response", G_CALLBACK (pass_response), msg);
gtk_widget_show ((GtkWidget *)password_dialog);
}
-
/**
* e_passwords_init:
*
/* We set data on each menu item specifying the corresponding ESource using this key. */
#define MENU_ITEM_SOURCE_DATA_ID "ESourceOptionMenu:Source"
-
struct _ESourceOptionMenuPrivate {
ESourceList *source_list;
g_free (foreach_data);
}
-
/* Menu callback. */
static void
select_source (option_menu, source);
}
-
/* Functions to keep the menu in sync with the ESourceList. */
static void
}
}
-
static void
source_list_changed_callback (ESourceList *list,
ESourceOptionMenu *menu)
G_CALLBACK (source_list_changed_callback), G_OBJECT (menu), 0);
}
-
/* GObject methods. */
static void
(* G_OBJECT_CLASS (e_source_option_menu_parent_class)->finalize) (object);
}
-
/* Initialization. */
static void
source_option_menu->priv = priv;
}
-
/* Public methods. */
/**
#define E_IS_SOURCE_OPTION_MENU(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_SOURCE_OPTION_MENU))
#define E_IS_SOURCE_OPTION_MENU_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_TYPE_SOURCE_OPTION_MENU))
-
typedef struct _ESourceOptionMenu ESourceOptionMenu;
typedef struct _ESourceOptionMenuPrivate ESourceOptionMenuPrivate;
typedef struct _ESourceOptionMenuClass ESourceOptionMenuClass;
ESource *selected_source);
};
-
GType e_source_option_menu_get_type (void);
GtkWidget *e_source_option_menu_new (ESourceList *list);
#define E_IS_SOURCE_SELECTOR_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_SOURCE_SELECTOR_DIALOG))
#define E_IS_SOURCE_SELECTOR_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_TYPE_SOURCE_SELECTOR_DIALOG))
-
typedef struct _ESourceSelectorDialog ESourceSelectorDialog;
typedef struct _ESourceSelectorDialogPrivate ESourceSelectorDialogPrivate;
typedef struct _ESourceSelectorDialogClass ESourceSelectorDialogClass;
return rebuild_data;
}
-
static void
free_rebuild_data (ESourceSelectorRebuildData *rebuild_data)
{
if (! gtk_tree_model_get_iter (model, &iter, path))
return FALSE;
-
gtk_tree_model_get (model, &iter, 0, &data, -1);
if (E_IS_SOURCE_GROUP (data)) {
g_object_unref (data);
return TRUE;
}
-
/* Callbacks. */
static void
if (name)
status = g_ascii_strncasecmp (name, key, strlen(key)) != 0;
-
g_object_unref (data);
return status;
g_signal_connect (G_OBJECT (selector), "row-expanded", G_CALLBACK (row_expanded_callback), selector);
}
-
/* Public API. */
/**
g_slist_free (list);
}
-
/**
* e_source_selector_show_selection:
* @selector: An ESourceSelector widget
#define E_IS_SOURCE_SELECTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_SOURCE_SELECTOR))
#define E_IS_SOURCE_SELECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_TYPE_SOURCE_SELECTOR))
-
typedef struct _ESourceSelector ESourceSelector;
typedef struct _ESourceSelectorPrivate ESourceSelectorPrivate;
typedef struct _ESourceSelectorClass ESourceSelectorClass;
gpointer padding3;
};
-
GType e_source_selector_get_type (void);
GtkWidget *e_source_selector_new (ESourceList *list);
g_print ("source selected: \"%s\"\n", e_source_peek_name (source));
}
-
static gint
on_idle_create_widget (const gchar *gconf_path)
{
return FALSE;
}
-
gint
main (gint argc, gchar **argv)
{
return FALSE;
}
-
gint
main (gint argc, gchar **argv)
{
return act;
}
-
/**
* e2k_addr_list_new:
* @nentries: the number of entries
void e2k_actions_free (GPtrArray *actions);
void e2k_action_free (E2kAction *act);
-
E2kAddrList *e2k_addr_list_new (gint nentries);
void e2k_addr_list_set_local (E2kAddrList *list,
gint entry_num,
return ac->exchange_dn ? E2K_AUTOCONFIG_OK : E2K_AUTOCONFIG_FAILED;
}
-
/* FIXME: make this cancellable */
static void
find_global_catalog (E2kAutoconfig *ac)
e2k_uri_free (owa_uri);
}
-
/* Approximate mapping from Exchange timezones to Olson ones. Exchange
* is less specific, so we factor in the language/country info from
* the locale in our guess.
return g_strdup (zonemap[i - 1].olson_name);
}
-
/* Config file handling */
static GHashTable *config_options;
try_auth_again:
username = g_strdup (*user);
-
password = e_passwords_get_password ("Exchange", key);
if (password) {
/* This can be the case, where user presses authenticate button and
E2kAutoconfigResult e2k_autoconfig_check_global_catalog (E2kAutoconfig *ac,
E2kOperation *op);
-
const gchar *e2k_autoconfig_lookup_option (const gchar *option);
G_END_DECLS
static void setup_message (SoupSession *session, SoupMessage *msg, SoupSocket *socket, gpointer user_data);
static void proxy_settings_changed (EProxy *proxy, gpointer user_data);
-
static void
proxy_settings_changed (EProxy *proxy, gpointer user_data)
{
E2K_MAKE_TYPE (e2k_context, E2kContext, class_init, init, PARENT_TYPE)
-
static void
renew_sub_list (gpointer key, gpointer value, gpointer data)
{
return status;
}
-
static void
update_unique_uri (E2kContext *ctx, SoupMessage *msg,
const gchar *folder_uri, const gchar *encoded_name, gint *count,
g_free (uri);
}
-
/* GET */
static SoupMessage *
search_data);
}
-
-
/* DELETE */
static SoupMessage *
return status;
}
-
/* Subscriptions */
typedef struct {
void e2k_context_unsubscribe (E2kContext *ctx,
const gchar *uri);
-
/*
* Utility functions
*/
static void finalize (GObject *);
static gint get_gc_connection (E2kGlobalCatalog *gc, E2kOperation *op);
-
static void
class_init (GObjectClass *object_class)
{
G_OBJECT_CLASS (parent_class)->finalize (object);
}
-
E2K_MAKE_TYPE (e2k_global_catalog, E2kGlobalCatalog, class_init, init, PARENT_TYPE)
static gint
return hostname;
}
-
static void
get_sid_values (E2kGlobalCatalog *gc, E2kOperation *op,
LDAPMessage *msg, E2kGlobalCatalogEntry *entry)
return status;
}
-
struct async_lookup_data {
E2kGlobalCatalog *gc;
E2kOperation *op;
const gchar *password,
E2kAutoconfigGalAuthPref use_auth);
-
typedef enum {
E2K_GLOBAL_CATALOG_OK,
E2K_GLOBAL_CATALOG_NO_SUCH_USER,
gdouble lookup_passwd_max_age (E2kGlobalCatalog *gc,
E2kOperation *op);
-
#define e2k_global_catalog_entry_free(gc, entry)
E2kGlobalCatalogStatus e2k_global_catalog_add_delegate (E2kGlobalCatalog *gc,
g_static_mutex_unlock (&op_mutex);
}
-
/**
* e2k_operation_start:
* @op: an #E2kOperation, or %NULL
g_static_mutex_unlock (&op_mutex);
}
-
/**
* e2k_operation_cancel:
* @op: an #E2kOperation
gpointer data);
void e2k_operation_finish (E2kOperation *op);
-
void e2k_operation_cancel (E2kOperation *op);
gboolean e2k_operation_is_cancelled (E2kOperation *op);
return ppath;
}
-
static gboolean
find_folders_recursive (const gchar *physical_path, const gchar *path,
EPathFindFoldersCallback callback, gpointer data)
return find_folders_recursive (prefix, "", callback, data);
}
-
/**
* e_path_rmdir:
* @prefix: a prefix to prepend to the path, or %NULL
return g_hash_table_size (props->set) == 0;
}
-
extern gchar e2k_des_key[8];
static E2kPropInfo *
E2K_PROPERTIES_SETTER (bool, gboolean, BOOL, g_strdup_printf ("%d", value != FALSE))
E2K_PROPERTIES_SETTER (date, gchar *, DATE, value)
-
-
/**
* e2k_properties_set_type_as_string:
* @props: an #E2kProperties
g_hash_table_destroy (fnd.seen_namespaces);
}
-
static GHashTable *namespaces;
static gint next_namespace = 'a';
static GStaticMutex namespaces_lock = G_STATIC_MUTEX_INIT;
void e2k_properties_remove (E2kProperties *props,
const gchar *propname);
-
typedef void (*E2kPropertiesForeachFunc) (const gchar *propname,
E2kPropType type,
gpointer value,
E2kPropertiesForeachFunc callback,
gpointer user_data);
-
typedef void(*E2kPropertiesForeachNamespaceFunc)(const gchar *namespace,
gchar abbrev,
gpointer user_data);
rn->ref_count++;
}
-
/* SQL export */
static gboolean rn_to_sql (E2kRestriction *rn, GString *sql, E2kRestrictionType inside);
return ret;
}
-
/* Binary import/export */
static gboolean
g_array_free (results_array, FALSE);
}
-
/**
* e2k_results_from_multistatus:
* @msg: a 207 Multi-Status response
g_free (results);
}
-
/* Iterators */
struct E2kResultIter {
E2kContext *ctx;
void e2k_results_free (E2kResult *results,
gint nresults);
-
GArray *e2k_results_array_new (void);
void e2k_results_array_add_from_multistatus (GArray *results_array,
void e2k_results_array_free (GArray *results_array,
gboolean free_results);
-
typedef struct E2kResultIter E2kResultIter;
typedef E2kHTTPStatus (*E2kResultIterFetchFunc) (E2kResultIter *iter,
return TRUE;
}
-
static gchar *
stringify_entryid (guint8 *data, gint len)
{
return TRUE;
}
-
/**
* e2k_rule_append_propvalue:
* @ba: a byte array containing a binary rule
g_byte_array_free (pv->value, TRUE);
}
-
/**
* e2k_rule_free:
* @rule: an #E2kRule
E2K_MAKE_TYPE (e2k_security_descriptor, E2kSecurityDescriptor, class_init, init, PARENT_TYPE)
-
/* This determines the relative ordering of any two ACEs in a SID.
* See docs/security for details.
*/
}
}
-
static xmlNode *
find_child (xmlNode *node, const xmlChar *name)
{
}
}
-
static struct {
const gchar *name;
guint32 perms;
void e2k_security_descriptor_remove_sid (E2kSecurityDescriptor *sd,
E2kSid *sid);
-
/* MAPI folder permissions */
#define E2K_PERMISSION_READ_ANY 0x001
#define E2K_PERMISSION_CREATE 0x002
return sid->priv->display_name;
}
-
/**
* e2k_sid_binary_sid_equal:
* @a: pointer to a binary SID
#define E2K_SID_WKS_ANONYMOUS "S-1-5-7"
#define E2K_SID_WKS_ANONYMOUS_NAME "Anonymous"
-
#endif
return g_datalist_get_data (&uri->params, name);
}
-
#define HEXVAL(c) (isdigit (c) ? (c) - '0' : g_ascii_tolower (c) - 'a' + 10)
/**
gchar *fragment;
} E2kUri;
-
E2kUri * e2k_uri_new (const gchar *uri_string);
void e2k_uri_free (E2kUri *uri);
const gchar *e2k_uri_get_param (E2kUri *uri, const gchar *name);
E2kAutoconfigResult *result,
GtkWindow *parent);
-
G_END_DECLS
#endif /* __EXCHANGE_VALIDATE_H_ */
e2k_results_free (results, nresults);
}
-
#define ALL_PROPS \
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>" \
"<propfind xmlns=\"DAV:\" xmlns:e=\"http://schemas.microsoft.com/exchange/\">" \
gint status;
gchar *eml_str, *top = uri, fav_uri[1024];
-
/* list the contents and search for the favorite properties */
e2k_operation_init (&op);
prop = E2K_PR_DAV_DISPLAY_NAME;
if (entry->user_account_control)
printf (" user_account_control : %d\n", entry->user_account_control);
-
maxAge = lookup_passwd_max_age (gc, &op);
printf("Password max age is %f \n", maxAge);
pwd_exp_days = (maxAge * 0.000000100)/86400;
void test_abort_if_http_error (E2kHTTPStatus status);
-
/* lower-level util */
gchar *test_ask_password (const gchar *prompt);
efe->priv->folder_size = folder_size;
}
-
/**
* e_folder_exchange_get_has_subfolders:
* @folder: an #EFolderExchange
return path;
}
-
/**
* e_folder_exchange_save_to_file:
* @folder: the folder
return folder;
}
-
-
/* E2kContext wrappers */
#define E_FOLDER_EXCHANGE_CONTEXT(efe) (exchange_account_get_context (((EFolderExchange *)efe)->priv->hier->account))
#define E_FOLDER_EXCHANGE_URI(efe) (((EFolderExchange *)efe)->priv->internal_uri)
gboolean e_folder_exchange_save_to_file (EFolder *folder,
const gchar *filename);
-
const gchar *e_folder_exchange_get_internal_uri (EFolder *folder);
void e_folder_exchange_set_internal_uri (EFolder *folder,
const gchar *internal_uri);
ExchangeHierarchy *e_folder_exchange_get_hierarchy (EFolder *folder);
-
/* E2kContext wrappers */
E2kHTTPStatus e_folder_exchange_propfind (EFolder *folder,
E2kOperation *op,
gpointer user_data);
void e_folder_exchange_unsubscribe (EFolder *folder);
-
E2kResultIter *e_folder_exchange_transfer_start (EFolder *source,
E2kOperation *op,
EFolder *dest,
gboolean delete_original,
gchar **permanent_url);
-
G_END_DECLS
#endif /* __E_FOLDER_EXCHANGE_H__ */
traverse_subtree (folder_tree, root_node, foreach_func, data);
}
-
/**
* e_folder_tree_get_path_for_data:
* @folder_tree: A pointer to an EFolderTree
GList *e_folder_type_registry_get_accepted_dnd_types_for_type (EFolderTypeRegistry *folder_type_registry,
const gchar *type_name);
-
G_END_DECLS
#endif /* _E_FOLDER_TYPE_REGISTRY_H_ */
return FALSE;
}
-
/* GObject methods. */
static void
G_OBJECT_CLASS (parent_class)->finalize (object);
}
-
E2K_MAKE_TYPE (exchange_account, ExchangeAccount, class_init, init, PARENT_TYPE)
-
void
exchange_account_rescan_tree (ExchangeAccount *account)
{
};
static const gint n_mailbox_info_props = G_N_ELEMENTS (mailbox_info_props);
-
-
static gboolean
account_moved (ExchangeAccount *account, E2kAutoconfig *ac)
{
return account->priv->account->source->save_passwd;
}
-
/**
* exchange_account_set_offline:
* @account: an #ExchangeAccount
GPtrArray *folders;
};
-
static void
add_folder (gpointer key, gpointer value, gpointer folders)
{
return NULL;
}
-
/**
* exchange_account_new:
* @adata: an #EAccount
void exchange_account_is_offline_sync_set (ExchangeAccount *account,
gint *mode);
-
typedef enum {
EXCHANGE_ACCOUNT_FOLDER_OK,
EXCHANGE_ACCOUNT_FOLDER_ALREADY_EXISTS,
void exchange_account_scan_foreign_hierarchy (ExchangeAccount *account,
const gchar *user_email);
-
G_END_DECLS
#endif /* __EXCHANGE_ACCOUNT_H__ */
#ifndef __EXCHANGE_CONSTANTS_H__
#define __EXCHANGE_CONSTANTS_H__
-
enum {
UNSUPPORTED_MODE = 0,
OFFLINE_MODE,
gdouble folder_size;
} folder_info;
-
struct _ExchangeFolderSizePrivate {
GHashTable *table;
#define EXCHANGE_IS_FOLDER_SIZE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EXCHANGE_TYPE_FOLDER_SIZE))
#define EXCHANGE_IS_FOLDER_SIZE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), EXCHANGE_TYPE_FOLDER_SIZE))
-
typedef struct _ExchangeFolderSize ExchangeFolderSize;
typedef struct _ExchangeFolderSizePrivate ExchangeFolderSizePrivate;
typedef struct _ExchangeFolderSizeClass ExchangeFolderSizeClass;
return result;
}
-
static ExchangeAccountFolderResult
create_folder (ExchangeHierarchy *hier, EFolder *parent,
const gchar *name, const gchar *type)
E2K_MAKE_TYPE (exchange_hierarchy_gal, ExchangeHierarchyGAL, NULL, NULL, PARENT_TYPE)
-
ExchangeHierarchy *
exchange_hierarchy_gal_new (ExchangeAccount *account,
const gchar *hierarchy_name,
E2K_MAKE_TYPE (exchange_hierarchy_somedav, ExchangeHierarchySomeDAV, class_init, init, PARENT_TYPE)
-
static inline gboolean
folder_is_unreadable (E2kProperties *props)
{
return folder_result;
}
-
GPtrArray *
exchange_hierarchy_somedav_get_hrefs (ExchangeHierarchySomeDAV *hsd)
{
GType exchange_hierarchy_somedav_get_type (void);
-
GPtrArray *exchange_hierarchy_somedav_get_hrefs (ExchangeHierarchySomeDAV *hsd);
ExchangeAccountFolderResult exchange_hierarchy_somedav_add_folder (ExchangeHierarchySomeDAV *hsd,
const gchar *uri);
E2K_MAKE_TYPE (exchange_hierarchy_webdav, ExchangeHierarchyWebDAV, class_init, init, PARENT_TYPE)
-
typedef struct {
const gchar *contentclass, *component;
gboolean offline_supported;
return EXCHANGE_ACCOUNT_FOLDER_OK;
}
-
if (!folders_rn) {
folders_rn =
e2k_restriction_andv (
EFolder *folder;
gchar *mf_name;
-
mf_name = g_build_filename (physical_path, "connector-metadata.xml", NULL);
folder = e_folder_exchange_new_from_file (sod->hier, mf_name);
if (!folder) {
gdouble exchange_hierarchy_webdav_get_total_folder_size (ExchangeHierarchyWebDAV *hwd);
-
G_END_DECLS
#endif /* __EXCHANGE_HIERARCHY_WEBDAV_H__ */
E2K_MAKE_TYPE (exchange_hierarchy, ExchangeHierarchy, class_init, NULL, PARENT_TYPE)
-
/**
* exchange_hierarchy_new_folder:
* @hier: the hierarchy
return HIER_CLASS (hier)->is_empty (hier);
}
-
static ExchangeAccountFolderResult
create_folder (ExchangeHierarchy *hier, EFolder *parent,
const gchar *name, const gchar *type)
remove_source);
}
-
static void
rescan (ExchangeHierarchy *hier)
{
HIER_CLASS (hier)->rescan (hier);
}
-
static ExchangeAccountFolderResult
scan_subtree (ExchangeHierarchy *hier, EFolder *folder, gint mode)
{
return HIER_CLASS (hier)->scan_subtree (hier, folder, mode);
}
-
static void
add_to_storage (ExchangeHierarchy *hier)
{
HIER_CLASS (hier)->add_to_storage (hier);
}
-
/**
* exchange_hierarchy_construct:
* @hier: the hierarchy
/* End of DES-defined tables */
-
/* bit 0 is left-most in byte */
static gint bytebit[] = {
0200,0100,040,020,010,04,02,01
};
-
/* Generate key schedule for encryption or decryption
* depending on the value of "decrypt"
*/
#include <ctype.h>
#include <string.h>
-
static guchar NTLM_NEGOTIATE_MESSAGE[] = {
'N', 'T', 'L', 'M', 'S', 'S', 'P', 0x00,
0x01, 0x00, 0x00, 0x00, 0x06, 0x82, 0x00, 0x00,
return message;
}
-
#define GET_SHORTY(p) ((p)[0] + ((p)[1] << 8))
static gchar *
return TRUE;
}
-
static void
ntlm_set_string (GByteArray *ba, gint offset, const gchar *data, gint len)
{
return message;
}
-
static void
setup_schedule (const guchar *key_56, XNTLM_DES_KS ks)
{
xntlm_des (ks, results + 16);
}
-
PROP_AGENT
};
-
static const gchar *GOOGLE_CLIENT_LOGIN = "https://www.google.com/accounts/ClientLogin";
GQuark
return TRUE;
}
-
/**
*
* gdata_google_service_get_feed:
return feed;
}
-
/**
*
* gdata_google_service_insert_entry:
return updated_entry;
}
-
/**
*
* gdata_google_service_delete_entry:
return gdata_google_service_update_entry_with_link (service, entry, entry_edit_url, error);
}
-
/**
*
* gdata_google_update_entry_with_link:
priv->name = NULL;
priv->agent = NULL;
-
priv->auth = g_new0(GDataGoogleServiceAuth,1);
priv->auth->username = NULL;
priv->auth->password = NULL;
}
}
-
static void gdata_google_service_class_init(gpointer g_class,
gpointer g_class_data)
{
gobject_class->dispose = gdata_google_service_dispose;
gobject_class->finalize = gdata_google_service_finalize;
-
g_object_class_install_property(gobject_class, PROP_NAME,
g_param_spec_string("name", "Name",
"The name (e.g. 'cl') of the service",
G_PARAM_STATIC_NICK |
G_PARAM_STATIC_BLURB));
-
g_object_class_install_property(gobject_class, PROP_AGENT,
g_param_spec_string("agent", "Agent",
"The agent (e.g 'evolution', 'tinymail') of the calling program",
return;
}
-
GType gdata_google_service_get_type (void)
{
static GType type = 0;
return type;
}
-
/*********API******* */
/**
*
*/
-
#include <config.h>
/* LibXML2 includes */
g_free (address);
}
-
static void gdata_entry_init (GTypeInstance *instance,
gpointer g_class)
{
return type;
}
-
/*** API ***/
static GDataEntryAuthor *
xmlnode_to_author (xmlDocPtr doc, xmlNodePtr cur)
return address_node;
}
-
/**
* gdata_entry_new:
* Creates a new #GDataEntry.
return priv->start_time;
}
-
/**
* gdata_entry_get_transparency:
* @entry: A #GDataEntry object.
#include <glib.h>
#include <glib-object.h>
-
/* LibXML2 includes */
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
-
G_BEGIN_DECLS
-
#define GDATA_TYPE_ENTRY (gdata_entry_get_type())
#define GDATA_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GDATA_TYPE_ENTRY, GDataEntry))
#define GDATA_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GDATA_TYPE_ENTRY, GDataEntryClass))
typedef struct _GDataEntryClass GDataEntryClass;
typedef struct _GDataEntryPrivate GDataEntryPrivate;
-
struct _GDataEntry {
GObject parent;
gboolean primary;
};
-
GType gdata_entry_get_type(void);
-
/***** API *****/
GDataEntry * gdata_entry_new(void);
#define GDATA_FEED_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDATA_TYPE_FEED, GDataFeedPrivate))
-
struct _GDataFeedAuthor {
gchar *email;
gchar *name;
};
typedef struct _GDataFeedLink GDataFeedLink;
-
-
struct _GDataFeedPrivate {
/* feed information */
if (priv->feedXML != NULL)
g_free(priv->feedXML);
-
/* Chain up to the parent class */
klass = GDATA_FEED_CLASS(g_type_class_peek(GDATA_TYPE_FEED));
parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
GObjectClass *gobject_class = G_OBJECT_CLASS(g_class);
GDataFeedClass *klass = GDATA_FEED_CLASS(g_class);
-
g_type_class_add_private(klass, sizeof (GDataFeedPrivate));
gobject_class->set_property = gdata_feed_set_property;
gobject_class->get_property = gdata_feed_get_property;
-
gobject_class->dispose = gdata_feed_dispose;
gobject_class->finalize = gdata_feed_finalize;
gobject_class->constructor = gdata_feed_constructor;
return type;
}
-
/*** API ***/
static GDataFeedAuthor *
xmlnode_to_author(xmlDocPtr doc, xmlNodePtr cur)
link->title = NULL;
link->type = NULL;
-
value = xmlGetProp(cur, (xmlChar *)"href");
if (value) {
link->href = g_strdup((gchar *)value);
return link;
}
-
static GDataFeedCategory *
xmlnode_to_category(xmlDocPtr doc, xmlNodePtr cur)
{
return g_object_new(GDATA_TYPE_FEED, NULL);
}
-
GDataFeed *
gdata_feed_new_from_xml(const gchar * feedXML, const gint length)
{
return feed;
}
-
gchar *
gdata_feed_generate_xml(GDataFeed *feed)
{
G_BEGIN_DECLS
-
#define GDATA_TYPE_FEED (gdata_feed_get_type())
#define GDATA_FEED(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GDATA_TYPE_FEED, GDataFeed))
#define GDATA_FEED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GDATA_TYPE_FEED, GDataFeedClass))
typedef struct _GDataFeedClass GDataFeedClass;
typedef struct _GDataFeedPrivate GDataFeedPrivate;
-
struct _GDataFeed {
GObject parent;
static GStaticMutex connecting = G_STATIC_MUTEX_INIT;
-
g_static_mutex_lock (&connecting);
/* search the connection in our hash table */
}
}
-
/* not found, so create a new connection */
cnc = g_object_new (E_TYPE_GW_CONNECTION, NULL);
}
-
EGwConnection *
e_gw_connection_new (const gchar *uri, const gchar *username, const gchar *password)
{
subparam = soup_soap_parameter_get_next_child_by_name (subparam, "item")) {
EGwItem *item;
-
item = e_gw_item_new_from_soap_parameter (cnc->priv->user_email, container, subparam);
subsubparam = soup_soap_parameter_get_first_child_by_name(subparam, "sync");
}
-
EGwConnectionStatus
e_gw_connection_get_items (EGwConnection *cnc, const gchar *container, const gchar *view, EGwFilter *filter, GList **list)
{
return E_GW_CONNECTION_STATUS_UNKNOWN;
}
-
e_gw_message_write_string_parameter (msg, "id", NULL, id);
if (view)
return E_GW_CONNECTION_STATUS_OK;
}
-
-
-
-
EGwConnectionStatus
e_gw_connection_remove_item (EGwConnection *cnc, const gchar *container, const gchar *id)
{
return status;
}
-
EGwConnectionStatus
e_gw_connection_get_address_book_id ( EGwConnection *cnc, gchar *book_name, gchar **id , gboolean *is_writable)
{
EGwConnectionPrivate *priv;
static GStaticMutex connecting = G_STATIC_MUTEX_INIT;
-
g_return_val_if_fail (E_IS_GW_CONNECTION (cnc), E_GW_CONNECTION_STATUS_INVALID_OBJECT);
priv = cnc->priv;
g_object_unref (msg);
return status;
-
}
EGwConnectionStatus
g_object_unref (msg);
return status;
-
-
}
-
EGwConnectionStatus
e_gw_connection_create_cursor (EGwConnection *cnc, const gchar *container, const gchar *view, EGwFilter *filter, gint *cursor)
{
}
-
-
EGwConnectionStatus
e_gw_connection_position_cursor (EGwConnection *cnc, const gchar *container, gint cursor, const gchar *seek, gint offset)
{
g_object_unref (msg);
return E_GW_CONNECTION_STATUS_OK;
-
}
-
EGwConnectionStatus
e_gw_connection_create_folder(EGwConnection *cnc, const gchar *parent_name,const gchar *folder_name, gchar **container_id)
{
return E_GW_CONNECTION_STATUS_UNKNOWN;
}
-
e_gw_message_write_string_parameter (msg, "id", NULL, id);
e_gw_message_write_int_parameter (msg, "offset", NULL, offset);
e_gw_message_write_int_parameter (msg, "length", NULL, length);
return status;
}
-
param = soup_soap_response_get_first_parameter_by_name (response, "part");
if (param) {
buf_length = soup_soap_parameter_get_property (param, "length");
return E_GW_CONNECTION_STATUS_UNKNOWN;
}
-
e_gw_message_write_string_parameter (msg, "id", NULL, id);
e_gw_message_write_int_parameter (msg, "offset", NULL, offset);
e_gw_message_write_int_parameter (msg, "length", NULL, length);
return status;
}
-
param = soup_soap_response_get_first_parameter_by_name (response, "part");
if (param) {
buf_length = soup_soap_parameter_get_property (param, "length");
g_return_val_if_fail (id != NULL, E_GW_CONNECTION_STATUS_INVALID_OBJECT);
g_return_val_if_fail (dest_container_id != NULL, E_GW_CONNECTION_STATUS_INVALID_OBJECT);
-
/* build the SOAP message */
msg = e_gw_message_new_with_header (cnc->priv->uri, cnc->priv->session_id, "moveItemRequest");
e_gw_message_write_string_parameter (msg, "id", NULL, id);
g_object_unref (msg);
return status;
-
}
EGwConnectionStatus
EGwConnectionStatus e_gw_connection_get_items_delta_info (EGwConnection *cnc, const gchar *container, gdouble *first_sequence, gdouble *last_sequence, gdouble *last_po_rebuild_time);
EGwConnectionStatus e_gw_connection_get_items_delta (EGwConnection *cnc, const gchar *container, const gchar *view, const gchar *count, const gchar * start_sequence, GList **add_list, GList **delete_list);
-
const gchar *e_gw_connection_get_uri (EGwConnection *cnc);
const gchar *e_gw_connection_get_session_id (EGwConnection *cnc);
const gchar *e_gw_connection_get_user_name (EGwConnection *cnc);
const gchar *e_gw_connection_get_version (EGwConnection *cnc);
const gchar *e_gw_connection_get_server_time (EGwConnection *cnc);
-
time_t e_gw_connection_get_date_from_string (const gchar *dtstring);
gchar *e_gw_connection_format_date_string (const gchar *dtstring);
-
EGwConnectionStatus e_gw_connection_create_item (EGwConnection *cnc, EGwItem *item, gchar ** id);
EGwConnectionStatus e_gw_connection_get_item (EGwConnection *cnc, const gchar *container, const gchar *id, const gchar *view, EGwItem **item);
EGwConnectionStatus e_gw_connection_modify_item (EGwConnection *cnc, const gchar *id, EGwItem *item);
g_free (value);
}
-
/* retrive the unread and total count */
subparam = soup_soap_parameter_get_first_child_by_name (param, "hasUnread");
if (!subparam) {
}
-
gboolean
e_gw_container_get_is_writable (EGwContainer *container)
{
};
-
-
void
e_gw_filter_add_filter_component (EGwFilter *filter, EGwFilterOpType operation, const gchar *field_name, const gchar *field_value)
{
}
-
if (operation_name != NULL) {
e_gw_message_write_string_parameter (msg, "op", NULL, operation_name);
soup_soap_message_end_element (msg);
}
-
-
static GSList*
append_complex_component (GSList *component_list, SoupSoapMessage *msg)
{
else
append_child_component (filter_component, msg);
-
}
soup_soap_message_end_element (msg);
filter->priv = priv;
}
-
static void
e_gw_filter_class_init (EGwFilterClass *klass)
{
#ifndef E_GW_FILTER_H
#define E_GW_FILTER_H
-
#include "soup-soap-message.h"
#include "soup-soap-response.h"
typedef struct _EGwFilterClass EGwFilterClass;
typedef struct _EGwFilterPrivate EGwFilterPrivate;
-
typedef enum {
E_GW_FILTER_OP_AND,
E_GW_FILTER_OP_OR,
priv->parent_threads = NULL;
item->priv = priv;
-
}
GType
}
/*FIXME gw recipientTypes need to be added after the server is fixed. */
-
/* update Recipient Status
look for accepted/declined and update the item else set it
to none. */
{
return item->priv->email_list;
-
}
void
}
}
-
}
static void
}
}
-
subparam = soup_soap_parameter_get_first_child_by_name(param, "phoneList");
if(subparam) {
g_hash_table_insert (simple_fields, (gpointer) "default_phone", soup_soap_parameter_get_property(subparam, "default"));
}
}
-
}
static void
g_hash_table_insert (simple_fields, (gpointer) "website", value);
}
-
}
static void
item->priv->trigger = trigger;
}
-
void
e_gw_item_set_to (EGwItem *item, const gchar *to)
{
return item->priv->track_info;
}
-
void
e_gw_item_set_autodelete (EGwItem *item, gboolean set)
{
else
e_gw_message_write_string_parameter (msg, "allDayEvent", NULL ,"0");
-
if (priv->trigger != 0) {
alarm = g_strdup_printf ("%d", priv->trigger);
e_gw_message_write_string_parameter_with_attribute (msg, "alarm", NULL, alarm, "enabled", "1");
return TRUE;
}
-
static void
append_contact_changes_to_soap_message (EGwItem *item, SoupSoapMessage *msg, gint change_type)
{
} EGwItemType;
-
typedef enum {
E_GW_ITEM_CHANGE_TYPE_ADD,
E_GW_ITEM_CHANGE_TYPE_UPDATE,
gchar *e_gw_item_get_delay_until (EGwItem *item);
void e_gw_item_free_cal_id (EGwItemCalId *calid);
-
#define E_GW_ITEM_CLASSIFICATION_PUBLIC "Public"
#define E_GW_ITEM_CLASSIFICATION_PRIVATE "Private"
#define E_GW_ITEM_CLASSIFICATION_CONFIDENTIAL "Confidential"
GSList * e_gw_item_get_attach_id_list (EGwItem *item);
void e_gw_item_set_attach_id_list (EGwItem *item, GSList *attach_list);
-
GSList *e_gw_item_get_recurrence_dates (EGwItem *item);
void e_gw_item_set_recurrence_dates (EGwItem *item, GSList *new_recurrence_dates);
const gchar *e_gw_item_get_parent_thread_ids (EGwItem *item);
const gchar * e_gw_item_get_message_id (EGwItem *item);
-
typedef struct {
gchar *email;
gchar *display_name;
const gchar *value);
void e_gw_message_write_int_parameter (SoupSoapMessage *msg, const gchar *name, const gchar *prefix, glong value);
-
void e_gw_message_write_footer (SoupSoapMessage *msg);
G_END_DECLS
#define E_GW_PROXY_MODIFY_FOLDERS (1 << 10)
#define E_GW_PROXY_READ_PRIVATE (1 << 11)
-
struct _proxyHandler {
gchar *uniqueid;
gchar *proxy_name;
return days_of_week [day-1];
}
-
-
#define E_GW_ITEM_RECURRENCE_FREQUENCY_MONTHLY "Monthly"
#define E_GW_ITEM_RECURRENCE_FREQUENCY_YEARLY "Yearly"
-
#define E_GW_ITEM_RECUR_OCCURRENCE_TYPE_FIRST "First"
#define E_GW_ITEM_RECUR_OCCURRENCE_TYPE_SECOND "Second"
#define E_GW_ITEM_RECUR_OCCURRENCE_TYPE_THIRD "Third"
short by_setpos [E_GW_ITEM_BY_SETPOS_SIZE];
} EGwItemRecurrenceRule;
-
#define E_GW_ITEM_RECUR_END_MARKER 0x7f7f
-
-
const gchar *e_gw_recur_get_day_of_week (short day);
#endif
} else
sopts->opened = E_GW_RETURN_NOTIFY_NONE;
-
} else if (!g_ascii_strcasecmp (field + i, "ReturnDelete")) {
if (val_param)
val_param = soup_soap_parameter_get_first_child_by_name (val_param, "mail");
} else
sopts->accepted = E_GW_RETURN_NOTIFY_NONE;
-
} else if (!g_ascii_strcasecmp (field + i, "ReturnCompleted")) {
if (val_param)
val_param = soup_soap_parameter_get_first_child_by_name (val_param, "mail");
return opts;
}
-
priv->doc->encoding = xmlCharStrdup ("UTF-8");
}
-
static xmlNsPtr
fetch_ns (SoupSoapMessage *msg, const gchar *prefix, const gchar *ns_uri)
{
priv->xmldoc = xmlNewDoc ((const xmlChar *)"1.0");
}
-
/**
* soup_soap_response_new:
*
return node;
}
-
gint
soup_soap_response_dump_response (SoupSoapResponse *response, FILE *buffer)
{
gint soup_soap_response_dump_response (SoupSoapResponse *response, FILE *buffer);
-
G_END_DECLS
#endif
gboolean is_offline_now;
};
-
static void
set_online_status (OfflineListener *offline_listener, gboolean is_offline)
{
}
-
static void
setup_offline_listener (OfflineListener *offline_listener)
{
}
-
static void
offline_listener_dispose (GObject *object)
{
}
-
-
static void
offline_listener_class_init (OfflineListener *klass)
{
object_class->dispose = offline_listener_dispose;
object_class->finalize = offline_listener_finalize;
-
-
}
-
GType
offline_listener_get_type (void)
{
#define OFFLINE_IS_LISTENER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), OFFLINE_TYPE_LISTENER))
#define OFFLINE_IS_LISTENER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), OFFLINE_TYPE_LISTENER))
-
typedef struct _OfflineListener OfflineListener;
typedef struct _OfflineListenerPrivate OfflineListenerPrivate;
typedef struct _OfflineListenerClass OfflineListenerClass;
};
-
GType offline_listener_get_type (void);
#if ENABLE_CALENDAR
return result == Bonobo_ACTIVATION_REG_SUCCESS;
}
-
#ifdef DEBUG_BACKENDS
static void
dump_backends (gint signal)