Revert "Make some use of anonymous unions [pgcrypto]"

This reverts commit efcd5199d8cb8e5098f79b38d0c46004e69d1a46.

I rebased my patch series incorrectly.  This patch contained unrelated
parts from another patch, which made the overall build fail.  Revert
for now and reconsider.

diff --git a/contrib/pgcrypto/openssl.c b/contrib/pgcrypto/openssl.c
index 276d83065880314171fff5621f080bd913bdde51..f179e80c8429ec00bbbcd7feae298652f16f976a 100644 (file)
--- a/contrib/pgcrypto/openssl.c
+++ b/contrib/pgcrypto/openssl.c
@@ -98,7 +98,7 @@ free_openssl_digest(OSSLDigest *digest)
 static unsigned
 digest_result_size(PX_MD *h)
 {
-       OSSLDigest *digest = (OSSLDigest *) h->ptr;
+       OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
        int                     result = EVP_MD_CTX_size(digest->ctx);
 
        if (result < 0)
@@ -110,7 +110,7 @@ digest_result_size(PX_MD *h)
 static unsigned
 digest_block_size(PX_MD *h)
 {
-       OSSLDigest *digest = (OSSLDigest *) h->ptr;
+       OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
        int                     result = EVP_MD_CTX_block_size(digest->ctx);
 
        if (result < 0)
@@ -122,7 +122,7 @@ digest_block_size(PX_MD *h)
 static void
 digest_reset(PX_MD *h)
 {
-       OSSLDigest *digest = (OSSLDigest *) h->ptr;
+       OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
 
        if (!EVP_DigestInit_ex(digest->ctx, digest->algo, NULL))
                elog(ERROR, "EVP_DigestInit_ex() failed");
@@ -131,7 +131,7 @@ digest_reset(PX_MD *h)
 static void
 digest_update(PX_MD *h, const uint8 *data, unsigned dlen)
 {
-       OSSLDigest *digest = (OSSLDigest *) h->ptr;
+       OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
 
        if (!EVP_DigestUpdate(digest->ctx, data, dlen))
                elog(ERROR, "EVP_DigestUpdate() failed");
@@ -140,7 +140,7 @@ digest_update(PX_MD *h, const uint8 *data, unsigned dlen)
 static void
 digest_finish(PX_MD *h, uint8 *dst)
 {
-       OSSLDigest *digest = (OSSLDigest *) h->ptr;
+       OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
 
        if (!EVP_DigestFinal_ex(digest->ctx, dst, NULL))
                elog(ERROR, "EVP_DigestFinal_ex() failed");
@@ -149,7 +149,7 @@ digest_finish(PX_MD *h, uint8 *dst)
 static void
 digest_free(PX_MD *h)
 {
-       OSSLDigest *digest = (OSSLDigest *) h->ptr;
+       OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
 
        free_openssl_digest(digest);
        pfree(h);
@@ -204,7 +204,7 @@ px_find_digest(const char *name, PX_MD **res)
        h->update = digest_update;
        h->finish = digest_finish;
        h->free = digest_free;
-       h->ptr = digest;
+       h->p.ptr = digest;
 
        *res = h;
        return 0;

diff --git a/contrib/pgcrypto/px.h b/contrib/pgcrypto/px.h
index 7846a63f301847885818ec7689003af16988b682..4b81fceab8ec2948f7d9ec9834a665dd5735f38f 100644 (file)
--- a/contrib/pgcrypto/px.h
+++ b/contrib/pgcrypto/px.h
@@ -117,7 +117,7 @@ struct px_digest
        {
                unsigned        code;
                void       *ptr;
-       };
+       }                       p;
 };
 
 struct px_alias

diff --git a/src/common/cryptohash.c b/src/common/cryptohash.c
index fc0555d2f9937ce3784749e71fee83deba9e713a..533e4aaea36df92f8312f359c67641aaa5579bc0 100644 (file)
--- a/src/common/cryptohash.c
+++ b/src/common/cryptohash.c
@@ -105,22 +105,22 @@ pg_cryptohash_init(pg_cryptohash_ctx *ctx)
        switch (ctx->type)
        {
                case PG_MD5:
-                       pg_md5_init(&ctx->md5);
+                       pg_md5_init(&ctx->data.md5);
                        break;
                case PG_SHA1:
-                       pg_sha1_init(&ctx->sha1);
+                       pg_sha1_init(&ctx->data.sha1);
                        break;
                case PG_SHA224:
-                       pg_sha224_init(&ctx->sha224);
+                       pg_sha224_init(&ctx->data.sha224);
                        break;
                case PG_SHA256:
-                       pg_sha256_init(&ctx->sha256);
+                       pg_sha256_init(&ctx->data.sha256);
                        break;
                case PG_SHA384:
-                       pg_sha384_init(&ctx->sha384);
+                       pg_sha384_init(&ctx->data.sha384);
                        break;
                case PG_SHA512:
-                       pg_sha512_init(&ctx->sha512);
+                       pg_sha512_init(&ctx->data.sha512);
                        break;
        }
 
@@ -141,22 +141,22 @@ pg_cryptohash_update(pg_cryptohash_ctx *ctx, const uint8 *data, size_t len)
        switch (ctx->type)
        {
                case PG_MD5:
-                       pg_md5_update(&ctx->md5, data, len);
+                       pg_md5_update(&ctx->data.md5, data, len);
                        break;
                case PG_SHA1:
-                       pg_sha1_update(&ctx->sha1, data, len);
+                       pg_sha1_update(&ctx->data.sha1, data, len);
                        break;
                case PG_SHA224:
-                       pg_sha224_update(&ctx->sha224, data, len);
+                       pg_sha224_update(&ctx->data.sha224, data, len);
                        break;
                case PG_SHA256:
-                       pg_sha256_update(&ctx->sha256, data, len);
+                       pg_sha256_update(&ctx->data.sha256, data, len);
                        break;
                case PG_SHA384:
-                       pg_sha384_update(&ctx->sha384, data, len);
+                       pg_sha384_update(&ctx->data.sha384, data, len);
                        break;
                case PG_SHA512:
-                       pg_sha512_update(&ctx->sha512, data, len);
+                       pg_sha512_update(&ctx->data.sha512, data, len);
                        break;
        }
 
@@ -182,7 +182,7 @@ pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest, size_t len)
                                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                                return -1;
                        }
-                       pg_md5_final(&ctx->md5, dest);
+                       pg_md5_final(&ctx->data.md5, dest);
                        break;
                case PG_SHA1:
                        if (len < SHA1_DIGEST_LENGTH)
@@ -190,7 +190,7 @@ pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest, size_t len)
                                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                                return -1;
                        }
-                       pg_sha1_final(&ctx->sha1, dest);
+                       pg_sha1_final(&ctx->data.sha1, dest);
                        break;
                case PG_SHA224:
                        if (len < PG_SHA224_DIGEST_LENGTH)
@@ -198,7 +198,7 @@ pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest, size_t len)
                                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                                return -1;
                        }
-                       pg_sha224_final(&ctx->sha224, dest);
+                       pg_sha224_final(&ctx->data.sha224, dest);
                        break;
                case PG_SHA256:
                        if (len < PG_SHA256_DIGEST_LENGTH)
@@ -206,7 +206,7 @@ pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest, size_t len)
                                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                                return -1;
                        }
-                       pg_sha256_final(&ctx->sha256, dest);
+                       pg_sha256_final(&ctx->data.sha256, dest);
                        break;
                case PG_SHA384:
                        if (len < PG_SHA384_DIGEST_LENGTH)
@@ -214,7 +214,7 @@ pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest, size_t len)
                                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                                return -1;
                        }
-                       pg_sha384_final(&ctx->sha384, dest);
+                       pg_sha384_final(&ctx->data.sha384, dest);
                        break;
                case PG_SHA512:
                        if (len < PG_SHA512_DIGEST_LENGTH)
@@ -222,7 +222,7 @@ pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest, size_t len)
                                ctx->error = PG_CRYPTOHASH_ERROR_DEST_LEN;
                                return -1;
                        }
-                       pg_sha512_final(&ctx->sha512, dest);
+                       pg_sha512_final(&ctx->data.sha512, dest);
                        break;
        }