obsolete.c

Go to the documentation of this file.

/* obsolete.c --- Obsolete functions kept around for backwards compatibility.
 * Copyright (C) 2002, 2003, 2004, 2005, 2006  Simon Josefsson
 *
 * This file is part of GNU SASL Library.
 *
 * GNU SASL Library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * GNU SASL Library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License License along with GNU SASL Library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#include "internal.h"

int
gsasl_client_listmech (Gsasl * ctx, char *out, size_t * outlen)
{
  char *tmp;
  int rc;

  rc = gsasl_client_mechlist (ctx, &tmp);

  if (rc == GSASL_OK)
    {
      size_t tmplen = strlen (tmp);

      if (tmplen >= *outlen)
        {
          free (tmp);
          return GSASL_TOO_SMALL_BUFFER;
        }

      if (out)
        strcpy (out, tmp);
      *outlen = tmplen + 1;
      free (tmp);
    }

  return rc;
}

int
gsasl_server_listmech (Gsasl * ctx, char *out, size_t * outlen)
{
  char *tmp;
  int rc;

  rc = gsasl_server_mechlist (ctx, &tmp);

  if (rc == GSASL_OK)
    {
      size_t tmplen = strlen (tmp);

      if (tmplen >= *outlen)
        {
          free (tmp);
          return GSASL_TOO_SMALL_BUFFER;
        }

      if (out)
        strcpy (out, tmp);
      *outlen = tmplen + 1;
      free (tmp);
    }

  return rc;
}

static int
_gsasl_step (Gsasl_session * sctx,
             const char *input, size_t input_len,
             char *output, size_t * output_len)
{
  char *tmp;
  size_t tmplen;
  int rc;

  rc = gsasl_step (sctx, input, input_len, &tmp, &tmplen);

  if (rc == GSASL_OK || rc == GSASL_NEEDS_MORE)
    {
      if (tmplen >= *output_len)
        {
          free (tmp);
          /* XXX We lose the step token here, don't we? */
          return GSASL_TOO_SMALL_BUFFER;
        }

      if (output)
        memcpy (output, tmp, tmplen);
      *output_len = tmplen;
      free (tmp);
    }

  return rc;
}

int
gsasl_client_step (Gsasl_session * sctx,
                   const char *input,
                   size_t input_len, char *output, size_t * output_len)
{
  return _gsasl_step (sctx, input, input_len, output, output_len);
}

int
gsasl_server_step (Gsasl_session * sctx,
                   const char *input,
                   size_t input_len, char *output, size_t * output_len)
{
  return _gsasl_step (sctx, input, input_len, output, output_len);
}

static int
_gsasl_step64 (Gsasl_session * sctx,
               const char *b64input, char *b64output, size_t b64output_len)
{
  char *tmp;
  int rc;

  rc = gsasl_step64 (sctx, b64input, &tmp);

  if (rc == GSASL_OK || rc == GSASL_NEEDS_MORE)
    {
      if (b64output_len <= strlen (tmp))
        {
          free (tmp);
          /* XXX We lose the step token here, don't we? */
          return GSASL_TOO_SMALL_BUFFER;
        }

      if (b64output)
        strcpy (b64output, tmp);
      free (tmp);
    }

  return rc;
}

int
gsasl_client_step_base64 (Gsasl_session * sctx,
                          const char *b64input,
                          char *b64output, size_t b64output_len)
{
  return _gsasl_step64 (sctx, b64input, b64output, b64output_len);
}

int
gsasl_server_step_base64 (Gsasl_session * sctx,
                          const char *b64input,
                          char *b64output, size_t b64output_len)
{
  return _gsasl_step64 (sctx, b64input, b64output, b64output_len);
}

void
gsasl_client_finish (Gsasl_session * sctx)
{
  gsasl_finish (sctx);
}

void
gsasl_server_finish (Gsasl_session * sctx)
{
  gsasl_finish (sctx);
}

Gsasl *
gsasl_client_ctx_get (Gsasl_session * sctx)
{
  return sctx->ctx;
}

void
gsasl_client_application_data_set (Gsasl_session * sctx,
                                   void *application_data)
{
  gsasl_appinfo_set (sctx, application_data);
}

void *
gsasl_client_application_data_get (Gsasl_session * sctx)
{
  return gsasl_appinfo_get (sctx);
}

Gsasl *
gsasl_server_ctx_get (Gsasl_session * sctx)
{
  return sctx->ctx;
}

void
gsasl_server_application_data_set (Gsasl_session * sctx,
                                   void *application_data)
{
  gsasl_appinfo_set (sctx, application_data);
}

void *
gsasl_server_application_data_get (Gsasl_session * sctx)
{
  return gsasl_appinfo_get (sctx);
}

int
gsasl_randomize (int strong, char *data, size_t datalen)
{
  if (strong)
    return gsasl_random (data, datalen);
  return gsasl_nonce (data, datalen);
}

Gsasl *
gsasl_ctx_get (Gsasl_session * sctx)
{
  return sctx->ctx;
}

int
gsasl_encode_inline (Gsasl_session * sctx,
                     const char *input, size_t input_len,
                     char *output, size_t * output_len)
{
  char *tmp;
  size_t tmplen;
  int res;

  res = gsasl_encode (sctx, input, input_len, &tmp, &tmplen);
  if (res == GSASL_OK)
    {
      if (*output_len < tmplen)
        return GSASL_TOO_SMALL_BUFFER;
      *output_len = tmplen;
      memcpy (output, tmp, tmplen);
      free (output);
    }

  return res;
}

int
gsasl_decode_inline (Gsasl_session * sctx,
                     const char *input, size_t input_len,
                     char *output, size_t * output_len)
{
  char *tmp;
  size_t tmplen;
  int res;

  res = gsasl_decode (sctx, input, input_len, &tmp, &tmplen);
  if (res == GSASL_OK)
    {
      if (*output_len < tmplen)
        return GSASL_TOO_SMALL_BUFFER;
      *output_len = tmplen;
      memcpy (output, tmp, tmplen);
      free (output);
    }

  return res;
}

void
gsasl_application_data_set (Gsasl * ctx, void *appdata)
{
  ctx->application_hook = appdata;
}

void *
gsasl_application_data_get (Gsasl * ctx)
{
  return ctx->application_hook;
}

void
gsasl_appinfo_set (Gsasl_session * sctx, void *appdata)
{
  sctx->application_data = appdata;
}

void *
gsasl_appinfo_get (Gsasl_session * sctx)
{
  return sctx->application_data;
}

const char *
gsasl_server_suggest_mechanism (Gsasl * ctx, const char *mechlist)
{
  return NULL;                  /* This function is just silly. */
}

void
gsasl_client_callback_authentication_id_set (Gsasl * ctx,
                                             Gsasl_client_callback_authentication_id
                                             cb)
{
  ctx->cbc_authentication_id = cb;
}

Gsasl_client_callback_authentication_id
gsasl_client_callback_authentication_id_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_authentication_id : NULL;
}

void
gsasl_client_callback_authorization_id_set (Gsasl * ctx,
                                            Gsasl_client_callback_authorization_id
                                            cb)
{
  ctx->cbc_authorization_id = cb;
}

Gsasl_client_callback_authorization_id
gsasl_client_callback_authorization_id_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_authorization_id : NULL;
}

void
gsasl_client_callback_password_set (Gsasl * ctx,
                                    Gsasl_client_callback_password cb)
{
  ctx->cbc_password = cb;
}


Gsasl_client_callback_password
gsasl_client_callback_password_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_password : NULL;
}

void
gsasl_client_callback_passcode_set (Gsasl * ctx,
                                    Gsasl_client_callback_passcode cb)
{
  ctx->cbc_passcode = cb;
}


Gsasl_client_callback_passcode
gsasl_client_callback_passcode_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_passcode : NULL;
}

void
gsasl_client_callback_pin_set (Gsasl * ctx, Gsasl_client_callback_pin cb)
{
  ctx->cbc_pin = cb;
}


Gsasl_client_callback_pin
gsasl_client_callback_pin_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_pin : NULL;
}

void
gsasl_client_callback_service_set (Gsasl * ctx,
                                   Gsasl_client_callback_service cb)
{
  ctx->cbc_service = cb;
}

Gsasl_client_callback_service
gsasl_client_callback_service_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_service : NULL;
}

void
gsasl_client_callback_anonymous_set (Gsasl * ctx,
                                     Gsasl_client_callback_anonymous cb)
{
  ctx->cbc_anonymous = cb;
}

Gsasl_client_callback_anonymous
gsasl_client_callback_anonymous_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_anonymous : NULL;
}

void
gsasl_client_callback_qop_set (Gsasl * ctx, Gsasl_client_callback_qop cb)
{
  ctx->cbc_qop = cb;
}

Gsasl_client_callback_qop
gsasl_client_callback_qop_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_qop : NULL;
}

void
gsasl_client_callback_maxbuf_set (Gsasl * ctx,
                                  Gsasl_client_callback_maxbuf cb)
{
  ctx->cbc_maxbuf = cb;
}

Gsasl_client_callback_maxbuf
gsasl_client_callback_maxbuf_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_maxbuf : NULL;
}

void
gsasl_client_callback_realm_set (Gsasl * ctx, Gsasl_client_callback_realm cb)
{
  ctx->cbc_realm = cb;
}

Gsasl_client_callback_realm
gsasl_client_callback_realm_get (Gsasl * ctx)
{
  return ctx ? ctx->cbc_realm : NULL;
}

void
gsasl_server_callback_validate_set (Gsasl * ctx,
                                    Gsasl_server_callback_validate cb)
{
  ctx->cbs_validate = cb;
}

Gsasl_server_callback_validate
gsasl_server_callback_validate_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_validate : NULL;
}

void
gsasl_server_callback_retrieve_set (Gsasl * ctx,
                                    Gsasl_server_callback_retrieve cb)
{
  ctx->cbs_retrieve = cb;
}

Gsasl_server_callback_retrieve
gsasl_server_callback_retrieve_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_retrieve : NULL;
}

void
gsasl_server_callback_cram_md5_set (Gsasl * ctx,
                                    Gsasl_server_callback_cram_md5 cb)
{
  ctx->cbs_cram_md5 = cb;
}

Gsasl_server_callback_cram_md5
gsasl_server_callback_cram_md5_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_cram_md5 : NULL;
}

void
gsasl_server_callback_digest_md5_set (Gsasl * ctx,
                                      Gsasl_server_callback_digest_md5 cb)
{
  ctx->cbs_digest_md5 = cb;
}

Gsasl_server_callback_digest_md5
gsasl_server_callback_digest_md5_get (Gsasl * ctx)
{
  return ctx->cbs_digest_md5;
}

void
gsasl_server_callback_external_set (Gsasl * ctx,
                                    Gsasl_server_callback_external cb)
{
  ctx->cbs_external = cb;
}

Gsasl_server_callback_external
gsasl_server_callback_external_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_external : NULL;
}

void
gsasl_server_callback_anonymous_set (Gsasl * ctx,
                                     Gsasl_server_callback_anonymous cb)
{
  ctx->cbs_anonymous = cb;
}

Gsasl_server_callback_anonymous
gsasl_server_callback_anonymous_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_anonymous : NULL;
}

void
gsasl_server_callback_realm_set (Gsasl * ctx, Gsasl_server_callback_realm cb)
{
  ctx->cbs_realm = cb;
}

Gsasl_server_callback_realm
gsasl_server_callback_realm_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_realm : NULL;
}

void
gsasl_server_callback_qop_set (Gsasl * ctx, Gsasl_server_callback_qop cb)
{
  ctx->cbs_qop = cb;
}

Gsasl_server_callback_qop
gsasl_server_callback_qop_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_qop : NULL;
}

void
gsasl_server_callback_maxbuf_set (Gsasl * ctx,
                                  Gsasl_server_callback_maxbuf cb)
{
  ctx->cbs_maxbuf = cb;
}

Gsasl_server_callback_maxbuf
gsasl_server_callback_maxbuf_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_maxbuf : NULL;
}

void
gsasl_server_callback_cipher_set (Gsasl * ctx,
                                  Gsasl_server_callback_cipher cb)
{
  ctx->cbs_cipher = cb;
}

Gsasl_server_callback_cipher
gsasl_server_callback_cipher_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_cipher : NULL;
}

void
gsasl_server_callback_securid_set (Gsasl * ctx,
                                   Gsasl_server_callback_securid cb)
{
  ctx->cbs_securid = cb;
}

Gsasl_server_callback_securid
gsasl_server_callback_securid_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_securid : NULL;
}

void
gsasl_server_callback_gssapi_set (Gsasl * ctx,
                                  Gsasl_server_callback_gssapi cb)
{
  ctx->cbs_gssapi = cb;
}

Gsasl_server_callback_gssapi
gsasl_server_callback_gssapi_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_gssapi : NULL;
}

void
gsasl_server_callback_service_set (Gsasl * ctx,
                                   Gsasl_server_callback_service cb)
{
  ctx->cbs_service = cb;
}

Gsasl_server_callback_service
gsasl_server_callback_service_get (Gsasl * ctx)
{
  return ctx ? ctx->cbs_service : NULL;
}

#if WITH_SASLPREP
# include <stringprep.h>
#endif

char *
gsasl_stringprep_nfkc (const char *in, ssize_t len)
{
  char *out = NULL;

#if WITH_SASLPREP
  out = stringprep_utf8_nfkc_normalize (in, len);
#endif

  return out;
}

char *
gsasl_stringprep_saslprep (const char *in, int *stringprep_rc)
{
  char *out = NULL;
#if WITH_SASLPREP
  int rc;

  rc = stringprep_profile (in, &out, "SASLprep", 0);
  if (stringprep_rc)
    *stringprep_rc = rc;
  if (rc != STRINGPREP_OK)
    out = NULL;
#endif

  return out;
}

char *
gsasl_stringprep_trace (const char *in, int *stringprep_rc)
{
  char *out = NULL;
#if WITH_SASLPREP
  int rc;

  rc = stringprep_profile (in, &out, "trace", 0);
  if (stringprep_rc)
    *stringprep_rc = rc;
  if (rc != STRINGPREP_OK)
    out = NULL;
#endif

  return out;
}

int
gsasl_md5pwd_get_password (const char *filename,
                           const char *username, char *key, size_t * keylen)
{
  char matchbuf[BUFSIZ];
  char line[BUFSIZ];
  FILE *fh;

  fh = fopen (filename, "r");
  if (fh == NULL)
    return GSASL_FOPEN_ERROR;

  sprintf (matchbuf, "%s\t", username);

  while (!feof (fh))
    {
      if (fgets (line, BUFSIZ, fh) == NULL)
        break;

      if (line[0] == '#')
        continue;

      while (strlen (line) > 0 && (line[strlen (line) - 1] == '\n' ||
                                   line[strlen (line) - 1] == '\r'))
        line[strlen (line) - 1] = '\0';

      if (strlen (line) <= strlen (matchbuf))
        continue;

      if (strncmp (matchbuf, line, strlen (matchbuf)) == 0)
        {
          if (*keylen < strlen (line) - strlen (matchbuf))
            {
              fclose (fh);
              return GSASL_TOO_SMALL_BUFFER;
            }

          *keylen = strlen (line) - strlen (matchbuf);

          if (key)
            memcpy (key, &line[strlen (matchbuf)], *keylen);

          fclose (fh);

          return GSASL_OK;
        }
    }

  if (fclose (fh) != 0)
    return GSASL_FCLOSE_ERROR;

  return GSASL_AUTHENTICATION_ERROR;
}


/*
 * Copyright (c) 1996-1999 by Internet Software Consortium.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

/*
 * Portions Copyright (c) 1995 by International Business Machines, Inc.
 *
 * International Business Machines, Inc. (hereinafter called IBM) grants
 * permission under its copyrights to use, copy, modify, and distribute this
 * Software with or without fee, provided that the above copyright notice and
 * all paragraphs of this notice appear in all copies, and that the name of IBM
 * not be used in connection with the marketing of any product incorporating
 * the Software or modifications thereof, without specific, written prior
 * permission.
 *
 * To the extent it has a right to do so, IBM grants an immunity from suit
 * under its patents, if any, for the use, sale or manufacture of products to
 * the extent that such products are used for performing Domain Name System
 * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
 * granted for any product per se or for any other function of any product.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
 * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
 * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
 */

#include <ctype.h>
#include <stdio.h>

#define Assert(Cond) if (!(Cond)) abort()

static const char Base64[] =
  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static const char Pad64 = '=';

int
gsasl_base64_encode (char const *src,
                     size_t srclength, char *target, size_t targsize)
{
  size_t datalength = 0;
  unsigned char input[3];
  unsigned char output[4];
  size_t i;

  while (2 < srclength)
    {
      input[0] = *src++;
      input[1] = *src++;
      input[2] = *src++;
      srclength -= 3;

      output[0] = input[0] >> 2;
      output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
      output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
      output[3] = input[2] & 0x3f;
      Assert (output[0] < 64);
      Assert (output[1] < 64);
      Assert (output[2] < 64);
      Assert (output[3] < 64);

      if (datalength + 4 > targsize)
        return (-1);
      target[datalength++] = Base64[output[0]];
      target[datalength++] = Base64[output[1]];
      target[datalength++] = Base64[output[2]];
      target[datalength++] = Base64[output[3]];
    }

  /* Now we worry about padding. */
  if (0 != srclength)
    {
      /* Get what's left. */
      input[0] = input[1] = input[2] = '\0';
      for (i = 0; i < srclength; i++)
        input[i] = *src++;

      output[0] = input[0] >> 2;
      output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
      output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
      Assert (output[0] < 64);
      Assert (output[1] < 64);
      Assert (output[2] < 64);

      if (datalength + 4 > targsize)
        return (-1);
      target[datalength++] = Base64[output[0]];
      target[datalength++] = Base64[output[1]];
      if (srclength == 1)
        target[datalength++] = Pad64;
      else
        target[datalength++] = Base64[output[2]];
      target[datalength++] = Pad64;
    }
  if (datalength >= targsize)
    return (-1);
  target[datalength] = '\0';    /* Returned value doesn't count \0. */
  return (datalength);
}

int
gsasl_base64_decode (char const *src, char *target, size_t targsize)
{
  int tarindex, state, ch;
  char *pos;

  state = 0;
  tarindex = 0;

  while ((ch = *src++) != '\0')
    {
      if (isspace (ch))         /* Skip whitespace anywhere. */
        continue;

      if (ch == Pad64)
        break;

      pos = strchr (Base64, ch);
      if (pos == 0)             /* A non-base64 character. */
        return (-1);

      switch (state)
        {
        case 0:
          if (target)
            {
              if ((size_t) tarindex >= targsize)
                return (-1);
              target[tarindex] = (pos - Base64) << 2;
            }
          state = 1;
          break;
        case 1:
          if (target)
            {
              if ((size_t) tarindex + 1 >= targsize)
                return (-1);
              target[tarindex] |= (pos - Base64) >> 4;
              target[tarindex + 1] = ((pos - Base64) & 0x0f) << 4;
            }
          tarindex++;
          state = 2;
          break;
        case 2:
          if (target)
            {
              if ((size_t) tarindex + 1 >= targsize)
                return (-1);
              target[tarindex] |= (pos - Base64) >> 2;
              target[tarindex + 1] = ((pos - Base64) & 0x03) << 6;
            }
          tarindex++;
          state = 3;
          break;
        case 3:
          if (target)
            {
              if ((size_t) tarindex >= targsize)
                return (-1);
              target[tarindex] |= (pos - Base64);
            }
          tarindex++;
          state = 0;
          break;
        default:
          abort ();
        }
    }

  /*
   * We are done decoding Base-64 chars.  Let's see if we ended
   * on a byte boundary, and/or with erroneous trailing characters.
   */

  if (ch == Pad64)
    {                           /* We got a pad char. */
      ch = *src++;              /* Skip it, get next. */
      switch (state)
        {
        case 0:         /* Invalid = in first position */
        case 1:         /* Invalid = in second position */
          return (-1);

        case 2:         /* Valid, means one byte of info */
          /* Skip any number of spaces. */
          for ((void) NULL; ch != '\0'; ch = *src++)
            if (!isspace (ch))
              break;
          /* Make sure there is another trailing = sign. */
          if (ch != Pad64)
            return (-1);
          ch = *src++;          /* Skip the = */
          /* Fall through to "single trailing =" case. */
          /* FALLTHROUGH */

        case 3:         /* Valid, means two bytes of info */
          /*
           * We know this char is an =.  Is there anything but
           * whitespace after it?
           */
          for ((void) NULL; ch != '\0'; ch = *src++)
            if (!isspace (ch))
              return (-1);

          /*
           * Now make sure for cases 2 and 3 that the "extra"
           * bits that slopped past the last full byte were
           * zeros.  If we don't check them, they become a
           * subliminal channel.
           */
          if (target && target[tarindex] != 0)
            return (-1);
        }
    }
  else
    {
      /*
       * We ended by seeing the end of the string.  Make sure we
       * have no partial bytes lying around.
       */
      if (state != 0)
        return (-1);
    }

  return (tarindex);
}

---