src/src/auths/gsasl_exim.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2012 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Copyright (c) Twitter Inc 2012 */
   9
  10 /* Interface to GNU SASL library for generic authentication. */
  11
  12 /* Trade-offs:
  13
  14 GNU SASL does not provide authentication data itself, so we have to expose
  15 that decision to configuration.  For some mechanisms, we need to act much
  16 like plaintext.  For others, we only need to be able to provide some
  17 evaluated data on demand.  There's no abstracted way (ie, without hardcoding
  18 knowledge of authenticators here) to know which need what properties; we
  19 can't query a session or the library for "we will need these for mechanism X".
  20
  21 So: we always require server_condition, even if sometimes it will just be
  22 set as "yes".  We do provide a number of other hooks, which might not make
  23 sense in all contexts.  For some, we can do checks at init time.
  24 */
  25
  26 #include "../exim.h"
  27
  28 #ifndef AUTH_GSASL
  29 /* dummy function to satisfy compilers when we link in an "empty" file. */
  30 static void dummy(int x) { dummy(x-1); }
  31 #else
  32
  33 #include <gsasl.h>
  34 #include "gsasl_exim.h"
  35
  36 /* Authenticator-specific options. */
  37 /* I did have server_*_condition options for various mechanisms, but since
  38 we only ever handle one mechanism at a time, I didn't see the point in keeping
  39 that.  In case someone sees a point, I've left the condition_check() API
  40 alone. */
  41 optionlist auth_gsasl_options[] = {
  42   { "server_channelbinding", opt_bool,
  43       (void *)(offsetof(auth_gsasl_options_block, server_channelbinding)) },
  44   { "server_hostname",      opt_stringptr,
  45       (void *)(offsetof(auth_gsasl_options_block, server_hostname)) },
  46   { "server_mech",          opt_stringptr,
  47       (void *)(offsetof(auth_gsasl_options_block, server_mech)) },
  48   { "server_password",      opt_stringptr,
  49       (void *)(offsetof(auth_gsasl_options_block, server_password)) },
  50   { "server_realm",         opt_stringptr,
  51       (void *)(offsetof(auth_gsasl_options_block, server_realm)) },
  52   { "server_scram_iter",    opt_stringptr,
  53       (void *)(offsetof(auth_gsasl_options_block, server_scram_iter)) },
  54   { "server_scram_salt",    opt_stringptr,
  55       (void *)(offsetof(auth_gsasl_options_block, server_scram_salt)) },
  56   { "server_service",       opt_stringptr,
  57       (void *)(offsetof(auth_gsasl_options_block, server_service)) }
  58 };
  59 /* GSASL_SCRAM_SALTED_PASSWORD documented only for client, so not implementing
  60 hooks to avoid cleartext passwords in the Exim server. */
  61
  62 int auth_gsasl_options_count =
  63   sizeof(auth_gsasl_options)/sizeof(optionlist);
  64
  65 /* Defaults for the authenticator-specific options. */
  66 auth_gsasl_options_block auth_gsasl_option_defaults = {
  67   US"smtp",                 /* server_service */
  68   US"$primary_hostname",    /* server_hostname */
  69   NULL,                     /* server_realm */
  70   NULL,                     /* server_mech */
  71   NULL,                     /* server_password */
  72   NULL,                     /* server_scram_iter */
  73   NULL,                     /* server_scram_salt */
  74   FALSE                     /* server_channelbinding */
  75 };
  76
  77 /* "Globals" for managing the gsasl interface. */
  78
  79 static Gsasl *gsasl_ctx = NULL;
  80 static int
  81   main_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop);
  82 static int
  83   server_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop, auth_instance *ablock);
  84 static int
  85   client_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop, auth_instance *ablock);
  86
  87 static BOOL sasl_error_should_defer = FALSE;
  88 static Gsasl_property callback_loop = 0;
  89 static BOOL checked_server_condition = FALSE;
  90
  91 enum { CURRENTLY_SERVER = 1, CURRENTLY_CLIENT = 2 };
  92
  93 struct callback_exim_state {
  94   auth_instance *ablock;
  95   int currently;
  96 };
  97
  98
  99 /*************************************************
 100 *          Initialization entry point            *
 101 *************************************************/
 102
 103 /* Called for each instance, after its options have been read, to
 104 enable consistency checks to be done, or anything else that needs
 105 to be set up. */
 106
 107 void
 108 auth_gsasl_init(auth_instance *ablock)
 109 {
 110   char *p;
 111   int rc, supported;
 112   auth_gsasl_options_block *ob =
 113     (auth_gsasl_options_block *)(ablock->options_block);
 114
 115   /* As per existing Cyrus glue, use the authenticator's public name as
 116   the default for the mechanism name; we don't handle multiple mechanisms
 117   in one authenticator, but the same driver can be used multiple times. */
 118
 119   if (ob->server_mech == NULL)
 120     ob->server_mech = string_copy(ablock->public_name);
 121
 122   /* Can get multiple session contexts from one library context, so just
 123   initialise the once. */
 124   if (gsasl_ctx == NULL) {
 125     rc = gsasl_init(&gsasl_ctx);
 126     if (rc != GSASL_OK) {
 127       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 128                 "couldn't initialise GNU SASL library: %s (%s)",
 129                 ablock->name, gsasl_strerror_name(rc), gsasl_strerror(rc));
 130     }
 131     gsasl_callback_set(gsasl_ctx, main_callback);
 132   }
 133
 134   /* We don't need this except to log it for debugging. */
 135   rc = gsasl_server_mechlist(gsasl_ctx, &p);
 136   if (rc != GSASL_OK)
 137     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 138               "failed to retrieve list of mechanisms: %s (%s)",
 139               ablock->name,  gsasl_strerror_name(rc), gsasl_strerror(rc));
 140   HDEBUG(D_auth) debug_printf("GNU SASL supports: %s\n", p);
 141
 142   supported = gsasl_client_support_p(gsasl_ctx, (const char *)ob->server_mech);
 143   if (!supported)
 144     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 145               "GNU SASL does not support mechanism \"%s\"",
 146               ablock->name, ob->server_mech);
 147
 148   if ((ablock->server_condition == NULL) &&
 149       (strcmpic(ob->server_mech, US"EXTERNAL") ||
 150        strcmpic(ob->server_mech, US"ANONYMOUS") ||
 151        strcmpic(ob->server_mech, US"PLAIN") ||
 152        strcmpic(ob->server_mech, US"LOGIN")))
 153     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 154               "Need server_condition for %s mechanism",
 155               ablock->name, ob->server_mech);
 156
 157   /* At present, for mechanisms we don't panic on absence of server_condition;
 158   need to figure out the most generically correct approach to deciding when
 159   it's critical and when it isn't.  Eg, for simple validation (PLAIN mechanism,
 160   etc) it clearly is critical.
 161
 162   So don't activate without server_condition, this might be relaxed in the future.
 163   */
 164   if (ablock->server_condition != NULL) ablock->server = TRUE;
 165   ablock->client = FALSE;
 166 }
 167
 168
 169 /* GNU SASL uses one top-level callback, registered at library level.
 170 We dispatch to client and server functions instead. */
 171
 172 static int
 173 main_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop)
 174 {
 175   int rc = 0;
 176   struct callback_exim_state *cb_state =
 177     (struct callback_exim_state *)gsasl_session_hook_get(sctx);
 178
 179   HDEBUG(D_auth) debug_printf("Callback entered, prop=%d (loop prop=%d)\n",
 180       prop, callback_loop);
 181
 182   if (cb_state == NULL) {
 183     HDEBUG(D_auth) debug_printf("  not from our server/client processing.\n");
 184     return GSASL_NO_CALLBACK;
 185   }
 186
 187   if (callback_loop > 0) {
 188     /* Most likely is that we were asked for property foo, and to
 189     expand the string we asked for property bar to put into an auth
 190     variable, but property bar is not supplied for this mechanism. */
 191     HDEBUG(D_auth)
 192       debug_printf("Loop, asked for property %d while handling property %d\n",
 193           prop, callback_loop);
 194     return GSASL_NO_CALLBACK;
 195   }
 196   callback_loop = prop;
 197
 198   if (cb_state->currently == CURRENTLY_CLIENT)
 199     rc = client_callback(ctx, sctx, prop, cb_state->ablock);
 200   else if (cb_state->currently == CURRENTLY_SERVER)
 201     rc = server_callback(ctx, sctx, prop, cb_state->ablock);
 202   else {
 203     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 204         "unhandled callback state, bug in Exim", cb_state->ablock->name);
 205     /* NOTREACHED */
 206   }
 207
 208   callback_loop = 0;
 209   return rc;
 210 }
 211
 212
 213 /*************************************************
 214 *             Server entry point                 *
 215 *************************************************/
 216
 217 /* For interface, see auths/README */
 218
 219 int
 220 auth_gsasl_server(auth_instance *ablock, uschar *initial_data)
 221 {
 222   char *tmps;
 223   char *to_send, *received;
 224   Gsasl_session *sctx = NULL;
 225   auth_gsasl_options_block *ob =
 226     (auth_gsasl_options_block *)(ablock->options_block);
 227   struct callback_exim_state cb_state;
 228   int rc, auth_result, exim_error, exim_error_override;
 229
 230   HDEBUG(D_auth)
 231     debug_printf("GNU SASL: initialising session for %s, mechanism %s.\n",
 232         ablock->name, ob->server_mech);
 233
 234   rc = gsasl_server_start(gsasl_ctx, (const char *)ob->server_mech, &sctx);
 235   if (rc != GSASL_OK) {
 236     auth_defer_msg = string_sprintf("GNU SASL: session start failure: %s (%s)",
 237         gsasl_strerror_name(rc), gsasl_strerror(rc));
 238     HDEBUG(D_auth) debug_printf("%s\n", auth_defer_msg);
 239     return DEFER;
 240   }
 241   /* Hereafter: gsasl_finish(sctx) please */
 242
 243   gsasl_session_hook_set(sctx, (void *)ablock);
 244   cb_state.ablock = ablock;
 245   cb_state.currently = CURRENTLY_SERVER;
 246   gsasl_session_hook_set(sctx, (void *)&cb_state);
 247
 248   tmps = CS expand_string(ob->server_service);
 249   gsasl_property_set(sctx, GSASL_SERVICE, tmps);
 250   tmps = CS expand_string(ob->server_hostname);
 251   gsasl_property_set(sctx, GSASL_HOSTNAME, tmps);
 252   if (ob->server_realm) {
 253     tmps = CS expand_string(ob->server_realm);
 254     if (tmps && *tmps) {
 255       gsasl_property_set(sctx, GSASL_REALM, tmps);
 256     }
 257   }
 258   /* We don't support protection layers. */
 259   gsasl_property_set(sctx, GSASL_QOPS, "qop-auth");
 260 #ifdef SUPPORT_TLS
 261   if (tls_channelbinding_b64) {
 262     /* Some auth mechanisms can ensure that both sides are talking withing the
 263     same security context; for TLS, this means that even if a bad certificate
 264     has been accepted, they remain MitM-proof because both sides must be within
 265     the same negotiated session; if someone is terminating one sesson and
 266     proxying data on within a second, authentication will fail.
 267
 268     We might not have this available, depending upon TLS implementation,
 269     ciphersuite, phase of moon ...
 270
 271     If we do, it results in extra SASL mechanisms being available; here,
 272     Exim's one-mechanism-per-authenticator potentially causes problems.
 273     It depends upon how GNU SASL will implement the PLUS variants of GS2
 274     and whether it automatically mandates a switch to the bound PLUS
 275     if the data is available.  Since default-on, despite being more secure,
 276     would then result in mechanism name changes on a library update, we
 277     have little choice but to default it off and let the admin choose to
 278     enable it.  *sigh*
 279     */
 280     if (ob->server_channelbinding) {
 281       HDEBUG(D_auth) debug_printf("Auth %s: Enabling channel-binding\n",
 282           ablock->name);
 283       gsasl_property_set(sctx, GSASL_CB_TLS_UNIQUE,
 284           (const char *) tls_channelbinding_b64);
 285     } else {
 286       HDEBUG(D_auth)
 287         debug_printf("Auth %s: Not enabling channel-binding (data available)\n",
 288             ablock->name);
 289     }
 290   } else {
 291     HDEBUG(D_auth)
 292       debug_printf("Auth %s: no channel-binding data available\n",
 293           ablock->name);
 294   }
 295 #endif
 296
 297   checked_server_condition = FALSE;
 298
 299   received = CS initial_data;
 300   to_send = NULL;
 301   exim_error = exim_error_override = OK;
 302
 303   do {
 304     rc = gsasl_step64(sctx, received, &to_send);
 305
 306     switch (rc) {
 307       case GSASL_OK:
 308         goto STOP_INTERACTION;
 309
 310       case GSASL_NEEDS_MORE:
 311         break;
 312
 313       case GSASL_AUTHENTICATION_ERROR:
 314       case GSASL_INTEGRITY_ERROR:
 315       case GSASL_NO_AUTHID:
 316       case GSASL_NO_ANONYMOUS_TOKEN:
 317       case GSASL_NO_AUTHZID:
 318       case GSASL_NO_PASSWORD:
 319       case GSASL_NO_PASSCODE:
 320       case GSASL_NO_PIN:
 321       case GSASL_BASE64_ERROR:
 322         HDEBUG(D_auth) debug_printf("GNU SASL permanent error: %s (%s)\n",
 323             gsasl_strerror_name(rc), gsasl_strerror(rc));
 324         log_write(0, LOG_REJECT, "%s authenticator (%s):\n  "
 325             "GNU SASL permanent failure: %s (%s)",
 326             ablock->name, ob->server_mech,
 327             gsasl_strerror_name(rc), gsasl_strerror(rc));
 328         if (rc == GSASL_BASE64_ERROR)
 329           exim_error_override = BAD64;
 330         goto STOP_INTERACTION;
 331
 332       default:
 333         auth_defer_msg = string_sprintf("GNU SASL temporary error: %s (%s)",
 334             gsasl_strerror_name(rc), gsasl_strerror(rc));
 335         HDEBUG(D_auth) debug_printf("%s\n", auth_defer_msg);
 336         exim_error_override = DEFER;
 337         goto STOP_INTERACTION;
 338     }
 339
 340     exim_error =
 341       auth_get_no64_data((uschar **)&received, (uschar *)to_send);
 342     if (exim_error)
 343       break; /* handles * cancelled check */
 344
 345   } while (rc == GSASL_NEEDS_MORE);
 346
 347 STOP_INTERACTION:
 348   auth_result = rc;
 349
 350   gsasl_finish(sctx);
 351
 352   /* Can return: OK DEFER FAIL CANCELLED BAD64 UNEXPECTED */
 353
 354   if (exim_error != OK)
 355     return exim_error;
 356
 357   if (auth_result != GSASL_OK) {
 358     HDEBUG(D_auth) debug_printf("authentication returned %s (%s)\n",
 359         gsasl_strerror_name(auth_result), gsasl_strerror(auth_result));
 360     if (exim_error_override != OK)
 361       return exim_error_override; /* might be DEFER */
 362     if (sasl_error_should_defer) /* overriding auth failure SASL error */
 363       return DEFER;
 364     return FAIL;
 365   }
 366
 367   /* Auth succeeded, check server_condition unless already done in callback */
 368   return checked_server_condition ? OK : auth_check_serv_cond(ablock);
 369 }
 370
 371 /* returns the GSASL status of expanding the Exim string given */
 372 static int
 373 condition_check(auth_instance *ablock, uschar *label, uschar *condition_string)
 374 {
 375   int exim_rc;
 376
 377   exim_rc = auth_check_some_cond(ablock, label, condition_string, FAIL);
 378
 379   if (exim_rc == OK) {
 380     return GSASL_OK;
 381   } else if (exim_rc == DEFER) {
 382     sasl_error_should_defer = TRUE;
 383     return GSASL_AUTHENTICATION_ERROR;
 384   } else if (exim_rc == FAIL) {
 385     return GSASL_AUTHENTICATION_ERROR;
 386   }
 387
 388   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 389             "Unhandled return from checking %s: %d",
 390             ablock->name, label, exim_rc);
 391   /* NOTREACHED */
 392   return GSASL_AUTHENTICATION_ERROR;
 393 }
 394
 395 static int
 396 server_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop, auth_instance *ablock)
 397 {
 398   char *tmps;
 399   uschar *propval;
 400   int cbrc = GSASL_NO_CALLBACK;
 401   int i;
 402   auth_gsasl_options_block *ob =
 403     (auth_gsasl_options_block *)(ablock->options_block);
 404
 405   HDEBUG(D_auth)
 406     debug_printf("GNU SASL callback %d for %s/%s as server\n",
 407         prop, ablock->name, ablock->public_name);
 408
 409   for (i = 0; i < AUTH_VARS; i++) auth_vars[i] = NULL;
 410   expand_nmax = 0;
 411
 412   switch (prop) {
 413     case GSASL_VALIDATE_SIMPLE:
 414       /* GSASL_AUTHID, GSASL_AUTHZID, and GSASL_PASSWORD */
 415       propval = (uschar *) gsasl_property_get(sctx, GSASL_AUTHID);
 416       auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 417       propval = (uschar *) gsasl_property_get(sctx, GSASL_AUTHZID);
 418       auth_vars[1] = expand_nstring[2] = propval ? propval : US"";
 419       propval = (uschar *) gsasl_property_get(sctx, GSASL_PASSWORD);
 420       auth_vars[2] = expand_nstring[3] = propval ? propval : US"";
 421       expand_nmax = 3;
 422       for (i = 1; i <= 3; ++i)
 423         expand_nlength[i] = Ustrlen(expand_nstring[i]);
 424
 425       cbrc = condition_check(ablock, US"server_condition", ablock->server_condition);
 426       checked_server_condition = TRUE;
 427       break;
 428
 429     case GSASL_VALIDATE_EXTERNAL:
 430       if (ablock->server_condition == NULL) {
 431         HDEBUG(D_auth) debug_printf("No server_condition supplied, to validate EXTERNAL.\n");
 432         cbrc = GSASL_AUTHENTICATION_ERROR;
 433         break;
 434       }
 435       propval = (uschar *) gsasl_property_get(sctx, GSASL_AUTHZID);
 436       /* We always set $auth1, even if only to empty string. */
 437       auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 438       expand_nlength[1] = Ustrlen(expand_nstring[1]);
 439       expand_nmax = 1;
 440
 441       cbrc = condition_check(ablock,
 442           US"server_condition (EXTERNAL)", ablock->server_condition);
 443       checked_server_condition = TRUE;
 444       break;
 445
 446     case GSASL_VALIDATE_ANONYMOUS:
 447       if (ablock->server_condition == NULL) {
 448         HDEBUG(D_auth) debug_printf("No server_condition supplied, to validate ANONYMOUS.\n");
 449         cbrc = GSASL_AUTHENTICATION_ERROR;
 450         break;
 451       }
 452       propval = (uschar *) gsasl_property_get(sctx, GSASL_ANONYMOUS_TOKEN);
 453       /* We always set $auth1, even if only to empty string. */
 454       auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 455       expand_nlength[1] = Ustrlen(expand_nstring[1]);
 456       expand_nmax = 1;
 457
 458       cbrc = condition_check(ablock,
 459           US"server_condition (ANONYMOUS)", ablock->server_condition);
 460       checked_server_condition = TRUE;
 461       break;
 462
 463     case GSASL_VALIDATE_GSSAPI:
 464       /* GSASL_AUTHZID and GSASL_GSSAPI_DISPLAY_NAME */
 465       propval = (uschar *) gsasl_property_get(sctx, GSASL_AUTHZID);
 466       auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 467       propval = (uschar *) gsasl_property_get(sctx, GSASL_GSSAPI_DISPLAY_NAME);
 468       auth_vars[1] = expand_nstring[2] = propval ? propval : US"";
 469       expand_nmax = 2;
 470       for (i = 1; i <= 2; ++i)
 471         expand_nlength[i] = Ustrlen(expand_nstring[i]);
 472
 473       /* In this one case, it perhaps makes sense to default back open?
 474       But for consistency, let's just mandate server_condition here too. */
 475       cbrc = condition_check(ablock,
 476           US"server_condition (GSSAPI family)", ablock->server_condition);
 477       checked_server_condition = TRUE;
 478       break;
 479
 480     case GSASL_PASSWORD:
 481       /* DIGEST-MD5: GSASL_AUTHID, GSASL_AUTHZID and GSASL_REALM
 482          CRAM-MD5: GSASL_AUTHID
 483          PLAIN: GSASL_AUTHID and GSASL_AUTHZID
 484          LOGIN: GSASL_AUTHID
 485        */
 486       if (ob->server_scram_iter) {
 487         tmps = CS expand_string(ob->server_scram_iter);
 488         gsasl_property_set(sctx, GSASL_SCRAM_ITER, tmps);
 489       }
 490       if (ob->server_scram_salt) {
 491         tmps = CS expand_string(ob->server_scram_salt);
 492         gsasl_property_set(sctx, GSASL_SCRAM_SALT, tmps);
 493       }
 494       /* Asking for GSASL_AUTHZID will probably call back into us.
 495       Do we really want to hardcode limits per mechanism?  What happens when
 496       a new mechanism is added to the library.  It *shouldn't* result in us
 497       needing to add more glue, since avoiding that is a large part of the
 498       point of SASL. */
 499       propval = (uschar *) gsasl_property_get(sctx, GSASL_AUTHID);
 500       auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 501       propval = (uschar *) gsasl_property_get(sctx, GSASL_AUTHZID);
 502       auth_vars[1] = expand_nstring[2] = propval ? propval : US"";
 503       propval = (uschar *) gsasl_property_get(sctx, GSASL_REALM);
 504       auth_vars[2] = expand_nstring[3] = propval ? propval : US"";
 505       expand_nmax = 3;
 506       for (i = 1; i <= 3; ++i)
 507         expand_nlength[i] = Ustrlen(expand_nstring[i]);
 508
 509       tmps = CS expand_string(ob->server_password);
 510       if (tmps == NULL) {
 511         sasl_error_should_defer = expand_string_forcedfail ? FALSE : TRUE;
 512         HDEBUG(D_auth) debug_printf("server_password expansion failed, so "
 513             "can't tell GNU SASL library the password for %s\n", auth_vars[0]);
 514         return GSASL_AUTHENTICATION_ERROR;
 515       }
 516       gsasl_property_set(sctx, GSASL_PASSWORD, tmps);
 517       /* This is inadequate; don't think Exim's store stacks are geared
 518       for memory wiping, so expanding strings will leave stuff laying around.
 519       But no need to compound the problem, so get rid of the one we can. */
 520       memset(tmps, '\0', strlen(tmps));
 521       cbrc = GSASL_OK;
 522       break;
 523
 524     default:
 525       HDEBUG(D_auth) debug_printf("Unrecognised callback: %d\n", prop);
 526       cbrc = GSASL_NO_CALLBACK;
 527   }
 528
 529   HDEBUG(D_auth) debug_printf("Returning %s (%s)\n",
 530       gsasl_strerror_name(cbrc), gsasl_strerror(cbrc));
 531
 532   return cbrc;
 533 }
 534
 535
 536 /*************************************************
 537 *              Client entry point                *
 538 *************************************************/
 539
 540 /* For interface, see auths/README */
 541
 542 int
 543 auth_gsasl_client(
 544   auth_instance *ablock,                 /* authenticator block */
 545   smtp_inblock *inblock,                 /* connection inblock */
 546   smtp_outblock *outblock,               /* connection outblock */
 547   int timeout,                           /* command timeout */
 548   uschar *buffer,                        /* buffer for reading response */
 549   int buffsize)                          /* size of buffer */
 550 {
 551   HDEBUG(D_auth)
 552     debug_printf("Client side NOT IMPLEMENTED: you should not see this!\n");
 553   /* NOT IMPLEMENTED */
 554   return FAIL;
 555 }
 556
 557 static int
 558 client_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop, auth_instance *ablock)
 559 {
 560   int cbrc = GSASL_NO_CALLBACK;
 561   HDEBUG(D_auth)
 562     debug_printf("GNU SASL callback %d for %s/%s as client\n",
 563         prop, ablock->name, ablock->public_name);
 564
 565   HDEBUG(D_auth)
 566     debug_printf("Client side NOT IMPLEMENTED: you should not see this!\n");
 567
 568   return cbrc;
 569 }
 570
 571 /*************************************************
 572 *                Diagnostic API                  *
 573 *************************************************/
 574
 575 void
 576 auth_gsasl_version_report(FILE *f)
 577 {
 578   const char *runtime;
 579   runtime = gsasl_check_version(NULL);
 580   fprintf(f, "Library version: GNU SASL: Compile: %s\n"
 581              "                           Runtime: %s\n",
 582           GSASL_VERSION, runtime);
 583 }
 584
 585 #endif  /* AUTH_GSASL */
 586
 587 /* End of gsasl_exim.c */