alx/mu4e
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* initial import of mu - the next generation

Browse Source
This commit is contained in:
Dirk-Jan C. Binnema
2009-11-25 22:55:06 +02:00
commit 2b0aca1bf7
34 changed files with 5140 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/Makefile.am Normal file
View File

@ -0,0 +1,36 @@
INCLUDES=$(XAPIAN_CXXFLAGS) $(GMIME_CFLAGS) $(GLIB_CFLAGS)
bin_PROGRAMS= \
mu
mu_SOURCES= \
mu-index.c \
mu-index.h \
mu-msg-fields.c \
mu-msg-fields.h \
mu-msg-flags.c \
mu-msg-flags.h \
mu-msg-gmime.c \
mu-msg-gmime.h \
mu-msg-str.c \
mu-msg-str.h \
mu-msg-xapian-priv.hh \
mu-msg-xapian.cc \
mu-msg-xapian.h \
mu-query.h \
mu-query.c \
mu-query-xapian.cc \
mu-query-xapian.h \
mu-path.c \
mu-path.h \
mu-result.h \
mu-store-xapian.cc \
mu-store-xapian.h \
mu-util.h \
mu-util.c \
mu.c
mu_LDADD= \
$(XAPIAN_LIBS) \
$(GMIME_LIBS) \
$(GLIB_LIBS)

284
src/mu-index.c Normal file
View File

@ -0,0 +1,284 @@
/*
** Copyright (C) 2008, 2009 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
1** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /*HAVE_CONFIG_H*/
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <glib.h>
#include <glib/gstdio.h>
#include <errno.h>
#include "mu-path.h"
#include "mu-index.h"
#include "mu-store-xapian.h"
struct _MuIndex {
MuStoreXapian *_xapian;
};
MuIndex*
mu_index_new (const char *xpath)
{
MuIndex *index;
g_return_val_if_fail (xpath, NULL);
do {
index = g_new0 (MuIndex, 1);
index->_xapian = mu_store_xapian_new (xpath);
if (!index->_xapian) {
g_warning ("%s: failed to get xapian store (%s)",
__FUNCTION__, xpath);
break;
}
return index;
} while (0);
mu_index_destroy (index);
return NULL;
}
void
mu_index_destroy (MuIndex *index)
{
if (!index)
return;
mu_store_xapian_destroy (index->_xapian);
g_free (index);
}
struct _MuIndexCallbackData {
MuIndexMsgCallback _idx_msg_cb;
MuIndexDirCallback _idx_dir_cb;
MuStoreXapian* _xapian;
void* _user_data;
MuIndexStats* _stats;
gboolean _force;
time_t _dirstamp;
};
typedef struct _MuIndexCallbackData MuIndexCallbackData;
static MuResult
insert_or_update_maybe (const char* fullpath, time_t filestamp,
MuIndexCallbackData *data, gboolean *updated)
{
MuMsgGMime *msg;
*updated = FALSE;
if ((size_t)filestamp <= (size_t)data->_dirstamp) {
if (!data->_force)
return MU_OK;
}
msg = mu_msg_gmime_new (fullpath);
if (!msg) {
g_warning ("%s: failed to create mu_msg for %s",
__FUNCTION__, fullpath);
return MU_ERROR;
}
/* we got a valid id; scan the message contents as well */
if (mu_store_xapian_store (data->_xapian, msg) != MU_OK) {
g_warning ("%s: storing content %s failed", __FUNCTION__,
fullpath);
/* ignore...*/
}
mu_msg_gmime_destroy (msg);
*updated = TRUE;
return MU_OK;
}
static MuResult
run_msg_callback_maybe (MuIndexCallbackData *data)
{
if (data && data->_idx_msg_cb) {
MuResult result =
data->_idx_msg_cb (data->_stats, data->_user_data);
if (result != MU_OK && result != MU_STOP)
g_warning ("%s: callback said %d",
__FUNCTION__, result);
}
return MU_OK;
}
static MuResult
on_run_maildir_msg (const char* fullpath, time_t filestamp,
MuIndexCallbackData *data)
{
MuResult result;
gboolean updated;
result = run_msg_callback_maybe (data);
if (result != MU_OK)
return result;
/* see if we need to update/insert anything...*/
result = insert_or_update_maybe (fullpath, filestamp, data,
&updated);
/* update statistics */
if (result == MU_OK && data && data->_stats) {
++data->_stats->_processed;
if (data && data->_stats) {
if (updated)
++data->_stats->_updated;
else
++data->_stats->_uptodate;
}
}
return result;
}
static MuResult
on_run_maildir_dir (const char* fullpath, gboolean enter,
MuIndexCallbackData *data)
{
/* xapian stores a per-dir timestamp; we use this timestamp
* to determine whether a message is up-to-data
*/
if (enter)
data->_dirstamp =
mu_store_xapian_get_timestamp (data->_xapian,
fullpath);
else
mu_store_xapian_set_timestamp (data->_xapian, fullpath,
time(NULL));
if (data->_idx_dir_cb)
return data->_idx_dir_cb (fullpath, enter,
data->_user_data);
return MU_OK;
}
static gboolean
check_path (const char* path)
{
g_return_val_if_fail (path, FALSE);
if (!g_path_is_absolute (path)) {
g_warning ("%s: path is not absolute '%s'",
__FUNCTION__, path);
return FALSE;
}
if (access (path, R_OK) != 0) {
g_warning ("%s: cannot open '%s': %s",
__FUNCTION__, path, strerror (errno));
return FALSE;
}
return TRUE;
}
MuResult
mu_index_run (MuIndex *index, const char* path,
gboolean force, MuIndexStats *stats,
MuIndexMsgCallback msg_cb, MuIndexDirCallback dir_cb,
void *user_data)
{
MuIndexCallbackData cb_data;
g_return_val_if_fail (index && index->_xapian, MU_ERROR);
g_return_val_if_fail (check_path (path), MU_ERROR);
cb_data._idx_msg_cb = msg_cb;
cb_data._idx_dir_cb = dir_cb;
cb_data._user_data = user_data;
cb_data._xapian = index->_xapian;
cb_data._stats = stats;
cb_data._force = force;
cb_data._dirstamp = 0;
return mu_path_walk_maildir (path,
(MuPathWalkMsgCallback)on_run_maildir_msg,
(MuPathWalkDirCallback)on_run_maildir_dir,
&cb_data);
}
static MuResult
on_stats_maildir_file (const char *fullpath, time_t timestamp,
MuIndexCallbackData *cb_data)
{
MuResult result;
if (cb_data && cb_data->_idx_msg_cb)
result = cb_data->_idx_msg_cb (cb_data->_stats,
cb_data->_user_data);
else
result = MU_OK;
if (result == MU_OK) {
if (cb_data->_stats)
++cb_data->_stats->_processed;
return MU_OK;
} else
return result; /* MU_STOP or MU_OK */
}
MuResult
mu_index_stats (MuIndex *index, const char* path,
MuIndexStats *stats, MuIndexMsgCallback cb_msg,
MuIndexDirCallback cb_dir, void *user_data)
{
MuIndexCallbackData cb_data;
g_return_val_if_fail (index, MU_ERROR);
g_return_val_if_fail (check_path (path), MU_ERROR);
cb_data._idx_msg_cb = cb_msg;
cb_data._idx_dir_cb = cb_dir;
cb_data._stats = stats;
cb_data._user_data = user_data;
cb_data._dirstamp = 0;
return mu_path_walk_maildir (path,
(MuPathWalkMsgCallback)on_stats_maildir_file,
NULL,&cb_data);
}
MuResult
mu_index_cleanup (MuIndex *index, MuIndexStats *stats,
MuIndexMsgCallback msg_cb,
MuIndexDirCallback dir_cb, void *user_data)
{
/* FIXME: implement this */
return MU_OK;
}

145
src/mu-index.h Normal file
View File

@ -0,0 +1,145 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_INDEX_H__
#define __MU_INDEX_H__
#include "mu-result.h" /* for MuResult */
/* opaque structure */
struct _MuIndex;
typedef struct _MuIndex MuIndex;
struct _MuIndexStats {
int _processed; /* number of msgs processed or counted */
int _updated; /* number of msgs new or updated */
int _cleaned_up; /* number of msgs cleaned up */
int _uptodate; /* number of msgs already uptodate */
};
typedef struct _MuIndexStats MuIndexStats;
/**
* create a new MuIndex instance. NOTE(1): the database does not
* have to exist yet, but the directory already has to exist;
* NOTE(2): before doing anything with the returned Index object,
* make sure you haved called g_type_init, and mu_msg_init somewhere
* in your code.
*
* @param xpath path to the xapian db to store the results
*
* @return a new MuIndex instance, or NULL in case of error
*/
MuIndex* mu_index_new (const char* xpath);
/**
* destroy the index instance
*
* @param index a MuIndex instance, or NULL
*/
void mu_index_destroy (MuIndex *index);
/**
* callback function for mu_index_(run|stats|cleanup), for each message
*
* @param stats pointer to structure to receive statistics data
* @param user_data pointer to user data
*
* @return MU_OK to continue, MU_STOP to stop, or MU_ERROR in
* case of some error.
*/
typedef MuResult (*MuIndexMsgCallback) (MuIndexStats* stats, void *user_data);
/**
* callback function for mu_index_(run|stats|cleanup), for each dir enter/leave
*
* @param path dirpath we just entered / left
* @param enter did we enter (TRUE) or leave(FALSE) the dir?
* @param user_data pointer to user data
*
* @return MU_OK to contiue, MU_STOP to stopd or MU_ERROR in
* case of some error.
*/
typedef MuResult (*MuIndexDirCallback) (const char* path, gboolean enter,
void *user_data);
/**
* start the indexing process
*
* @param index a valid MuIndex instance
* @param path the path to index
* @param force if != 0, force re-indexing already index messages; this is
* obviously a lot slower than only indexing new/changed messages
* @param result a structure with some statistics about the results
* @param cb_msg a callback function called for every msg indexed;
* @param cb_dir a callback function called for every dir entered/left;
* @param user_data a user pointer that will be passed to the callback function
*
* @return MU_OK if the stats gathering was completed succesfully,
* MU_STOP if the user stopped or MU_ERROR in
* case of some error.
*/
MuResult mu_index_run (MuIndex *index, const char* path, gboolean force,
MuIndexStats *result, MuIndexMsgCallback msg_cb,
MuIndexDirCallback dir_cb, void *user_data);
/**
* gather some statistics about the Maildir; this is usually much faster
* than mu_index_run, and can thus be used to provide some information to the user
* note though that the statistics may be different from the reality that
* mu_index_run sees, when there are updates in the Maildir
*
* @param index a valid MuIndex instance
* @param path the path to get stats for
* @param result a structure with some statistics about the results
* @param cb a callback function which will be called for every msg;
* @param user_data a user pointer that will be passed to the callback function
* xb
* @return MU_OK if the stats gathering was completed succesfully,
* MU_STOP if the user stopped or MU_ERROR in
* case of some error.
*/
MuResult mu_index_stats (MuIndex *index, const char* path, MuIndexStats *result,
MuIndexMsgCallback msg_cb, MuIndexDirCallback dir_cb,
void *user_data);
typedef MuResult (*MuIndexCleanupCallback) (MuIndexStats*, void *user_data);
/**
* cleanup the database; ie. remove entries for which no longer a corresponding
* file exists in the maildir
*
* @param index a valid MuIndex instance
* @param result a structure with some statistics about the results
* @param cb a callback function which will be called for every msg;
* @param user_data a user pointer that will be passed to the callback function
*
* @return MU_OK if the stats gathering was completed succesfully,
* MU_STOP if the user stopped or MU_ERROR in
* case of some error.
*/
MuResult mu_index_cleanup (MuIndex *index, MuIndexStats *result,
MuIndexMsgCallback msg_cb, MuIndexDirCallback dir_cb,
void *user_data);
#endif /*__MU_INDEX_H__*/

260
src/mu-msg-fields.c Normal file
View File

@ -0,0 +1,260 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <string.h>
#include "mu-msg-fields.h"
enum _FieldFlags {
FLAG_XAPIAN = 1 << 1, /* field available in xapian */
FLAG_GMIME = 1 << 2, /* field available in gmime */
FLAG_INDEX = 1 << 3 /* field is indexable */
};
typedef enum _FieldFlags FieldFlags;
struct _MuMsgField {
const char *_name;
const char *_shortcut;
const char *_prefix;
MuMsgFieldId _id;
MuMsgFieldType _type;
FieldFlags _flags;
};
static const MuMsgField FIELD_DATA[] = {
{ "body", "b", "B",
MU_MSG_FIELD_ID_BODY_TEXT,
MU_MSG_FIELD_TYPE_STRING,
FLAG_XAPIAN | FLAG_GMIME | FLAG_INDEX
},
{ "bodyhtml", "h", NULL,
MU_MSG_FIELD_ID_BODY_HTML,
MU_MSG_FIELD_TYPE_STRING,
FLAG_GMIME
},
{ "cc", "c", "C",
MU_MSG_FIELD_ID_CC,
MU_MSG_FIELD_TYPE_STRING,
FLAG_XAPIAN | FLAG_GMIME | FLAG_INDEX
},
{ "date", "d", "D",
MU_MSG_FIELD_ID_DATE,
MU_MSG_FIELD_TYPE_TIME_T,
FLAG_XAPIAN | FLAG_GMIME
},
{ "flags", "F", "G",
MU_MSG_FIELD_ID_FLAGS,
MU_MSG_FIELD_TYPE_INT,
FLAG_XAPIAN | FLAG_GMIME
},
{ "from", "f", "F",
MU_MSG_FIELD_ID_FROM,
MU_MSG_FIELD_TYPE_STRING,
FLAG_XAPIAN | FLAG_GMIME | FLAG_INDEX
},
{ "path", "p", "P",
MU_MSG_FIELD_ID_PATH,
MU_MSG_FIELD_TYPE_STRING,
FLAG_XAPIAN | FLAG_GMIME
},
{ "prio", "P", "I",
MU_MSG_FIELD_ID_PRIORITY,
MU_MSG_FIELD_TYPE_INT,
FLAG_XAPIAN | FLAG_GMIME
},
{ "size", "z", "Z",
MU_MSG_FIELD_ID_SIZE,
MU_MSG_FIELD_TYPE_BYTESIZE,
FLAG_XAPIAN | FLAG_GMIME
},
{ "subject", "s", "S",
MU_MSG_FIELD_ID_SUBJECT,
MU_MSG_FIELD_TYPE_STRING,
FLAG_XAPIAN | FLAG_GMIME | FLAG_INDEX
},
{ "to", "t", "T",
MU_MSG_FIELD_ID_TO,
MU_MSG_FIELD_TYPE_STRING,
FLAG_XAPIAN | FLAG_GMIME | FLAG_INDEX
},
{ "msgid", "m", NULL,
MU_MSG_FIELD_ID_MSGID,
MU_MSG_FIELD_TYPE_STRING,
FLAG_GMIME
},
{ "timestamp", "i", NULL,
MU_MSG_FIELD_ID_TIMESTAMP,
MU_MSG_FIELD_TYPE_TIME_T,
FLAG_GMIME
},
{ NULL, NULL, NULL, 0, 0, 0 }
};
void
mu_msg_field_foreach (MuMsgFieldForEachFunc func, gconstpointer data)
{
const MuMsgField* cursor = &FIELD_DATA[0];
while (cursor->_name) {
func (cursor, data);
++cursor;
}
}
typedef gboolean (*FieldMatchFunc) (const MuMsgField *field,
gconstpointer data);
static const MuMsgField*
find_field (FieldMatchFunc matcher, gconstpointer data)
{
const MuMsgField* cursor = &FIELD_DATA[0];
while (cursor->_name) {
if (matcher (cursor, data))
return cursor;
++cursor;
}
return NULL;
}
static gboolean
match_name (const MuMsgField *field, const gchar* name)
{
return strcmp (field->_name, name) == 0;
}
const MuMsgField*
mu_msg_field_from_name (const char* str)
{
g_return_val_if_fail (str, NULL);
return find_field ((FieldMatchFunc)match_name, str);
}
static gboolean
match_shortcut (const MuMsgField *field, char kar)
{
return field->_shortcut[0] == kar;
}
const MuMsgField*
mu_msg_field_from_shortcut (char kar)
{
return find_field ((FieldMatchFunc)match_shortcut,
GUINT_TO_POINTER((guint)kar));
}
static gboolean
match_id (const MuMsgField *field, MuMsgFieldId id)
{
return field->_id == id;
}
const MuMsgField*
mu_msg_field_from_id (MuMsgFieldId id)
{
return find_field ((FieldMatchFunc)match_id,
GUINT_TO_POINTER(id));
}
gboolean
mu_msg_field_is_xapian_enabled (const MuMsgField *field)
{
g_return_val_if_fail (field, FALSE);
return field->_flags & FLAG_XAPIAN;
}
gboolean
mu_msg_field_is_gmime_enabled (const MuMsgField *field)
{
g_return_val_if_fail (field, FALSE);
return field->_flags & FLAG_GMIME;
}
gboolean
mu_msg_field_is_xapian_indexable (const MuMsgField *field)
{
g_return_val_if_fail (field, FALSE);
return field->_flags & FLAG_INDEX;
}
gboolean
mu_msg_field_is_numeric (const MuMsgField *field)
{
MuMsgFieldType type;
g_return_val_if_fail (field, FALSE);
type = mu_msg_field_type (field);
return type == MU_MSG_FIELD_TYPE_BYTESIZE ||
type == MU_MSG_FIELD_TYPE_TIME_T ||
type == MU_MSG_FIELD_TYPE_INT;
}
const char*
mu_msg_field_name (const MuMsgField *field)
{
g_return_val_if_fail (field, NULL);
return field->_name;
}
const char*
mu_msg_field_shortcut (const MuMsgField *field)
{
g_return_val_if_fail (field, NULL);
return field->_shortcut;
}
MuMsgFieldId
mu_msg_field_id (const MuMsgField *field)
{
g_return_val_if_fail (field, MU_MSG_FIELD_ID_NONE);
return field->_id;
}
const char*
mu_msg_field_xapian_prefix (const MuMsgField *field)
{
g_return_val_if_fail (field, NULL);
return field->_prefix;
}
MuMsgFieldType
mu_msg_field_type (const MuMsgField *field)
{
g_return_val_if_fail (field, MU_MSG_FIELD_TYPE_NONE);
return field->_type;
}

88
src/mu-msg-fields.h Normal file
View File

@ -0,0 +1,88 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_MSG_FIELDS_H__
#define __MU_MSG_FIELDS_H__
#include <glib.h>
G_BEGIN_DECLS
/* don't change the order, add new types at the end */
enum _MuMsgFieldId {
MU_MSG_FIELD_ID_BODY_TEXT,
MU_MSG_FIELD_ID_BODY_HTML,
MU_MSG_FIELD_ID_CC,
MU_MSG_FIELD_ID_DATE,
MU_MSG_FIELD_ID_FLAGS,
MU_MSG_FIELD_ID_FROM,
MU_MSG_FIELD_ID_PATH,
MU_MSG_FIELD_ID_PRIORITY,
MU_MSG_FIELD_ID_SIZE,
MU_MSG_FIELD_ID_SUBJECT,
MU_MSG_FIELD_ID_TO,
MU_MSG_FIELD_ID_MSGID,
MU_MSG_FIELD_ID_TIMESTAMP,
MU_MSG_FIELD_ID_NUM,
};
typedef enum _MuMsgFieldId MuMsgFieldId;
static const guint MU_MSG_FIELD_ID_NONE = MU_MSG_FIELD_ID_NUM + 1;
struct _MuMsgField;
typedef struct _MuMsgField MuMsgField;
/* don't change the order, add new types at the end */
enum _MuMsgFieldType {
MU_MSG_FIELD_TYPE_STRING,
MU_MSG_FIELD_TYPE_BYTESIZE,
MU_MSG_FIELD_TYPE_TIME_T,
MU_MSG_FIELD_TYPE_INT,
MU_MSG_FIELD_TYPE_NUM
};
typedef enum _MuMsgFieldType MuMsgFieldType;
static const guint MU_MSG_FIELD_TYPE_NONE = MU_MSG_FIELD_TYPE_NUM + 1;
typedef void (*MuMsgFieldForEachFunc) (const MuMsgField *field,
gconstpointer data);
void mu_msg_field_foreach (MuMsgFieldForEachFunc func, gconstpointer data);
const char* mu_msg_field_name (const MuMsgField *field) G_GNUC_CONST;
const char* mu_msg_field_shortcut (const MuMsgField *field) G_GNUC_CONST;
const char* mu_msg_field_xapian_prefix (const MuMsgField *field) G_GNUC_PURE;
MuMsgFieldId mu_msg_field_id (const MuMsgField *field) G_GNUC_CONST;
MuMsgFieldType mu_msg_field_type (const MuMsgField *field) G_GNUC_CONST;
gboolean mu_msg_field_is_numeric (const MuMsgField *field) G_GNUC_CONST;
gboolean mu_msg_field_is_xapian_enabled (const MuMsgField *field) G_GNUC_PURE;
gboolean mu_msg_field_is_gmime_enabled (const MuMsgField *field) G_GNUC_PURE;
gboolean mu_msg_field_is_xapian_indexable (const MuMsgField *field) G_GNUC_PURE;
const MuMsgField* mu_msg_field_from_name (const char* str) G_GNUC_PURE;
const MuMsgField* mu_msg_field_from_shortcut (char kar) G_GNUC_CONST;
const MuMsgField* mu_msg_field_from_id (MuMsgFieldId) G_GNUC_CONST;
G_END_DECLS
#endif /*__MU_MSG_FIELDS_H__*/

199
src/mu-msg-flags.c Normal file
View File

@ -0,0 +1,199 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 3, or (at your option) any
** later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <glib.h>
#include <string.h>
#include "mu-msg-flags.h"
static struct {
char kar;
MuMsgFlags flag;
gboolean file_flag;
} FLAG_CHARS[] = {
{'D', MU_MSG_FLAG_DRAFT, TRUE},
{'F', MU_MSG_FLAG_FLAGGED, TRUE},
{'N', MU_MSG_FLAG_NEW, TRUE},
{'P', MU_MSG_FLAG_PASSED, TRUE},
{'R', MU_MSG_FLAG_REPLIED, TRUE},
{'S', MU_MSG_FLAG_SEEN, TRUE},
{'T', MU_MSG_FLAG_TRASHED, TRUE},
{'a', MU_MSG_FLAG_HAS_ATTACH, FALSE},
{'s', MU_MSG_FLAG_SIGNED, FALSE},
{'x', MU_MSG_FLAG_ENCRYPTED, FALSE}
};
MuMsgFlags
mu_msg_flags_from_str (const char* str)
{
MuMsgFlags flags = 0;
while (str[0]) {
int i;
MuMsgFlags oneflag = MU_MSG_FLAG_UNKNOWN;
for (i = 0; i != G_N_ELEMENTS(FLAG_CHARS); ++i) {
if (str[0] == FLAG_CHARS[i].kar) {
oneflag = FLAG_CHARS[i].flag;
break;
}
}
if (oneflag == MU_MSG_FLAG_UNKNOWN)
return MU_MSG_FLAG_UNKNOWN;
else
flags |= oneflag;
++str;
}
return flags;
}
MuMsgFlags
mu_msg_flags_from_char (char c)
{
char str[2];
str[0] = c;
str[1] = '\0';
return mu_msg_flags_from_str (str);
}
const char*
mu_msg_flags_to_str_s (MuMsgFlags flags)
{
int i = 0, j = 0;
static char buf[G_N_ELEMENTS(FLAG_CHARS) + 1];
for (i = 0; i != G_N_ELEMENTS(FLAG_CHARS); ++i)
if (flags & FLAG_CHARS[i].flag)
buf[j++] = FLAG_CHARS[i].kar;
buf[j] = '\0';
return buf;
}
gboolean
mu_msg_flags_is_file_flag (MuMsgFlags flag)
{
int i = 0;
for (i = 0; i != G_N_ELEMENTS(FLAG_CHARS); ++i)
if (flag == FLAG_CHARS[i].flag)
return FLAG_CHARS[i].file_flag;
return FALSE;
}
/*
* is this a 'new' msg or a 'cur' msg?; if new, we return
* (in info) a ptr to the info part
*/
enum _MsgType {
MSG_TYPE_CUR,
MSG_TYPE_NEW,
MSG_TYPE_OTHER
};
typedef enum _MsgType MsgType;
static MsgType
check_msg_type (const char* path, char **info)
{
char *dir, *file;
MsgType mtype;
/* try to find the info part */
/* note that we can use either the ':' or '!' as separator;
* the former is the official, but as it does not work on e.g. VFAT
* file systems, some Maildir implementations use the latter instead
* (or both). For example, Tinymail/modest does this. The python
* documentation at http://docs.python.org/lib/mailbox-maildir.html
* mentions the '!' as well as a 'popular choice'
*/
dir = g_path_get_dirname (path);
file = g_path_get_basename (path);
if (!(*info = strrchr(file, ':')))
*info = strrchr (file, '!'); /* Tinymail */
if (*info)
++(*info); /* skip the ':' or '!' */
if (g_str_has_suffix (dir, G_DIR_SEPARATOR_S "cur")) {
if (!*info)
g_message ("'cur' file, but no info part: %s", path);
mtype = MSG_TYPE_CUR;
} else if (g_str_has_suffix (dir, G_DIR_SEPARATOR_S "new")) {
/* if (*info) */
/* g_message ("'new' file, ignoring info part: %s", path); */
mtype = MSG_TYPE_NEW;
} else
mtype = MSG_TYPE_OTHER; /* file has been added explicitly as
a single message */
if (*info)
*info = g_strdup (*info);
g_free (dir);
g_free (file);
return mtype;
}
MuMsgFlags
mu_msg_flags_from_file (const char* path)
{
MuMsgFlags flags;
MsgType mtype;
char *info = NULL;
g_return_val_if_fail (path, MU_MSG_FLAG_UNKNOWN);
g_return_val_if_fail (!g_str_has_suffix(path,G_DIR_SEPARATOR_S),
MU_MSG_FLAG_UNKNOWN);
mtype = check_msg_type (path, &info);
/* we ignore any flags for a new message */
if (mtype == MSG_TYPE_NEW) {
g_free (info);
return MU_MSG_FLAG_NEW;
}
flags = 0;
if (mtype == MSG_TYPE_CUR || mtype == MSG_TYPE_OTHER) {
char *cursor = info;
/* only support the "2," format */
if (cursor && cursor[0]=='2' && cursor[1]==',') {
cursor += 2; /* jump past 2, */
while (*cursor) {
MuMsgFlags oneflag =
mu_msg_flags_from_char (*cursor);
/* ignore anything but file flags */
if (mu_msg_flags_is_file_flag(oneflag))
flags |= oneflag;
++cursor;
}
}
}
g_free (info);
return flags;
}

117
src/mu-msg-flags.h Normal file
View File

@ -0,0 +1,117 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 3, or (at your option) any
** later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_MSG_FLAGS_H__
#define __MU_MSG_FLAGS_H__
#include <glib.h>
G_BEGIN_DECLS
enum _MuMsgFlags {
MU_MSG_FLAG_UNKNOWN = 0,
MU_MSG_FLAG_NONE = 1 << 0,
/* these we get from the file */
MU_MSG_FLAG_NEW = 1 << 1,
MU_MSG_FLAG_SEEN = 1 << 2,
MU_MSG_FLAG_UNREAD = 1 << 3,
MU_MSG_FLAG_REPLIED = 1 << 4,
MU_MSG_FLAG_FLAGGED = 1 << 5,
MU_MSG_FLAG_TRASHED = 1 << 6,
MU_MSG_FLAG_DRAFT = 1 << 7,
MU_MSG_FLAG_PASSED = 1 << 8,
/* these we get from the contents */
MU_MSG_FLAG_SIGNED = 1 << 10,
MU_MSG_FLAG_ENCRYPTED = 1 << 11,
MU_MSG_FLAG_HAS_ATTACH = 1 << 12
/* any new fields go here */
/* so the existing numbers stay valid note that we're also */
/* using these numbers in the database, so they should not change */
};
typedef enum _MuMsgFlags MuMsgFlags;
/**
* convert the char-per-flag description into a MuMsgFlags value; the characters
* D=draft,F=flagged,N=new,P=passed,R=replied,S=seen,T=trashed
* a=has-attachment,s=signed, x=encrypted
* if any other characters are seen, MU_MSG_FLAG_UNKNOWN is returned.
*
* @param str a string
*
* @return a MuMSgFlags value, or MU_MSG_FLAG_UNKNOWN in case of error
*/
MuMsgFlags mu_msg_flags_from_str (const char* str) G_GNUC_PURE;
/**
* convert the char-per-flag description into a MuMsgFlags value; NOTE, each
* of the characters must be a valid
*
* @param c a character
*
* @return a MuMSgFlags value, or MU_MSG_FLAG_UNKNOWN in case of error
*/
MuMsgFlags mu_msg_flags_from_char (char c) G_GNUC_CONST;
/**
* get a string for a given set of flags, OR'ed in
* @param flags; one character per flag:
* D=draft,F=flagged,N=new,P=passed,R=replied,S=seen,T=trashed
* a=has-attachment,s=signed, x=encrypted
*
* mu_msg_flags_to_str_s returns a ptr to a static buffer, ie.,
* ie, is not re-entrant. copy the string if needed.
*
* @param flags file flags
*
* @return a string representation of the flags
*/
const char* mu_msg_flags_to_str_s (MuMsgFlags flags) G_GNUC_CONST;
/**
* get the Maildir flags from a mailfile. The flags are as specified
* in http://cr.yp.to/proto/maildir.html, plus MU_MSG_FLAG_NEW for
* new messages, ie the ones that live in new/. The flags are
* logically OR'ed. Note that the file does not have to exist; the
* flags are based on the name only.
*
* @param pathname of a mailfile; it does not have to refer to an
* actual message
*
* @return the flags, or MU_MSG_FILE_FLAG_UNKNOWN in case of error
*/
MuMsgFlags mu_msg_flags_from_file (const char* pathname) G_GNUC_PURE;
/**
* is the message flag a file flag? ie. encoded in the filename
*
* @param flag the flag to check; note, this should be a single flag
* not some flags OR'ed together
*
* @return TRUE if it is a file flag, FALSE otherwise
*/
gboolean mu_msg_flags_is_file_flag (MuMsgFlags flag) G_GNUC_CONST;
G_END_DECLS
#endif /*__MU_MSG_FLAGS_H__*/

849
src/mu-msg-gmime.c Normal file
View File

@ -0,0 +1,849 @@
/*
** Copyright (C) 2008, 2009 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <gmime/gmime.h>
#include <stdlib.h>
#include <ctype.h>
#include "mu-msg-gmime.h"
enum StringFields {
HTML_FIELD = 0,
TEXT_FIELD,
TO_FIELD,
CC_FIELD,
PATH_FIELD,
FLAGS_FIELD_STR,
FIELD_NUM
};
struct _MuMsgGMime {
GMimeMessage *_mime_msg;
MuMsgFlags _flags;
char* _fields[FIELD_NUM];
size_t _size;
time_t _timestamp;
MuMsgPriority _prio;
};
void
mu_msg_gmime_destroy (MuMsgGMime *msg)
{
int i;
if (!msg)
return;
if (G_IS_OBJECT(msg->_mime_msg)) {
g_object_unref (msg->_mime_msg);
msg->_mime_msg = NULL;
}
for (i = 0; i != FIELD_NUM; ++i)
g_free (msg->_fields[i]);
g_slice_free (MuMsgGMime, msg);
}
static gboolean
init_file_metadata (MuMsgGMime* msg, const char* path)
{
struct stat statbuf;
if (access (path, R_OK) != 0) {
g_warning ("%s: cannot read file %s: %s",
__FUNCTION__, path, strerror(errno));
return FALSE;
}
if (stat (path, &statbuf) < 0) {
g_warning ("%s: cannot stat %s: %s",
__FUNCTION__, path, strerror(errno));
return FALSE;
}
if (!S_ISREG(statbuf.st_mode)) {
g_warning ("%s: not a regular file: %s",
__FUNCTION__, path);
return FALSE;
}
msg->_timestamp = statbuf.st_mtime;
msg->_size = statbuf.st_size;
msg->_fields[PATH_FIELD] = strdup (path);
return TRUE;
}
static gboolean
init_mime_msg (MuMsgGMime *msg)
{
FILE *file;
GMimeStream *stream;
GMimeParser *parser;
file = fopen (mu_msg_gmime_get_path(msg), "r");
if (!file) {
g_warning ("%s:cannot open %s: %s",
__FUNCTION__, mu_msg_gmime_get_path(msg),
strerror (errno));
return FALSE;
}
stream = g_mime_stream_file_new (file);
if (!stream) {
g_warning ("%s: cannot create mime stream", __FUNCTION__);
fclose (file);
return FALSE;
}
parser = g_mime_parser_new_with_stream (stream);
g_object_unref (stream);
if (!parser) {
g_warning ("%s: cannot create mime parser", __FUNCTION__);
return FALSE;
}
msg->_mime_msg = g_mime_parser_construct_message (parser);
g_object_unref (parser);
if (!msg->_mime_msg) {
g_warning ("%s: cannot create mime message", __FUNCTION__);
return FALSE;
}
return TRUE;
}
MuMsgGMime*
mu_msg_gmime_new (const char* filepath)
{
MuMsgGMime *msg;
g_return_val_if_fail (filepath, NULL);
msg = g_slice_new0 (MuMsgGMime);
if (!msg)
return NULL;
if (!init_file_metadata(msg, filepath)) {
mu_msg_gmime_destroy (msg);
return NULL;
}
if (!init_mime_msg(msg)) {
mu_msg_gmime_destroy (msg);
return NULL;
}
return msg;
}
const char*
mu_msg_gmime_get_path (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, NULL);
return msg->_fields[PATH_FIELD];
}
const char*
mu_msg_gmime_get_subject (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, NULL);
return g_mime_message_get_subject (msg->_mime_msg);
}
const char*
mu_msg_gmime_get_msgid (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, NULL);
return g_mime_message_get_message_id (msg->_mime_msg);
}
const char*
mu_msg_gmime_get_from (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, NULL);
return g_mime_message_get_sender (msg->_mime_msg);
}
const char*
mu_msg_gmime_get_to (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, NULL);
if (!msg->_fields[TO_FIELD]) {
char *to;
InternetAddressList *recps;
recps = g_mime_message_get_recipients (msg->_mime_msg,
GMIME_RECIPIENT_TYPE_TO);
/* FIXME */
to = (char*)internet_address_list_to_string (recps, TRUE);
if (to && strlen(to) == 0)
g_free (to);
else
msg->_fields[TO_FIELD] = to;
}
return msg->_fields[TO_FIELD];
}
const char*
mu_msg_gmime_get_cc (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, NULL);
if (!msg->_fields[CC_FIELD]) {
char *cc;
InternetAddressList *recps;
recps = g_mime_message_get_recipients (msg->_mime_msg,
GMIME_RECIPIENT_TYPE_CC);
cc = internet_address_list_to_string (recps, TRUE);
if (cc && strlen(cc) == 0)
g_free (cc);
else
msg->_fields[CC_FIELD] = cc;
}
return msg->_fields[CC_FIELD];
}
time_t
mu_msg_gmime_get_date (MuMsgGMime *msg)
{
time_t t;
g_return_val_if_fail (msg, 0);
/* TODO: is the GMT-offset relevant? */
g_mime_message_get_date(msg->_mime_msg, &t, NULL);
return t;
}
static gboolean
part_is_inline (GMimeObject *part)
{
GMimeContentDisposition *disp;
gboolean result;
const char *str;
g_return_val_if_fail (GMIME_IS_PART(part), FALSE);
disp = g_mime_object_get_content_disposition (part);
if (!GMIME_IS_CONTENT_DISPOSITION(disp))
return FALSE;
str = g_mime_content_disposition_get_disposition (disp);
/* if it's not inline, it's an attachment */
result = (str && (strcmp(str,GMIME_DISPOSITION_INLINE) == 0));
return result;
}
static void
msg_cflags_cb (GMimeObject *parent, GMimeObject *part, MuMsgFlags *flags)
{
if (GMIME_IS_PART(part))
if ((*flags & MU_MSG_FLAG_HAS_ATTACH) == 0)
if (!part_is_inline(part))
*flags |= MU_MSG_FLAG_HAS_ATTACH;
}
static MuMsgFlags
get_content_flags (MuMsgGMime *msg)
{
GMimeContentType *ctype;
MuMsgFlags flags = 0;
GMimeObject *part;
if (!GMIME_IS_MESSAGE(msg->_mime_msg)) {
g_warning ("Neeeeee!");
return 0;
}
g_mime_message_foreach (msg->_mime_msg,
(GMimeObjectForeachFunc)msg_cflags_cb,
&flags);
/* note: signed or encrypted status for a message is determined by
* the top-level mime-part
*/
if ((part = g_mime_message_get_mime_part(msg->_mime_msg))) {
ctype = g_mime_object_get_content_type
(GMIME_OBJECT(part));
if (!ctype) {
g_warning ("not a content type!");
return 0;
}
if (ctype) {
if (g_mime_content_type_is_type (ctype,"*", "signed"))
flags |= MU_MSG_FLAG_SIGNED;
if (g_mime_content_type_is_type (ctype,"*", "encrypted"))
flags |= MU_MSG_FLAG_ENCRYPTED;
}
} else
g_warning ("No top level mime part ?!");
return flags;
}
MuMsgFlags
mu_msg_gmime_get_flags (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, MU_MSG_FLAG_UNKNOWN);
if (msg->_flags == MU_MSG_FLAG_UNKNOWN) {
msg->_flags = 0;
msg->_flags = mu_msg_flags_from_file (mu_msg_gmime_get_path(msg));
msg->_flags |= get_content_flags (msg);
}
return msg->_flags;
}
size_t
mu_msg_gmime_get_size (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, -1);
return msg->_size;
}
static char*
to_lower (char *s)
{
char *t = s;
while (t&&*t) {
t[0] = g_ascii_tolower(t[0]);
++t;
}
return s;
}
static char*
get_prio_str (MuMsgGMime *msg)
{
const char *str;
GMimeObject *obj;
obj = GMIME_OBJECT(msg->_mime_msg);
str = g_mime_object_get_header (obj, "X-Priority");
if (!str)
str = g_mime_object_get_header (obj, "X-MSMail-Priority");
if (!str)
str = g_mime_object_get_header (obj, "Importance");
if (!str)
str = g_mime_object_get_header (obj, "Precedence");
if (str)
return (to_lower(g_strdup(str)));
else
return NULL;
}
static MuMsgPriority
parse_prio_str (const char* priostr)
{
int i;
struct {
const char* _str;
MuMsgPriority _prio;
} str_prio[] = {
{ "high", MU_MSG_PRIORITY_HIGH },
{ "1", MU_MSG_PRIORITY_HIGH },
{ "2", MU_MSG_PRIORITY_HIGH },
{ "normal", MU_MSG_PRIORITY_NORMAL },
{ "3", MU_MSG_PRIORITY_NORMAL },
{ "low", MU_MSG_PRIORITY_LOW },
{ "list", MU_MSG_PRIORITY_LOW },
{ "bulk", MU_MSG_PRIORITY_LOW },
{ "4", MU_MSG_PRIORITY_LOW },
{ "5", MU_MSG_PRIORITY_LOW }
};
for (i = 0; i != G_N_ELEMENTS(str_prio); ++i)
if (g_strstr_len (priostr, -1, str_prio[i]._str) != NULL)
return str_prio[i]._prio;
/* e.g., last-fm uses 'fm-user'... as precedence */
return MU_MSG_PRIORITY_NORMAL;
}
MuMsgPriority
mu_msg_gmime_get_priority (MuMsgGMime *msg)
{
char* priostr;
MuMsgPriority prio;
g_return_val_if_fail (msg, 0);
if (msg->_prio != MU_MSG_PRIORITY_NONE)
return msg->_prio;
priostr = get_prio_str (msg);
if (!priostr)
return MU_MSG_PRIORITY_NORMAL;
prio = parse_prio_str (priostr);
g_free (priostr);
return prio;
}
const char*
mu_msg_gmime_get_header (MuMsgGMime *msg, const char* header)
{
g_return_val_if_fail (msg, NULL);
g_return_val_if_fail (header, NULL);
return g_mime_object_get_header (GMIME_OBJECT(msg->_mime_msg),
header);
}
time_t
mu_msg_gmime_get_timestamp (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, 0);
return msg->_timestamp;
}
struct _GetBodyData {
GMimeObject *_txt_part, *_html_part;
gboolean _want_html;
};
typedef struct _GetBodyData GetBodyData;
static void
get_body_cb (GMimeObject *parent, GMimeObject *part, GetBodyData *data)
{
GMimeContentDisposition *disp;
GMimeContentType *ct;
/* already found what we're looking for? */
if ((data->_want_html && data->_html_part != NULL) ||
(!data->_want_html && data->_txt_part != NULL))
return;
ct = g_mime_object_get_content_type (part);
if (!GMIME_IS_CONTENT_TYPE(ct)) {
g_warning ("not a content type!");
return;
}
/* is it not an attachment? */
disp = g_mime_object_get_content_disposition (GMIME_OBJECT(part));
if (GMIME_IS_CONTENT_DISPOSITION(disp)) {
const char *str;
str = g_mime_content_disposition_get_disposition (disp);
if (str && (strcmp(str,GMIME_DISPOSITION_INLINE) != 0))
return; /* not inline, so it's not the body */
}
/* is it right content type? */
if (g_mime_content_type_is_type (ct, "text", "plain"))
data->_txt_part = part;
else if (g_mime_content_type_is_type (ct, "text", "html"))
data->_html_part = part;
else
return; /* wrong type */
}
/* turn \0-terminated buf into ascii (which is a utf8 subset);
* convert any non-ascii into '.'
*/
static void
asciify (char *buf)
{
char *c;
for (c = buf; c && *c; ++c)
if (!isascii(*c))
c[0] = '.';
}
/* NOTE: buffer will be *freed* or returned unchanged */
static char*
convert_to_utf8 (GMimePart *part, char *buffer)
{
GMimeContentType *ctype;
const char* charset;
GError *err = NULL;
g_return_val_if_fail (GMIME_IS_OBJECT(part), NULL);
ctype = g_mime_object_get_content_type (GMIME_OBJECT(part));
if (!GMIME_IS_CONTENT_TYPE(ctype)) {
g_warning ("not a content type!");
return NULL;
}
charset = g_mime_content_type_get_parameter (ctype, "charset");
if (charset)
charset = g_mime_charset_iconv_name (charset);
/* of course, the charset specified may be incorrect... */
if (charset) {
char * utf8 = g_convert_with_fallback (buffer, -1, "UTF-8",
charset, (gchar*)".",
NULL, NULL,
&err);
if (!utf8) {
/* g_message ("%s: conversion failed from %s: %s", */
/* __FUNCTION__, charset, */
/* err ? err ->message : ""); */
if (err)
g_error_free (err);
} else {
g_free (buffer);
return utf8;
}
}
/* hmmm.... no charset at all, or conversion failed; ugly hack:
* replace all non-ascii chars with '.' instead... TODO: come up
* with something better */
asciify (buffer);
return buffer;
}
static char*
part_to_string (GMimePart *part, gboolean convert_utf8)
{
GMimeDataWrapper *wrapper;
GMimeStream *stream = NULL;
ssize_t buflen, bytes;
char *buffer = NULL;
g_return_val_if_fail (GMIME_IS_OBJECT(part), NULL);
wrapper = g_mime_part_get_content_object (part);
if (!wrapper) {
g_warning ("failed to create data wrapper");
goto cleanup;
}
stream = g_mime_stream_mem_new ();
if (!stream) {
g_warning ("failed to create mem stream");
goto cleanup;
}
buflen = g_mime_data_wrapper_write_to_stream (wrapper, stream);
if (buflen == 0) /* empty buffer */
goto cleanup;
buffer = (char*)malloc(buflen + 1);
if (!buffer) {
g_warning ("failed to allocate %d bytes", (int)buflen);
goto cleanup;
}
g_mime_stream_reset (stream);
/* we read everything in one go */
bytes = g_mime_stream_read (stream, buffer, buflen);
if (bytes < 0) {
free (buffer);
buffer = NULL;
} else
buffer[bytes]='\0';
/* convert_to_utf8 will free the old 'buffer' if needed */
if (buffer && convert_utf8)
buffer = convert_to_utf8 (part, buffer);
cleanup:
if (stream)
g_object_unref (G_OBJECT(stream));
/* if (wrapper) */
/* g_object_unref (G_OBJECT(wrapper)); */
return buffer;
}
static char*
mu_msg_gmime_get_body (MuMsgGMime *msg, gboolean want_html)
{
GetBodyData data;
g_return_val_if_fail (msg, NULL);
g_return_val_if_fail (GMIME_IS_OBJECT(msg->_mime_msg), NULL);
memset (&data, 0, sizeof(GetBodyData));
data._want_html = want_html;
g_mime_message_foreach (msg->_mime_msg,
(GMimeObjectForeachFunc)get_body_cb,
&data);
if (want_html)
return data._html_part ? part_to_string (GMIME_PART(data._html_part), FALSE) : NULL;
else
return data._txt_part ? part_to_string (GMIME_PART(data._txt_part), TRUE) : NULL;
}
const char*
mu_msg_gmime_get_body_html (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, NULL);
if (msg->_fields[HTML_FIELD])
return msg->_fields[HTML_FIELD];
else {
return msg->_fields[HTML_FIELD] = mu_msg_gmime_get_body (msg, TRUE);
}
}
const char*
mu_msg_gmime_get_body_text (MuMsgGMime *msg)
{
g_return_val_if_fail (msg, NULL);
if (msg->_fields[TEXT_FIELD])
return msg->_fields[TEXT_FIELD];
else
return msg->_fields[TEXT_FIELD] = mu_msg_gmime_get_body (msg, FALSE);
}
const char*
mu_msg_gmime_get_field_string (MuMsgGMime *msg, const MuMsgField* field)
{
MuMsgFieldId id;
g_return_val_if_fail (msg, NULL);
id = mu_msg_field_id (field);
g_return_val_if_fail (id != MU_MSG_FIELD_ID_NONE, NULL);
switch (id) {
case MU_MSG_FIELD_ID_BODY_TEXT: return mu_msg_gmime_get_body_text (msg);
case MU_MSG_FIELD_ID_BODY_HTML: return mu_msg_gmime_get_body_html (msg);
case MU_MSG_FIELD_ID_CC: return mu_msg_gmime_get_cc (msg);
case MU_MSG_FIELD_ID_FROM: return mu_msg_gmime_get_from (msg);
case MU_MSG_FIELD_ID_PATH: return mu_msg_gmime_get_path (msg);
case MU_MSG_FIELD_ID_SUBJECT: return mu_msg_gmime_get_subject (msg);
case MU_MSG_FIELD_ID_TO: return mu_msg_gmime_get_to (msg);
case MU_MSG_FIELD_ID_MSGID: return mu_msg_gmime_get_to (msg);
default:
g_return_val_if_reached (NULL);
}
}
gint64
mu_msg_gmime_get_field_numeric (MuMsgGMime *msg, const MuMsgField* field)
{
MuMsgFieldId id;
g_return_val_if_fail (msg, 0);
id = mu_msg_field_id (field);
g_return_val_if_fail (id != MU_MSG_FIELD_ID_NONE, 0);
switch (id) {
case MU_MSG_FIELD_ID_DATE:
return mu_msg_gmime_get_date(msg);
case MU_MSG_FIELD_ID_FLAGS:
return mu_msg_gmime_get_flags(msg);
case MU_MSG_FIELD_ID_PRIORITY:
return mu_msg_gmime_get_priority(msg);
case MU_MSG_FIELD_ID_SIZE:
return mu_msg_gmime_get_size(msg);
default:
g_warning ("%s: %u", __FUNCTION__, (guint)id);
g_return_val_if_reached (0);
}
}
static int
mu_msg_gmime_get_contacts_from (MuMsgGMime *msg, MuMsgGMimeContactsCallback cb,
void *ptr)
{
int i;
InternetAddressList *list;
/* we go through this whole excercise of trying to get a *list*
* of 'From:' address (usually there is only one...), because
* internet_address_parse_string has the nice side-effect of
* splitting in names and addresses for us */
list = internet_address_list_parse_string (
g_mime_message_get_sender (msg->_mime_msg));
for (i = 0; i != internet_address_list_length(list); ++i) {
MuMsgContact contact; /* stack allocated */
InternetAddress *addr =
internet_address_list_get_address (list, i);
if (addr) {
int result;
contact._name = internet_address_get_name (addr);
contact._type = MU_MSG_CONTACT_TYPE_FROM;
/* we only support internet addresses;
* if we don't check, g_mime hits an assert
*/
contact._addr = internet_address_mailbox_get_addr
(INTERNET_ADDRESS_MAILBOX(addr));
result = (cb)(&contact,ptr);
/* note: don't unref addr here, as it's owned */
/* by the list (at least that is what valgrind tells... */
if ((result = (cb)(&contact,ptr)) != 0) {
/* callback tells us to stop */
if (list)
g_object_unref (G_OBJECT(list));
return result;
}
}
}
if (list)
g_object_unref (G_OBJECT(list));
return 0;
}
int
mu_msg_gmime_get_contacts_foreach (MuMsgGMime *msg,
MuMsgGMimeContactsCallback cb,
void *ptr)
{
int i, result;
struct {
GMimeRecipientType _gmime_type;
MuMsgContactType _type;
} ctypes[] = {
{GMIME_RECIPIENT_TYPE_TO, MU_MSG_CONTACT_TYPE_TO},
{GMIME_RECIPIENT_TYPE_CC, MU_MSG_CONTACT_TYPE_CC},
{GMIME_RECIPIENT_TYPE_BCC, MU_MSG_CONTACT_TYPE_BCC},
};
g_return_val_if_fail (cb && msg, -1);
/* first, get the from address */
if ((result = mu_msg_gmime_get_contacts_from (msg, cb, ptr)) != 0)
return result; /* callback told us to stop */
for (i = 0; i != sizeof(ctypes)/sizeof(ctypes[0]); ++i) {
MuMsgContact contact; /* stack allocated */
InternetAddressList *list;
int i;
list = g_mime_message_get_recipients
(msg->_mime_msg, ctypes[i]._gmime_type);
for (i = 0; i != internet_address_list_length(list); ++i) {
InternetAddress *addr =
internet_address_list_get_address (list, i);
if (addr) {
contact._name = internet_address_get_name (addr);
contact._type = ctypes[i]._type;
/* we only support internet addresses;
* if we don't check, g_mime hits an assert
*/
contact._addr = internet_address_mailbox_get_addr(
INTERNET_ADDRESS_MAILBOX(addr));
result = (cb)(&contact,ptr);
if (result != 0) /* callback tells us to stop */
return result;
}
}
}
return 0;
}
static gboolean _initialized = FALSE;
void
mu_msg_gmime_init (void)
{
if (!_initialized) {
g_mime_init(0);
_initialized = TRUE;
}
}
void
mu_msg_gmime_uninit (void)
{
if (_initialized) {
g_mime_shutdown();
_initialized = FALSE;
}
}

267
src/mu-msg-gmime.h Normal file
View File

@ -0,0 +1,267 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_MSG_READ_H__
#define __MU_MSG_READ_H__
#include "mu-msg.h"
#include "mu-path.h"
G_BEGIN_DECLS
struct _MuMsgGMime;
typedef struct _MuMsgGMime MuMsgGMime;
/**
* initialize the message parsing system; this function must be called
* before doing any message parsing (ie., any of the other
* mu_msg_gmime functions). when done with the message parsing system,
* call mu_msg_gmime_uninit. Note: calling this function on an already
* initialized system has no effect
*/
void mu_msg_gmime_init (void);
/**
* uninitialize the messge parsing system that has previously been
* initialized with mu_msg_init. not calling mu_msg_uninit after
* mu_msg_init has been called will lead to memory leakage. Note:
* calling mu_msg_uninit on an uninitialized system has no
* effect
*/
void mu_msg_gmime_uninit (void);
/**
* create a new MuMsgGMime* instance which parses a message and provides
* read access to its properties; call mu_msg_destroy when done with
* done with it.
*
* @param path full path to an email message file
*
* @return a new MuMsgGMime instance or NULL in case of error
*/
MuMsgGMime* mu_msg_gmime_new (const char* filepath);
/**
* destroy a MuMsgGMime* instance; call this function when done with
* a MuMsgGMime
*
* @param msg a MuMsgGMime* instance or NULL
*/
void mu_msg_gmime_destroy (MuMsgGMime *msg);
/**
* get the plain text body of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the plain text body or NULL in case of error or if there is no
* such body. the returned string should *not* be modified or freed.
* The returned data is in UTF8 or NULL.
*/
const char* mu_msg_gmime_get_body_text (MuMsgGMime *msg);
/**
* get the html body of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the html body or NULL in case of error or if there is no
* such body. the returned string should *not* be modified or freed.
*/
const char* mu_msg_gmime_get_body_html (MuMsgGMime *msg);
/**
* get the sender (From:) of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the sender of this Message or NULL in case of error or if there
* is no sender. the returned string should *not* be modified or freed.
*/
const char* mu_msg_gmime_get_from (MuMsgGMime *msg);
/**
* get the recipients (To:) of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the sender of this Message or NULL in case of error or if there
* are no recipients. the returned string should *not* be modified or freed.
*/
const char* mu_msg_gmime_get_to (MuMsgGMime *msg);
/**
* get the carbon-copy recipients (Cc:) of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the Cc: recipients of this Message or NULL in case of error or if
* there are no such recipients. the returned string should *not* be modified
* or freed.
*/
const char* mu_msg_gmime_get_cc (MuMsgGMime *msg);
/**
* get the file system path of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the path of this Message or NULL in case of error.
* the returned string should *not* be modified or freed.
*/
const char* mu_msg_gmime_get_path (MuMsgGMime *msg);
/**
* get the subject of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the subject of this Message or NULL in case of error or if there
* is no subject. the returned string should *not* be modified or freed.
*/
const char* mu_msg_gmime_get_subject (MuMsgGMime *msg);
/**
* get the Message-Id of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the Message-Id of this Message or NULL in case of error or if there
* is none. the returned string should *not* be modified or freed.
*/
const char* mu_msg_gmime_get_msgid (MuMsgGMime *msg);
/**
* get any arbitrary header from this message
*
* @param a valid MuMsgGMime* instance
* @header the header requested
*
* @return the header requested or NULL in case of error or if there
* is no such header. the returned string should *not* be modified or freed.
*/
const char* mu_msg_gmime_get_header (MuMsgGMime *msg,
const char* header);
/**
* get the message date/time (the Date: field) as time_t, using UTC
*
* @param a valid MuMsgGMime* instance
*
* @return message date/time or 0 in case of error or if there
* is no such header.
*/
time_t mu_msg_gmime_get_date (MuMsgGMime *msg);
/**
* get the flags for this message
*
* @param msg valid MuMsgGMime* instance
*
* @return the fileflags as logically OR'd #Mu MsgFlags or 0 if
* there are none.
*/
MuMsgFlags mu_msg_gmime_get_flags (MuMsgGMime *msg);
/**
* get the file size in bytes of this message
*
* @param a valid MuMsgGMime* instance
*
* @return the filesize
*/
size_t mu_msg_gmime_get_size (MuMsgGMime *msg);
/**
* get some field value as string
*
* @param msg a valid MuMsgGmime instance
* @param field the field to retrieve; it must be a string-typed field
*
* @return a string that should not be freed
*/
const char* mu_msg_gmime_get_field_string (MuMsgGMime *msg,
const MuMsgField* field);
/**
* get some field value as string
*
* @param msg a valid MuMsgGmime instance
* @param field the field to retrieve; it must be a numeric field
*
* @return a string that should not be freed
*/
gint64 mu_msg_gmime_get_field_numeric (MuMsgGMime *msg,
const MuMsgField* field);
/**
* get the message priority for this message
* (MU_MSG_PRIORITY_LOW, MU_MSG_PRIORITY_NORMAL or MU_MSG_PRIORITY_HIGH)
* the X-Priority, X-MSMailPriority, Importance and Precedence header are
* checked, in that order.
* if no explicit priority is set, MU_MSG_PRIORITY_NORMAL is assumed
*
* @param a valid MuMsgGMime* instance
*
* @return the message priority (!= 0) or 0 in case of error
*/
MuMsgPriority mu_msg_gmime_get_priority (MuMsgGMime *msg);
/**
* get the timestamp (mtime) for the file containing this message
*
* @param a valid MuMsgGMime* instance
*
* @return the timestamp or 0 in case of error
*/
time_t mu_msg_gmime_get_timestamp (MuMsgGMime *msg);
typedef int (*MuMsgGMimeContactsCallback) (MuMsgContact*, void *ptr);
/**
* call a function for each of the contacts in a message
*
* @param msg a valid MuMsgGMime* instance
* @param cb a callback function to call for each contact; when
* the callback returns non-0, the function stops, and this last
* callback return value is returned
* @param ptr a user-provide pointer that will be passed to the callback
*
* @return 0 if the callback was called for each recipient, -1 if there
* was an error and any other != 0 number the callback returned
*/
int mu_msg_gmime_get_contacts_foreach (MuMsgGMime *msg,
MuMsgGMimeContactsCallback cb,
void *ptr);
G_END_DECLS
#endif /*__MU_MSG_H__*/

87
src/mu-msg-str.c Normal file
View File

@ -0,0 +1,87 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <glib.h>
#include "mu-msg-str.h"
#include "mu-msg-flags.h"
const char*
mu_msg_str_date_s (time_t t)
{
struct tm *tmbuf;
static char buf[64];
tmbuf = localtime(&t);
strftime (buf, 64, "%c", tmbuf);
return buf;
}
char*
mu_msg_str_date (time_t t)
{
return g_strdup (mu_msg_str_date_s(t));
}
const char*
mu_msg_str_size_s (size_t s)
{
static char buf[32];
if (s >= 1000 * 1000)
g_snprintf(buf, 32, "%.1fM", (double)s/(1000*1000));
else
g_snprintf(buf, 32, "%.1fk", (double)s/(1000));
return buf;
}
char*
mu_msg_str_size (size_t s)
{
return g_strdup (mu_msg_str_size_s(s));
}
const char*
mu_msg_str_flags_s (MuMsgFlags flags)
{
return mu_msg_flags_to_str_s (flags);
}
char*
mu_msg_str_flags (MuMsgFlags flags)
{
return g_strdup (mu_msg_str_flags_s(flags));
}
const char*
mu_msg_str_prio (MuMsgPriority prio)
{
switch (prio) {
case MU_MSG_PRIORITY_LOW: return "low";
case MU_MSG_PRIORITY_NORMAL: return "normal";
case MU_MSG_PRIORITY_HIGH: return "high";
default:
g_warning ("%s: invalid priority %d", __FUNCTION__, prio);
return "Err";
}
}

94
src/mu-msg-str.h Normal file
View File

@ -0,0 +1,94 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_MSG_STR_H__
#define __MU_MSG_STR_H__
#include <time.h>
#include <sys/types.h>
#include "mu-msg.h"
#include "mu-msg-flags.h"
/**
* get a display string for a given time_t;
* use the preferred date/time for the current locale
* (ie., '%c' in strftime).
*
* mu_msg_str_date_s returns a ptr to a static buffer,
* while mu_msg_str_date returns dynamically allocated
* memory that must be freed after use.
*
* @param t the time as time_t
*
* @return a string representation of the time; see above
* for what to do with it
*/
const char* mu_msg_str_date_s (time_t t) G_GNUC_CONST;
char* mu_msg_str_date (time_t t);
/**
* get a display size for a given off_t;
* uses M for sizes > 1000*1000, k for smaller sizes
*
* mu_msg_str_size_s returns a ptr to a static buffer,
* while mu_msg_str_size returns dynamically allocated
* memory that must be freed after use.
*
* @param t the size as an off_t
*
* @return a string representation of the size; see above
* for what to do with it
*/
const char* mu_msg_str_size_s (size_t s) G_GNUC_CONST;
char* mu_msg_str_size (size_t s);
/**
* get a display string for a given set of flags, OR'ed in
* @param flags; one character per flag:
* D=draft,F=flagged,N=new,P=passed,R=replied,S=seen,T=trashed
* a=has-attachment,s=signed, x=encrypted
*
* mu_msg_str_file_flags_s returns a ptr to a static buffer,
* while mu_msg_str_file_flags returns dynamically allocated
* memory that must be freed after use.
*
* @param flags file flags
*
* @return a string representation of the flags; see above
* for what to do with it
*/
const char* mu_msg_str_flags_s (MuMsgFlags flags) G_GNUC_CONST;
char* mu_msg_str_flags (MuMsgFlags flags);
/**
* get a display string for a message priority; either
* High,Low or Normal
*
* @param flags file flags
*
* @return a string representation of the priority; see above
* for what to do with it, or NULL in case of error
*/
const char* mu_msg_str_prio (MuMsgPriority prio) G_GNUC_CONST;
#endif /*__MU_MSG_STR_H__*/

27
src/mu-msg-xapian-priv.hh Normal file
View File

@ -0,0 +1,27 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_MSG_XAPIAN_PRIV_HH__
#define __MU_MSG_XAPIAN_PRIV_HH__
#include <xapian.h>
MuMsgXapian *mu_msg_xapian_new (const Xapian::Enquire& enq, size_t batchsize);
#endif /*__MU_MSG_XAPIAN_PRIV_HH__*/

234
src/mu-msg-xapian.cc Normal file
View File

@ -0,0 +1,234 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <stdlib.h>
#include <iostream>
#include <string.h>
#include "xapian.h"
#include "mu-msg-xapian.h"
struct _MuMsgXapian {
Xapian::Enquire *_enq;
Xapian::MSet _matches;
Xapian::MSet::const_iterator _cursor;
size_t _batchsize;
size_t _offset;
char* _str[MU_MSG_FIELD_ID_NUM];
};
MuMsgXapian *
mu_msg_xapian_new (const Xapian::Enquire& enq, size_t batchsize)
{
MuMsgXapian *msg;
try {
msg = new MuMsgXapian;
memset (msg->_str, 0, sizeof(msg->_str));
msg->_enq = new Xapian::Enquire(enq);
msg->_matches = msg->_enq->get_mset (0, batchsize);
if (!msg->_matches.empty())
msg->_cursor = msg->_matches.begin();
msg->_batchsize = batchsize;
msg->_offset = 0;
return msg;
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
}
return msg;
}
void
mu_msg_xapian_destroy (MuMsgXapian *msg)
{
if (msg) {
for (int i = 0; i != MU_MSG_FIELD_ID_NUM; ++i)
g_free (msg->_str[i]);
delete msg->_enq;
delete msg;
}
}
gboolean
mu_msg_xapian_next (MuMsgXapian *msg)
{
g_return_val_if_fail (msg, FALSE);
g_return_val_if_fail (!mu_msg_xapian_is_done(msg), FALSE);
if (++msg->_cursor == msg->_matches.end())
return FALSE; /* no more matches */
for (int i = 0; i != MU_MSG_FIELD_ID_NUM; ++i) {
g_free (msg->_str[i]);
msg->_str[i] = NULL;
}
return TRUE;
}
gboolean
mu_msg_xapian_is_done (MuMsgXapian *msg)
{
if (msg->_matches.empty())
return TRUE;
if (msg->_cursor == msg->_matches.end())
return TRUE;
return FALSE;
}
const gchar*
mu_msg_xapian_get_field (MuMsgXapian *row, const MuMsgField *field)
{
g_return_val_if_fail (row, NULL);
g_return_val_if_fail (!mu_msg_xapian_is_done(row), NULL);
g_return_val_if_fail (field, NULL);
try {
MuMsgFieldId id = mu_msg_field_id (field);
if (!row->_str[id]) { /* cache the value */
Xapian::Document doc (row->_cursor.get_document());
row->_str[id] = g_strdup (doc.get_value(id).c_str());
}
return row->_str[id];
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
}
return NULL;
}
gint64
mu_msg_xapian_get_field_numeric (MuMsgXapian *row, const MuMsgField *field)
{
g_return_val_if_fail (mu_msg_field_is_numeric(field), -1);
return Xapian::sortable_unserialise(
mu_msg_xapian_get_field(row, field));
}
static const gchar*
get_field (MuMsgXapian *row, MuMsgFieldId id)
{
return mu_msg_xapian_get_field(row, mu_msg_field_from_id (id));
}
unsigned int
mu_msg_xapian_get_id (MuMsgXapian *row)
{
g_return_val_if_fail (row, NULL);
const char *str;
try {
return row->_cursor.get_document().get_docid();
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
}
return 0;
}
const char*
mu_msg_xapian_get_path(MuMsgXapian *row)
{
return get_field (row, MU_MSG_FIELD_ID_PATH);
}
const char*
mu_msg_xapian_get_from (MuMsgXapian *row)
{
return get_field (row, MU_MSG_FIELD_ID_FROM);
}
const char*
mu_msg_xapian_get_to (MuMsgXapian *row)
{
return get_field (row, MU_MSG_FIELD_ID_TO);
}
const char*
mu_msg_xapian_get_cc (MuMsgXapian *row)
{
return get_field (row, MU_MSG_FIELD_ID_CC);
}
const char*
mu_msg_xapian_get_subject (MuMsgXapian *row)
{
return get_field (row, MU_MSG_FIELD_ID_SUBJECT);
}
size_t
mu_msg_xapian_get_size (MuMsgXapian *row)
{
return atoi(get_field (row, MU_MSG_FIELD_ID_SIZE));
}
time_t
mu_msg_xapian_get_date (MuMsgXapian *row)
{
return atoi(get_field (row, MU_MSG_FIELD_ID_DATE));
}
MuMsgFlags
mu_msg_xapian_get_flags (MuMsgXapian *row)
{
return (MuMsgFlags)atoi(get_field
(row, MU_MSG_FIELD_ID_FLAGS));
}
MuMsgPriority
mu_msg_xapian_get_priority (MuMsgXapian *row)
{
return (MuMsgPriority)atoi(get_field
(row, MU_MSG_FIELD_ID_PRIORITY));
}

52
src/mu-msg-xapian.h Normal file
View File

@ -0,0 +1,52 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_MSG_XAPIAN_H__
#define __MU_MSG_XAPIAN_H__
#include "mu-msg.h"
G_BEGIN_DECLS
struct _MuMsgXapian;
typedef struct _MuMsgXapian MuMsgXapian;
gboolean mu_msg_xapian_next (MuMsgXapian *msg);
gboolean mu_msg_xapian_is_done (MuMsgXapian *msg);
void mu_msg_xapian_destroy (MuMsgXapian *msg);
unsigned int mu_msg_xapian_get_id (MuMsgXapian *row);
const char* mu_msg_xapian_get_path (MuMsgXapian *row);
size_t mu_msg_xapian_get_size (MuMsgXapian *row);
time_t mu_msg_xapian_get_timestamp (MuMsgXapian *row);
time_t mu_msg_xapian_get_date (MuMsgXapian *row);
const char* mu_msg_xapian_get_from (MuMsgXapian *row);
const char* mu_msg_xapian_get_to (MuMsgXapian *row);
const char* mu_msg_xapian_get_cc (MuMsgXapian *row);
const char* mu_msg_xapian_get_subject (MuMsgXapian *row);
MuMsgFlags mu_msg_xapian_get_flags (MuMsgXapian *row);
MuMsgPriority mu_msg_xapian_get_priority (MuMsgXapian *row);
const gchar* mu_msg_xapian_get_field (MuMsgXapian *row,
const MuMsgField *field);
gint64 mu_msg_xapian_get_field_numeric (MuMsgXapian *row,
const MuMsgField *field);
G_END_DECLS
#endif /*__MU_MSG_XAPIAN_H__*/

62
src/mu-msg.h Normal file
View File

@ -0,0 +1,62 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_MSG_H__
#define __MU_MSG_H__
#include "mu-msg-flags.h"
#include "mu-msg-fields.h"
/* what kind of message is this; use by the indexer */
enum _MuMsgStatus {
MU_MSG_STATUS_NEW, /* message is new */
MU_MSG_STATUS_UPDATE, /* message is to be updated */
MU_MSG_STATUS_CLEANUP, /* message is to be cleaned up from db */
MU_MSG_STATUS_CLEANED_UP, /* message has been cleaned up from db */
MU_MSG_STATUS_EXISTS, /* message exists (will not be cleaned up) */
MU_MSG_STATUS_UPTODATE /* message is up-to-date */
};
typedef enum _MuMsgStatus MuMsgStatus;
enum _MuMsgPriority {
MU_MSG_PRIORITY_NONE = 0,
MU_MSG_PRIORITY_LOW = 1,
MU_MSG_PRIORITY_NORMAL = 2,
MU_MSG_PRIORITY_HIGH = 3
};
typedef enum _MuMsgPriority MuMsgPriority;
enum _MuMsgContactType { /* Reply-To:? */
MU_MSG_CONTACT_TYPE_TO,
MU_MSG_CONTACT_TYPE_FROM,
MU_MSG_CONTACT_TYPE_CC,
MU_MSG_CONTACT_TYPE_BCC
};
typedef enum _MuMsgContactType MuMsgContactType;
struct _MuMsgContact {
const char *_name; /* Foo Bar */
const char *_addr; /* foo@bar.cuux */
MuMsgContactType _type; /*MU_MSG_CONTACT_TYPE_{TO,CC,BCC,FROM}*/
};
typedef struct _MuMsgContact MuMsgContact;
#endif /*__MU_MSG_H__*/

224
src/mu-path.c Normal file
View File

@ -0,0 +1,224 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <dirent.h>
#include <errno.h>
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <glib/gstdio.h>
#include <string.h>
#include "mu-path.h"
#include "mu-msg-flags.h"
static MuResult process_dir (const char* path, MuPathWalkMsgCallback msg_cb,
MuPathWalkDirCallback dir_cb, void *data);
static MuResult
process_file (const char* fullpath, MuPathWalkMsgCallback cb, void *data)
{
MuResult result;
struct stat statbuf;
if (!cb)
return MU_OK;
/* FIXME: may remove this access, and only use 'stat'? may be faster */
if (G_UNLIKELY(access(fullpath, R_OK) != 0)) {
g_warning ("cannot access %s: %s", fullpath, strerror(errno));
return MU_ERROR;
}
if (G_UNLIKELY(stat (fullpath, &statbuf) != 0)) {
g_warning ("cannot stat %s: %s", fullpath, strerror(errno));
return MU_ERROR;
}
result = (cb)(fullpath,statbuf.st_mtime,data);
if (G_LIKELY(result == MU_OK || result == MU_STOP))
return result;
else {
g_warning ("%s: failed %d in callback (%s)",
__FUNCTION__, result, fullpath);
return result;
}
}
/* determine if path is a maildir leaf-dir; ie. if it's 'cur' or 'new'
* (we're ignoring 'tmp' for obvious reasons)
*/
static gboolean
is_maildir_new_or_cur (const char *path)
{
size_t len;
const char *sfx;
/* path is the full path; it cannot possibly be shorter
* than 4 for a maildir (/cur or /new)
*/
if (!path||(len = strlen(path)) < 4)
return FALSE;
sfx = &path[len - 4];
if (sfx[0] != G_DIR_SEPARATOR) /* small optimization */
return FALSE;
else if (sfx[1] != 'c' && sfx[1] != 'n')
return FALSE; /* optimization */
else
return (strcmp (sfx + 1, "cur") == 0 ||
strcmp (sfx + 1, "new") == 0);
}
static MuResult
process_dir_entry (const char* path,struct dirent *entry,
MuPathWalkMsgCallback cb_msg, MuPathWalkDirCallback cb_dir,
void *data)
{
char* fullpath;
/* ignore anything starting with a dot */
if (G_UNLIKELY(entry->d_name[0] == '.'))
return MU_OK;
fullpath = g_newa (char, strlen(path) + 1 + strlen(entry->d_name) + 1);
sprintf (fullpath, "%s%c%s", path, G_DIR_SEPARATOR, entry->d_name);
switch (entry->d_type) {
case DT_REG:
/* we only want files in cur/ and new/ */
if (!is_maildir_new_or_cur (path))
return MU_OK;
return process_file (fullpath, cb_msg, data);
case DT_DIR:
return process_dir (fullpath, cb_msg, cb_dir, data);
default:
return MU_OK; /* ignore other types */
}
}
static struct dirent*
dirent_copy (struct dirent *entry)
{
struct dirent *d = g_slice_new (struct dirent);
/* NOTE: simply memcpy'ing sizeof(struct dirent) bytes will
* give memory errors*/
return (struct dirent*)memcpy (d, entry, entry->d_reclen);
}
static void
dirent_destroy (struct dirent *entry)
{
g_slice_free(struct dirent, entry);
}
static gint
dirent_cmp (struct dirent *d1, struct dirent *d2)
{
return d1->d_ino - d2->d_ino;
}
static MuResult
process_dir (const char* path, MuPathWalkMsgCallback msg_cb,
MuPathWalkDirCallback dir_cb, void *data)
{
MuResult result = MU_OK;
GList *lst, *c;
struct dirent *entry;
DIR* dir;
dir = opendir (path);
if (G_UNLIKELY(!dir)) {
g_warning ("failed to open %s: %s", path, strerror(errno));
return MU_ERROR;
}
if (dir_cb) {
MuResult rv = dir_cb (path, TRUE, data);
if (rv != MU_OK) {
closedir (dir);
return rv;
}
}
/* we sort the inodes, which makes file-access much faster on
some filesystems, such as ext3fs */
lst = NULL;
while ((entry = readdir (dir)))
lst = g_list_prepend (lst, dirent_copy(entry));
c = lst = g_list_sort (lst, (GCompareFunc)dirent_cmp);
for (c = lst; c && result == MU_OK; c = c->next)
result = process_dir_entry (path, (struct dirent*)c->data,
msg_cb, dir_cb, data);
g_list_foreach (lst, (GFunc)dirent_destroy, NULL);
g_list_free (lst);
closedir (dir);
if (dir_cb)
return dir_cb (path, FALSE, data);
return result;
}
MuResult
mu_path_walk_maildir (const char *path, MuPathWalkMsgCallback cb_msg,
MuPathWalkDirCallback cb_dir, void *data)
{
struct stat statbuf;
g_return_val_if_fail (path && cb_msg, MU_ERROR);
if (access(path, R_OK) != 0) {
g_warning ("cannot access %s: %s", path, strerror(errno));
return MU_ERROR;
}
if (stat (path, &statbuf) != 0) {
g_warning ("cannot stat %s: %s", path, strerror(errno));
return MU_ERROR;
}
if ((statbuf.st_mode & S_IFMT) == S_IFREG)
return process_file (path, cb_msg, data);
if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
return process_dir (path, cb_msg, cb_dir, data);
g_warning ("%s: unsupported file type for %s",
__FUNCTION__, path);
return MU_ERROR;
}

74
src/mu-path.h Normal file
View File

@ -0,0 +1,74 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_PATH_H__
#define __MU_PATH_H__
#include <glib.h>
#include <sys/types.h> /* for mode_t */
#include "mu-result.h" /* for MuResult */
/**
* MuPathWalkMsgCallback -- callback function for mu_path_walk_maildir; see the
* documentation there. It will be called for each message found
*/
typedef MuResult (*MuPathWalkMsgCallback) (const char* fullpath,
time_t timestamp,
void *user_data);
/**
* MuPathWalkDirCallback -- callback function for mu_path_walk_maildir; see the
* documentation there. It will be called each time a dir is entered or left.
*/
typedef MuResult (*MuPathWalkDirCallback) (const char* fullpath,
gboolean enter, /* enter (TRUE) or leave (FALSE) dir?*/
void *user_data);
/**
* start a recursive scan of a maildir; for each file found, we call
* callback with the path (with the Maildir path of scanner_new as
* root), the filename, the timestamp (mtime) of the file,and the
* *data pointer, for user data. dot-files are ignored, as well as
* files outside cur/ and new/ dirs and unreadable files; however,
* dotdirs are visited (ie. '.dotdir/cur'), so this enables Maildir++.
* (http://www.inter7.com/courierimap/README.maildirquota.html,
* search for 'Mission statement')
*
* mu_path_walk_maildir wills stop if the callbacks return something
* != MU_OK. For example, it can return MU_STOP to stop the scan, or
* some error.
*
* @param path the maildir path to scan
* @param cb_msg the callback function called for each msg
* @param cb_dir the callback function called for each dir
* @param data user data pointer
*
* @return a scanner result; MU_OK if everything went ok,
* MU_STOP if we want to stop, or MU_ERROR in
* case of error
*/
MuResult mu_path_walk_maildir (const char *path,
MuPathWalkMsgCallback cb_msg,
MuPathWalkDirCallback cb_dir,
void *data);
#endif /*__MU_PATH_H__*/

217
src/mu-query-xapian.cc Normal file
View File

@ -0,0 +1,217 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <stdlib.h>
#include <xapian.h>
#include <glib/gstdio.h>
#include <string.h>
#include <string>
#include "mu-query-xapian.h"
#include "mu-msg-xapian.h"
#include "mu-msg-xapian-priv.hh"
struct _MuQueryXapian {
Xapian::Database *_db;
Xapian::QueryParser _qparser;
Xapian::Sorter* _sorters[MU_MSG_FIELD_TYPE_NUM];
};
static void
add_prefix (const MuMsgField* field, Xapian::QueryParser* qparser)
{
if (!mu_msg_field_is_xapian_enabled(field))
return;
const std::string prefix (mu_msg_field_xapian_prefix(field));
qparser->add_boolean_prefix(std::string(mu_msg_field_name(field)),
prefix);
qparser->add_boolean_prefix(std::string(mu_msg_field_shortcut(field)),
prefix);
/* make the empty string match this field too*/
qparser->add_prefix ("", prefix);
}
MuQueryXapian*
mu_query_xapian_new (const char* path, GError **err)
{
MuQueryXapian *self;
g_return_val_if_fail (path, NULL);
if (!g_file_test (path, G_FILE_TEST_IS_DIR) ||
g_access(path, R_OK) != 0) {
g_set_error (err, 0, 0,"'%s' is not a readable xapian dir", path);
return NULL;
}
try {
self = new MuQueryXapian;
self->_db = new Xapian::Database(path);
self->_qparser.set_database(*self->_db);
self->_qparser.set_default_op(Xapian::Query::OP_OR);
self->_qparser.set_stemming_strategy
(Xapian::QueryParser::STEM_SOME);
memset (self->_sorters, 0, sizeof(self->_sorters));
mu_msg_field_foreach ((MuMsgFieldForEachFunc)add_prefix,
(gconstpointer)&self->_qparser);
return self;
} catch (const Xapian::Error &ex) {
g_set_error (err, 0, 0,"%s: caught xapian exception '%s' (%s)",
__FUNCTION__, ex.get_msg().c_str(),
ex.get_error_string());
} catch (...) {
delete self->_db;
g_set_error (err, 0, 0,"%s: caught exception", __FUNCTION__);
}
if (self) {
delete self->_db;
delete self;
}
return NULL;
}
void
mu_query_xapian_destroy (MuQueryXapian *self)
{
if (!self)
return;
try {
for (int i = 0; i != MU_MSG_FIELD_TYPE_NUM; ++i) {
delete self->_sorters[i];
self->_sorters[i] = 0;
}
delete self->_db;
delete self;
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
}
}
static Xapian::Query
get_query (MuQueryXapian *self, const char* searchexpr)
{
return (self->_qparser.parse_query
(searchexpr,
Xapian::QueryParser::FLAG_BOOLEAN |
Xapian::QueryParser::FLAG_PHRASE |
Xapian::QueryParser::FLAG_LOVEHATE |
Xapian::QueryParser::FLAG_BOOLEAN_ANY_CASE |
Xapian::QueryParser::FLAG_WILDCARD |
Xapian::QueryParser::FLAG_PURE_NOT |
Xapian::QueryParser::FLAG_PARTIAL));
}
MuMsgXapian*
mu_query_xapian_run (MuQueryXapian *self, const char* searchexpr,
const MuMsgField* sortfield, gboolean ascending)
{
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (searchexpr, NULL);
try {
Xapian::Query q(get_query(self, searchexpr));
Xapian::Enquire enq (*self->_db);
if (sortfield)
enq.set_sort_by_value (
(Xapian::valueno)mu_msg_field_id(sortfield),
ascending);
enq.set_query (q);
enq.set_cutoff (0,0);
return mu_msg_xapian_new (enq, 10000);
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' for expr '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
searchexpr, err.get_error_string());
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
}
return NULL;
}
char*
mu_query_xapian_as_string (MuQueryXapian *self, const char* searchexpr)
{
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (searchexpr, NULL);
try {
Xapian::Query q(get_query(self, searchexpr));
return g_strdup(q.get_description().c_str());
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
}
return NULL;
}
char*
mu_query_xapian_combine (GSList *lst, gboolean connect_or)
{
GString *str;
g_return_val_if_fail (lst, NULL);
str = g_string_sized_new (64); /* just a guess */
while (lst) {
const char* cnx = "";
if (lst->next)
cnx = connect_or ? " OR " : " AND ";
g_string_append_printf (str, "%s%s", (gchar*)lst->data, cnx);
lst = lst->next;
}
return g_string_free (str, FALSE);
}

96
src/mu-query-xapian.h Normal file
View File

@ -0,0 +1,96 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_QUERY_XAPIAN_H__
#define __MU_QUERY_XAPIAN_H__
#include <glib.h>
#include "mu-msg-xapian.h"
G_BEGIN_DECLS
/*
* MuQueryXapian
*/
struct _MuQueryXapian;
typedef struct _MuQueryXapian MuQueryXapian;
/**
* create a new MuQueryXapian instance.
*
* @param path path to the xapian db to search
* @param err receives error information (if there is any)
*
* @return a new MuQueryXapian instance, or NULL in case of error.
* when the instance is no longer needed, use mu_query_xapian_destroy
* to free it
*/
MuQueryXapian *mu_query_xapian_new (const char* path, GError **err);
/**
* destroy the MuQueryXapian instance
*
* @param self a MuQueryXapian instance, or NULL
*/
void mu_query_xapian_destroy (MuQueryXapian *self);
/**
* run a Xapian query; for the syntax, please refer to the mu-find
* manpage, or http://xapian.org/docs/queryparser.html
*
* @param self a valid MuQueryXapian instance
* @param expr the search expression
*
* @return a MuMsgXapian instance you can iterate over, or NULL in
* case of error
*/
MuMsgXapian* mu_query_xapian_run (MuQueryXapian *self,
const char* expr,
const MuMsgField* sortfield,
gboolean ascending);
/**
* create a xapian query from list of expressions; for the syntax,
* please refer to the mu-find manpage, or
* http://xapian.org/docs/queryparser.html
*
* @param lst a list of search expressions
* @param connect_or if TRUE, combine the expressions with OR, otherwise use AND
*
* @return a string with the combined xapian expression or NULL in
* case of error; free with g_free when it's no longer needed
*/
char* mu_query_xapian_combine (GSList *lst, gboolean connect_or);
/**
* get a string representation of the Xapian search query
*
* @param self a MuQueryXapian instance
* @param searchexpr a xapian search expression
*
* @return the string representation of the xapian query, or NULL in case of
* error; free the returned value with g_free
*/
char* mu_query_xapian_as_string (MuQueryXapian *self, const char* searchexpr);
G_END_DECLS
#endif /*__MU_QUERY_XAPIAN_H__*/

263
src/mu-query.c Normal file
View File

@ -0,0 +1,263 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <glib.h>
#include <glib/gstdio.h>
#include <stdio.h>
#include <string.h>
#include "mu-util.h"
#include "mu-result.h"
#include "mu-msg-str.h"
#include "mu-msg-flags.h"
#include "mu-query-xapian.h"
struct _FindOptions {
gboolean _links;
gboolean _print;
gboolean _query;
char* _fields;
char* _sortfield_str;
const MuMsgField* _sortfield;
gboolean _ascending_flag, _descending_flag;
gboolean _sortdir_ascending;
};
typedef struct _FindOptions FindOptions;
static FindOptions FIND_OPTIONS;
static GOptionEntry OPTION_ENTRIES[] = {
{"links", 'l', 0, G_OPTION_ARG_NONE, &FIND_OPTIONS._links,
"generate symlinks to matching messages", NULL},
{"print", 'p', 0, G_OPTION_ARG_NONE, &FIND_OPTIONS._print,
"print matching messages to screen (default)", NULL},
{"query", 'q', 0, G_OPTION_ARG_NONE, &FIND_OPTIONS._query,
"print a string representation of the Xapian query", NULL},
{"fields", 'f', 0, G_OPTION_ARG_STRING, &FIND_OPTIONS._fields,
"fields to display in output", NULL},
{"sortfield", 's', 0, G_OPTION_ARG_STRING, &FIND_OPTIONS._sortfield_str,
"field to sort on", NULL},
{"ascending", 'a', 0, G_OPTION_ARG_NONE, &FIND_OPTIONS._ascending_flag,
"sort ascending", NULL},
{"descending", 'c', 0, G_OPTION_ARG_NONE, &FIND_OPTIONS._descending_flag,
"sort ascending", NULL},
{NULL}
};
GOptionGroup*
mu_query_option_group (void)
{
GOptionGroup *og;
og = g_option_group_new ("query",
"options for quering the e-mail database",
"", NULL, NULL);
g_option_group_add_entries (og, OPTION_ENTRIES);
return og;
}
static gboolean
handle_options_sort_field_dir (void)
{
const MuMsgField *field;
if (FIND_OPTIONS._sortfield_str) {
field = mu_msg_field_from_name (FIND_OPTIONS._sortfield_str);
if (!field && strlen(FIND_OPTIONS._sortfield_str) == 1)
field = mu_msg_field_from_shortcut
(FIND_OPTIONS._sortfield_str[0]);
if (!field) {
g_warning ("not a valid sort field: '%s'",
FIND_OPTIONS._sortfield_str);
return FALSE;
}
FIND_OPTIONS._sortfield = field;
}
if (FIND_OPTIONS._ascending_flag && FIND_OPTIONS._descending_flag) {
g_warning ("ignoring option '--descending'");
FIND_OPTIONS._sortdir_ascending = TRUE;
} else if (!FIND_OPTIONS._descending_flag)
FIND_OPTIONS._sortdir_ascending = !FIND_OPTIONS._descending_flag;
return TRUE;
}
static gboolean
handle_options (void)
{
//GError *err = NULL;
/* if (!mu_conf_handle_options (mu_app_conf(),OPTION_ENTRIES, argcp, argvp, */
/* &err)) { */
/* g_printerr ("option parsing failed: %s\n", */
/* (err && err->message) ? err->message : "?" ); */
/* if (err) */
/* g_error_free (err); */
/* return FALSE; */
/* } */
/* if nothing specified, or fields are specified use print */
if ((!FIND_OPTIONS._links && !FIND_OPTIONS._query)||FIND_OPTIONS._fields)
FIND_OPTIONS._print = TRUE;
/* if no fields are specified, use 'd f s' */
if (FIND_OPTIONS._print && !FIND_OPTIONS._fields) {
FIND_OPTIONS._fields = "d f s"; /* default: date-from-subject.. */
if (!FIND_OPTIONS._ascending_flag) /* ... and sort descending */
FIND_OPTIONS._sortdir_ascending = FALSE;
}
if (!handle_options_sort_field_dir ())
return FALSE;
return TRUE;
}
static gboolean
print_query (MuQueryXapian *xapian, const gchar *query)
{
char *querystr;
querystr = mu_query_xapian_as_string (xapian, query);
g_print ("%s\n", querystr);
g_free (querystr);
return TRUE;
}
static const gchar*
display_field (MuMsgXapian *row, const MuMsgField* field)
{
gint64 val;
switch (mu_msg_field_type(field)) {
case MU_MSG_FIELD_TYPE_STRING:
return mu_msg_xapian_get_field (row, field);
case MU_MSG_FIELD_TYPE_INT:
if (mu_msg_field_id(field) == MU_MSG_FIELD_ID_PRIORITY) {
val = mu_msg_xapian_get_field_numeric (row, field);
return mu_msg_str_prio ((MuMsgPriority)val);
}
if (mu_msg_field_id(field) == MU_MSG_FIELD_ID_FLAGS) {
val = mu_msg_xapian_get_field_numeric (row, field);
return mu_msg_str_flags_s ((MuMsgPriority)val);
}
return mu_msg_xapian_get_field (row, field); /* as string */
case MU_MSG_FIELD_TYPE_TIME_T:
val = mu_msg_xapian_get_field_numeric (row, field);
return mu_msg_str_date_s ((time_t)val);
case MU_MSG_FIELD_TYPE_BYTESIZE:
val = mu_msg_xapian_get_field_numeric (row, field);
return mu_msg_str_size_s ((time_t)val);
default:
g_return_val_if_reached (NULL);
}
}
static gboolean
print_rows (MuQueryXapian *xapian, const gchar *query, FindOptions *opts)
{
MuMsgXapian *row;
row = mu_query_xapian_run (xapian, query,
opts->_sortfield, opts->_sortdir_ascending);
if (!row) {
g_printerr ("error: running query failed\n");
return FALSE;
}
while (!mu_msg_xapian_is_done (row)) {
const char* fields = opts->_fields;
int printlen = 0;
while (*fields) {
const MuMsgField* field =
mu_msg_field_from_shortcut (*fields);
if (!field)
printlen += printf ("%c", *fields);
else
printlen += printf ("%s", display_field(row,
field));
++fields;
}
if (printlen >0)
printf ("\n");
mu_msg_xapian_next (row);
}
mu_msg_xapian_destroy (row);
return TRUE;
}
static gboolean
do_output (MuQueryXapian *xapian, GSList *args, FindOptions* opts)
{
gchar *query;
gboolean retval = TRUE;
query = mu_query_xapian_combine (args, FALSE);
if (opts->_query)
retval = print_query (xapian, query);
if (retval && opts->_print)
retval = print_rows (xapian, query, opts);
g_free (query);
return retval;
}
MuResult
mu_query_run (GSList *args)
{
GError *err = 0;
MuQueryXapian *xapian;
MuResult rv;
rv = MU_OK;
handle_options ();
xapian = mu_query_xapian_new ("/home/djcb/.mu", &err);
if (!xapian) {
if (err) {
g_printerr ("error: %s\n", err->message);
g_error_free (err);
}
return MU_ERROR;
}
rv = do_output (xapian, args, &FIND_OPTIONS) ? 0 : 1;
mu_query_xapian_destroy (xapian);
return rv;
}

10
src/mu-query.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef __MU_QUERY_H__
#define __MU_QUERY_H__
MuResult mu_query_run (GSList *args);
GOptionGroup* mu_query_option_group (void);
#endif /*__MU_QUERY_H__*/

30
src/mu-result.h Normal file
View File

@ -0,0 +1,30 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 3, or (at your option) any
** later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_RESULT_H__
#define __MU_RESULT_H__
enum _MuResult {
MU_OK, /* all went ok */
MU_STOP, /* user wants to stop */
MU_ERROR /* some error occured */
};
typedef enum _MuResult MuResult;
#endif /*__MU_RESULT__*/

340
src/mu-store-xapian.cc Normal file
View File

@ -0,0 +1,340 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 3, or (at your option) any
** later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <xapian.h>
#include <string.h>
#include <stdio.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /*HAVE_CONFIG_H*/
#include "mu-msg.h"
#include "mu-msg-gmime.h"
#include "mu-store-xapian.h"
struct _MuStoreXapian {
Xapian::WritableDatabase *_db;
/* transaction handling */
bool _in_transaction;
int _processed;
size_t _transaction_size;
};
MuStoreXapian*
mu_store_xapian_new (const char* path)
{
MuStoreXapian *store;
g_return_val_if_fail (path, NULL);
try {
store = g_new0(MuStoreXapian,1);
store->_db = new Xapian::WritableDatabase
(path,Xapian::DB_CREATE_OR_OPEN);
/* keep count of processed docs */
store->_transaction_size = 10000; /* default */
store->_in_transaction = false;
store->_processed = 0;
g_message ("%s: opened %s", __FUNCTION__, path);
return store;
} catch (const Xapian::Error &err) {
delete store->_db;
g_free (store);
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
return NULL;
} catch (...) {
delete store->_db;
g_free (store);
g_warning ("%s: caught exception", __FUNCTION__);
return NULL;
}
}
void
mu_store_xapian_tune (MuStoreXapian *store,
unsigned int transaction_size)
{
g_return_if_fail (store);
if (transaction_size) {
g_message ("tune: setting xapian transaction size to %u",
transaction_size);
store->_transaction_size = transaction_size;
}
}
void
mu_store_xapian_destroy (MuStoreXapian *store)
{
if (!store)
return;
try {
if (store->_in_transaction) {
store->_in_transaction = false;
store->_db->commit_transaction();
}
store->_db->flush();
g_message ("closing xapian database with %d documents",
(int)store->_db->get_doccount());
delete store->_db;
g_free (store);
} catch (const Xapian::Error &err) {
g_free (store);
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
} catch (...) {
g_free (store);
g_warning ("%s: caught exception", __FUNCTION__);
}
}
static void
add_terms_values_number (Xapian::Document& doc, MuMsgGMime *msg,
const MuMsgField* field)
{
const std::string pfx (mu_msg_field_xapian_prefix(field), 1);
gint64 num = mu_msg_gmime_get_field_numeric (msg, field);
const std::string numstr (Xapian::sortable_serialise((double)num));
doc.add_value ((Xapian::valueno)mu_msg_field_id(field), numstr);
doc.add_term (pfx + numstr);
}
static void
add_terms_values_string (Xapian::Document& doc, MuMsgGMime *msg,
const MuMsgField* field)
{
const char* str = mu_msg_gmime_get_field_string (msg, field);
if (G_UNLIKELY(!str))
return;
const std::string value (str);
const std::string prefix (mu_msg_field_xapian_prefix(field));
if (mu_msg_field_is_xapian_indexable (field)) {
Xapian::TermGenerator termgen;
termgen.set_document (doc);
termgen.index_text_without_positions (value, 1, prefix);
} else
doc.add_term(prefix + value);
doc.add_value ((Xapian::valueno)mu_msg_field_id(field), value);
}
static void
add_terms_values_body (Xapian::Document& doc, MuMsgGMime *msg,
const MuMsgField* field)
{
if (G_UNLIKELY((mu_msg_gmime_get_flags(msg) & MU_MSG_FLAG_ENCRYPTED)))
return; /* don't store encrypted bodies */
const char *str = mu_msg_gmime_get_body_text(msg);
if (!str)
str = mu_msg_gmime_get_body_html(msg); /* FIXME: html->html fallback */
if (!str)
return; /* no body... */
Xapian::TermGenerator termgen;
termgen.index_text(str, 1, mu_msg_field_xapian_prefix(field));
termgen.set_document(doc);
}
struct _MsgDoc {
Xapian::Document *_doc;
MuMsgGMime *_msg;
};
typedef struct _MsgDoc MsgDoc;
static void
add_terms_values (const MuMsgField* field, MsgDoc* msgdoc)
{
MuMsgFieldType type;
if (!mu_msg_field_is_xapian_enabled(field))
return;
type = mu_msg_field_type (field);
if (G_LIKELY(type == MU_MSG_FIELD_TYPE_STRING)) {
if (G_UNLIKELY(mu_msg_field_id (field) ==
MU_MSG_FIELD_ID_BODY_TEXT))
add_terms_values_body (*msgdoc->_doc, msgdoc->_msg,
field);
else
add_terms_values_string (*msgdoc->_doc, msgdoc->_msg,
field);
return;
}
if (type == MU_MSG_FIELD_TYPE_BYTESIZE ||
type == MU_MSG_FIELD_TYPE_TIME_T ||
type == MU_MSG_FIELD_TYPE_INT) {
add_terms_values_number (*msgdoc->_doc, msgdoc->_msg, field);
return;
}
g_return_if_reached ();
}
MuResult
mu_store_xapian_store (MuStoreXapian *store, MuMsgGMime *msg)
{
static const MuMsgField* pathfield =
mu_msg_field_from_id(MU_MSG_FIELD_ID_PATH);
static const std::string pathprefix
(mu_msg_field_xapian_prefix(pathfield));
g_return_val_if_fail (store, MU_ERROR);
g_return_val_if_fail (msg, MU_ERROR);
try {
const char* body;
Xapian::Document newdoc;
Xapian::docid id;
gboolean commit_now;
MsgDoc msgdoc = { &newdoc, msg };
// start transaction if needed
if (G_UNLIKELY(!store->_in_transaction)) {
store->_db->begin_transaction();
store->_in_transaction = true;
}
mu_msg_field_foreach ((MuMsgFieldForEachFunc)add_terms_values,
&msgdoc);
/* we replace all existing documents for this file */
const std::string pathterm (pathprefix +
mu_msg_gmime_get_path(msg));
id = store->_db->replace_document (pathterm, newdoc);
commit_now = ++store->_processed % store->_transaction_size == 0;
if (G_UNLIKELY(commit_now)) {
store->_in_transaction = false;
store->_db->commit_transaction();
}
return MU_OK;
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
}
if (store->_in_transaction) {
store->_in_transaction = false;
store->_db->cancel_transaction();
}
return MU_ERROR;
}
MuResult
mu_store_xapian_cleanup (MuStoreXapian *store, const char* msgpath)
{
g_return_val_if_fail (store, MU_ERROR);
g_return_val_if_fail (msgpath, MU_ERROR);
try {
return MU_OK; /* TODO: */
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
return MU_ERROR;
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
return MU_ERROR;
}
}
time_t
mu_store_xapian_get_timestamp (MuStoreXapian *store, const char* msgpath)
{
g_return_val_if_fail (store, 0);
g_return_val_if_fail (msgpath, 0);
try {
const std::string stamp (store->_db->get_metadata (msgpath));
if (stamp.empty())
return 0;
return (time_t) g_ascii_strtoull (stamp.c_str(), NULL, 10);
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
return MU_ERROR;
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
return MU_ERROR;
}
return 0;
}
void
mu_store_xapian_set_timestamp (MuStoreXapian *store, const char* msgpath,
time_t stamp)
{
g_return_if_fail (store);
g_return_if_fail (msgpath);
try {
char buf[24];
sprintf (buf, "%" G_GUINT64_FORMAT, (guint64)stamp);
store->_db->set_metadata (msgpath, buf);
} catch (const Xapian::Error &err) {
g_warning ("%s: caught xapian exception '%s' (%s)",
__FUNCTION__, err.get_msg().c_str(),
err.get_error_string());
} catch (...) {
g_warning ("%s: caught exception", __FUNCTION__);
}
}

50
src/mu-store-xapian.h Normal file
View File

@ -0,0 +1,50 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 3, or (at your option) any
** later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_STORE_XAPIAN_H__
#define __MU_STORE_XAPIAN_H__
#include <glib.h>
#include <inttypes.h>
#include "mu-msg-gmime.h"
G_BEGIN_DECLS
struct _MuStoreXapian;
typedef struct _MuStoreXapian MuStoreXapian;
MuStoreXapian* mu_store_xapian_new (const char* path);
void mu_store_xapian_tune (MuStoreXapian *store,
unsigned int transaction_size);
void mu_store_xapian_destroy (MuStoreXapian *store);
MuResult mu_store_xapian_store (MuStoreXapian *store,
MuMsgGMime *msg);
MuResult mu_store_xapian_cleanup (MuStoreXapian *store,
const char* msgpath);
void mu_store_xapian_set_timestamp (MuStoreXapian *store,
const char* msgpath,
time_t stamp);
time_t mu_store_xapian_get_timestamp (MuStoreXapian *store,
const char* msgpath);
G_END_DECLS
#endif /*__MU_STORE_XAPIAN_H__*/

72
src/mu-util.c Normal file
View File

@ -0,0 +1,72 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <stdlib.h>
#include <string.h>
#include "mu-util.h"
char*
mu_util_homedir_expand (const char *path)
{
const char* home;
if (!path)
return NULL;
if (path[0] != '~' || path[1] != G_DIR_SEPARATOR)
return g_strdup (path);
home = getenv ("HOME");
if (!home)
home = g_get_home_dir ();
return g_strdup_printf ("%s%s", home, path + 1);
}
GSList *
mu_util_strlist_from_args (int argc, char *argv[])
{
GSList *lst;
int i;
g_return_val_if_fail (argc >= 0, NULL);
if (argc == 0)
return NULL;
g_return_val_if_fail (argv, NULL);
/* we prepend args in opposite direction;
* prepending is faster
*/
for (i = argc - 1, lst = NULL; i >= 0; --i) {
if (!argv[i])
continue;
lst = g_slist_prepend (lst, g_strdup(argv[i]));
}
return lst;
}
void
mu_util_strlist_free (GSList *lst)
{
g_slist_foreach (lst, (GFunc)g_free, NULL);
g_slist_free (lst);
}

64
src/mu-util.h Normal file
View File

@ -0,0 +1,64 @@
/*
** Copyright (C) 2008 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#ifndef __MU_UTIL_H__
#define __MU_UTIL_H__
#include <glib.h>
G_BEGIN_DECLS
/**
* get the expanded path; currently only a starting '~/' will be
* replaced by the users home directory, ie. for a user 'bob' this could mean
* something like "~/my/path/to/something" --> "/home/bob/my/path/to/something"
*
* @param path path to expand
*
* @return the expanded path as a newly allocated string, or NULL in
* case of error
*/
char* mu_util_homedir_expand (const char* path);
/**
* take a char*[] and turn it into a GSList
*
* @param argc numbers of strings
* @param argv array of strings
*
* @return a newly allocated GSList of the arguments; or NULL in case
* of error. use mu_exprs_helpers_strlist_free when done with the list
*/
GSList *mu_util_strlist_from_args (int argc, char *argv[]);
/**
* free a list of strings, as produced by mu_expr_helpers_strlist_from_args or
* mu_expr_helpers_strlist_from_str
*
* @param lst a list or NULL
*/
void mu_util_strlist_free (GSList *lst);
G_END_DECLS
#endif /*__MU_UTIL_H__*/

135
src/mu.c Normal file
View File

@ -0,0 +1,135 @@
/*
** Copyright (C) 2008, 2009 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 3, or (at your option) any
** later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation,
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
*/
#include <glib.h>
#include <glib-object.h>
#include <string.h>
#include "mu-index.h"
#include "mu-query.h"
#include "mu-util.h"
#include "mu-msg-gmime.h"
static MuResult
msg_cb (MuIndexStats* stats, void *user_data)
{
char *kars="-\\|/";
static int i = 0;
g_print ("%s%c", (!i)?"":"\b", kars[i % 4]);
++i;
return MU_OK;
}
static void
show_help (const char* cmd)
{
if (cmd)
g_print ("Help about %s\n", cmd);
else
g_print ("General help");
}
static gboolean opt_debug;
static gboolean opt_quiet;
static GOptionEntry entries[] = {
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &opt_debug,
"print debug output to standard-error", NULL },
{ "quiet", 'q', 0, G_OPTION_ARG_NONE, &opt_quiet,
"don't give any progress information", NULL },
{ NULL }
};
int
main (int argc, char *argv[])
{
const char* cmd;
GError *error = NULL;
GOptionContext *context;
MuResult rv;
g_type_init ();
context = g_option_context_new ("- search your e-mail");
g_option_context_add_main_entries (context, entries, "mu");
g_option_context_add_group (context, mu_query_option_group());
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_printerr ("option parsing failed: %s\n",
error->message);
g_error_free (error);
return 1;
}
if (argc < 2 || !( strcmp(argv[1], "index") == 0 ||
strcmp(argv[1], "search") == 0 ||
strcmp(argv[1], "help") == 0)) {
g_printerr ("usage: mu [options] command [parameters]\n"
"\twhere command is one of index, search, help\n");
return 1;
}
cmd = argv[1];
if (strcmp (cmd, "help") == 0) {
show_help (argc > 2 ? argv[2] : NULL);
return 0;
}
mu_msg_gmime_init ();
rv = MU_OK;
if (strcmp(cmd, "index") == 0) {
MuIndex *midx;
MuIndexStats stats;
midx = mu_index_new ("/home/djcb/.mu");
rv = mu_index_run (midx,
"/home/djcb/Maildir",
FALSE, &stats, msg_cb, NULL, NULL);
mu_index_destroy (midx);
} else if (strcmp(cmd, "search") == 0) {
GSList *args;
if (argc < 3) { /* FIXME */
g_printerr ("error!\n");
return 1;
}
args = mu_util_strlist_from_args (argc-2, argv+2);
rv = mu_query_run (args);
mu_util_strlist_free (args);
}
mu_msg_gmime_uninit ();
return rv == MU_OK ? 0 : 1;
}