pgpdebug.c

著名的加密软件的应用于电子邮件中

                    break;
                }
                default:
                {
                    char      errorBuf[32];

                    pgpFormatStr(errorBuf, sizeof(errorBuf), FALSE,
                                 "[INVALID %B]",
                                 formatStrIndex - cmdStartIndex + 1,
                                 formatStr + cmdStartIndex);
                    AppendChars(buffer, &bufferIndex, bufferSize,
                                canonicalizeNLs, errorBuf, strlen(errorBuf));
                    break;
                }
            }
        }
    }

    if (putNullTerminator)
    {
        if (bufferIndex >= bufferSize)
            bufferIndex = bufferSize - 1;
        buffer[bufferIndex] = '\0';
    }

    stringLength = bufferIndex - (putLengthPrefix ? 1 : 0);

    if (putLengthPrefix)
        buffer[0] = (stringLength <= 255) ? stringLength : 255;

    return stringLength;
}

    uchar *
pgpFormatHStr(
    uchar *         buffer,
    int             bufferSize,
    Boolean         canonicalizeNLs,
    char const *    formatStr,
    ...)
{
    va_list         args;

    va_start(args, formatStr);
    pgpFormatVAStr(buffer, bufferSize, TRUE, TRUE, canonicalizeNLs,
                   formatStr, args);
    va_end(args);
    return buffer;
}

    uchar *
pgpFormatPStr(
    uchar *         buffer,
    int             bufferSize,
    Boolean         canonicalizeNLs,
    char const *    formatStr,
    ...)
{
    va_list         args;

    va_start(args, formatStr);
    pgpFormatVAStr(buffer, bufferSize, TRUE, FALSE, canonicalizeNLs,
                   formatStr, args);
    va_end(args);
    return buffer;
}

    uchar *
pgpFormatPStr255(
    uchar *          buffer,
    Boolean          canonicalizeNLs,
    char const *     formatStr,
    ...)
{
    va_list          args;

    va_start(args, formatStr);
    pgpFormatVAStr(buffer, 256, TRUE, FALSE, canonicalizeNLs, formatStr, args);
    va_end(args);
    return buffer;
}

    char *
pgpFormatStr(
    char *           buffer,
    int              bufferSize,
    Boolean          canonicalizeNLs,
    char const *     formatStr,
    ...)
{
    va_list          args;

    va_start(args, formatStr);
    pgpFormatVAStr((uchar *)buffer, bufferSize, FALSE, TRUE, canonicalizeNLs,
                   formatStr, args);
    va_end(args);
    return buffer;
}

#if DEBUG  /* [ */

    uchar *
pgpDebugFormatHStr(
    uchar *          buffer,
    int              bufferSize,
    char const *     formatStr,
    ...)
{
    va_list          args;

    va_start(args, formatStr);
    pgpFormatVAStr(buffer, bufferSize, TRUE, TRUE, TRUE, formatStr, args);
    va_end(args);
    return buffer;
}

    uchar *
pgpDebugPrefixFormatHStr(
    uchar *          buffer,
    int              bufferSize,
    char const *     formatStr,
    ...)
{
    va_list          args;
    int              origSize;  /* Including null, but not length prefix */
    int              origOffset;
    int              prefixSize; /* Including length prefix, no null */
    int              totalLen;

    /*
     * Move the original string (except length prefix) to the end of the
     * buffer.
     */
    origSize = buffer[0] + 1;
    if (origSize == 256)
        origSize = strlen((char const *)buffer + 1) + 1;
    origOffset = bufferSize - origSize;
    pgpCopyMemory(buffer + 1, buffer + origOffset, origSize);

    /* Format the new prefix, without null-terminator */
    va_start(args, formatStr);
    prefixSize = 1 + pgpFormatVAStr(buffer, origOffset, TRUE, FALSE, TRUE,
                                    formatStr, args);
    va_end(args);

    /* Add a separating string */
    AppendChars(buffer, &prefixSize, origOffset, TRUE, ":\n  ", 4);

    /* Move the original part back so that it's adjacent to the prefix */
    pgpCopyMemory(buffer + origOffset, buffer + prefixSize, origSize);

    /* Set the length prefix */
    totalLen = (origSize - 1) + (prefixSize - 1);
    buffer[0] = (totalLen <= 255) ? totalLen : 255;

    return buffer;
}

    void
pgpDebugFillMemory(
    void *           buffer,
    size_t           length)
{
    pgpFillMemory(buffer, length, 0xDD);
}

    static char
pgpMemAccessTest(
    void const *     addr)
{
    return *(volatile char const *)addr;
}

    Boolean
pgpaInternalAddrValid(
    pgpaCallPrefixDef,
    void const *     addr,
    int              alignSize,
    char const *     varName)
{
#if MACINTOSH
    /* XXX alignof() doesn't match up with reality...bummer */
    if (alignSize > 2)
        alignSize = 2;
#endif

  pgpaAssert(addr != NULL);
  pgpaAssert(alignSize > 0);
  pgpaAssert(alignSize == 1 || (ulong)addr % alignSize == 0);
#if MACINTOSH
  pgpaAssert((ulong)addr >= 256);
#endif
  pgpaFmtMsg((pgpaFmtPrefix,
              "pgpaAddrValidAligned failed on %s (%p) (align %d)",
              varName, addr, alignSize));

  if (!pgpaFailed)
      pgpMemAccessTest(addr);

  return pgpaFailed;
}

    Boolean
pgpaInternalStrLenValid(
    pgpaCallPrefixDef,
    char const *     str,
    ulong            minLen,
    ulong            maxLen,
    char const *     varName)
{
    ulong            i;

    pgpaAddrValid(str, char);

    for (i = 0; !pgpaFailed && str[i] != '\0'; i++)
    {
        pgpaFailIf(i >= maxLen, (pgpaFmtPrefix,
                "longer than %lu chars", maxLen));
        pgpaFailIf((uchar)(str[i]) < '\b', (pgpaFmtPrefix,
                "suspicious char 0x%x at index %lu", str[i], i));
    }

    pgpaFailIf(i < minLen, (pgpaFmtPrefix, "shorter than %lu chars", minLen));
    pgpaFmtMsg((pgpaFmtPrefix, "pgpaStrLenValid failed on %s (%p)",
                varName, str));

    return pgpaFailed;
}

    Boolean
pgpaInternalPStrLenValid(
    pgpaCallPrefixDef,
    uchar const *    str,
    int              minLen,
    int              maxLen,
    char const *     varName)
{
    int              len;
    int              i;

    pgpa((
          pgpaAssert(minLen >= 0),
          pgpaAssert(maxLen <= 255),
          pgpaMsg("Invalid parameters to pgpaPStrLenValid")));

    pgpaAddrValid(str, uchar);

    if (!pgpaFailed)
    {
        len = str[0];

        pgpaFailIf(len > maxLen, (pgpaFmtPrefix,
                    "longer than %d chars", maxLen));
        pgpaFailIf(len < minLen, (pgpaFmtPrefix,
                    "shorter than %d chars", minLen));

        for (i = 1; !pgpaFailed && i <= len; i++)
            pgpaFailIf(str[i] < '\b', (pgpaFmtPrefix,
                    "suspicious char 0x%x at index %d", str[i], i));

        pgpaFailIf(i < minLen, (pgpaFmtPrefix,
                    "shorter than %lu chars", minLen));
    }

    pgpaFmtMsg((pgpaFmtPrefix,
                    "pgpaPStrLenValid failed on %s (%p)", varName, str));

    return pgpaFailed;
}

    void
pgpDebugHook(void)
{
}

#endif  /* ] DEBUG */

/*
* Local Variables:
* tab-width: 4
* End:
* vi: ts=4 sw=4
* vim: si
*/