digest: Rename SHA-512/256 to SHA-2-512/256

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/_pakfire/_pakfiremodule.c b/src/_pakfire/_pakfiremodule.c
index b00b000de2a43c2a277dbda7e42cd5be95dc4f2b..da78553e7a6640972727814bf0ff42c8922553cf 100644 (file)
--- a/src/_pakfire/_pakfiremodule.c
+++ b/src/_pakfire/_pakfiremodule.c
@@ -114,9 +114,9 @@ PyMODINIT_FUNC PyInit__pakfire(void) {
        }
 
        // Add digest constants
-       if (PyModule_AddIntMacro(module, PAKFIRE_DIGEST_SHA512))
+       if (PyModule_AddIntMacro(module, PAKFIRE_DIGEST_SHA2_512))
                return NULL;
-       if (PyModule_AddIntMacro(module, PAKFIRE_DIGEST_SHA256))
+       if (PyModule_AddIntMacro(module, PAKFIRE_DIGEST_SHA2_256))
                return NULL;
 
        // Pakfire

diff --git a/src/_pakfire/package.c b/src/_pakfire/package.c
index 45211a878e24343172c96789d746df99458282b0..a9fbdbe8afa3d20ac7b0ded5140919f408fdd478 100644 (file)
--- a/src/_pakfire/package.c
+++ b/src/_pakfire/package.c
@@ -208,27 +208,27 @@ static PyObject* Package_get_hexdigest(PackageObject* self, enum pakfire_digest_
        return PyUnicode_FromString(hexdigest);
 }
 
-static PyObject* Package_get_hexdigest_sha256(PackageObject* self) {
-       return Package_get_hexdigest(self, PAKFIRE_DIGEST_SHA256);
+static PyObject* Package_get_hexdigest_sha2_256(PackageObject* self) {
+       return Package_get_hexdigest(self, PAKFIRE_DIGEST_SHA2_256);
 }
 
-static PyObject* Package_get_hexdigest_sha512(PackageObject* self) {
-       return Package_get_hexdigest(self, PAKFIRE_DIGEST_SHA512);
+static PyObject* Package_get_hexdigest_sha2_512(PackageObject* self) {
+       return Package_get_hexdigest(self, PAKFIRE_DIGEST_SHA2_512);
 }
 
 static int Package_set_hexdigest(PackageObject* self,
-               enum pakfire_digest_types type, PyObject* value) {
+               const enum pakfire_digest_types type, PyObject* value) {
        const char* hexdigest = PyUnicode_FromValue(value);
 
        return pakfire_package_set_hexdigest(self->package, type, hexdigest);
 }
 
-static int Package_set_hexdigest_sha256(PackageObject* self, PyObject* value) {
-       return Package_set_hexdigest(self, PAKFIRE_DIGEST_SHA256, value);
+static int Package_set_hexdigest_sha2_256(PackageObject* self, PyObject* value) {
+       return Package_set_hexdigest(self, PAKFIRE_DIGEST_SHA2_256, value);
 }
 
-static int Package_set_hexdigest_sha512(PackageObject* self, PyObject* value) {
-       return Package_set_hexdigest(self, PAKFIRE_DIGEST_SHA512, value);
+static int Package_set_hexdigest_sha2_512(PackageObject* self, PyObject* value) {
+       return Package_set_hexdigest(self, PAKFIRE_DIGEST_SHA2_512, value);
 }
 
 static PyObject* Package_get_summary(PackageObject* self) {
@@ -776,16 +776,16 @@ static struct PyGetSetDef Package_getsetters[] = {
                NULL
        },
        {
-               "hexdigest_sha256",
-               (getter)Package_get_hexdigest_sha256,
-               (setter)Package_set_hexdigest_sha256,
+               "hexdigest_sha2_256",
+               (getter)Package_get_hexdigest_sha2_256,
+               (setter)Package_set_hexdigest_sha2_256,
                NULL,
                NULL
        },
        {
-               "hexdigest_sha512",
-               (getter)Package_get_hexdigest_sha512,
-               (setter)Package_set_hexdigest_sha512,
+               "hexdigest_sha2_512",
+               (getter)Package_get_hexdigest_sha2_512,
+               (setter)Package_set_hexdigest_sha2_512,
                NULL,
                NULL
        },

diff --git a/src/libpakfire/archive.c b/src/libpakfire/archive.c
index 192a562383de284e16b6dfe00ecc1b2ce8567abd..dd7d20dacbf110bc2877d024ac1510685d613d17 100644 (file)
--- a/src/libpakfire/archive.c
+++ b/src/libpakfire/archive.c
@@ -925,12 +925,12 @@ static int pakfire_archive_make_package_from_json(struct pakfire_archive* archiv
 
        // Set digest
        switch (PAKFIRE_ARCHIVE_CHECKSUM) {
-               case PAKFIRE_DIGEST_SHA512:
-                       pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha512);
+               case PAKFIRE_DIGEST_SHA2_512:
+                       pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha2_512);
                        break;
 
-               case PAKFIRE_DIGEST_SHA256:
-                       pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha256);
+               case PAKFIRE_DIGEST_SHA2_256:
+                       pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha2_256);
                        break;
 
                case PAKFIRE_DIGEST_UNDEFINED:
@@ -1264,12 +1264,12 @@ static int pakfire_archive_make_legacy_package(struct pakfire_archive* archive,
 
        // Set digest
        switch (PAKFIRE_ARCHIVE_CHECKSUM) {
-               case PAKFIRE_DIGEST_SHA512:
-                       pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha512);
+               case PAKFIRE_DIGEST_SHA2_512:
+                       pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha2_512);
                        break;
 
-               case PAKFIRE_DIGEST_SHA256:
-                       pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha256);
+               case PAKFIRE_DIGEST_SHA2_256:
+                       pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha2_256);
                        break;
 
                case PAKFIRE_DIGEST_UNDEFINED:

diff --git a/src/libpakfire/db.c b/src/libpakfire/db.c
index 0596f9fa79f20399032cefe1b4d14eb5300546bb..4635b6fa7cb33d9f1a79d3e11183cff2d5f7ca90 100644 (file)
--- a/src/libpakfire/db.c
+++ b/src/libpakfire/db.c
@@ -836,8 +836,8 @@ static const struct pakfire_digest {
        enum pakfire_digest_types type;
        const char* prefix;
 } pakfire_digests[] = {
-       { PAKFIRE_DIGEST_SHA512, "sha512:" },
-       { PAKFIRE_DIGEST_SHA256, "sha256:" },
+       { PAKFIRE_DIGEST_SHA2_512, "sha512:" },
+       { PAKFIRE_DIGEST_SHA2_256, "sha256:" },
        { 0, NULL },
 };
 
@@ -1100,7 +1100,7 @@ static int pakfire_db_add_files(struct pakfire_db* db, unsigned long id, struct
                size_t sha512_length = 0;
 
                // SHA-512 Digest
-               sha512_digest = pakfire_file_get_digest(file, PAKFIRE_DIGEST_SHA512, &sha512_length);
+               sha512_digest = pakfire_file_get_digest(file, PAKFIRE_DIGEST_SHA2_512, &sha512_length);
                if (sha512_digest) {
                        r = sqlite3_bind_blob(stmt, 12, sha512_digest, sha512_length, NULL);
                } else {
@@ -1117,7 +1117,7 @@ static int pakfire_db_add_files(struct pakfire_db* db, unsigned long id, struct
                size_t sha256_length = 0;
 
                // SHA-256 Digest
-               sha256_digest = pakfire_file_get_digest(file, PAKFIRE_DIGEST_SHA256, &sha256_length);
+               sha256_digest = pakfire_file_get_digest(file, PAKFIRE_DIGEST_SHA2_256, &sha256_length);
                if (sha256_digest) {
                        r = sqlite3_bind_blob(stmt, 13, sha256_digest, sha256_length, NULL);
                } else {
@@ -2120,12 +2120,12 @@ static int pakfire_db_load_file(struct pakfire_db* db, struct pakfire_filelist*
                pakfire_file_set_mtime(file, mtime);
 
        // SHA-512 Digest
-       r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA512, 7);
+       r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA2_512, 7);
        if (r)
                goto ERROR;
 
        // SHA-256 Digest
-       r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA256, 8);
+       r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA2_256, 8);
        if (r)
                goto ERROR;
 

diff --git a/src/libpakfire/digest.c b/src/libpakfire/digest.c
index 362355f231f6c06644af1cf70ba973b6e20247a5..c35be92c66458fdad9235b9e730b64b397624610 100644 (file)
--- a/src/libpakfire/digest.c
+++ b/src/libpakfire/digest.c
@@ -39,10 +39,10 @@ size_t pakfire_digest_length(const enum pakfire_digest_types digest) {
                case PAKFIRE_DIGEST_BLAKE2S256:
                        return BLAKE2S256_DIGEST_LENGTH;
 
-               case PAKFIRE_DIGEST_SHA512:
+               case PAKFIRE_DIGEST_SHA2_512:
                        return SHA512_DIGEST_LENGTH;
 
-               case PAKFIRE_DIGEST_SHA256:
+               case PAKFIRE_DIGEST_SHA2_256:
                        return SHA256_DIGEST_LENGTH;
 
                case PAKFIRE_DIGEST_UNDEFINED:
@@ -68,13 +68,13 @@ void pakfire_digests_reset(struct pakfire_digests* digests, int types) {
        if (!types)
                types = ~types;
 
-       // Reset SHA-512
-       if (types & PAKFIRE_DIGEST_SHA512)
-               memset(digests->sha512, 0, sizeof(digests->sha512));
+       // Reset SHA-2-512
+       if (types & PAKFIRE_DIGEST_SHA2_512)
+               memset(digests->sha2_512, 0, sizeof(digests->sha2_512));
 
-       // Reset SHA-256
-       if (types & PAKFIRE_DIGEST_SHA256)
-               memset(digests->sha256, 0, sizeof(digests->sha256));
+       // Reset SHA-2-256
+       if (types & PAKFIRE_DIGEST_SHA2_256)
+               memset(digests->sha2_256, 0, sizeof(digests->sha2_256));
 }
 
 static int pakfire_digests_check_length(struct pakfire* pakfire,
@@ -165,8 +165,8 @@ int pakfire_digests_compute_from_file(struct pakfire* pakfire,
                struct pakfire_digests* digests, const int types, FILE* f) {
        EVP_MD_CTX* blake2b512_ctx = NULL;
        EVP_MD_CTX* blake2s256_ctx = NULL;
-       EVP_MD_CTX* sha512_ctx = NULL;
-       EVP_MD_CTX* sha256_ctx = NULL;
+       EVP_MD_CTX* sha2_512_ctx = NULL;
+       EVP_MD_CTX* sha2_256_ctx = NULL;
        char buffer[PAKFIRE_BUFFER_SIZE];
        int r = 1;
 
@@ -185,16 +185,16 @@ int pakfire_digests_compute_from_file(struct pakfire* pakfire,
        }
 
        // Initialize context for SHA-512
-       if (types & PAKFIRE_DIGEST_SHA512) {
-               sha512_ctx = __pakfire_digest_setup(pakfire, EVP_sha512());
-               if (!sha512_ctx)
+       if (types & PAKFIRE_DIGEST_SHA2_512) {
+               sha2_512_ctx = __pakfire_digest_setup(pakfire, EVP_sha512());
+               if (!sha2_512_ctx)
                        goto ERROR;
        }
 
        // Initialize context for SHA-256
-       if (types & PAKFIRE_DIGEST_SHA256) {
-               sha256_ctx = __pakfire_digest_setup(pakfire, EVP_sha256());
-               if (!sha256_ctx)
+       if (types & PAKFIRE_DIGEST_SHA2_256) {
+               sha2_256_ctx = __pakfire_digest_setup(pakfire, EVP_sha256());
+               if (!sha2_256_ctx)
                        goto ERROR;
        }
 
@@ -218,13 +218,13 @@ int pakfire_digests_compute_from_file(struct pakfire* pakfire,
                if (r)
                        goto ERROR;
 
-               // SHA-512
-               r = __pakfire_digest_update(pakfire, sha512_ctx, buffer, bytes_read);
+               // SHA-2-512
+               r = __pakfire_digest_update(pakfire, sha2_512_ctx, buffer, bytes_read);
                if (r)
                        goto ERROR;
 
-               // SHA-256
-               r = __pakfire_digest_update(pakfire, sha256_ctx, buffer, bytes_read);
+               // SHA-2-256
+               r = __pakfire_digest_update(pakfire, sha2_256_ctx, buffer, bytes_read);
                if (r)
                        goto ERROR;
        }
@@ -240,12 +240,12 @@ int pakfire_digests_compute_from_file(struct pakfire* pakfire,
                goto ERROR;
 
        // Finalize SHA-512
-       r = __pakfire_digest_finalize(pakfire, sha512_ctx, digests->sha512);
+       r = __pakfire_digest_finalize(pakfire, sha2_512_ctx, digests->sha2_512);
        if (r)
                goto ERROR;
 
        // Finalize SHA-256
-       r = __pakfire_digest_finalize(pakfire, sha256_ctx, digests->sha256);
+       r = __pakfire_digest_finalize(pakfire, sha2_256_ctx, digests->sha2_256);
        if (r)
                goto ERROR;
 
@@ -257,10 +257,10 @@ ERROR:
                EVP_MD_CTX_free(blake2b512_ctx);
        if (blake2s256_ctx)
                EVP_MD_CTX_free(blake2s256_ctx);
-       if (sha512_ctx)
-               EVP_MD_CTX_free(sha512_ctx);
-       if (sha256_ctx)
-               EVP_MD_CTX_free(sha256_ctx);
+       if (sha2_512_ctx)
+               EVP_MD_CTX_free(sha2_512_ctx);
+       if (sha2_256_ctx)
+               EVP_MD_CTX_free(sha2_256_ctx);
 
        // Reset file offset to the beginning
        rewind(f);
@@ -317,21 +317,21 @@ int pakfire_digests_compare(struct pakfire* pakfire, const struct pakfire_digest
        }
 
        // Check SHA-512
-       if (types & PAKFIRE_DIGEST_SHA512) {
-               r = CRYPTO_memcmp(digests1->sha512, digests2->sha512, sizeof(digests1->sha512));
+       if (types & PAKFIRE_DIGEST_SHA2_512) {
+               r = CRYPTO_memcmp(digests1->sha2_512, digests2->sha2_512, sizeof(digests1->sha2_512));
                if (r) {
-                       pakfire_digests_compare_mismatch(pakfire, "SHA-512",
-                               digests1->sha512, digests2->sha512, sizeof(digests1->sha512));
+                       pakfire_digests_compare_mismatch(pakfire, "SHA-2-512",
+                               digests1->sha2_512, digests2->sha2_512, sizeof(digests1->sha2_512));
                        return 1;
                }
        }
 
        // Check SHA-256
-       if (types & PAKFIRE_DIGEST_SHA256) {
-               r = CRYPTO_memcmp(digests1->sha256, digests2->sha256, sizeof(digests1->sha256));
+       if (types & PAKFIRE_DIGEST_SHA2_256) {
+               r = CRYPTO_memcmp(digests1->sha2_256, digests2->sha2_256, sizeof(digests1->sha2_256));
                if (r) {
-                       pakfire_digests_compare_mismatch(pakfire, "SHA-256",
-                               digests1->sha256, digests2->sha256, sizeof(digests1->sha256));
+                       pakfire_digests_compare_mismatch(pakfire, "SHA-2-256",
+                               digests1->sha2_256, digests2->sha2_256, sizeof(digests1->sha2_256));
                        return 1;
                }
        }
@@ -359,12 +359,12 @@ int pakfire_digests_compare_one(struct pakfire* pakfire, struct pakfire_digests*
                        memcpy(digests2.blake2s256, digest, sizeof(digests2.blake2s256));
                        break;
 
-               case PAKFIRE_DIGEST_SHA512:
-                       memcpy(digests2.sha512, digest, sizeof(digests2.sha512));
+               case PAKFIRE_DIGEST_SHA2_512:
+                       memcpy(digests2.sha2_512, digest, sizeof(digests2.sha2_512));
                        break;
 
-               case PAKFIRE_DIGEST_SHA256:
-                       memcpy(digests2.sha256, digest, sizeof(digests2.sha256));
+               case PAKFIRE_DIGEST_SHA2_256:
+                       memcpy(digests2.sha2_256, digest, sizeof(digests2.sha2_256));
                        break;
 
                case PAKFIRE_DIGEST_UNDEFINED:

diff --git a/src/libpakfire/downloader.c b/src/libpakfire/downloader.c
index 6a872c8add5b6a46dca350c26278aac75c1eaa2f..c5947d1eaee9e77fe6e2286c5863b35188d5a18a 100644 (file)
--- a/src/libpakfire/downloader.c
+++ b/src/libpakfire/downloader.c
@@ -354,11 +354,11 @@ static struct pakfire_transfer* pakfire_downloader_create_transfer(
                        transfer->md = EVP_blake2s256();
                        break;
 
-               case PAKFIRE_DIGEST_SHA512:
+               case PAKFIRE_DIGEST_SHA2_512:
                        transfer->md = EVP_sha512();
                        break;
 
-               case PAKFIRE_DIGEST_SHA256:
+               case PAKFIRE_DIGEST_SHA2_256:
                        transfer->md = EVP_sha256();
                        break;
 

diff --git a/src/libpakfire/file.c b/src/libpakfire/file.c
index cced21ea2a8d753986098664b50fa313b1687cf6..e42e8622cfc19ad5af978602058598f02a539230 100644 (file)
--- a/src/libpakfire/file.c
+++ b/src/libpakfire/file.c
@@ -151,15 +151,15 @@ static int pakfire_file_from_archive_entry(struct pakfire_file* file, struct arc
                        if (r)
                                goto ERROR;
 
-               // Digest: SHA-512
-               } else if (strcmp(attr, "PAKFIRE.digests.sha512") == 0) {
-                       r = pakfire_file_set_digest(file, PAKFIRE_DIGEST_SHA512, value, size);
+               // Digest: SHA-2-512
+               } else if (strcmp(attr, "PAKFIRE.digests.sha2_512") == 0) {
+                       r = pakfire_file_set_digest(file, PAKFIRE_DIGEST_SHA2_512, value, size);
                        if (r)
                                goto ERROR;
 
-               // Digest: SHA-256
-               } else if (strcmp(attr, "PAKFIRE.digests.sha256") == 0) {
-                       r = pakfire_file_set_digest(file, PAKFIRE_DIGEST_SHA256, value, size);
+               // Digest: SHA-2-256
+               } else if (strcmp(attr, "PAKFIRE.digests.sha2_256") == 0) {
+                       r = pakfire_file_set_digest(file, PAKFIRE_DIGEST_SHA2_256, value, size);
                        if (r)
                                goto ERROR;
 
@@ -296,15 +296,15 @@ struct archive_entry* pakfire_file_archive_entry(struct pakfire_file* file) {
                archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.blake2s256",
                        file->digests.blake2s256, sizeof(file->digests.blake2s256));
 
-       // SHA-512
-       if (pakfire_digest_set(file->digests.sha512))
-               archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.sha512",
-                       file->digests.sha512, sizeof(file->digests.sha512));
+       // SHA-2-512
+       if (pakfire_digest_set(file->digests.sha2_512))
+               archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.sha2_512",
+                       file->digests.sha2_512, sizeof(file->digests.sha2_512));
 
-       // SHA-256
-       if (pakfire_digest_set(file->digests.sha256))
-               archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.sha256",
-                       file->digests.sha256, sizeof(file->digests.sha256));
+       // SHA-2-256
+       if (pakfire_digest_set(file->digests.sha2_256))
+               archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.sha2_256",
+                       file->digests.sha2_256, sizeof(file->digests.sha2_256));
 
        return entry;
 }
@@ -499,23 +499,23 @@ PAKFIRE_EXPORT const unsigned char* pakfire_file_get_digest(
 
                        return file->digests.blake2s256;
 
-               case PAKFIRE_DIGEST_SHA512:
-                       if (!pakfire_digest_set(file->digests.sha512))
+               case PAKFIRE_DIGEST_SHA2_512:
+                       if (!pakfire_digest_set(file->digests.sha2_512))
                                return NULL;
 
                        if (length)
-                               *length = sizeof(file->digests.sha512);
+                               *length = sizeof(file->digests.sha2_512);
 
-                       return file->digests.sha512;
+                       return file->digests.sha2_512;
 
-               case PAKFIRE_DIGEST_SHA256:
-                       if (!pakfire_digest_set(file->digests.sha256))
+               case PAKFIRE_DIGEST_SHA2_256:
+                       if (!pakfire_digest_set(file->digests.sha2_256))
                                return NULL;
 
                        if (length)
-                               *length = sizeof(file->digests.sha256);
+                               *length = sizeof(file->digests.sha2_256);
 
-                       return file->digests.sha256;
+                       return file->digests.sha2_256;
 
                case PAKFIRE_DIGEST_UNDEFINED:
                        break;
@@ -548,12 +548,12 @@ PAKFIRE_EXPORT int pakfire_file_set_digest(struct pakfire_file* file,
                        memcpy(file->digests.blake2s256, digest, sizeof(file->digests.blake2s256));
                        break;
 
-               case PAKFIRE_DIGEST_SHA512:
-                       memcpy(file->digests.sha512, digest, sizeof(file->digests.sha512));
+               case PAKFIRE_DIGEST_SHA2_512:
+                       memcpy(file->digests.sha2_512, digest, sizeof(file->digests.sha2_512));
                        break;
 
-               case PAKFIRE_DIGEST_SHA256:
-                       memcpy(file->digests.sha256, digest, sizeof(file->digests.sha256));
+               case PAKFIRE_DIGEST_SHA2_256:
+                       memcpy(file->digests.sha2_256, digest, sizeof(file->digests.sha2_256));
                        break;
 
                case PAKFIRE_DIGEST_UNDEFINED:
@@ -830,11 +830,11 @@ static int pakfire_file_verify_payload(struct pakfire_file* file, const struct s
        }
 
        // Check if this file has any digests at all
-       if (pakfire_digest_set(file->digests.sha512))
-               digest_types |= PAKFIRE_DIGEST_SHA512;
+       if (pakfire_digest_set(file->digests.sha2_512))
+               digest_types |= PAKFIRE_DIGEST_SHA2_512;
 
-       if (pakfire_digest_set(file->digests.sha256))
-               digest_types |= PAKFIRE_DIGEST_SHA256;
+       if (pakfire_digest_set(file->digests.sha2_256))
+               digest_types |= PAKFIRE_DIGEST_SHA2_256;
 
        if (!digest_types) {
                ERROR(file->pakfire, "%s: No digests available\n", file->path);

diff --git a/src/libpakfire/include/pakfire/digest.h b/src/libpakfire/include/pakfire/digest.h
index f059c5ce498abe3d9abda417924ef9ad6c3a8302..6b6072907030a4d2ef9dfcd76953b35b4fb4bbe3 100644 (file)
--- a/src/libpakfire/include/pakfire/digest.h
+++ b/src/libpakfire/include/pakfire/digest.h
@@ -24,8 +24,8 @@
 // Pakfire knows these digests
 enum pakfire_digest_types {
        PAKFIRE_DIGEST_UNDEFINED  = 0,
-       PAKFIRE_DIGEST_SHA256     = (1 << 0),
-       PAKFIRE_DIGEST_SHA512     = (1 << 1),
+       PAKFIRE_DIGEST_SHA2_256   = (1 << 0),
+       PAKFIRE_DIGEST_SHA2_512   = (1 << 1),
        PAKFIRE_DIGEST_BLAKE2S256 = (1 << 2),
        PAKFIRE_DIGEST_BLAKE2B512 = (1 << 3),
 };
@@ -41,7 +41,7 @@ enum pakfire_digest_types {
 #include <pakfire/pakfire.h>
 
 // libsolv only supports storing one checksum which has to be of a supported type
-#define PAKFIRE_ARCHIVE_CHECKSUM PAKFIRE_DIGEST_SHA512
+#define PAKFIRE_ARCHIVE_CHECKSUM PAKFIRE_DIGEST_SHA2_512
 
 // Define BLAKE2's digest lengths
 #ifndef BLAKE2S256_DIGEST_LENGTH
@@ -60,19 +60,19 @@ struct pakfire_digests {
        // BLAKE2s256
        unsigned char blake2s256[BLAKE2S256_DIGEST_LENGTH];
 
-       // SHA-512
-       unsigned char sha512[SHA512_DIGEST_LENGTH];
+       // SHA2-512
+       unsigned char sha2_512[SHA512_DIGEST_LENGTH];
 
-       // SHA-256
-       unsigned char sha256[SHA256_DIGEST_LENGTH];
+       // SHA2-256
+       unsigned char sha2_256[SHA256_DIGEST_LENGTH];
 };
 
 #define PAKFIRE_DIGESTS_INIT \
        { \
                .blake2b512 = 0, \
                .blake2s256 = 0, \
-               .sha512 = 0, \
-               .sha256 = 0, \
+               .sha2_512 = 0, \
+               .sha2_256 = 0, \
        }
 
 size_t pakfire_digest_length(const enum pakfire_digest_types digest);

diff --git a/src/libpakfire/package.c b/src/libpakfire/package.c
index a9eb3b740df29646dc0d04aaa99fd5f7f8fd21f9..9f56e565635d6e20dace10dc6642868f7be3ce33 100644 (file)
--- a/src/libpakfire/package.c
+++ b/src/libpakfire/package.c
@@ -399,10 +399,10 @@ PAKFIRE_EXPORT void pakfire_package_set_uuid(struct pakfire_package* pkg, const
 static enum pakfire_digest_types pakfire_package_id2digest(Id id) {
        switch (id) {
                case REPOKEY_TYPE_SHA512:
-                       return PAKFIRE_DIGEST_SHA512;
+                       return PAKFIRE_DIGEST_SHA2_512;
 
                case REPOKEY_TYPE_SHA256:
-                       return PAKFIRE_DIGEST_SHA256;
+                       return PAKFIRE_DIGEST_SHA2_256;
        }
 
        return 0;
@@ -450,11 +450,11 @@ PAKFIRE_EXPORT int pakfire_package_set_digest(struct pakfire_package* pkg,
        int r = 1;
 
        switch (type) {
-               case PAKFIRE_DIGEST_SHA256:
+               case PAKFIRE_DIGEST_SHA2_256:
                        id = REPOKEY_TYPE_SHA256;
                        break;
 
-               case PAKFIRE_DIGEST_SHA512:
+               case PAKFIRE_DIGEST_SHA2_512:
                        id = REPOKEY_TYPE_SHA512;
                        break;
 
@@ -1141,11 +1141,11 @@ PAKFIRE_EXPORT char* pakfire_package_dump(struct pakfire_package* pkg, int flags
                // Digest
                const char* hexdigest = pakfire_package_get_hexdigest(pkg, &digest);
                switch (digest) {
-                       case PAKFIRE_DIGEST_SHA512:
+                       case PAKFIRE_DIGEST_SHA2_512:
                                pakfire_package_dump_add_line(&string, _("SHA512 Digest"), hexdigest);
                                break;
 
-                       case PAKFIRE_DIGEST_SHA256:
+                       case PAKFIRE_DIGEST_SHA2_256:
                                pakfire_package_dump_add_line(&string, _("SHA256 Digest"), hexdigest);
                                break;
 

diff --git a/src/pakfire/constants.py b/src/pakfire/constants.py
index cbfcc1a8542435ff0b626b69ae2e812de80aaaac..b0c462cb3847423f95185af5cefd103cb3efce5b 100644 (file)
--- a/src/pakfire/constants.py
+++ b/src/pakfire/constants.py
@@ -27,8 +27,8 @@ from .__version__ import PAKFIRE_VERSION
 
 # Fetch digest constants
 from ._pakfire import (
-       PAKFIRE_DIGEST_SHA512,
-       PAKFIRE_DIGEST_SHA256,
+       PAKFIRE_DIGEST_SHA2_512,
+       PAKFIRE_DIGEST_SHA2_256,
 )
 
 # The default hub to connect to.

diff --git a/tests/libpakfire/digest.c b/tests/libpakfire/digest.c
index 1084eedfcb10a87de994e90af2ab3e670de1b133..12b7c17592d9bbb8ffba752f717466b103d32b7c 100644 (file)
--- a/tests/libpakfire/digest.c
+++ b/tests/libpakfire/digest.c
@@ -27,7 +27,7 @@
 const char* RANDOM_FILE = ABS_TOP_SRCDIR "/tests/data/digest/random";
 
 static const struct pakfire_digests expected_digests = {
-       .sha512 = {
+       .sha2_512 = {
                0xa1, 0x98, 0x97, 0x9b, 0x13, 0x44, 0xf3, 0x64, 0x48, 0x0e, 0x0f, 0xd1,
                0xbc, 0xde, 0x8f, 0x50, 0xf3, 0x3c, 0x92, 0x8e, 0xf0, 0xe7, 0x5d, 0x6e,
                0x1a, 0x28, 0x67, 0x1e, 0x16, 0x49, 0x7b, 0xc2, 0xd6, 0x64, 0xe5, 0x21,
@@ -35,7 +35,7 @@ static const struct pakfire_digests expected_digests = {
                0x16, 0xe7, 0xe7, 0x27, 0x33, 0xd9, 0x66, 0xb5, 0x0a, 0x39, 0x6d, 0xa8,
                0xb2, 0xb4, 0xac, 0x05,
        },
-       .sha256 = {
+       .sha2_256 = {
                0x16, 0xf9, 0x01, 0xc1, 0x83, 0x31, 0x43, 0x88, 0x4f, 0x16, 0x6a, 0xe4,
                0x81, 0x34, 0x51, 0x99, 0xcf, 0x91, 0x94, 0xa3, 0xb6, 0x01, 0x75, 0xd9,
                0xb9, 0xca, 0x93, 0xd9, 0xd7, 0xa0, 0x4b, 0xa6,
@@ -46,8 +46,8 @@ static int test_init(const struct test* t) {
        struct pakfire_digests digests = PAKFIRE_DIGESTS_INIT;
 
        // Check if everything is initialized correctly
-       ASSERT(pakfire_digest_set(digests.sha512) == 0);
-       ASSERT(pakfire_digest_set(digests.sha256) == 0);
+       ASSERT(pakfire_digest_set(digests.sha2_512) == 0);
+       ASSERT(pakfire_digest_set(digests.sha2_256) == 0);
 
        return EXIT_SUCCESS;
 
@@ -68,13 +68,13 @@ static int test_random(const struct test* t) {
 
        // Compare the digests
        ASSERT_SUCCESS(pakfire_digests_compare(t->pakfire,
-               &digests, &expected_digests, PAKFIRE_DIGESTS_ALL));
+               &digests, &expected_digests, PAKFIRE_DIGEST_SHA2_512|PAKFIRE_DIGEST_SHA2_256));
 
        // Check if the individual digests match
        ASSERT_SUCCESS(pakfire_digests_compare_one(t->pakfire, &digests,
-               PAKFIRE_DIGEST_SHA512, expected_digests.sha512, sizeof(expected_digests.sha512)));
+               PAKFIRE_DIGEST_SHA2_512, expected_digests.sha2_512, sizeof(expected_digests.sha2_512)));
        ASSERT_SUCCESS(pakfire_digests_compare_one(t->pakfire, &digests,
-               PAKFIRE_DIGEST_SHA256, expected_digests.sha256, sizeof(expected_digests.sha256)));
+               PAKFIRE_DIGEST_SHA2_256, expected_digests.sha2_256, sizeof(expected_digests.sha2_256)));
 
        r = EXIT_SUCCESS;