mcodecs.h

Go to the documentation of this file.

/*
   Copyright (C) 2000-2001 Dawit Alemayehu <adawit@kde.org>
   Copyright (C) 2001 Rik Hemsley (rikkus) <rik@kde.org>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License (LGPL)
   version 2 as published by the Free Software Foundation.

   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 Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

   RFC 1321 "MD5 Message-Digest Algorithm" Copyright (C) 1991-1992.             // krazy:exclude=copyright
   RSA Data Security, Inc. Created 1991. All rights reserved.

   The QMD5 class is based on a C++ implementation of
   "RSA Data Security, Inc. MD5 Message-Digest Algorithm" by
   Mordechai T. Abzug,  Copyright (c) 1995.  This implementation                // krazy:exclude=copyright
   passes the test-suite as defined in RFC 1321.

   The encoding and decoding utilities in KCodecs with the exception of
   quoted-printable are based on the java implementation in HTTPClient
   package by Ronald Tschalär Copyright (C) 1996-1999.                          // krazy:exclude=copyright

   The quoted-printable codec as described in RFC 2045, section 6.7. is by
   Rik Hemsley (C) 2001.
*/

#ifndef KCODECS_H
#define KCODECS_H

#define QBase64 QCodecs

#include "mythbaseexp.h"

class QByteArray;
class QIODevice;

namespace QCodecs
{
  MBASE_PUBLIC QByteArray quotedPrintableEncode(const QByteArray & in,
                                        bool useCRLF = true);

  MBASE_PUBLIC void quotedPrintableEncode(const QByteArray & in, QByteArray& out,
                                    bool useCRLF);

  MBASE_PUBLIC QByteArray quotedPrintableDecode(const QByteArray & in);

  MBASE_PUBLIC void quotedPrintableDecode(const QByteArray & in, QByteArray& out);


  MBASE_PUBLIC QByteArray uuencode( const QByteArray& in );

  MBASE_PUBLIC void uuencode( const QByteArray& in, QByteArray& out );

  MBASE_PUBLIC QByteArray uudecode( const QByteArray& in );

  MBASE_PUBLIC void uudecode( const QByteArray& in, QByteArray& out );


  MBASE_PUBLIC QByteArray base64Encode( const QByteArray& in, bool insertLFs = false);

  MBASE_PUBLIC void base64Encode( const QByteArray& in, QByteArray& out,
                            bool insertLFs = false );

  MBASE_PUBLIC QByteArray base64Decode( const QByteArray& in );

  MBASE_PUBLIC void base64Decode( const QByteArray& in, QByteArray& out );

}

class QMD5Private;
class MBASE_PUBLIC QMD5
{
public:

  typedef unsigned char Digest[16];

  QMD5();
  ~QMD5();

  explicit QMD5(const char* in, int len = -1);

  explicit QMD5(const QByteArray& a );

  void update(const char* in, int len = -1);

  void update(const unsigned char* in, int len = -1);

  void update(const QByteArray& in );

  bool update(QIODevice& file);

  void reset();

  const Digest& rawDigest (); //krazy:exclude=constref (simple array)

  void rawDigest( QMD5::Digest& bin );

  QByteArray hexDigest ();

  void hexDigest(QByteArray&);

  QByteArray base64Digest ();

  bool verify( const QMD5::Digest& digest);

  bool verify(const QByteArray&);

protected:
  void transform( const unsigned char buffer[64] );

  void finalize();

private:
  QMD5(const QMD5& u);
  QMD5& operator=(const QMD5& md);

  void init();
  void encode( unsigned char* output, quint32 *in, quint32 len );
  void decode( quint32 *output, const unsigned char* in, quint32 len );

  static quint32 rotate_left( quint32 x, quint32 n );
  static quint32 F( quint32 x, quint32 y, quint32 z );
  static quint32 G( quint32 x, quint32 y, quint32 z );
  static quint32 H( quint32 x, quint32 y, quint32 z );
  static quint32 I( quint32 x, quint32 y, quint32 z );
  static void FF( quint32& a, quint32 b, quint32 c, quint32 d, quint32 x,
                  quint32  s, quint32 ac );
  static void GG( quint32& a, quint32 b, quint32 c, quint32 d, quint32 x,
                  quint32 s, quint32 ac );
  static void HH( quint32& a, quint32 b, quint32 c, quint32 d, quint32 x,
                  quint32 s, quint32 ac );
  static void II( quint32& a, quint32 b, quint32 c, quint32 d, quint32 x,
                  quint32 s, quint32 ac );

private:
  quint32 m_state[4];
  quint32 m_count[2];
  quint8 m_buffer[64];
  Digest m_digest;
  bool m_finalized;

  QMD5Private* d;
};


#endif // KCODECS_H

---