auth.h File Reference

IMAP authenticator multiplexor. More...

#include "config.h"
#include <stdbool.h>

Include dependency graph for auth.h:

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

Go to the source code of this file.

Enumerations
enum	ImapAuthRes { IMAP_AUTH_SUCCESS = 0 , IMAP_AUTH_FAILURE , IMAP_AUTH_UNAVAIL }
	Results of IMAP Authentication. More...

Functions
bool	imap_auth_is_valid (const char *authenticator)
	Check if string is a valid imap authentication method.
enum ImapAuthRes	imap_auth_plain (struct ImapAccountData *adata, const char *method)
	SASL PLAIN support - Implements ImapAuth::authenticate()
enum ImapAuthRes	imap_auth_anon (struct ImapAccountData *adata, const char *method)
	Authenticate anonymously - Implements ImapAuth::authenticate()
enum ImapAuthRes	imap_auth_cram_md5 (struct ImapAccountData *adata, const char *method)
	Authenticate using CRAM-MD5 - Implements ImapAuth::authenticate()
enum ImapAuthRes	imap_auth_login (struct ImapAccountData *adata, const char *method)
	Plain LOGIN support - Implements ImapAuth::authenticate()
enum ImapAuthRes	imap_auth_gss (struct ImapAccountData *adata, const char *method)
	GSS Authentication support - Implements ImapAuth::authenticate()
enum ImapAuthRes	imap_auth_oauth (struct ImapAccountData *adata, const char *method)
	Authenticate an IMAP connection using OAUTHBEARER - Implements ImapAuth::authenticate()
enum ImapAuthRes	imap_auth_xoauth2 (struct ImapAccountData *adata, const char *method)
	Authenticate an IMAP connection using XOAUTH2 - Implements ImapAuth::authenticate()

Detailed Description

IMAP authenticator multiplexor.

Authors

• Brendan Cully

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 auth.h.

Enumeration Type Documentation

ImapAuthRes

enum ImapAuthRes

Results of IMAP Authentication.

Enumerator
IMAP_AUTH_SUCCESS	Authentication successful.
IMAP_AUTH_FAILURE	Authentication failed.
IMAP_AUTH_UNAVAIL	Authentication method not permitted.

Definition at line 37 of file auth.h.

{
  IMAP_AUTH_SUCCESS = 0, 
  IMAP_AUTH_FAILURE,     
  IMAP_AUTH_UNAVAIL,     
};

Function Documentation

imap_auth_is_valid()

bool imap_auth_is_valid

(

const char *

authenticator

)

Check if string is a valid imap authentication method.

Parameters

authenticator

Authenticator string to check

Return values

true	Argument is a valid auth method

Validate whether an input string is an accepted imap authentication method as defined by ImapAuthenticators.

Definition at line 90 of file auth.c.

{
  for (size_t i = 0; i < mutt_array_size(ImapAuthenticators); i++)
  {
    const struct ImapAuth *auth = &ImapAuthenticators[i];
    if (auth->method && mutt_istr_equal(auth->method, authenticator))
      return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_auth_plain()

enum ImapAuthRes imap_auth_plain	(	struct ImapAccountData *	adata,
		const char *	method
	)

SASL PLAIN support - Implements ImapAuth::authenticate()

Definition at line 41 of file auth_plain.c.

{
  int rc = IMAP_RES_CONTINUE;
  enum ImapAuthRes res = IMAP_AUTH_SUCCESS;
  static const char auth_plain_cmd[] = "AUTHENTICATE PLAIN";
  char buf[256] = { 0 };
 
  if (mutt_account_getuser(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
  if (mutt_account_getpass(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  mutt_message(_("Logging in..."));
 
  /* Prepare full AUTHENTICATE PLAIN message */
  mutt_sasl_plain_msg(buf, sizeof(buf), auth_plain_cmd, adata->conn->account.user,
                      adata->conn->account.user, adata->conn->account.pass);
 
  if (adata->capabilities & IMAP_CAP_SASL_IR)
  {
    imap_cmd_start(adata, buf);
  }
  else
  {
    /* Split the message so we send AUTHENTICATE PLAIN first, and the
     * credentials after the first command continuation request */
    buf[sizeof(auth_plain_cmd) - 1] = '\0';
    imap_cmd_start(adata, buf);
    while (rc == IMAP_RES_CONTINUE)
    {
      rc = imap_cmd_step(adata);
    }
    if (rc == IMAP_RES_RESPOND)
    {
      mutt_str_cat(buf + sizeof(auth_plain_cmd),
                   sizeof(buf) - sizeof(auth_plain_cmd), "\r\n");
      mutt_socket_send(adata->conn, buf + sizeof(auth_plain_cmd));
      rc = IMAP_RES_CONTINUE;
    }
  }
 
  while (rc == IMAP_RES_CONTINUE)
  {
    rc = imap_cmd_step(adata);
  }
 
  if (rc == IMAP_RES_BAD)
  {
    res = IMAP_AUTH_UNAVAIL;
  }
  else if (rc == IMAP_RES_NO)
  {
    mutt_error(_("Login failed"));
    res = IMAP_AUTH_FAILURE;
  }
 
  mutt_clear_error();
  return res;
}

Here is the call graph for this function:

imap_auth_anon()

enum ImapAuthRes imap_auth_anon	(	struct ImapAccountData *	adata,
		const char *	method
	)

Authenticate anonymously - Implements ImapAuth::authenticate()

This is basically a stripped-down version of the cram-md5 method.

Definition at line 41 of file auth_anon.c.

{
  int rc;
 
  if (!(adata->capabilities & IMAP_CAP_AUTH_ANONYMOUS))
    return IMAP_AUTH_UNAVAIL;
 
  if (mutt_account_getuser(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  if (adata->conn->account.user[0] != '\0')
    return IMAP_AUTH_UNAVAIL;
 
  // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_message(_("Authenticating (%s)..."), "anonymous");
 
  imap_cmd_start(adata, "AUTHENTICATE ANONYMOUS");
 
  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);
 
  if (rc != IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG1, "Invalid response from server\n");
    goto bail;
  }
 
  mutt_socket_send(adata->conn, "ZHVtbXkK\r\n"); /* base64 ("dummy") */
 
  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);
 
  if (rc != IMAP_RES_OK)
  {
    mutt_debug(LL_DEBUG1, "Error receiving server response\n");
    goto bail;
  }
 
  if (imap_code(adata->buf))
    return IMAP_AUTH_SUCCESS;
 
bail:
  // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_error(_("%s authentication failed"), "anonymous");
  return IMAP_AUTH_FAILURE;
}

Here is the call graph for this function:

imap_auth_cram_md5()

enum ImapAuthRes imap_auth_cram_md5	(	struct ImapAccountData *	adata,
		const char *	method
	)

Authenticate using CRAM-MD5 - Implements ImapAuth::authenticate()

Definition at line 95 of file auth_cram.c.

{
  char ibuf[2048], obuf[1024];
  unsigned char hmac_response[MD5_DIGEST_LEN];
  int len;
  int rc;
 
  if (!(adata->capabilities & IMAP_CAP_AUTH_CRAM_MD5))
    return IMAP_AUTH_UNAVAIL;
 
  // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_message(_("Authenticating (%s)..."), "CRAM-MD5");
 
  /* get auth info */
  if (mutt_account_getlogin(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
  if (mutt_account_getpass(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  imap_cmd_start(adata, "AUTHENTICATE CRAM-MD5");
 
  /* From RFC2195:
   * The data encoded in the first ready response contains a presumptively
   * arbitrary string of random digits, a timestamp, and the fully-qualified
   * primary host name of the server. The syntax of the unencoded form must
   * correspond to that of an RFC822 'msg-id' [RFC822] as described in [POP3].  */
  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);
 
  if (rc != IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG1, "Invalid response from server: %s\n", ibuf);
    goto bail;
  }
 
  len = mutt_b64_decode(adata->buf + 2, obuf, sizeof(obuf));
  if (len == -1)
  {
    mutt_debug(LL_DEBUG1, "Error decoding base64 response\n");
    goto bail;
  }
 
  obuf[len] = '\0';
  mutt_debug(LL_DEBUG2, "CRAM challenge: %s\n", obuf);
 
  /* The client makes note of the data and then responds with a string
   * consisting of the user name, a space, and a 'digest'. The latter is
   * computed by applying the keyed MD5 algorithm from [KEYED-MD5] where the
   * key is a shared secret and the digested text is the timestamp (including
   * angle-brackets).
   *
   * Note: The user name shouldn't be quoted. Since the digest can't contain
   *   spaces, there is no ambiguity. Some servers get this wrong, we'll work
   *   around them when the bug report comes in. Until then, we'll remain
   *   blissfully RFC-compliant.  */
  hmac_md5(adata->conn->account.pass, obuf, hmac_response);
  /* dubious optimisation I saw elsewhere: make the whole string in one call */
  int off = snprintf(obuf, sizeof(obuf), "%s ", adata->conn->account.user);
  mutt_md5_toascii(hmac_response, obuf + off);
  mutt_debug(LL_DEBUG2, "CRAM response: %s\n", obuf);
 
  /* ibuf must be long enough to store the base64 encoding of obuf,
   * plus the additional debris */
  mutt_b64_encode(obuf, strlen(obuf), ibuf, sizeof(ibuf) - 2);
  mutt_str_cat(ibuf, sizeof(ibuf), "\r\n");
  mutt_socket_send(adata->conn, ibuf);
 
  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);
 
  if (rc != IMAP_RES_OK)
  {
    mutt_debug(LL_DEBUG1, "Error receiving server response\n");
    goto bail;
  }
 
  if (imap_code(adata->buf))
    return IMAP_AUTH_SUCCESS;
 
bail:
  // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_error(_("%s authentication failed"), "CRAM-MD5");
  return IMAP_AUTH_FAILURE;
}

Here is the call graph for this function:

imap_auth_login()

enum ImapAuthRes imap_auth_login	(	struct ImapAccountData *	adata,
		const char *	method
	)

Plain LOGIN support - Implements ImapAuth::authenticate()

Definition at line 44 of file auth_login.c.

{
  char q_user[256], q_pass[256];
  char buf[1024] = { 0 };
 
  if ((adata->capabilities & IMAP_CAP_LOGINDISABLED))
  {
    mutt_message(_("LOGIN disabled on this server"));
    return IMAP_AUTH_UNAVAIL;
  }
 
  if (mutt_account_getuser(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
  if (mutt_account_getpass(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  mutt_message(_("Logging in..."));
 
  imap_quote_string(q_user, sizeof(q_user), adata->conn->account.user, false);
  imap_quote_string(q_pass, sizeof(q_pass), adata->conn->account.pass, false);
 
  /* don't print the password unless we're at the ungodly debugging level
   * of 5 or higher */
 
  const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
  if (c_debug_level < IMAP_LOG_PASS)
    mutt_debug(LL_DEBUG2, "Sending LOGIN command for %s\n", adata->conn->account.user);
 
  snprintf(buf, sizeof(buf), "LOGIN %s %s", q_user, q_pass);
  if (imap_exec(adata, buf, IMAP_CMD_PASS) == IMAP_EXEC_SUCCESS)
  {
    mutt_clear_error();
    return IMAP_AUTH_SUCCESS;
  }
 
  mutt_error(_("Login failed"));
  return IMAP_AUTH_FAILURE;
}

Here is the call graph for this function:

imap_auth_gss()

enum ImapAuthRes imap_auth_gss	(	struct ImapAccountData *	adata,
		const char *	method
	)

GSS Authentication support - Implements ImapAuth::authenticate()

Definition at line 104 of file auth_gss.c.

{
  gss_buffer_desc request_buf, send_token;
  gss_buffer_t sec_token;
  gss_name_t target_name;
  gss_ctx_id_t context;
  gss_OID mech_name;
  char server_conf_flags;
  gss_qop_t quality;
  int cflags;
  OM_uint32 maj_stat, min_stat;
  unsigned long buf_size;
  int rc2, rc = IMAP_AUTH_FAILURE;
 
  if (!(adata->capabilities & IMAP_CAP_AUTH_GSSAPI))
    return IMAP_AUTH_UNAVAIL;
 
  if (mutt_account_getuser(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  struct Buffer *buf1 = buf_pool_get();
  struct Buffer *buf2 = buf_pool_get();
 
  /* get an IMAP service ticket for the server */
  buf_printf(buf1, "imap@%s", adata->conn->account.host);
  request_buf.value = buf1->data;
  request_buf.length = buf_len(buf1);
 
  const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
  maj_stat = gss_import_name(&min_stat, &request_buf, gss_nt_service_name, &target_name);
  if (maj_stat != GSS_S_COMPLETE)
  {
    mutt_debug(LL_DEBUG2, "Couldn't get service name for [%s]\n", buf1->data);
    rc = IMAP_AUTH_UNAVAIL;
    goto cleanup;
  }
  else if (c_debug_level >= 2)
  {
    gss_display_name(&min_stat, target_name, &request_buf, &mech_name);
    mutt_debug(LL_DEBUG2, "Using service name [%s]\n", (char *) request_buf.value);
    gss_release_buffer(&min_stat, &request_buf);
  }
  /* Acquire initial credentials - without a TGT GSSAPI is UNAVAIL */
  sec_token = GSS_C_NO_BUFFER;
  context = GSS_C_NO_CONTEXT;
 
  /* build token */
  maj_stat = gss_init_sec_context(&min_stat, GSS_C_NO_CREDENTIAL, &context, target_name,
                                  GSS_C_NO_OID, GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG,
                                  0, GSS_C_NO_CHANNEL_BINDINGS, sec_token, NULL,
                                  &send_token, (unsigned int *) &cflags, NULL);
  if ((maj_stat != GSS_S_COMPLETE) && (maj_stat != GSS_S_CONTINUE_NEEDED))
  {
    print_gss_error(maj_stat, min_stat);
    mutt_debug(LL_DEBUG1, "Error acquiring credentials - no TGT?\n");
    gss_release_name(&min_stat, &target_name);
 
    rc = IMAP_AUTH_UNAVAIL;
    goto cleanup;
  }
 
  /* now begin login */
  // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_message(_("Authenticating (%s)..."), "GSSAPI");
 
  imap_cmd_start(adata, "AUTHENTICATE GSSAPI");
 
  /* expect a null continuation response ("+") */
  do
  {
    rc2 = imap_cmd_step(adata);
  } while (rc2 == IMAP_RES_CONTINUE);
 
  if (rc2 != IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG2, "Invalid response from server: %s\n", buf1->data);
    gss_release_name(&min_stat, &target_name);
    goto bail;
  }
 
  /* now start the security context initialisation loop... */
  mutt_debug(LL_DEBUG2, "Sending credentials\n");
  mutt_b64_buffer_encode(buf1, send_token.value, send_token.length);
  gss_release_buffer(&min_stat, &send_token);
  buf_addstr(buf1, "\r\n");
  mutt_socket_send(adata->conn, buf_string(buf1));
 
  while (maj_stat == GSS_S_CONTINUE_NEEDED)
  {
    /* Read server data */
    do
    {
      rc2 = imap_cmd_step(adata);
    } while (rc2 == IMAP_RES_CONTINUE);
 
    if (rc2 != IMAP_RES_RESPOND)
    {
      mutt_debug(LL_DEBUG1, "#1 Error receiving server response\n");
      gss_release_name(&min_stat, &target_name);
      goto bail;
    }
 
    if (mutt_b64_buffer_decode(buf2, adata->buf + 2) < 0)
    {
      mutt_debug(LL_DEBUG1, "Invalid base64 server response\n");
      gss_release_name(&min_stat, &target_name);
      goto err_abort_cmd;
    }
    request_buf.value = buf2->data;
    request_buf.length = buf_len(buf2);
    sec_token = &request_buf;
 
    /* Write client data */
    maj_stat = gss_init_sec_context(&min_stat, GSS_C_NO_CREDENTIAL, &context, target_name,
                                    GSS_C_NO_OID, GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG,
                                    0, GSS_C_NO_CHANNEL_BINDINGS, sec_token, NULL,
                                    &send_token, (unsigned int *) &cflags, NULL);
    if ((maj_stat != GSS_S_COMPLETE) && (maj_stat != GSS_S_CONTINUE_NEEDED))
    {
      print_gss_error(maj_stat, min_stat);
      mutt_debug(LL_DEBUG1, "Error exchanging credentials\n");
      gss_release_name(&min_stat, &target_name);
 
      goto err_abort_cmd;
    }
    mutt_b64_buffer_encode(buf1, send_token.value, send_token.length);
    gss_release_buffer(&min_stat, &send_token);
    buf_addstr(buf1, "\r\n");
    mutt_socket_send(adata->conn, buf_string(buf1));
  }
 
  gss_release_name(&min_stat, &target_name);
 
  /* get security flags and buffer size */
  do
  {
    rc2 = imap_cmd_step(adata);
  } while (rc2 == IMAP_RES_CONTINUE);
 
  if (rc2 != IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG1, "#2 Error receiving server response\n");
    goto bail;
  }
  if (mutt_b64_buffer_decode(buf2, adata->buf + 2) < 0)
  {
    mutt_debug(LL_DEBUG1, "Invalid base64 server response\n");
    goto err_abort_cmd;
  }
  request_buf.value = buf2->data;
  request_buf.length = buf_len(buf2);
 
  maj_stat = gss_unwrap(&min_stat, context, &request_buf, &send_token, &cflags, &quality);
  if (maj_stat != GSS_S_COMPLETE)
  {
    print_gss_error(maj_stat, min_stat);
    mutt_debug(LL_DEBUG2, "Couldn't unwrap security level data\n");
    gss_release_buffer(&min_stat, &send_token);
    goto err_abort_cmd;
  }
  mutt_debug(LL_DEBUG2, "Credential exchange complete\n");
 
  /* first byte is security levels supported. We want NONE */
  server_conf_flags = ((char *) send_token.value)[0];
  if (!(((char *) send_token.value)[0] & GSS_AUTH_P_NONE))
  {
    mutt_debug(LL_DEBUG2, "Server requires integrity or privacy\n");
    gss_release_buffer(&min_stat, &send_token);
    goto err_abort_cmd;
  }
 
  /* we don't care about buffer size if we don't wrap content. But here it is */
  ((char *) send_token.value)[0] = '\0';
  buf_size = ntohl(*((long *) send_token.value));
  gss_release_buffer(&min_stat, &send_token);
  mutt_debug(LL_DEBUG2, "Unwrapped security level flags: %c%c%c\n",
             (server_conf_flags & GSS_AUTH_P_NONE) ? 'N' : '-',
             (server_conf_flags & GSS_AUTH_P_INTEGRITY) ? 'I' : '-',
             (server_conf_flags & GSS_AUTH_P_PRIVACY) ? 'P' : '-');
  mutt_debug(LL_DEBUG2, "Maximum GSS token size is %ld\n", buf_size);
 
  /* agree to terms (hack!) */
  buf_size = htonl(buf_size); /* not relevant without integrity/privacy */
  buf_reset(buf1);
  buf_addch(buf1, GSS_AUTH_P_NONE);
  buf_addstr_n(buf1, ((char *) &buf_size) + 1, 3);
  /* server decides if principal can log in as user */
  buf_addstr(buf1, adata->conn->account.user);
  request_buf.value = buf1->data;
  request_buf.length = buf_len(buf1);
  maj_stat = gss_wrap(&min_stat, context, 0, GSS_C_QOP_DEFAULT, &request_buf,
                      &cflags, &send_token);
  if (maj_stat != GSS_S_COMPLETE)
  {
    mutt_debug(LL_DEBUG2, "Error creating login request\n");
    goto err_abort_cmd;
  }
 
  mutt_b64_buffer_encode(buf1, send_token.value, send_token.length);
  mutt_debug(LL_DEBUG2, "Requesting authorisation as %s\n", adata->conn->account.user);
  buf_addstr(buf1, "\r\n");
  mutt_socket_send(adata->conn, buf_string(buf1));
 
  /* Joy of victory or agony of defeat? */
  do
  {
    rc2 = imap_cmd_step(adata);
  } while (rc2 == IMAP_RES_CONTINUE);
  if (rc2 == IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG1, "Unexpected server continuation request\n");
    goto err_abort_cmd;
  }
  if (imap_code(adata->buf))
  {
    /* flush the security context */
    mutt_debug(LL_DEBUG2, "Releasing GSS credentials\n");
    maj_stat = gss_delete_sec_context(&min_stat, &context, &send_token);
    if (maj_stat != GSS_S_COMPLETE)
      mutt_debug(LL_DEBUG1, "Error releasing credentials\n");
 
    /* send_token may contain a notification to the server to flush
     * credentials. RFC1731 doesn't specify what to do, and since this
     * support is only for authentication, we'll assume the server knows
     * enough to flush its own credentials */
    gss_release_buffer(&min_stat, &send_token);
 
    rc = IMAP_AUTH_SUCCESS;
    goto cleanup;
  }
  else
  {
    goto bail;
  }
 
err_abort_cmd:
  mutt_socket_send(adata->conn, "*\r\n");
  do
  {
    rc2 = imap_cmd_step(adata);
  } while (rc2 == IMAP_RES_CONTINUE);
 
bail:
  // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_error(_("%s authentication failed"), "GSSAPI");
  rc = IMAP_AUTH_FAILURE;
 
cleanup:
  buf_pool_release(&buf1);
  buf_pool_release(&buf2);
 
  return rc;
}

Here is the call graph for this function:

imap_auth_oauth()

enum ImapAuthRes imap_auth_oauth	(	struct ImapAccountData *	adata,
		const char *	method
	)

Authenticate an IMAP connection using OAUTHBEARER - Implements ImapAuth::authenticate()

Definition at line 109 of file auth_oauth.c.

{
  return imap_auth_oauth_xoauth2(adata, method, false);
}

Here is the call graph for this function:

imap_auth_xoauth2()

enum ImapAuthRes imap_auth_xoauth2	(	struct ImapAccountData *	adata,
		const char *	method
	)

Authenticate an IMAP connection using XOAUTH2 - Implements ImapAuth::authenticate()

Definition at line 117 of file auth_oauth.c.

{
  return imap_auth_oauth_xoauth2(adata, method, true);
}

Here is the call graph for this function: