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; }