gboolean
bookmark_join(const char *jid)
{
assert(jid != NULL);
Bookmark *bookmark = g_hash_table_lookup(bookmarks, jid);
if (!bookmark) {
return FALSE;
}
char *account_name = session_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
if (!muc_active(bookmark->barejid)) {
char *nick = bookmark->nick;
if (!nick) {
nick = account->muc_nick;
}
presence_join_room(bookmark->barejid, nick, bookmark->password);
muc_join(bookmark->barejid, nick, bookmark->password, FALSE);
account_free(account);
} else if (muc_roster_complete(bookmark->barejid)) {
ui_room_join(bookmark->barejid, TRUE);
account_free(account);
}
return TRUE;
}
prof_otrpolicy_t
otr_get_policy(const char *const recipient)
{
char *account_name = jabber_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
// check contact specific setting
if (g_list_find_custom(account->otr_manual, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_MANUAL;
}
if (g_list_find_custom(account->otr_opportunistic, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_OPPORTUNISTIC;
}
if (g_list_find_custom(account->otr_always, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_ALWAYS;
}
// check default account setting
if (account->otr_policy) {
prof_otrpolicy_t result;
if (g_strcmp0(account->otr_policy, "manual") == 0) {
result = PROF_OTRPOLICY_MANUAL;
}
if (g_strcmp0(account->otr_policy, "opportunistic") == 0) {
result = PROF_OTRPOLICY_OPPORTUNISTIC;
}
if (g_strcmp0(account->otr_policy, "always") == 0) {
result = PROF_OTRPOLICY_ALWAYS;
}
account_free(account);
return result;
}
account_free(account);
// check global setting
char *pref_otr_policy = prefs_get_string(PREF_OTR_POLICY);
// pref defaults to manual
prof_otrpolicy_t result = PROF_OTRPOLICY_MANUAL;
if (strcmp(pref_otr_policy, "opportunistic") == 0) {
result = PROF_OTRPOLICY_OPPORTUNISTIC;
} else if (strcmp(pref_otr_policy, "always") == 0) {
result = PROF_OTRPOLICY_ALWAYS;
}
prefs_free_string(pref_otr_policy);
return result;
}
void
sv_ev_login_account_success(char *account_name)
{
ProfAccount *account = accounts_get_account(account_name);
#ifdef HAVE_LIBOTR
otr_on_connect(account);
#endif
ui_handle_login_account_success(account);
// attempt to rejoin rooms with passwords
GList *curr = muc_rooms();
while (curr) {
char *password = muc_password(curr->data);
if (password) {
char *nick = muc_nick(curr->data);
presence_join_room(curr->data, nick, password);
}
curr = g_list_next(curr);
}
g_list_free(curr);
log_info("%s logged in successfully", account->jid);
account_free(account);
}
gboolean
bookmark_join(const char *jid)
{
Bookmark *item = malloc(sizeof(*item));
item->jid = strdup(jid);
item->nick = NULL;
item->password = NULL;
item->autojoin = FALSE;
GList *found = g_list_find_custom(bookmark_list, item, _match_bookmark_by_jid);
_bookmark_item_destroy(item);
if (found == NULL) {
return FALSE;
} else {
char *account_name = jabber_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
Bookmark *item = found->data;
if (!muc_active(item->jid)) {
char *nick = item->nick;
if (nick == NULL) {
nick = account->muc_nick;
}
presence_join_room(item->jid, nick, item->password);
muc_join(item->jid, nick, item->password, FALSE);
account_free(account);
} else if (muc_roster_complete(item->jid)) {
ui_room_join(item->jid, TRUE);
}
return TRUE;
}
}
char*
message_send_chat_pgp(const char *const barejid, const char *const msg)
{
xmpp_conn_t * const conn = connection_get_conn();
xmpp_ctx_t * const ctx = connection_get_ctx();
char *state = _session_state(barejid);
char *jid = _session_jid(barejid);
char *id = create_unique_id("msg");
xmpp_stanza_t *message = NULL;
#ifdef HAVE_LIBGPGME
char *account_name = jabber_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
if (account->pgp_keyid) {
Jid *jidp = jid_create(jid);
char *encrypted = p_gpg_encrypt(jidp->barejid, msg);
if (encrypted) {
message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, "This message is encrypted.");
xmpp_stanza_t *x = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(x, STANZA_NAME_X);
xmpp_stanza_set_ns(x, STANZA_NS_ENCRYPTED);
xmpp_stanza_t *enc_st = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(enc_st, encrypted);
xmpp_stanza_add_child(x, enc_st);
xmpp_stanza_release(enc_st);
xmpp_stanza_add_child(message, x);
xmpp_stanza_release(x);
free(encrypted);
} else {
message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);
}
jid_destroy(jidp);
} else {
message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);
}
account_free(account);
#else
message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);
#endif
free(jid);
if (state) {
stanza_attach_state(ctx, message, state);
}
stanza_attach_carbons_private(ctx, message);
if (prefs_get_boolean(PREF_RECEIPTS_REQUEST)) {
stanza_attach_receipt_request(ctx, message);
}
xmpp_send(conn, message);
xmpp_stanza_release(message);
return id;
}
static struct account *account_parse(struct chunk *chunk, const unsigned char key[KDF_HASH_LEN])
{
struct account *parsed = new0(struct account, 1);
entry_plain(id);
entry_crypt(name);
entry_crypt(group);
entry_hex(url);
entry_crypt(note);
skip(fav);
skip(sharedfromaid);
entry_crypt(username);
entry_crypt(password);
entry_boolean(pwprotect);
skip(genpw);
skip(sn);
skip(last_touch);
skip(autologin);
skip(never_autofill);
skip(realm_data);
skip(fiid);
skip(custom_js);
skip(submit_id);
skip(captcha_id);
skip(urid);
skip(basic_auth);
skip(method);
skip(action);
skip(groupid);
skip(deleted);
skip(attachkey);
skip(attachpresent);
skip(individualshare);
skip(notetype);
skip(noalert);
skip(last_modified_gmt);
skip(hasbeenshared);
skip(last_pwchange_gmt);
skip(created_gmt);
skip(vulnerable);
if (parsed->name[0] == 16)
parsed->name[0] = '\0';
if (parsed->group[0] == 16)
parsed->group[0] = '\0';
if (strlen(parsed->name) && strlen(parsed->group))
xasprintf(&parsed->fullname, "%s/%s", parsed->group, parsed->name);
else
parsed->fullname = xstrdup(parsed->name);
return parsed;
error:
account_free(parsed);
return NULL;
}
END_TEST
START_TEST (test_account_free)
{
Account * a = account_create(); /*!< @todo Mock account create or hand code? */
account_free(a);
fail_unless(a == NULL, "Memory not properly freed");
}
void blob_free(struct blob *blob)
{
if (!blob)
return;
for (struct account *account = blob->account_head, *next_account = NULL; account; account = next_account) {
next_account = account->next;
account_free(account);
}
free(blob);
}
void
sv_ev_roster_received(void)
{
if (prefs_get_boolean(PREF_ROSTER)) {
ui_show_roster();
}
char *account_name = session_get_account_name();
#ifdef HAVE_LIBGPGME
// check pgp key valid if specified
ProfAccount *account = accounts_get_account(account_name);
if (account && account->pgp_keyid) {
char *err_str = NULL;
if (!p_gpg_valid_key(account->pgp_keyid, &err_str)) {
cons_show_error("Invalid PGP key ID specified: %s, %s", account->pgp_keyid, err_str);
}
free(err_str);
}
account_free(account);
#endif
// send initial presence
resource_presence_t conn_presence = accounts_get_login_presence(account_name);
char *last_activity_str = accounts_get_last_activity(account_name);
if (last_activity_str) {
GDateTime *nowdt = g_date_time_new_now_utc();
GTimeVal lasttv;
gboolean res = g_time_val_from_iso8601(last_activity_str, &lasttv);
if (res) {
GDateTime *lastdt = g_date_time_new_from_timeval_utc(&lasttv);
GTimeSpan diff_micros = g_date_time_difference(nowdt, lastdt);
int diff_secs = (diff_micros / 1000) / 1000;
if (prefs_get_boolean(PREF_LASTACTIVITY)) {
cl_ev_presence_send(conn_presence, NULL, diff_secs);
} else {
cl_ev_presence_send(conn_presence, NULL, 0);
}
g_date_time_unref(lastdt);
} else {
cl_ev_presence_send(conn_presence, NULL, 0);
}
free(last_activity_str);
g_date_time_unref(nowdt);
} else {
cl_ev_presence_send(conn_presence, NULL, 0);
}
const char *fulljid = connection_get_fulljid();
plugins_on_connect(account_name, fulljid);
}
int cmd_rm(int argc, char **argv)
{
unsigned char key[KDF_HASH_LEN];
struct session *session = NULL;
struct blob *blob = NULL;
static struct option long_options[] = {
{"sync", required_argument, NULL, 'S'},
{"color", required_argument, NULL, 'C'},
{0, 0, 0, 0}
};
int option;
int option_index;
char *name;
enum blobsync sync = BLOB_SYNC_AUTO;
struct account *found;
while ((option = getopt_long(argc, argv, "", long_options, &option_index)) != -1) {
switch (option) {
case 'S':
sync = parse_sync_string(optarg);
break;
case 'C':
terminal_set_color_mode(
parse_color_mode_string(optarg));
break;
case '?':
default:
die_usage(cmd_rm_usage);
}
}
if (argc - optind != 1)
die_usage(cmd_rm_usage);
name = argv[optind];
init_all(sync, key, &session, &blob);
found = find_unique_account(blob, name);
if (!found)
die("Could not find specified account '%s'.", name);
if (found->share && found->share->readonly)
die("%s is a readonly shared entry from %s. It cannot be deleted.", found->fullname, found->share->name);
list_del(&found->list);
lastpass_remove_account(sync, key, session, found, blob);
blob_save(blob, key);
account_free(found);
session_free(session);
blob_free(blob);
return 0;
}
void
cl_ev_presence_send(const resource_presence_t presence_type, const char *const msg, const int idle_secs)
{
char *signed_status = NULL;
#ifdef HAVE_LIBGPGME
char *account_name = jabber_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
if (account->pgp_keyid) {
signed_status = p_gpg_sign(msg, account->pgp_keyid);
}
account_free(account);
#endif
presence_send(presence_type, msg, idle_secs, signed_status);
free(signed_status);
}
END_TEST
START_TEST (test_get_account_property)
{
Account * a = account_create();
/**
* @todo Mock things …
*/
fail_unless(_get_account_property(a, CONTAINER_COUNT, FALSE) == 3, "Incorrect container account returned!");
fail_unless(_get_account_property(a, CONTAINER_COUNT, TRUE) == 3, "Incorrect container account returned!");
/**
* @todo Check accesses to request function.
*/
account_free(a);
}
static bool deser_wallet_account(struct wallet *wlt, struct const_buffer *buf)
{
struct wallet_account *acct;
acct = calloc(1, sizeof(*acct));
if (!acct)
return false;
if (!deser_varstr(&acct->name, buf) ||
!deser_u32(&acct->acct_idx, buf) ||
!deser_u32(&acct->next_key_idx, buf))
goto err_out;
parr_add(wlt->accounts, acct);
return true;
err_out:
account_free(acct);
return false;
}
void
sv_ev_login_account_success(char *account_name, gboolean secured)
{
ProfAccount *account = accounts_get_account(account_name);
roster_create();
#ifdef HAVE_LIBOTR
otr_on_connect(account);
#endif
#ifdef HAVE_LIBGPGME
p_gpg_on_connect(account->jid);
#endif
ui_handle_login_account_success(account, secured);
// attempt to rejoin rooms with passwords
GList *curr = muc_rooms();
while (curr) {
char *password = muc_password(curr->data);
if (password) {
char *nick = muc_nick(curr->data);
presence_join_room(curr->data, nick, password);
}
curr = g_list_next(curr);
}
g_list_free(curr);
log_info("%s logged in successfully", account->jid);
if (account->startscript) {
scripts_exec(account->startscript);
}
account_free(account);
}
/* @Test */
void test_pop3(void)
{
struct list pop3_list;
struct account *ac;
struct pop3_server *pop3_server;
struct pop3_dl_options dl_options = {0};
char *profile_path;
char *pwd;
debug_init();
debug_set_level(25);
pwd = realpath(".", NULL);
CU_ASSERT(pwd != NULL);
profile_path = mycombinepath(pwd, "test-account-profile");
CU_ASSERT(profile_path != NULL);
config_set_user_profile_directory(profile_path);
CU_ASSERT(codesets_init() != 0);
CU_ASSERT(progmon_init() != 0);
CU_ASSERT(init_threads() != 0);
CU_ASSERT(load_config() != 0);
CU_ASSERT(init_folders() != 0);
ac = account_malloc();
CU_ASSERT(ac != NULL);
CU_ASSERT(ac->imap != NULL);
CU_ASSERT(ac->pop != NULL);
ac->recv_type = 0;
if (ac->pop->name) free(ac->pop->name);
ac->pop->name = mystrdup("localhost");
CU_ASSERT(ac->pop->name != NULL);
if (ac->pop->login) free(ac->pop->login);
ac->pop->login = mystrdup("test");
CU_ASSERT(ac->pop->login != NULL);
if (ac->pop->passwd) free(ac->pop->passwd);
ac->pop->passwd = mystrdup("test");
CU_ASSERT(ac->pop->passwd != NULL);
ac->pop->ssl = 0;
ac->pop->port = 10110;
insert_config_account(ac);
mails_test_account(ac, mails_test_account_callback);
sleep(3);
account_free(ac);
cleanup_threads();
del_folders();
free_config();
progmon_deinit();
codesets_cleanup();
free(profile_path);
free(pwd);
}
static void wallet_free_account(void *p)
{
struct wallet_account *acct = p;
account_free(acct);
}
static int
_bookmark_handle_result(xmpp_conn_t *const conn,
xmpp_stanza_t *const stanza, void *const userdata)
{
xmpp_ctx_t *ctx = connection_get_ctx();
char *id = (char *)userdata;
xmpp_stanza_t *ptr;
xmpp_stanza_t *nick;
xmpp_stanza_t *password_st;
char *name;
char *jid;
char *autojoin;
char *password;
gboolean autojoin_val;
Jid *my_jid;
Bookmark *item;
xmpp_timed_handler_delete(conn, _bookmark_handle_delete);
g_free(id);
name = xmpp_stanza_get_name(stanza);
if (!name || strcmp(name, STANZA_NAME_IQ) != 0) {
return 0;
}
ptr = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
if (!ptr) {
return 0;
}
ptr = xmpp_stanza_get_child_by_name(ptr, STANZA_NAME_STORAGE);
if (!ptr) {
return 0;
}
if (bookmark_ac == NULL) {
bookmark_ac = autocomplete_new();
}
my_jid = jid_create(jabber_get_fulljid());
ptr = xmpp_stanza_get_children(ptr);
while (ptr) {
name = xmpp_stanza_get_name(ptr);
if (!name || strcmp(name, STANZA_NAME_CONFERENCE) != 0) {
ptr = xmpp_stanza_get_next(ptr);
continue;
}
jid = xmpp_stanza_get_attribute(ptr, STANZA_ATTR_JID);
if (!jid) {
ptr = xmpp_stanza_get_next(ptr);
continue;
}
log_debug("Handle bookmark for %s", jid);
name = NULL;
nick = xmpp_stanza_get_child_by_name(ptr, "nick");
if (nick) {
char *tmp;
tmp = xmpp_stanza_get_text(nick);
if (tmp) {
name = strdup(tmp);
xmpp_free(ctx, tmp);
}
}
password = NULL;
password_st = xmpp_stanza_get_child_by_name(ptr, "password");
if (password_st) {
char *tmp;
tmp = xmpp_stanza_get_text(password_st);
if (tmp) {
password = strdup(tmp);
xmpp_free(ctx, tmp);
}
}
autojoin = xmpp_stanza_get_attribute(ptr, "autojoin");
if (autojoin && (strcmp(autojoin, "1") == 0 || strcmp(autojoin, "true") == 0)) {
autojoin_val = TRUE;
} else {
autojoin_val = FALSE;
}
autocomplete_add(bookmark_ac, jid);
item = malloc(sizeof(*item));
item->jid = strdup(jid);
item->nick = name;
item->password = password;
item->autojoin = autojoin_val;
bookmark_list = g_list_append(bookmark_list, item);
if (autojoin_val) {
Jid *room_jid;
char *account_name = jabber_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
if (name == NULL) {
name = account->muc_nick;
}
log_debug("Autojoin %s with nick=%s", jid, name);
room_jid = jid_create_from_bare_and_resource(jid, name);
if (!muc_active(room_jid->barejid)) {
presence_join_room(jid, name, password);
muc_join(jid, name, password, TRUE);
}
jid_destroy(room_jid);
account_free(account);
}
ptr = xmpp_stanza_get_next(ptr);
}
jid_destroy(my_jid);
return 0;
}
static bool postconfig_run(void)
{
struct account account = {0};
char *zone = 0;
bool utc = true;
if(chdir(INSTALL_ROOT) == -1)
{
error(strerror(errno));
return false;
}
if(mount("none",INSTALL_ROOT "/dev","devtmpfs",0,0) == -1)
{
error(strerror(errno));
return false;
}
if(mount("none",INSTALL_ROOT "/proc","proc",0,0) == -1)
{
error(strerror(errno));
return false;
}
if(mount("none",INSTALL_ROOT "/sys","sysfs",0,0) == -1)
{
error(strerror(errno));
return false;
}
if(!is_root_setup() && (!ui_window_root(&account) || !root_action(&account)))
{
account_free(&account);
return false;
}
account_free(&account);
if(!is_user_setup() && (!ui_window_user(&account) || !user_action(&account)))
{
account_free(&account);
return false;
}
account_free(&account);
if(!get_timezone_data() || !ui_window_time(tz_data,&zone,&utc) || !time_action(zone,utc))
return false;
if(umount2(INSTALL_ROOT "/dev",MNT_DETACH) == -1)
{
error(strerror(errno));
return false;
}
if(umount2(INSTALL_ROOT "/proc",MNT_DETACH) == -1)
{
error(strerror(errno));
return false;
}
if(umount2(INSTALL_ROOT "/sys",MNT_DETACH) == -1)
{
error(strerror(errno));
return false;
}
return true;
}
