static SignatureStatus pgpmime_get_sig_status(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data = (PrivacyDataPGP *) mimeinfo->privacy;
cm_return_val_if_fail(data != NULL, SIGNATURE_INVALID);
return sgpgme_sigstat_gpgme_to_privacy(data->ctx, data->sigstatus);
}
static gint pop3_getauth_pass_send(Pop3Session *session)
{
cm_return_val_if_fail(session->pass != NULL, -1);
session->state = POP3_GETAUTH_PASS;
pop3_gen_send(session, "PASS %s", session->pass);
return PS_SUCCESS;
}
static gint pop3_getauth_user_send(Pop3Session *session)
{
cm_return_val_if_fail(session->user != NULL, -1);
session->state = POP3_GETAUTH_USER;
pop3_gen_send(session, "USER %s", session->user);
return PS_SUCCESS;
}
static gchar *pgpmime_get_sig_info_full(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data = (PrivacyDataPGP *) mimeinfo->privacy;
cm_return_val_if_fail(data != NULL, g_strdup("Error"));
return sgpgme_sigstat_info_full(data->ctx, data->sigstatus);
}
/**
* Retrieve user attribute object for update.
* \param item UserAttribute to update.
* \return object, or <i>NULL</i> if none created.
*/
AttrKeyValue *ldapsvr_retrieve_attribute(UserAttribute *item) {
AttrKeyValue *newItem;
cm_return_val_if_fail(item != NULL, NULL);
newItem = attrkeyvalue_create();
newItem->key = g_strdup(item->name);
newItem->value = g_strdup(item->value);
return newItem;
}
static GSList *news_get_msginfos(Folder *folder, FolderItem *item, GSList *msgnum_list)
{
NewsSession *session;
GSList *elem, *msginfo_list = NULL, *tmp_msgnum_list, *tmp_msginfo_list;
guint first, last, next;
cm_return_val_if_fail(folder != NULL, NULL);
cm_return_val_if_fail(FOLDER_CLASS(folder) == &news_class, NULL);
cm_return_val_if_fail(msgnum_list != NULL, NULL);
cm_return_val_if_fail(item != NULL, NULL);
session = news_session_get(folder);
cm_return_val_if_fail(session != NULL, NULL);
tmp_msgnum_list = g_slist_copy(msgnum_list);
tmp_msgnum_list = g_slist_sort(tmp_msgnum_list, g_int_compare);
progressindicator_start(PROGRESS_TYPE_NETWORK);
first = GPOINTER_TO_INT(tmp_msgnum_list->data);
last = first;
news_folder_lock(NEWS_FOLDER(item->folder));
for(elem = g_slist_next(tmp_msgnum_list); elem != NULL; elem = g_slist_next(elem)) {
next = GPOINTER_TO_INT(elem->data);
if(next != (last + 1)) {
tmp_msginfo_list = news_get_msginfos_for_range(session, item, first, last);
msginfo_list = g_slist_concat(msginfo_list, tmp_msginfo_list);
first = next;
}
last = next;
}
news_folder_unlock(NEWS_FOLDER(item->folder));
tmp_msginfo_list = news_get_msginfos_for_range(session, item, first, last);
msginfo_list = g_slist_concat(msginfo_list, tmp_msginfo_list);
g_slist_free(tmp_msgnum_list);
progressindicator_stop(PROGRESS_TYPE_NETWORK);
return msginfo_list;
}
gchar *get_part_as_string(MimeInfo *mimeinfo)
{
gchar *textdata = NULL;
gchar *filename = NULL;
FILE *fp;
cm_return_val_if_fail(mimeinfo != NULL, 0);
procmime_decode_content(mimeinfo);
if (mimeinfo->content == MIMECONTENT_MEM)
textdata = g_strdup(mimeinfo->data.mem);
else {
filename = procmime_get_tmp_file_name(mimeinfo);
if (procmime_get_part(filename, mimeinfo) < 0) {
g_warning("error dumping temporary file '%s'", filename);
g_free(filename);
return NULL;
}
fp = claws_fopen(filename,"rb");
if (!fp) {
g_warning("error opening temporary file '%s'", filename);
g_free(filename);
return NULL;
}
textdata = fp_read_noconv(fp);
claws_fclose(fp);
g_unlink(filename);
g_free(filename);
}
if (!g_utf8_validate(textdata, -1, NULL)) {
gchar *tmp = NULL;
codeconv_set_strict(TRUE);
if (procmime_mimeinfo_get_parameter(mimeinfo, "charset")) {
tmp = conv_codeset_strdup(textdata,
procmime_mimeinfo_get_parameter(mimeinfo, "charset"),
CS_UTF_8);
}
if (!tmp) {
tmp = conv_codeset_strdup(textdata,
conv_get_locale_charset_str_no_utf8(),
CS_UTF_8);
}
codeconv_set_strict(FALSE);
if (!tmp) {
tmp = conv_codeset_strdup(textdata,
conv_get_locale_charset_str_no_utf8(),
CS_UTF_8);
}
if (tmp) {
g_free(textdata);
textdata = tmp;
}
}
return textdata;
}
/**
* Retrieve E-Mail address object for update.
* \param item ItemEmail to update.
* \return object, or <i>NULL</i> if none created.
*/
EmailKeyValue *ldapsvr_retrieve_item_email(ItemEMail *item) {
EmailKeyValue *newItem;
cm_return_val_if_fail(item != NULL, NULL);
newItem = emailkeyvalue_create();
newItem->alias = g_strdup(ADDRITEM_NAME(item));
newItem->mail = g_strdup(item->address);
newItem->remarks = g_strdup(item->remarks);
return newItem;
}
/**
* Test value of stop flag. This method should be used to determine whether a
* query has stopped running.
* \param qry Query object.
* \return Value of stop flag.
*/
static gboolean ldapqry_get_stop_flag( LdapQuery *qry ) {
gboolean value;
cm_return_val_if_fail( qry != NULL, TRUE );
pthread_mutex_lock( qry->mutexStop );
value = qry->stopFlag;
pthread_mutex_unlock( qry->mutexStop );
return value;
}
static gboolean pgpinline_is_signed(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data = NULL;
const gchar *sig_indicator = "-----BEGIN PGP SIGNED MESSAGE-----";
gchar *textdata, *sigpos;
cm_return_val_if_fail(mimeinfo != NULL, FALSE);
if (procmime_mimeinfo_parent(mimeinfo) == NULL)
return FALSE; /* not parent */
if (mimeinfo->type != MIMETYPE_TEXT &&
(mimeinfo->type != MIMETYPE_APPLICATION ||
g_ascii_strcasecmp(mimeinfo->subtype, "pgp")))
return FALSE;
/* Seal the deal. This has to be text/plain through and through. */
if (mimeinfo->type == MIMETYPE_APPLICATION)
{
mimeinfo->type = MIMETYPE_TEXT;
g_free(mimeinfo->subtype);
mimeinfo->subtype = g_strdup("plain");
}
if (mimeinfo->privacy != NULL) {
data = (PrivacyDataPGP *) mimeinfo->privacy;
if (data->done_sigtest)
return data->is_signed;
}
textdata = get_part_as_string(mimeinfo);
if (!textdata)
return FALSE;
if ((sigpos = strstr(textdata, sig_indicator)) == NULL) {
g_free(textdata);
return FALSE;
}
if (!(sigpos == textdata) && !(sigpos[-1] == '\n')) {
g_free(textdata);
return FALSE;
}
g_free(textdata);
if (data == NULL) {
data = pgpinline_new_privacydata();
mimeinfo->privacy = (PrivacyData *) data;
}
if (data != NULL) {
data->done_sigtest = TRUE;
data->is_signed = TRUE;
}
return TRUE;
}
/**
* Test value of busy flag. This method will return a value of <i>FALSE</i>
* when a query has completed running.
* \param qry Query object.
* \return Value of busy flag.
*/
static gboolean ldapqry_get_busy_flag( LdapQuery *qry ) {
gboolean value;
cm_return_val_if_fail( qry != NULL, FALSE );
pthread_mutex_lock( qry->mutexBusy );
value = qry->busyFlag;
pthread_mutex_unlock( qry->mutexBusy );
return value;
}
/*
* Save properties to file.
* return: Status code.
*/
gint xmlprops_save_file( XmlProperty *props ) {
cm_return_val_if_fail( props != NULL, -1 );
props->retVal = MGU_NO_FILE;
if( props->path == NULL || *props->path == '\0' ) return props->retVal;
xmlprops_write_to( props, props->path );
return props->retVal;
}
/**
* Deside which kind of operation is required to handle
* updating the specified attribute
*
* \param ld AddressBook resource
* \param server Reference to server
* \param dn dn for the entry
* \param attr Attribute
* \param value New value
* \return int, return will be LDAP_MOD_ADD, LDAP_MOD_REPLACE, or LDAP_MOD_DELETE
*/
int ldapsvr_deside_operation(LDAP *ld, LdapServer *server, char *dn, char *attr, char *value) {
int rc;
gboolean dummy = FALSE;
#ifdef OPEN_LDAP_API_AT_LEAST_3000
struct berval val;
#endif
cm_return_val_if_fail(ld != NULL || server != NULL || dn != NULL || attr != NULL, -1);
if (value == NULL)
return -1;
/* value containing empty string cause invalid syntax. A bug in
* the LDAP library? Therefore we add a dummy value
*/
if (strcmp(value,"") == 0) {
value = g_strdup("thisisonlyadummy");
dummy = TRUE;
}
#ifdef OPEN_LDAP_API_AT_LEAST_3000
val.bv_val = value;
val.bv_len = strlen(value);
rc = ldap_compare_ext_s(ld, dn, attr, &val, NULL, NULL);
#else
/* This is deprecated as of OpenLDAP-2.3.0 */
rc = ldap_compare_s(ld, dn, attr, value);
#endif
debug_print("ldap_compare for (%s:%s)\" error_code[0x%x]: %s\n",
attr, value, rc, ldaputil_get_error(ld));
switch (rc) {
case LDAP_COMPARE_FALSE:
if (dummy)
return LDAP_MOD_DELETE;
else
return LDAP_MOD_REPLACE;
case LDAP_COMPARE_TRUE: return -1;
case LDAP_NO_SUCH_ATTRIBUTE: return LDAP_MOD_ADD;
/* LDAP_INAPPROPRIATE_MATCHING needs extensive testing because I
* am not aware off the condition causing this return value!
*/
case LDAP_INAPPROPRIATE_MATCHING:
if (dummy)
value = NULL;
return ldapsvr_compare_manual_attr(ld, server, dn, attr, value);
case LDAP_UNDEFINED_TYPE: return -2;
case LDAP_INVALID_SYNTAX: return -2;
default: return -2;
}
}
static gint news_get_num_list(Folder *folder, FolderItem *item, GSList **msgnum_list, gboolean *old_uids_valid)
{
NewsSession *session;
gint i, ok, num, first, last, nummsgs = 0;
gchar *dir;
cm_return_val_if_fail(item != NULL, -1);
cm_return_val_if_fail(item->folder != NULL, -1);
cm_return_val_if_fail(FOLDER_CLASS(folder) == &news_class, -1);
session = news_session_get(folder);
cm_return_val_if_fail(session != NULL, -1);
*old_uids_valid = TRUE;
news_folder_lock(NEWS_FOLDER(item->folder));
ok = news_select_group(folder, item->path, &num, &first, &last);
if (ok != NEWSNNTP_NO_ERROR) {
log_warning(LOG_PROTOCOL, _("couldn't set group: %s\n"), item->path);
news_folder_unlock(NEWS_FOLDER(item->folder));
return -1;
}
dir = news_folder_get_path(folder);
if (num <= 0)
remove_all_numbered_files(dir);
else if (last < first)
log_warning(LOG_PROTOCOL, _("invalid article range: %d - %d\n"),
first, last);
else {
for (i = first; i <= last; i++) {
*msgnum_list = g_slist_prepend(*msgnum_list,
GINT_TO_POINTER(i));
nummsgs++;
}
debug_print("removing old messages from %d to %d in %s\n",
first, last, dir);
remove_numbered_files(dir, 1, first - 1);
}
g_free(dir);
news_folder_unlock(NEWS_FOLDER(item->folder));
return nummsgs;
}
static int news_remove_msg (Folder *folder,
FolderItem *item,
gint msgnum)
{
gchar *path, *filename;
cm_return_val_if_fail(folder != NULL, -1);
cm_return_val_if_fail(item != NULL, -1);
path = folder_item_get_path(item);
if (!is_dir_exist(path))
make_dir_hier(path);
filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(msgnum), NULL);
g_free(path);
claws_unlink(filename);
g_free(filename);
return 0;
}
static gint news_rename_folder(Folder *folder, FolderItem *item,
const gchar *name)
{
gchar *path;
cm_return_val_if_fail(folder != NULL, -1);
cm_return_val_if_fail(item != NULL, -1);
cm_return_val_if_fail(item->path != NULL, -1);
cm_return_val_if_fail(name != NULL, -1);
path = folder_item_get_path(item);
if (!is_dir_exist(path))
make_dir_hier(path);
g_free(item->name);
item->name = g_strdup(name);
return 0;
}
static gint mh_remove_folder(Folder *folder, FolderItem *item)
{
gchar *path;
cm_return_val_if_fail(folder != NULL, -1);
cm_return_val_if_fail(item != NULL, -1);
cm_return_val_if_fail(item->path != NULL, -1);
path = folder_item_get_path(item);
if (remove_dir_recursive(path) < 0) {
g_warning("can't remove directory `%s'\n", path);
g_free(path);
return -1;
}
g_free(path);
folder_item_remove(item);
return 0;
}
static gchar *mh_fetch_msg(Folder *folder, FolderItem *item, gint num)
{
gchar *path;
gchar *file;
cm_return_val_if_fail(item != NULL, NULL);
cm_return_val_if_fail(num > 0, NULL);
path = folder_item_get_path(item);
file = g_strconcat(path, G_DIR_SEPARATOR_S, itos(num), NULL);
if (!is_file_exist(file)) {
g_free(file);
g_free(path);
return NULL;
}
g_free(path);
return file;
}
static gint send_recv_message(Session *session, const gchar *msg, gpointer data)
{
gchar buf[BUFFSIZE];
SMTPSession *smtp_session = SMTP_SESSION(session);
SendProgressDialog *dialog = (SendProgressDialog *)data;
gchar *state_str = NULL;
cm_return_val_if_fail(dialog != NULL, -1);
switch (smtp_session->state) {
case SMTP_READY:
return 0;
case SMTP_HELO:
g_snprintf(buf, sizeof(buf), _("Sending HELO..."));
state_str = _("Authenticating");
statusbar_print_all(_("Sending message..."));
break;
case SMTP_EHLO:
g_snprintf(buf, sizeof(buf), _("Sending EHLO..."));
state_str = _("Authenticating");
statusbar_print_all(_("Sending message..."));
break;
case SMTP_AUTH:
g_snprintf(buf, sizeof(buf), _("Authenticating..."));
state_str = _("Authenticating");
break;
case SMTP_FROM:
g_snprintf(buf, sizeof(buf), _("Sending MAIL FROM..."));
state_str = _("Sending");
break;
case SMTP_RCPT:
g_snprintf(buf, sizeof(buf), _("Sending RCPT TO..."));
state_str = _("Sending");
break;
case SMTP_DATA:
case SMTP_EOM:
g_snprintf(buf, sizeof(buf), _("Sending DATA..."));
state_str = _("Sending");
break;
case SMTP_QUIT:
g_snprintf(buf, sizeof(buf), _("Quitting..."));
state_str = _("Quitting");
break;
case SMTP_ERROR:
g_warning("send: error: %s", msg);
return 0;
default:
return 0;
}
progress_dialog_set_label(dialog->dialog, buf);
progress_dialog_list_set_status(dialog->dialog, 0, state_str);
return 0;
}
static gint mh_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
GHashTable *relation)
{
gchar *destfile;
GSList *cur;
MsgFileInfo *fileinfo;
cm_return_val_if_fail(dest != NULL, -1);
cm_return_val_if_fail(file_list != NULL, -1);
if (dest->last_num < 0) {
mh_get_last_num(folder, dest);
if (dest->last_num < 0) return -1;
}
for (cur = file_list; cur != NULL; cur = cur->next) {
fileinfo = (MsgFileInfo *)cur->data;
destfile = mh_get_new_msg_filename(dest);
if (destfile == NULL) return -1;
#ifdef G_OS_UNIX
if (link(fileinfo->file, destfile) < 0) {
#endif
if (copy_file(fileinfo->file, destfile, TRUE) < 0) {
g_warning(_("can't copy message %s to %s\n"),
fileinfo->file, destfile);
g_free(destfile);
return -1;
}
#ifdef G_OS_UNIX
}
#endif
if (relation != NULL)
g_hash_table_insert(relation, fileinfo, GINT_TO_POINTER(dest->last_num + 1));
g_free(destfile);
dest->last_num++;
}
mh_write_sequences(dest, TRUE);
return dest->last_num;
}
/* return newly constructed GtkPixmap from GdkPixmap */
GtkWidget *stock_pixmap_widget(StockPixmap icon)
{
GdkPixbuf *pixbuf;
cm_return_val_if_fail(icon >= 0 && icon < N_STOCK_PIXMAPS, NULL);
if (stock_pixbuf_gdk(icon, &pixbuf) != -1)
return gtk_image_new_from_pixbuf(pixbuf);
return NULL;
}
/*
* Return link list of all groups in address cache. Note that the list contains
* references to items. Do *NOT* attempt to use the addrcache_free_xxx() functions...
* this will destroy the address cache data!
* Return: List of items, or NULL if none.
*/
GList *addrcache_get_all_groups( AddressCache *cache ) {
GList *list = NULL;
cm_return_val_if_fail( cache != NULL, NULL );
cache->tempList = NULL;
g_hash_table_foreach( cache->itemHash, addrcache_get_all_groups_vis, cache );
list = cache->tempList;
cache->tempList = NULL;
return list;
}
/**
* Get person object from cache
*
* \param server Resource to LDAP
* \param uid PersonID in cache
* \return person object, or <i>NULL</i> if fail
*/
ItemPerson *ldapsvr_get_contact(LdapServer *server, gchar *uid) {
AddrItemObject *aio;
cm_return_val_if_fail(server != NULL || uid != NULL, NULL);
aio = addrcache_get_object(server->addressCache, uid);
if (aio) {
if(aio->type == ITEMTYPE_PERSON) {
return (ItemPerson *) aio;
}
}
return NULL;
}
/**
* Deside if dn needs to be changed
*
* \param hash GHashTable with user input.
* \param dn dn for current object
* \return Rdn structure
*/
Rdn *ldapsvr_modify_dn(GHashTable *hash, gchar *dn) {
Rdn *rdn;
gchar *pos, *compare;
gchar *rest;
gchar *val;
cm_return_val_if_fail(hash != NULL || dn != NULL, NULL);
pos = g_strstr_len(dn, strlen(dn), "=");
if (!pos)
return NULL;
compare = g_strndup(dn, pos - dn);
pos++;
rest = g_strstr_len(pos, strlen(pos), ",");
val = g_strndup(pos, rest - pos);
if (val == NULL) {
if (compare)
g_free(compare);
return NULL;
}
rdn = rdn_create();
rdn->value = val;
rdn->attribute = compare;
if (strcmp("mail", rdn->attribute) == 0) {
GList *list = g_hash_table_lookup(hash, rdn->attribute);
while (list) {
EmailKeyValue *item = list->data;
compare = (gchar *) item->mail;
if (strcmp(compare, rdn->value) == 0) {
update_rdn(rdn, compare, rest);
return rdn;
}
list = g_list_next(list);
}
/* if compare and rdn->attribute are equal then last email removed/empty */
if (strcmp(compare, rdn->attribute) != 0) {
/* RDN changed. Find new */
update_rdn(rdn, compare, rest);
return rdn;
}
}
else {
compare = g_hash_table_lookup(hash, rdn->attribute);
/* if compare and rdn->attribute are equal then dn removed/empty */
if (compare != NULL && strcmp(compare, rdn->attribute) != 0) {
update_rdn(rdn, compare, rest);
return rdn;
}
}
rdn_free(rdn);
return NULL;
}
ERTFParser *ertf_parser_new(FILE *fp, CodeConverter *conv)
{
ERTFParser *parser;
cm_return_val_if_fail(fp != NULL, NULL);
cm_return_val_if_fail(conv != NULL, NULL);
parser = g_new0(ERTFParser, 1);
parser->fp = fp;
parser->conv = conv;
parser->str = g_string_new(NULL);
parser->buf = g_string_new(NULL);
parser->bufp = parser->buf->str;
parser->newline = TRUE;
parser->empty_line = TRUE;
parser->space = FALSE;
parser->pre = FALSE;
return parser;
}
static gint mh_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
{
GSList msglist;
cm_return_val_if_fail(msginfo != NULL, -1);
msglist.data = msginfo;
msglist.next = NULL;
return mh_copy_msgs(folder, dest, &msglist, NULL);
}
gint mh_get_num_list(Folder *folder, FolderItem *item, GSList **list, gboolean *old_uids_valid)
{
gchar *path;
GDir *dp;
const gchar *d;
GError *error = NULL;
gint num, nummsgs = 0;
cm_return_val_if_fail(item != NULL, -1);
debug_print("mh_get_num_list(): Scanning %s ...\n", item->path?item->path:"(null)");
*old_uids_valid = TRUE;
path = folder_item_get_path(item);
cm_return_val_if_fail(path != NULL, -1);
if (change_dir(path) < 0) {
g_free(path);
return -1;
}
g_free(path);
if ((dp = g_dir_open(".", 0, &error)) == NULL) {
g_message("Couldn't open current directory: %s (%d).\n",
error->message, error->code);
g_error_free(error);
return -1;
}
while ((d = g_dir_read_name(dp)) != NULL) {
if ((num = to_number(d)) > 0) {
*list = g_slist_prepend(*list, GINT_TO_POINTER(num));
nummsgs++;
}
}
g_dir_close(dp);
mh_set_mtime(folder, item);
return nummsgs;
}
static gboolean
key_pressed_cb (GtkWidget *widget, GdkEventKey *event, gpointer data)
{
struct select_keys_s *sk = data;
cm_return_val_if_fail (sk, FALSE);
if (event && event->keyval == GDK_KEY_Escape) {
sk->okay = 0;
gtk_main_quit ();
}
return FALSE;
}
gboolean privacy_system_can_encrypt(const gchar *id)
{
PrivacySystem *system;
cm_return_val_if_fail(id != NULL, FALSE);
system = privacy_get_system(id);
if (system == NULL)
return FALSE;
return system->can_encrypt;
}
gboolean privacy_encrypt(const gchar *id, MimeInfo *mimeinfo, const gchar *encdata)
{
PrivacySystem *system;
cm_return_val_if_fail(id != NULL, FALSE);
cm_return_val_if_fail(mimeinfo != NULL, FALSE);
if (encdata == NULL) {
privacy_set_error(_("No recipient keys defined."));
return FALSE;
}
system = privacy_get_system(id);
if (system == NULL)
return FALSE;
if (!system->can_encrypt)
return FALSE;
if (system->encrypt == NULL)
return FALSE;
return system->encrypt(mimeinfo, encdata);
}
