Following the license change, modify the boilerplates in crypto/blake2/

[openssl.git] / crypto / blake2 / blake2_impl.h

diff --git a/crypto/blake2/blake2_impl.h b/crypto/blake2/blake2_impl.h
index bd02de9ad2ac52f6637c479782427b086ca7115f..52477a8fe260fbf3adf260c15820bc8ba3ca9500 100644 (file)
--- a/crypto/blake2/blake2_impl.h
+++ b/crypto/blake2/blake2_impl.h
@@ -1,24 +1,22 @@
 /*
- * Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.
- * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
  *
- * Licensed under the OpenSSL licenses, (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
  * https://www.openssl.org/source/license.html
- * or in the file LICENSE in the source distribution.
  */
 
 /*
  * Derived from the BLAKE2 reference implementation written by Samuel Neves.
+ * Copyright 2012, Samuel Neves <sneves@dei.uc.pt>
  * More information about the BLAKE2 hash function and its implementations
  * can be found at https://blake2.net.
  */
 
 #include <string.h>
-#include "e_os.h"
 
-static ossl_inline uint32_t load32(const void *src)
+static ossl_inline uint32_t load32(const uint8_t *src)
 {
     const union {
         long one;
@@ -30,16 +28,15 @@ static ossl_inline uint32_t load32(const void *src)
         memcpy(&w, src, sizeof(w));
         return w;
     } else {
-        const uint8_t *p = (const uint8_t *)src;
-        uint32_t w = *p++;
-        w |= (uint32_t)(*p++) <<  8;
-        w |= (uint32_t)(*p++) << 16;
-        w |= (uint32_t)(*p++) << 24;
+        uint32_t w = ((uint32_t)src[0])
+                   | ((uint32_t)src[1] <<  8)
+                   | ((uint32_t)src[2] << 16)
+                   | ((uint32_t)src[3] << 24);
         return w;
     }
 }
 
-static ossl_inline uint64_t load64(const void *src)
+static ossl_inline uint64_t load64(const uint8_t *src)
 {
     const union {
         long one;
@@ -51,20 +48,19 @@ static ossl_inline uint64_t load64(const void *src)
         memcpy(&w, src, sizeof(w));
         return w;
     } else {
-        const uint8_t *p = (const uint8_t *)src;
-        uint64_t w = *p++;
-        w |= (uint64_t)(*p++) <<  8;
-        w |= (uint64_t)(*p++) << 16;
-        w |= (uint64_t)(*p++) << 24;
-        w |= (uint64_t)(*p++) << 32;
-        w |= (uint64_t)(*p++) << 40;
-        w |= (uint64_t)(*p++) << 48;
-        w |= (uint64_t)(*p++) << 56;
+        uint64_t w = ((uint64_t)src[0])
+                   | ((uint64_t)src[1] <<  8)
+                   | ((uint64_t)src[2] << 16)
+                   | ((uint64_t)src[3] << 24)
+                   | ((uint64_t)src[4] << 32)
+                   | ((uint64_t)src[5] << 40)
+                   | ((uint64_t)src[6] << 48)
+                   | ((uint64_t)src[7] << 56);
         return w;
     }
 }
 
-static ossl_inline void store32(void *dst, uint32_t w)
+static ossl_inline void store32(uint8_t *dst, uint32_t w)
 {
     const union {
         long one;
@@ -82,7 +78,7 @@ static ossl_inline void store32(void *dst, uint32_t w)
     }
 }
 
-static ossl_inline void store64(void *dst, uint64_t w)
+static ossl_inline void store64(uint8_t *dst, uint64_t w)
 {
     const union {
         long one;
@@ -100,40 +96,34 @@ static ossl_inline void store64(void *dst, uint64_t w)
     }
 }
 
-static ossl_inline uint64_t load48(const void *src)
+static ossl_inline uint64_t load48(const uint8_t *src)
 {
-    const uint8_t *p = (const uint8_t *)src;
-    uint64_t w = *p++;
-    w |= (uint64_t)(*p++) <<  8;
-    w |= (uint64_t)(*p++) << 16;
-    w |= (uint64_t)(*p++) << 24;
-    w |= (uint64_t)(*p++) << 32;
-    w |= (uint64_t)(*p++) << 40;
+    uint64_t w = ((uint64_t)src[0])
+               | ((uint64_t)src[1] <<  8)
+               | ((uint64_t)src[2] << 16)
+               | ((uint64_t)src[3] << 24)
+               | ((uint64_t)src[4] << 32)
+               | ((uint64_t)src[5] << 40);
     return w;
 }
 
-static ossl_inline void store48(void *dst, uint64_t w)
+static ossl_inline void store48(uint8_t *dst, uint64_t w)
 {
     uint8_t *p = (uint8_t *)dst;
-    *p++ = (uint8_t)w;
-    w >>= 8;
-    *p++ = (uint8_t)w;
-    w >>= 8;
-    *p++ = (uint8_t)w;
-    w >>= 8;
-    *p++ = (uint8_t)w;
-    w >>= 8;
-    *p++ = (uint8_t)w;
-    w >>= 8;
-    *p++ = (uint8_t)w;
+    p[0] = (uint8_t)w;
+    p[1] = (uint8_t)(w>>8);
+    p[2] = (uint8_t)(w>>16);
+    p[3] = (uint8_t)(w>>24);
+    p[4] = (uint8_t)(w>>32);
+    p[5] = (uint8_t)(w>>40);
 }
 
-static ossl_inline uint32_t rotr32(const uint32_t w, const unsigned c)
+static ossl_inline uint32_t rotr32(const uint32_t w, const unsigned int c)
 {
     return (w >> c) | (w << (32 - c));
 }
 
-static ossl_inline uint64_t rotr64(const uint64_t w, const unsigned c)
+static ossl_inline uint64_t rotr64(const uint64_t w, const unsigned int c)
 {
     return (w >> c) | (w << (64 - c));
 }