ssl.h File Reference

Handling of SSL encryption. More...

#include "config.h"
#include <stdbool.h>
#include "mutt/lib.h"

Include dependency graph for ssl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	CertMenuData
	Certificate data to use in the Menu. More...

Functions
	ARRAY_HEAD (CertArray, const char *)
	Array of text making up a Certificate. More...
void	cert_array_clear (struct CertArray *carr)
	Free all memory of a CertArray. More...
int	mutt_ssl_socket_setup (struct Connection *conn)
	Set up SSL socket mulitplexor. More...
int	dlg_verify_certificate (const char *title, struct CertArray *carr, bool allow_always, bool allow_skip)
	Ask the user to validate the certificate. More...

Detailed Description

Handling of SSL encryption.

Authors

• Tommi Komulainen

Copyright

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 2 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, see http://www.gnu.org/licenses/.

Definition in file ssl.h.

Function Documentation

ARRAY_HEAD()

ARRAY_HEAD	(	CertArray	,
		const char *
	)

Array of text making up a Certificate.

cert_array_clear()

void cert_array_clear

(

struct CertArray *

carr

)

Free all memory of a CertArray.

Parameters

carr	Array of text to clear

Note

Array is emptied, but not freed

Definition at line 158 of file dlg_verifycert.c.

{
  const char **line = NULL;
  ARRAY_FOREACH(line, carr)
  {
    FREE(line);
  }
}

Here is the caller graph for this function:

mutt_ssl_socket_setup()

int mutt_ssl_socket_setup

(

struct Connection *

conn

)

Set up SSL socket mulitplexor.

Parameters

conn	Connection to a server

Return values

0	Success
-1	Error

Definition at line 1123 of file gnutls.c.

{
  if (tls_init() < 0)
    return -1;
 
  conn->open = tls_socket_open;
  conn->read = tls_socket_read;
  conn->write = tls_socket_write;
  conn->close = tls_socket_close;
  conn->poll = tls_socket_poll;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dlg_verify_certificate()

int dlg_verify_certificate	(	const char *	title,
		struct CertArray *	carr,
		bool	allow_always,
		bool	allow_skip
	)

Ask the user to validate the certificate.

Parameters

title	Menu title
carr	Certificate text to display
allow_always	If true, allow the user to always accept the certificate
allow_skip	If true, allow the user to skip the verification

Return values

1	Reject certificate (or menu aborted)
2	Accept certificate once
3	Accept certificate always/skip (see notes)
4	Accept certificate skip

The possible retvals will depend on the parameters. The options are given in the order: Reject, Once, Always, Skip. The retval represents the chosen option.

Definition at line 182 of file dlg_verifycert.c.

{
  struct MuttWindow *dlg = simple_dialog_new(MENU_GENERIC, WT_DLG_CERTIFICATE, VerifyHelp);
 
  struct CertMenuData mdata = { carr };
 
  struct Menu *menu = dlg->wdata;
  menu->mdata = &mdata;
  menu->mdata_free = NULL; // Menu doesn't own the data
  menu->make_entry = cert_make_entry;
  menu->max = ARRAY_SIZE(carr);
 
  struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
  sbar_set_title(sbar, title);
 
  if (allow_always)
  {
    if (allow_skip)
    {
      mdata.prompt = _("(r)eject, accept (o)nce, (a)ccept always, (s)kip");
      /* L10N: The letters correspond to the choices in the string:
         "(r)eject, accept (o)nce, (a)ccept always, (s)kip"
         This is an interactive certificate confirmation prompt for an SSL connection. */
      mdata.keys = _("roas");
    }
    else
    {
      mdata.prompt = _("(r)eject, accept (o)nce, (a)ccept always");
      /* L10N: The letters correspond to the choices in the string:
         "(r)eject, accept (o)nce, (a)ccept always"
         This is an interactive certificate confirmation prompt for an SSL connection. */
      mdata.keys = _("roa");
    }
  }
  else
  {
    if (allow_skip)
    {
      mdata.prompt = _("(r)eject, accept (o)nce, (s)kip");
      /* L10N: The letters correspond to the choices in the string:
         "(r)eject, accept (o)nce, (s)kip"
         This is an interactive certificate confirmation prompt for an SSL connection. */
      mdata.keys = _("ros");
    }
    else
    {
      mdata.prompt = _("(r)eject, accept (o)nce");
      /* L10N: The letters correspond to the choices in the string:
         "(r)eject, accept (o)nce"
         This is an interactive certificate confirmation prompt for an SSL connection. */
      mdata.keys = _("ro");
    }
  }
  msgwin_set_text(MT_COLOR_PROMPT, mdata.prompt);
 
  bool old_ime = OptIgnoreMacroEvents;
  OptIgnoreMacroEvents = true;
 
  // ---------------------------------------------------------------------------
  // Event Loop
  int choice = 0;
  int op = OP_NULL;
  do
  {
    window_redraw(NULL);
    msgwin_set_text(MT_COLOR_PROMPT, mdata.prompt);
 
    // Try to catch dialog keys before ops
    if (menu_dialog_dokey(menu, &op) != 0)
    {
      struct KeyEvent event = km_dokey_event(MENU_GENERIC);
      if (event.ch == 'q')
        op = OP_EXIT;
      else
        op = event.op;
    }
 
    if (op == OP_TIMEOUT)
      continue;
 
    // Convert menubar movement to scrolling
    op = menu_dialog_translate_op(op);
 
    if (op <= OP_MAX)
      mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    else
      mutt_debug(LL_DEBUG1, "Got choice %d\n", op - OP_MAX);
 
    switch (op)
    {
      case -1:         // Abort: Ctrl-G
      case OP_EXIT:    // Q)uit
      case OP_MAX + 1: // R)eject
        choice = 1;
        break;
      case OP_MAX + 2: // O)nce
        choice = 2;
        break;
      case OP_MAX + 3: // A)lways / S)kip
        choice = 3;
        break;
      case OP_MAX + 4: // S)kip
        choice = 4;
        break;
 
      case OP_JUMP:
      case OP_JUMP_1:
      case OP_JUMP_2:
      case OP_JUMP_3:
      case OP_JUMP_4:
      case OP_JUMP_5:
      case OP_JUMP_6:
      case OP_JUMP_7:
      case OP_JUMP_8:
      case OP_JUMP_9:
        mutt_error(_("Jumping is not implemented for dialogs"));
        continue;
 
      case OP_SEARCH:
      case OP_SEARCH_NEXT:
      case OP_SEARCH_OPPOSITE:
      case OP_SEARCH_REVERSE:
        mutt_error(_("Search is not implemented for this menu"));
        continue;
    }
 
    (void) menu_function_dispatcher(menu->win, op);
  } while (choice == 0);
  // ---------------------------------------------------------------------------
 
  OptIgnoreMacroEvents = old_ime;
 
  simple_dialog_free(&dlg);
 
  return choice;
}

Here is the call graph for this function:

Here is the caller graph for this function: