lib/anonymous.c

   1 /* anonymous.c  implementation of SASL mechanism ANONYMOUS from RFC 2245
   2  * Copyright (C) 2002  Simon Josefsson
   3  *
   4  * This file is part of libgsasl.
   5  *
   6  * Libgsasl is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Libgsasl is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with libgsasl; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "internal.h"
  23
  24 #ifdef USE_ANONYMOUS
  25
  26 int
  27 _gsasl_anonymous_client_init (Gsasl_ctx *ctx)
  28 {
  29   return GSASL_OK;
  30 }
  31
  32 void
  33 _gsasl_anonymous_client_done (Gsasl_ctx *ctx)
  34 {
  35   return;
  36 }
  37
  38 int
  39 _gsasl_anonymous_client_start (Gsasl_session_ctx *cctx,
  40                                void **mech_data)
  41 {
  42   Gsasl_ctx *ctx;
  43   int *step;
  44
  45   ctx = gsasl_client_ctx_get (cctx);
  46   if (ctx == NULL)
  47     return GSASL_CANNOT_GET_CTX;
  48
  49   if (gsasl_client_callback_anonymous_get (ctx) == NULL)
  50     return GSASL_NEED_SERVER_ANONYMOUS_CALLBACK;
  51
  52   step = (int*) malloc(sizeof(*step));
  53   if (step == NULL)
  54     return GSASL_MALLOC_ERROR;
  55
  56   *step = 0;
  57
  58   *mech_data = step;
  59
  60   return GSASL_OK;
  61 }
  62
  63 int
  64 _gsasl_anonymous_client_step  (Gsasl_session_ctx *cctx,
  65                                void *mech_data,
  66                                const char *input,
  67                                size_t input_len,
  68                                char *output,
  69                                size_t *output_len)
  70 {
  71   int *step = mech_data;
  72   Gsasl_client_callback_anonymous cb_anonymous;
  73   Gsasl_ctx *ctx;
  74   int res;
  75
  76   if (*step > 0)
  77     return GSASL_OK;
  78
  79   (*step)++;
  80
  81   ctx = gsasl_client_ctx_get (cctx);
  82   if (ctx == NULL)
  83     return GSASL_CANNOT_GET_CTX;
  84
  85   cb_anonymous = gsasl_client_callback_anonymous_get (ctx);
  86   if (cb_anonymous == NULL)
  87     return GSASL_NEED_SERVER_ANONYMOUS_CALLBACK;
  88
  89   res = cb_anonymous (cctx, output, output_len);
  90   if (res != GSASL_OK)
  91       return res;
  92
  93   *output_len = strlen(output);
  94
  95   return GSASL_NEEDS_MORE;
  96 }
  97
  98 int
  99 _gsasl_anonymous_client_finish (Gsasl_session_ctx *cctx,
 100                                 void *mech_data)
 101 {
 102   int *step = mech_data;
 103
 104   free(step);
 105
 106   return GSASL_OK;
 107 }
 108
 109 /* Server */
 110
 111 int
 112 _gsasl_anonymous_server_init (Gsasl_ctx *ctx)
 113 {
 114   return GSASL_OK;
 115 }
 116
 117 void
 118 _gsasl_anonymous_server_done (Gsasl_ctx *ctx)
 119 {
 120   return;
 121 }
 122
 123 int
 124 _gsasl_anonymous_server_start (Gsasl_session_ctx *sctx,
 125                                void **mech_data)
 126 {
 127   Gsasl_ctx *ctx;
 128
 129   ctx = gsasl_server_ctx_get (sctx);
 130   if (ctx == NULL)
 131     return GSASL_CANNOT_GET_CTX;
 132
 133   if (gsasl_server_callback_anonymous_get (ctx) == NULL)
 134     return GSASL_NEED_SERVER_ANONYMOUS_CALLBACK;
 135
 136   return GSASL_OK;
 137 }
 138
 139 int
 140 _gsasl_anonymous_server_step (Gsasl_session_ctx *sctx,
 141                               void *mech_data,
 142                               const char *input,
 143                               size_t input_len,
 144                               char *output,
 145                               size_t *output_len)
 146 {
 147   Gsasl_server_callback_anonymous cb_anonymous;
 148   Gsasl_ctx *ctx;
 149   char *token;
 150   int res;
 151
 152   if (input_len == 0)
 153     {
 154       *output_len = 0;
 155       return GSASL_NEEDS_MORE;
 156     }
 157
 158   ctx = gsasl_server_ctx_get (sctx);
 159   if (ctx == NULL)
 160     return GSASL_CANNOT_GET_CTX;
 161
 162   cb_anonymous = gsasl_server_callback_anonymous_get (ctx);
 163   if (cb_anonymous == NULL)
 164     return GSASL_NEED_SERVER_ANONYMOUS_CALLBACK;
 165
 166   token = malloc(input_len + 1);
 167   if (token == NULL)
 168     return GSASL_MALLOC_ERROR;
 169
 170   memcpy(token, input, input_len);
 171   token[input_len] = '\0';
 172
 173   res = cb_anonymous(sctx, token);
 174
 175   free(token);
 176
 177   return res;
 178 }
 179
 180 int
 181 _gsasl_anonymous_server_finish (Gsasl_session_ctx *sctx,
 182                                 void *mech_data)
 183 {
 184   return GSASL_OK;
 185 }
 186
 187 #endif /* USE_ANONYMOUS */