[RFC v5 088/126] Cryptography: introduce ERRP_AUTO_PROPAGATE

[Vladimir Sementsov-Ogievskiy]

If we want to add some info to errp (by error_prepend() or
error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro.
Otherwise, this info will not be added when errp == &fatal_err
(the program will exit prior to the error_append_hint() or
error_prepend() call).  Fix such cases.

If we want to check error after errp-function call, we need to
introduce local_err and than propagate it to errp. Instead, use
ERRP_AUTO_PROPAGATE macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or
   &error_fatel, this means that we don't break error_abort
   (we'll abort on error_set, not on error_propagate)

This commit (together with its neighbors) was generated by

for f in $(git grep -l errp \*.[ch]); do \
    spatch --sp-file scripts/coccinelle/auto-propagated-errp.cocci \
    --macro-file scripts/cocci-macro-file.h --in-place --no-show-diff $f; \
done;

then fix a bit of compilation problems: coccinelle for some reason
leaves several
f() {
    ...
    goto out;
    ...
    out:
}
patterns, with "out:" at function end.

then
./python/commit-per-subsystem.py MAINTAINERS "$(< auto-msg)"

(auto-msg was a file with this commit message)

Still, for backporting it may be more comfortable to use only the first
command and then do one huge commit.

Reported-by: Kevin Wolf <address@hidden>
Reported-by: Greg Kurz <address@hidden>
Signed-off-by: Vladimir Sementsov-Ogievskiy <address@hidden>
---
 crypto/block-luks.c | 56 +++++++++++++++++++--------------------------
 crypto/secret.c     | 17 ++++++--------
 crypto/tlssession.c |  7 +++---
 3 files changed, 33 insertions(+), 47 deletions(-)

diff --git a/crypto/block-luks.c b/crypto/block-luks.c
index 4861db810c..45c21c2fcc 100644
--- a/crypto/block-luks.c
+++ b/crypto/block-luks.c
@@ -442,8 +442,8 @@ qcrypto_block_luks_store_header(QCryptoBlock *block,
                                 void *opaque,
                                 Error **errp)
 {
+    ERRP_AUTO_PROPAGATE();
     const QCryptoBlockLUKS *luks = block->opaque;
-    Error *local_err = NULL;
     size_t i;
     g_autofree QCryptoBlockLUKSHeader *hdr_copy = NULL;
 
@@ -469,10 +469,9 @@ qcrypto_block_luks_store_header(QCryptoBlock *block,
 
     /* Write out the partition header and key slot headers */
     writefunc(block, 0, (const uint8_t *)hdr_copy, sizeof(*hdr_copy),
-              opaque, &local_err);
+              opaque, errp);
 
-    if (local_err) {
-        error_propagate(errp, local_err);
+    if (*errp) {
         return -1;
     }
     return 0;
@@ -603,9 +602,9 @@ qcrypto_block_luks_check_header(const QCryptoBlockLUKS 
*luks, Error **errp)
 static int
 qcrypto_block_luks_parse_header(QCryptoBlockLUKS *luks, Error **errp)
 {
+    ERRP_AUTO_PROPAGATE();
     g_autofree char *cipher_mode = g_strdup(luks->header.cipher_mode);
     char *ivgen_name, *ivhash_name;
-    Error *local_err = NULL;
 
     /*
      * The cipher_mode header contains a string that we have
@@ -632,17 +631,15 @@ qcrypto_block_luks_parse_header(QCryptoBlockLUKS *luks, 
Error **errp)
         ivhash_name++;
 
         luks->ivgen_hash_alg = qcrypto_block_luks_hash_name_lookup(ivhash_name,
-                                                                   &local_err);
-        if (local_err) {
-            error_propagate(errp, local_err);
+                                                                   errp);
+        if (*errp) {
             return -1;
         }
     }
 
     luks->cipher_mode = qcrypto_block_luks_cipher_mode_lookup(cipher_mode,
-                                                              &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
+                                                              errp);
+    if (*errp) {
         return -1;
     }
 
@@ -650,24 +647,21 @@ qcrypto_block_luks_parse_header(QCryptoBlockLUKS *luks, 
Error **errp)
             qcrypto_block_luks_cipher_name_lookup(luks->header.cipher_name,
                                                   luks->cipher_mode,
                                                   luks->header.master_key_len,
-                                                  &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
+                                                  errp);
+    if (*errp) {
         return -1;
     }
 
     luks->hash_alg =
             qcrypto_block_luks_hash_name_lookup(luks->header.hash_spec,
-                                                &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
+                                                errp);
+    if (*errp) {
         return -1;
     }
 
     luks->ivgen_alg = qcrypto_block_luks_ivgen_name_lookup(ivgen_name,
-                                                           &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
+                                                           errp);
+    if (*errp) {
         return -1;
     }
 
@@ -679,9 +673,8 @@ qcrypto_block_luks_parse_header(QCryptoBlockLUKS *luks, 
Error **errp)
         luks->ivgen_cipher_alg =
                 qcrypto_block_luks_essiv_cipher(luks->cipher_alg,
                                                 luks->ivgen_hash_alg,
-                                                &local_err);
-        if (local_err) {
-            error_propagate(errp, local_err);
+                                                errp);
+        if (*errp) {
             return -1;
         }
     } else {
@@ -1186,9 +1179,9 @@ qcrypto_block_luks_create(QCryptoBlock *block,
                           void *opaque,
                           Error **errp)
 {
+    ERRP_AUTO_PROPAGATE();
     QCryptoBlockLUKS *luks;
     QCryptoBlockCreateOptionsLUKS luks_opts;
-    Error *local_err = NULL;
     g_autofree uint8_t *masterkey = NULL;
     size_t header_sectors;
     size_t split_key_sectors;
@@ -1298,9 +1291,8 @@ qcrypto_block_luks_create(QCryptoBlock *block,
         luks->ivgen_cipher_alg =
                 qcrypto_block_luks_essiv_cipher(luks_opts.cipher_alg,
                                                 luks_opts.ivgen_hash_alg,
-                                                &local_err);
-        if (local_err) {
-            error_propagate(errp, local_err);
+                                                errp);
+        if (*errp) {
             goto error;
         }
     } else {
@@ -1364,9 +1356,8 @@ qcrypto_block_luks_create(QCryptoBlock *block,
                                        luks->header.master_key_salt,
                                        QCRYPTO_BLOCK_LUKS_SALT_LEN,
                                        QCRYPTO_BLOCK_LUKS_DIGEST_LEN,
-                                       &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
+                                       errp);
+    if (*errp) {
         goto error;
     }
 
@@ -1439,9 +1430,8 @@ qcrypto_block_luks_create(QCryptoBlock *block,
         block->sector_size;
 
     /* Reserve header space to match payload offset */
-    initfunc(block, block->payload_offset, opaque, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
+    initfunc(block, block->payload_offset, opaque, errp);
+    if (*errp) {
         goto error;
     }
 
diff --git a/crypto/secret.c b/crypto/secret.c
index 1cf0ad0ce8..962d2c1d44 100644
--- a/crypto/secret.c
+++ b/crypto/secret.c
@@ -178,27 +178,25 @@ qcrypto_secret_prop_set_loaded(Object *obj,
                                bool value,
                                Error **errp)
 {
+    ERRP_AUTO_PROPAGATE();
     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 
     if (value) {
-        Error *local_err = NULL;
         uint8_t *input = NULL;
         size_t inputlen = 0;
         uint8_t *output = NULL;
         size_t outputlen = 0;
 
-        qcrypto_secret_load_data(secret, &input, &inputlen, &local_err);
-        if (local_err) {
-            error_propagate(errp, local_err);
+        qcrypto_secret_load_data(secret, &input, &inputlen, errp);
+        if (*errp) {
             return;
         }
 
         if (secret->keyid) {
             qcrypto_secret_decrypt(secret, input, inputlen,
-                                   &output, &outputlen, &local_err);
+                                   &output, &outputlen, errp);
             g_free(input);
-            if (local_err) {
-                error_propagate(errp, local_err);
+            if (*errp) {
                 return;
             }
             input = output;
@@ -206,10 +204,9 @@ qcrypto_secret_prop_set_loaded(Object *obj,
         } else {
             if (secret->format != QCRYPTO_SECRET_FORMAT_RAW) {
                 qcrypto_secret_decode(input, inputlen,
-                                      &output, &outputlen, &local_err);
+                                      &output, &outputlen, errp);
                 g_free(input);
-                if (local_err) {
-                    error_propagate(errp, local_err);
+                if (*errp) {
                     return;
                 }
                 input = output;
diff --git a/crypto/tlssession.c b/crypto/tlssession.c
index 33203e8ca7..abb3912304 100644
--- a/crypto/tlssession.c
+++ b/crypto/tlssession.c
@@ -256,13 +256,13 @@ static int
 qcrypto_tls_session_check_certificate(QCryptoTLSSession *session,
                                       Error **errp)
 {
+    ERRP_AUTO_PROPAGATE();
     int ret;
     unsigned int status;
     const gnutls_datum_t *certs;
     unsigned int nCerts, i;
     time_t now;
     gnutls_x509_crt_t cert = NULL;
-    Error *err = NULL;
 
     now = time(NULL);
     if (now == ((time_t)-1)) {
@@ -354,9 +354,8 @@ qcrypto_tls_session_check_certificate(QCryptoTLSSession 
*session,
                 bool allow;
 
                 allow = qauthz_is_allowed_by_id(session->authzid,
-                                                session->peername, &err);
-                if (err) {
-                    error_propagate(errp, err);
+                                                session->peername, errp);
+                if (*errp) {
                     goto error;
                 }
                 if (!allow) {
-- 
2.21.0