classify.h 3.8 KB
Newer Older
1
2
3
4
/* -*- mode: c++; c-basic-offset:4 -*-
    utils/classify.h

    This file is part of Kleopatra, the KDE keymanager
5
6
7
    SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB

    SPDX-License-Identifier: GPL-2.0-or-later
8
9
*/

Laurent Montel's avatar
Laurent Montel committed
10
#pragma once
11
12
13

#include <kleo_export.h>

Ingo Klöcker's avatar
Ingo Klöcker committed
14
15
16
#include <gpgme++/global.h>

class QByteArray;
17
class QString;
Ingo Klöcker's avatar
Ingo Klöcker committed
18
class QStringList;
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

namespace Kleo
{

namespace Class
{
enum {
    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,

    AnyType            = AnyMessageType | AnyCertStoreType | CertificateRequest | CertificateRevocationList,
    TypeMask           = AnyType
};
}

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 const char *outputFileExtension(unsigned int classification, bool usePGPFileExt);

KLEO_EXPORT QString printableClassification(unsigned int classification);

#define make_convenience( What, Mask )                                  \
    inline bool is##What( const QString & filename ) {                  \
        return ( classify( filename ) & Class::Mask ) == Class::What ;  \
    }                                                                   \
90
91
    inline bool is##What( const unsigned int classification ) {         \
        return ( classification & Class::Mask ) == Class::What ;        \
92
93
94
95
    }                                                                   \
    inline bool mayBe##What( const QString & filename ) {               \
        return classify( filename ) & Class::What ;                     \
    }                                                                   \
96
97
    inline bool mayBe##What( const unsigned int classification ) {      \
        return classification & Class::What ;                           \
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
    }

make_convenience(CMS,     ProtocolMask)
make_convenience(OpenPGP, ProtocolMask)

make_convenience(Binary, FormatMask)
make_convenience(Ascii,  FormatMask)

make_convenience(DetachedSignature, TypeMask)
make_convenience(OpaqueSignature,   TypeMask)
make_convenience(CipherText,        TypeMask)
make_convenience(AnyMessageType,    TypeMask)
make_convenience(CertificateRevocationList, TypeMask)
make_convenience(AnyCertStoreType,  TypeMask)
#undef make_convenience

114
inline GpgME::Protocol findProtocol(const unsigned int classification)
115
{
116
    if (isOpenPGP(classification)) {
117
        return GpgME::OpenPGP;
118
    } else if (isCMS(classification)) {
119
120
121
122
123
124
125
126
127
128
129
130
        return GpgME::CMS;
    } else {
        return GpgME::UnknownProtocol;
    }
}
inline GpgME::Protocol findProtocol(const QString &filename)
{
    return findProtocol(classify(filename));
}

}