mutt stable branch with some hacks
Basic autocrypt account menu.
Provide ability to create, delete, and toggle the prefer-encrypt and
enabled flag for an account.
Hook into the index via 'A' <autocrypt-acct-menu>.
+520
-8
+5
OPS
+5
OPS
···
3
3
OP_ATTACH_VIEW_MAILCAP "force viewing of attachment using mailcap"
4
4
OP_ATTACH_VIEW_TEXT "view attachment as text"
5
5
OP_ATTACH_COLLAPSE "Toggle display of subparts"
6
+
OP_AUTOCRYPT_ACCT_MENU "manage autocrypt accounts"
7
+
OP_AUTOCRYPT_CREATE_ACCT "create a new autocrypt account"
8
+
OP_AUTOCRYPT_DELETE_ACCT "delete the current account"
9
+
OP_AUTOCRYPT_TOGGLE_ACTIVE "toggle the current account active/inactive"
10
+
OP_AUTOCRYPT_TOGGLE_PREFER "toggle the current account prefer-encrypt flag"
6
11
OP_BOTTOM_PAGE "move to the bottom of the page"
7
12
OP_BOUNCE_MESSAGE "remail a message to another user"
8
13
OP_BROWSER_NEW_FILE "select a new file in this directory"
+1
-1
autocrypt/Makefile.am
+1
-1
autocrypt/Makefile.am
+10
-5
autocrypt/autocrypt.c
+10
-5
autocrypt/autocrypt.c
···
100
100
mutt_autocrypt_db_close ();
101
101
}
102
102
103
-
/* Creates a brand new account the first time autocrypt is initialized */
104
-
int mutt_autocrypt_account_init (void)
103
+
/* Creates a brand new account.
104
+
* This is used the first time autocrypt is initialized, and
105
+
* in the account menu. */
106
+
int mutt_autocrypt_account_init (int prompt)
105
107
{
106
108
ADDRESS *addr = NULL;
107
109
BUFFER *keyid = NULL, *keydata = NULL;
108
110
AUTOCRYPT_ACCOUNT *account = NULL;
109
111
int done = 0, rv = -1, prefer_encrypt = 0;
110
112
111
-
dprint (1, (debugfile, "In mutt_autocrypt_account_init\n"));
112
-
if (mutt_yesorno (_("Create an initial autocrypt account?"),
113
+
if (prompt)
114
+
{
115
+
if (mutt_yesorno (_("Create an initial autocrypt account?"),
113
116
MUTT_YES) != MUTT_YES)
114
-
return 0;
117
+
return 0;
118
+
}
115
119
116
120
keyid = mutt_buffer_pool_get ();
117
121
keydata = mutt_buffer_pool_get ();
···
152
156
if (account)
153
157
{
154
158
mutt_error _("That email address already has an autocrypt account");
159
+
mutt_sleep (1);
155
160
goto cleanup;
156
161
}
157
162
+1
autocrypt/autocrypt.h
+1
autocrypt/autocrypt.h
+160
-1
autocrypt/autocrypt_db.c
+160
-1
autocrypt/autocrypt_db.c
···
28
28
/* Prepared statements */
29
29
static sqlite3_stmt *AccountGetStmt;
30
30
static sqlite3_stmt *AccountInsertStmt;
31
+
static sqlite3_stmt *AccountUpdateStmt;
32
+
static sqlite3_stmt *AccountDeleteStmt;
31
33
static sqlite3_stmt *PeerGetStmt;
32
34
static sqlite3_stmt *PeerInsertStmt;
33
35
static sqlite3_stmt *PeerUpdateStmt;
···
74
76
if (autocrypt_db_create (mutt_b2s (db_path)))
75
77
goto cleanup;
76
78
/* Don't abort the whole init process because account creation failed */
77
-
mutt_autocrypt_account_init ();
79
+
mutt_autocrypt_account_init (1);
78
80
}
79
81
else
80
82
{
···
108
110
AccountGetStmt = NULL;
109
111
sqlite3_finalize (AccountInsertStmt);
110
112
AccountInsertStmt = NULL;
113
+
sqlite3_finalize (AccountUpdateStmt);
114
+
AccountUpdateStmt = NULL;
115
+
sqlite3_finalize (AccountDeleteStmt);
116
+
AccountDeleteStmt = NULL;
111
117
112
118
sqlite3_finalize (PeerGetStmt);
113
119
PeerGetStmt = NULL;
···
304
310
cleanup:
305
311
rfc822_free_address (&norm_addr);
306
312
sqlite3_reset (AccountInsertStmt);
313
+
return rv;
314
+
}
315
+
316
+
int mutt_autocrypt_db_account_update (AUTOCRYPT_ACCOUNT *acct)
317
+
{
318
+
int rv = -1;
319
+
320
+
if (!AccountUpdateStmt)
321
+
{
322
+
if (sqlite3_prepare_v3 (
323
+
AutocryptDB,
324
+
"UPDATE account SET "
325
+
"keyid = ?, "
326
+
"keydata = ?, "
327
+
"prefer_encrypt = ?, "
328
+
"enabled = ? "
329
+
"WHERE email_addr = ?;",
330
+
-1,
331
+
SQLITE_PREPARE_PERSISTENT,
332
+
&AccountUpdateStmt,
333
+
NULL) != SQLITE_OK)
334
+
goto cleanup;
335
+
}
336
+
337
+
if (sqlite3_bind_text (AccountUpdateStmt,
338
+
1,
339
+
acct->keyid,
340
+
-1,
341
+
SQLITE_STATIC) != SQLITE_OK)
342
+
goto cleanup;
343
+
if (sqlite3_bind_text (AccountUpdateStmt,
344
+
2,
345
+
acct->keydata,
346
+
-1,
347
+
SQLITE_STATIC) != SQLITE_OK)
348
+
goto cleanup;
349
+
if (sqlite3_bind_int (AccountUpdateStmt,
350
+
3,
351
+
acct->prefer_encrypt) != SQLITE_OK)
352
+
goto cleanup;
353
+
if (sqlite3_bind_int (AccountUpdateStmt,
354
+
4,
355
+
acct->enabled) != SQLITE_OK)
356
+
goto cleanup;
357
+
if (sqlite3_bind_text (AccountUpdateStmt,
358
+
5,
359
+
acct->email_addr,
360
+
-1,
361
+
SQLITE_STATIC) != SQLITE_OK)
362
+
goto cleanup;
363
+
364
+
if (sqlite3_step (AccountUpdateStmt) != SQLITE_DONE)
365
+
goto cleanup;
366
+
367
+
rv = 0;
368
+
369
+
cleanup:
370
+
sqlite3_reset (AccountUpdateStmt);
371
+
return rv;
372
+
}
373
+
374
+
int mutt_autocrypt_db_account_delete (AUTOCRYPT_ACCOUNT *acct)
375
+
{
376
+
int rv = -1;
377
+
378
+
if (!AccountDeleteStmt)
379
+
{
380
+
if (sqlite3_prepare_v3 (
381
+
AutocryptDB,
382
+
"DELETE from account "
383
+
"WHERE email_addr = ?;",
384
+
-1,
385
+
SQLITE_PREPARE_PERSISTENT,
386
+
&AccountDeleteStmt,
387
+
NULL) != SQLITE_OK)
388
+
goto cleanup;
389
+
}
390
+
391
+
if (sqlite3_bind_text (AccountDeleteStmt,
392
+
1,
393
+
acct->email_addr,
394
+
-1,
395
+
SQLITE_STATIC) != SQLITE_OK)
396
+
goto cleanup;
397
+
398
+
if (sqlite3_step (AccountDeleteStmt) != SQLITE_DONE)
399
+
goto cleanup;
400
+
401
+
rv = 0;
402
+
403
+
cleanup:
404
+
sqlite3_reset (AccountDeleteStmt);
405
+
return rv;
406
+
}
407
+
408
+
int mutt_autocrypt_db_account_get_all (AUTOCRYPT_ACCOUNT ***accounts, int *num_accounts)
409
+
{
410
+
int rv = -1, result;
411
+
sqlite3_stmt *stmt = NULL;
412
+
AUTOCRYPT_ACCOUNT **results = NULL, *account;
413
+
int results_len = 0, results_count = 0;
414
+
415
+
*accounts = NULL;
416
+
*num_accounts = 0;
417
+
418
+
/* Note, speed is not of the essence for the account management screen,
419
+
* so we don't bother with a persistent prepared statement */
420
+
if (sqlite3_prepare_v2 (
421
+
AutocryptDB,
422
+
"SELECT "
423
+
"email_addr, "
424
+
"keyid, "
425
+
"keydata, "
426
+
"prefer_encrypt, "
427
+
"enabled "
428
+
"FROM account "
429
+
"ORDER BY email_addr",
430
+
-1,
431
+
&stmt,
432
+
NULL) != SQLITE_OK)
433
+
goto cleanup;
434
+
435
+
while ((result = sqlite3_step (stmt)) == SQLITE_ROW)
436
+
{
437
+
if (results_count == results_len)
438
+
{
439
+
results_len += 5;
440
+
safe_realloc (&results, results_len * sizeof(AUTOCRYPT_ACCOUNT *));
441
+
}
442
+
443
+
results[results_count++] = account = mutt_autocrypt_db_account_new ();
444
+
445
+
account->email_addr = strdup_column_text (stmt, 0);
446
+
account->keyid = strdup_column_text (stmt, 1);
447
+
account->keydata = strdup_column_text (stmt, 2);
448
+
account->prefer_encrypt = sqlite3_column_int (stmt, 3);
449
+
account->enabled = sqlite3_column_int (stmt, 4);
450
+
}
451
+
452
+
if (result == SQLITE_DONE)
453
+
{
454
+
*accounts = results;
455
+
rv = *num_accounts = results_count;
456
+
}
457
+
else
458
+
{
459
+
while (results_count > 0)
460
+
mutt_autocrypt_db_account_free (&results[--results_count]);
461
+
FREE (&results);
462
+
}
463
+
464
+
cleanup:
465
+
sqlite3_finalize (stmt);
307
466
return rv;
308
467
}
309
468
+4
-1
autocrypt/autocrypt_private.h
+4
-1
autocrypt/autocrypt_private.h
···
21
21
22
22
#include <sqlite3.h>
23
23
24
-
int mutt_autocrypt_account_init (void);
24
+
int mutt_autocrypt_account_init (int prompt);
25
25
26
26
int mutt_autocrypt_db_init (int can_create);
27
27
void mutt_autocrypt_db_close (void);
···
33
33
int mutt_autocrypt_db_account_get (ADDRESS *addr, AUTOCRYPT_ACCOUNT **account);
34
34
int mutt_autocrypt_db_account_insert (ADDRESS *addr, const char *keyid,
35
35
const char *keydata, int prefer_encrypt);
36
+
int mutt_autocrypt_db_account_update (AUTOCRYPT_ACCOUNT *acct);
37
+
int mutt_autocrypt_db_account_delete (AUTOCRYPT_ACCOUNT *acct);
38
+
int mutt_autocrypt_db_account_get_all (AUTOCRYPT_ACCOUNT ***accounts, int *num_accounts);
36
39
37
40
AUTOCRYPT_PEER *mutt_autocrypt_db_peer_new (void);
38
41
void mutt_autocrypt_db_peer_free (AUTOCRYPT_PEER **peer);
+11
curs_main.c
+11
curs_main.c
···
45
45
#include "monitor.h"
46
46
#endif
47
47
48
+
#ifdef USE_AUTOCRYPT
49
+
#include "autocrypt.h"
50
+
#endif
51
+
48
52
#include "mutt_crypt.h"
49
53
50
54
···
2562
2566
mutt_reflow_windows();
2563
2567
break;
2564
2568
#endif
2569
+
2570
+
#ifdef USE_AUTOCRYPT
2571
+
case OP_AUTOCRYPT_ACCT_MENU:
2572
+
mutt_autocrypt_account_menu ();
2573
+
break;
2574
+
#endif
2575
+
2565
2576
default:
2566
2577
if (menu->menu == MENU_MAIN)
2567
2578
km_error_key (MENU_MAIN);
+1
doc/manual.xml.tail
+1
doc/manual.xml.tail
+13
functions.h
+13
functions.h
···
86
86
87
87
const struct binding_t OpMain[] = { /* map: index */
88
88
{ "create-alias", OP_CREATE_ALIAS, "a" },
89
+
#ifdef USE_AUTOCRYPT
90
+
{ "autocrypt-acct-menu", OP_AUTOCRYPT_ACCT_MENU, "A" },
91
+
#endif
89
92
{ "bounce-message", OP_BOUNCE_MESSAGE, "b" },
90
93
{ "break-thread", OP_MAIN_BREAK_THREAD, "#" },
91
94
{ "change-folder", OP_MAIN_CHANGE_FOLDER, "c" },
···
500
503
{ NULL, 0, NULL }
501
504
};
502
505
#endif /* MIXMASTER */
506
+
507
+
#ifdef USE_AUTOCRYPT
508
+
const struct binding_t OpAutocryptAcct[] = { /* map: autocrypt account */
509
+
{ "create-account", OP_AUTOCRYPT_CREATE_ACCT, "c" },
510
+
{ "delete-account", OP_AUTOCRYPT_DELETE_ACCT, "D" },
511
+
{ "toggle-active", OP_AUTOCRYPT_TOGGLE_ACTIVE, "a" },
512
+
{ "toggle-prefer-encrypt", OP_AUTOCRYPT_TOGGLE_PREFER, "p" },
513
+
{ NULL, 0, NULL }
514
+
};
515
+
#endif
+1
globals.h
+1
globals.h
···
41
41
WHERE char *AttachCharset;
42
42
WHERE char *AttachFormat;
43
43
#ifdef USE_AUTOCRYPT
44
+
WHERE char *AutocryptAcctFormat;
44
45
WHERE char *AutocryptDir;
45
46
WHERE char *AutocryptSignAs; /* This is used in crypt-gpgme.c */
46
47
WHERE char *AutocryptDefaultKey; /* Used for postponing messages */
+14
init.h
+14
init.h
···
325
325
** passive encryption protection with keys exchanged via headers.
326
326
** TODO: add a section in the manual describing this is more detail.
327
327
*/
328
+
{ "autocrypt_acct_format", DT_STR, R_MENU, {.p=&AutocryptAcctFormat}, {.p="%4n %-30a %20p %10s"} },
329
+
/*
330
+
** .pp
331
+
** This variable describes the format of the ``autocrypt account'' menu.
332
+
** The following \fCprintf(3)\fP-style sequences are understood
333
+
** .dl
334
+
** .dt %a .dd email address
335
+
** .dt %k .dd gpg keyid
336
+
** .dt %n .dd current entry number
337
+
** .dt %p .dd prefer-encrypt flag
338
+
** .dt %s .dd status flag (active/inactive)
339
+
** .de
340
+
** .pp
341
+
*/
328
342
{ "autocrypt_dir", DT_PATH, R_NONE, {.p=&AutocryptDir}, {.p="~/.mutt/autocrypt"} },
329
343
/*
330
344
** .pp
+9
keymap.c
+9
keymap.c
···
770
770
km_bindkey ("l", MENU_MIX, OP_MIX_CHAIN_NEXT);
771
771
#endif
772
772
773
+
#ifdef USE_AUTOCRYPT
774
+
create_bindings (OpAutocryptAcct, MENU_AUTOCRYPT_ACCT);
775
+
#endif
776
+
773
777
/* bindings for the line editor */
774
778
create_bindings (OpEditor, MENU_EDITOR);
775
779
···
1025
1029
#ifdef MIXMASTER
1026
1030
case MENU_MIX:
1027
1031
return OpMix;
1032
+
#endif
1033
+
1034
+
#ifdef USE_AUTOCRYPT
1035
+
case MENU_AUTOCRYPT_ACCT:
1036
+
return OpAutocryptAcct;
1028
1037
#endif
1029
1038
1030
1039
}
+7
keymap.h
+7
keymap.h
···
77
77
MENU_MIX,
78
78
#endif
79
79
80
+
#ifdef USE_AUTOCRYPT
81
+
MENU_AUTOCRYPT_ACCT,
82
+
#endif
80
83
81
84
82
85
MENU_MAX
···
116
119
117
120
#ifdef MIXMASTER
118
121
extern const struct binding_t OpMix[];
122
+
#endif
123
+
124
+
#ifdef USE_AUTOCRYPT
125
+
extern const struct binding_t OpAutocryptAcct[];
119
126
#endif
120
127
121
128
#include "keymap_defs.h"