File indexing completed on 2024-05-26 05:24:32

 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/classify.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include "kleo_export.h"
 
 #include <QStringList>
 
 #include <gpgme++/global.h>
 
 class QByteArray;
 class QString;
 
 namespace Kleo
 {
 
 namespace Class
 {
 enum {
     // clang-format off
     NoClass                   = 0,
 
     // protocol:
     CMS                       = 0x01,
     OpenPGP                   = 0x02,
 
     AnyProtocol               = OpenPGP | CMS,
     ProtocolMask              = AnyProtocol,
 
     // format:
     Binary                    = 0x04,
     Ascii                     = 0x08,
 
     AnyFormat                 = Binary | Ascii,
     FormatMask                = AnyFormat,
 
     // type:
     DetachedSignature         = 0x010,
     OpaqueSignature           = 0x020,
     ClearsignedMessage        = 0x040,
 
     AnySignature              = DetachedSignature | OpaqueSignature | ClearsignedMessage,
 
     CipherText                = 0x080,
 
     AnyMessageType            = AnySignature | CipherText,
 
     Importable                = 0x100,
     Certificate               = 0x200 | Importable,
     ExportedPSM               = 0x400 | Importable,
 
     AnyCertStoreType          = Certificate | ExportedPSM,
 
     CertificateRequest        = 0x800,
 
     CertificateRevocationList = 0x1000,
 
     MimeFile                  = 0x2000,
 
     AnyType                   = AnyMessageType | AnyCertStoreType | CertificateRequest | CertificateRevocationList,
     TypeMask                  = AnyType | MimeFile
     // clang-format on
 };
 }
 
 KLEO_EXPORT unsigned int classify(const QString &filename);
 KLEO_EXPORT unsigned int classify(const QStringList &fileNames);
 KLEO_EXPORT unsigned int classifyContent(const QByteArray &data);
 
 KLEO_EXPORT QString findSignedData(const QString &signatureFileName);
 KLEO_EXPORT QStringList findSignatures(const QString &signedDataFileName);
 KLEO_EXPORT QString outputFileName(const QString &input);
 
 /** Check if a string looks like a fingerprint (SHA1 sum) */
 KLEO_EXPORT bool isFingerprint(const QString &fpr);
 
 /** Check if a filename matches a ChecksumDefinition pattern */
 KLEO_EXPORT bool isChecksumFile(const QString &file);
 
 KLEO_EXPORT QString outputFileExtension(unsigned int classification, bool usePGPFileExt);
 
 KLEO_EXPORT QString printableClassification(unsigned int classification);
 
 inline bool isCMS(const QString &filename)
 {
     return (classify(filename) & Class::ProtocolMask) == Class::CMS;
 }
 inline bool isCMS(const unsigned int classification)
 {
     return (classification & Class::ProtocolMask) == Class::CMS;
 }
 inline bool mayBeCMS(const QString &filename)
 {
     return classify(filename) & Class::CMS;
 }
 inline bool mayBeCMS(const unsigned int classification)
 {
     return classification & Class::CMS;
 }
 
 inline bool isOpenPGP(const QString &filename)
 {
     return (classify(filename) & Class::ProtocolMask) == Class::OpenPGP;
 }
 inline bool isOpenPGP(const unsigned int classification)
 {
     return (classification & Class::ProtocolMask) == Class::OpenPGP;
 }
 inline bool mayBeOpenPGP(const QString &filename)
 {
     return classify(filename) & Class::OpenPGP;
 }
 inline bool mayBeOpenPGP(const unsigned int classification)
 {
     return classification & Class::OpenPGP;
 }
 
 inline bool isBinary(const QString &filename)
 {
     return (classify(filename) & Class::FormatMask) == Class::Binary;
 }
 inline bool isBinary(const unsigned int classification)
 {
     return (classification & Class::FormatMask) == Class::Binary;
 }
 inline bool mayBeBinary(const QString &filename)
 {
     return classify(filename) & Class::Binary;
 }
 inline bool mayBeBinary(const unsigned int classification)
 {
     return classification & Class::Binary;
 }
 
 inline bool isAscii(const QString &filename)
 {
     return (classify(filename) & Class::FormatMask) == Class::Ascii;
 }
 inline bool isAscii(const unsigned int classification)
 {
     return (classification & Class::FormatMask) == Class::Ascii;
 }
 inline bool mayBeAscii(const QString &filename)
 {
     return classify(filename) & Class::Ascii;
 }
 inline bool mayBeAscii(const unsigned int classification)
 {
     return classification & Class::Ascii;
 }
 
 inline bool isDetachedSignature(const QString &filename)
 {
     return (classify(filename) & Class::TypeMask) == Class::DetachedSignature;
 }
 inline bool isDetachedSignature(const unsigned int classification)
 {
     return (classification & Class::TypeMask) == Class::DetachedSignature;
 }
 inline bool mayBeDetachedSignature(const QString &filename)
 {
     return classify(filename) & Class::DetachedSignature;
 }
 inline bool mayBeDetachedSignature(const unsigned int classification)
 {
     return classification & Class::DetachedSignature;
 }
 
 inline bool isOpaqueSignature(const QString &filename)
 {
     return (classify(filename) & Class::TypeMask) == Class::OpaqueSignature;
 }
 inline bool isOpaqueSignature(const unsigned int classification)
 {
     return (classification & Class::TypeMask) == Class::OpaqueSignature;
 }
 inline bool mayBeOpaqueSignature(const QString &filename)
 {
     return classify(filename) & Class::OpaqueSignature;
 }
 inline bool mayBeOpaqueSignature(const unsigned int classification)
 {
     return classification & Class::OpaqueSignature;
 }
 
 inline bool isCipherText(const QString &filename)
 {
     return (classify(filename) & Class::TypeMask) == Class::CipherText;
 }
 inline bool isCipherText(const unsigned int classification)
 {
     return (classification & Class::TypeMask) == Class::CipherText;
 }
 inline bool mayBeCipherText(const QString &filename)
 {
     return classify(filename) & Class::CipherText;
 }
 inline bool mayBeCipherText(const unsigned int classification)
 {
     return classification & Class::CipherText;
 }
 
 inline bool isAnyMessageType(const QString &filename)
 {
     return (classify(filename) & Class::TypeMask) == Class::AnyMessageType;
 }
 inline bool isAnyMessageType(const unsigned int classification)
 {
     return (classification & Class::TypeMask) == Class::AnyMessageType;
 }
 inline bool mayBeAnyMessageType(const QString &filename)
 {
     return classify(filename) & Class::AnyMessageType;
 }
 inline bool mayBeAnyMessageType(const unsigned int classification)
 {
     return classification & Class::AnyMessageType;
 }
 
 inline bool isCertificateRevocationList(const QString &filename)
 {
     return (classify(filename) & Class::TypeMask) == Class::CertificateRevocationList;
 }
 inline bool isCertificateRevocationList(const unsigned int classification)
 {
     return (classification & Class::TypeMask) == Class::CertificateRevocationList;
 }
 inline bool mayBeCertificateRevocationList(const QString &filename)
 {
     return classify(filename) & Class::CertificateRevocationList;
 }
 inline bool mayBeCertificateRevocationList(const unsigned int classification)
 {
     return classification & Class::CertificateRevocationList;
 }
 
 inline bool isAnyCertStoreType(const QString &filename)
 {
     return (classify(filename) & Class::TypeMask) == Class::AnyCertStoreType;
 }
 inline bool isAnyCertStoreType(const unsigned int classification)
 {
     return (classification & Class::TypeMask) == Class::AnyCertStoreType;
 }
 inline bool mayBeAnyCertStoreType(const QString &filename)
 {
     return classify(filename) & Class::AnyCertStoreType;
 }
 inline bool mayBeAnyCertStoreType(const unsigned int classification)
 {
     return classification & Class::AnyCertStoreType;
 }
 
 inline bool isMimeFile(const unsigned int classification)
 {
     return (classification & Class::TypeMask) == Class::MimeFile;
 }
 
 inline bool isMimeFile(const QString &filename)
 {
     return (classify(filename) & Class::TypeMask) == Class::MimeFile;
 }
 
 inline bool mayBeMimeFile(const QString &filename)
 {
     return classify(filename) & Class::MimeFile;
 }
 inline bool mayBeMimeFile(const unsigned int classification)
 {
     return classification & Class::MimeFile;
 }
 
 inline GpgME::Protocol findProtocol(const unsigned int classification)
 {
     if (isOpenPGP(classification)) {
         return GpgME::OpenPGP;
     } else if (isCMS(classification)) {
         return GpgME::CMS;
     } else {
         return GpgME::UnknownProtocol;
     }
 }
 inline GpgME::Protocol findProtocol(const QString &filename)
 {
     return findProtocol(classify(filename));
 }
 
 }