Remove damned ancient DOS line endings from Irrlicht. Hopefully I did not go overboard.

1 files changed, 142 insertions, 142 deletions

diff --git a/libraries/irrlicht-1.8/source/Irrlicht/aesGladman/hmac.cpp b/libraries/irrlicht-1.8/source/Irrlicht/aesGladman/hmac.cpp
index b24294d..147afa2 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/aesGladman/hmac.cpp
+++ b/libraries/irrlicht-1.8/source/Irrlicht/aesGladman/hmac.cpp
@@ -1,142 +1,142 @@
-/*

- ---------------------------------------------------------------------------

- Copyright (c) 2002, Dr Brian Gladman <                 >, Worcester, UK.

- All rights reserved.

-

- LICENSE TERMS

-

- The free distribution and use of this software in both source and binary

- form is allowed (with or without changes) provided that:

-

-   1. distributions of this source code include the above copyright

-      notice, this list of conditions and the following disclaimer;

-

-   2. distributions in binary form include the above copyright

-      notice, this list of conditions and the following disclaimer

-      in the documentation and/or other associated materials;

-

-   3. the copyright holder's name is not used to endorse products

-      built using this software without specific written permission.

-

- ALTERNATIVELY, provided that this notice is retained in full, this product

- may be distributed under the terms of the GNU General Public License (GPL),

- in which case the provisions of the GPL apply INSTEAD OF those given above.

-

- DISCLAIMER

-

- This software is provided 'as is' with no explicit or implied warranties

- in respect of its properties, including, but not limited to, correctness

- and/or fitness for purpose.

- ---------------------------------------------------------------------------

- Issue Date: 26/08/2003

- Includes a bugfix from Dr Brian Gladman made on 16/04/2012 for compiling on 64-bit

-

- This is an implementation of HMAC, the FIPS standard keyed hash function

-*/

-

-

-#include "hmac.h"

-

-#define HMAC_IPAD (0x36 * (((unsigned long)-1) / 0xff))

-#define HMAC_OPAD (0x5c * (((unsigned long)-1) / 0xff))

-

-/* initialise the HMAC context to zero */

-void hmac_sha_begin(hmac_ctx cx[1])

-{

-    memset(cx, 0, sizeof(hmac_ctx));

-}

-

-/* input the HMAC key (can be called multiple times)    */

-int hmac_sha_key(const unsigned char key[], unsigned long key_len, hmac_ctx cx[1])

-{

-    if(cx->klen == HMAC_IN_DATA)                /* error if further key input   */

-        return HMAC_BAD_MODE;                   /* is attempted in data mode    */

-

-    if(cx->klen + key_len > HMAC_HASH_INPUT_SIZE)    /* if the key has to be hashed  */

-    {

-        if(cx->klen <= HMAC_HASH_INPUT_SIZE)         /* if the hash has not yet been */

-        {                                       /* started, initialise it and   */

-            sha_begin(cx->ctx);                /* hash stored key characters   */

-            sha_hash(cx->key, cx->klen, cx->ctx);

-        }

-

-        sha_hash(key, key_len, cx->ctx);       /* hash long key data into hash */

-    }

-    else                                        /* otherwise store key data     */

-        memcpy(cx->key + cx->klen, key, key_len);

-

-    cx->klen += key_len;                        /* update the key length count  */

-    return HMAC_OK;

-}

-

-/* input the HMAC data (can be called multiple times) - */

-/* note that this call terminates the key input phase   */

-void hmac_sha_data(const unsigned char data[], unsigned long data_len, hmac_ctx cx[1])

-{   unsigned int i;

-

-    if(cx->klen != HMAC_IN_DATA)                /* if not yet in data phase */

-    {

-        if(cx->klen > HMAC_HASH_INPUT_SIZE)          /* if key is being hashed   */

-        {                                       /* complete the hash and    */

-            sha_end(cx->key, cx->ctx);         /* store the result as the  */

-            cx->klen = HMAC_HASH_OUTPUT_SIZE;        /* key and set new length   */

-        }

-

-        /* pad the key if necessary */

-        memset(cx->key + cx->klen, 0, HMAC_HASH_INPUT_SIZE - cx->klen);

-

-        /* xor ipad into key value  */

-        for(i = 0; i < HMAC_HASH_INPUT_SIZE / sizeof(unsigned long); ++i)

-            ((unsigned long*)cx->key)[i] ^= HMAC_IPAD;

-

-        /* and start hash operation */

-        sha_begin(cx->ctx);

-        sha_hash(cx->key, HMAC_HASH_INPUT_SIZE, cx->ctx);

-

-        /* mark as now in data mode */

-        cx->klen = HMAC_IN_DATA;

-    }

-

-    /* hash the data (if any)       */

-    if(data_len)

-        sha_hash(data, data_len, cx->ctx);

-}

-

-/* compute and output the MAC value */

-void hmac_sha_end(unsigned char mac[], unsigned long mac_len, hmac_ctx cx[1])

-{   unsigned char dig[HMAC_HASH_OUTPUT_SIZE];

-    unsigned int i;

-

-    /* if no data has been entered perform a null data phase        */

-    if(cx->klen != HMAC_IN_DATA)

-        hmac_sha_data((const unsigned char*)0, 0, cx);

-

-    sha_end(dig, cx->ctx);         /* complete the inner hash      */

-

-    /* set outer key value using opad and removing ipad */

-    for(i = 0; i < HMAC_HASH_INPUT_SIZE / sizeof(unsigned long); ++i)

-        ((unsigned long*)cx->key)[i] ^= HMAC_OPAD ^ HMAC_IPAD;

-

-    /* perform the outer hash operation */

-    sha_begin(cx->ctx);

-    sha_hash(cx->key, HMAC_HASH_INPUT_SIZE, cx->ctx);

-    sha_hash(dig, HMAC_HASH_OUTPUT_SIZE, cx->ctx);

-    sha_end(dig, cx->ctx);

-

-    /* output the hash value            */

-    for(i = 0; i < mac_len; ++i)

-        mac[i] = dig[i];

-}

-

-/* 'do it all in one go' subroutine     */

-void hmac_sha(const unsigned char key[], unsigned long key_len,

-          const unsigned char data[], unsigned long data_len,

-          unsigned char mac[], unsigned long mac_len)

-{   hmac_ctx    cx[1];

-

-    hmac_sha_begin(cx);

-    hmac_sha_key(key, key_len, cx);

-    hmac_sha_data(data, data_len, cx);

-    hmac_sha_end(mac, mac_len, cx);

-}

-

+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 2002, Dr Brian Gladman <                 >, Worcester, UK.
+ All rights reserved.
+
+ LICENSE TERMS
+
+ The free distribution and use of this software in both source and binary
+ form is allowed (with or without changes) provided that:
+
+   1. distributions of this source code include the above copyright
+      notice, this list of conditions and the following disclaimer;
+
+   2. distributions in binary form include the above copyright
+      notice, this list of conditions and the following disclaimer
+      in the documentation and/or other associated materials;
+
+   3. the copyright holder's name is not used to endorse products
+      built using this software without specific written permission.
+
+ ALTERNATIVELY, provided that this notice is retained in full, this product
+ may be distributed under the terms of the GNU General Public License (GPL),
+ in which case the provisions of the GPL apply INSTEAD OF those given above.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 26/08/2003
+ Includes a bugfix from Dr Brian Gladman made on 16/04/2012 for compiling on 64-bit
+
+ This is an implementation of HMAC, the FIPS standard keyed hash function
+*/
+
+
+#include "hmac.h"
+
+#define HMAC_IPAD (0x36 * (((unsigned long)-1) / 0xff))
+#define HMAC_OPAD (0x5c * (((unsigned long)-1) / 0xff))
+
+/* initialise the HMAC context to zero */
+void hmac_sha_begin(hmac_ctx cx[1])
+{
+    memset(cx, 0, sizeof(hmac_ctx));
+}
+
+/* input the HMAC key (can be called multiple times)    */
+int hmac_sha_key(const unsigned char key[], unsigned long key_len, hmac_ctx cx[1])
+{
+    if(cx->klen == HMAC_IN_DATA)                /* error if further key input   */
+        return HMAC_BAD_MODE;                   /* is attempted in data mode    */
+
+    if(cx->klen + key_len > HMAC_HASH_INPUT_SIZE)    /* if the key has to be hashed  */
+    {
+        if(cx->klen <= HMAC_HASH_INPUT_SIZE)         /* if the hash has not yet been */
+        {                                       /* started, initialise it and   */
+            sha_begin(cx->ctx);                /* hash stored key characters   */
+            sha_hash(cx->key, cx->klen, cx->ctx);
+        }
+
+        sha_hash(key, key_len, cx->ctx);       /* hash long key data into hash */
+    }
+    else                                        /* otherwise store key data     */
+        memcpy(cx->key + cx->klen, key, key_len);
+
+    cx->klen += key_len;                        /* update the key length count  */
+    return HMAC_OK;
+}
+
+/* input the HMAC data (can be called multiple times) - */
+/* note that this call terminates the key input phase   */
+void hmac_sha_data(const unsigned char data[], unsigned long data_len, hmac_ctx cx[1])
+{   unsigned int i;
+
+    if(cx->klen != HMAC_IN_DATA)                /* if not yet in data phase */
+    {
+        if(cx->klen > HMAC_HASH_INPUT_SIZE)          /* if key is being hashed   */
+        {                                       /* complete the hash and    */
+            sha_end(cx->key, cx->ctx);         /* store the result as the  */
+            cx->klen = HMAC_HASH_OUTPUT_SIZE;        /* key and set new length   */
+        }
+
+        /* pad the key if necessary */
+        memset(cx->key + cx->klen, 0, HMAC_HASH_INPUT_SIZE - cx->klen);
+
+        /* xor ipad into key value  */
+        for(i = 0; i < HMAC_HASH_INPUT_SIZE / sizeof(unsigned long); ++i)
+            ((unsigned long*)cx->key)[i] ^= HMAC_IPAD;
+
+        /* and start hash operation */
+        sha_begin(cx->ctx);
+        sha_hash(cx->key, HMAC_HASH_INPUT_SIZE, cx->ctx);
+
+        /* mark as now in data mode */
+        cx->klen = HMAC_IN_DATA;
+    }
+
+    /* hash the data (if any)       */
+    if(data_len)
+        sha_hash(data, data_len, cx->ctx);
+}
+
+/* compute and output the MAC value */
+void hmac_sha_end(unsigned char mac[], unsigned long mac_len, hmac_ctx cx[1])
+{   unsigned char dig[HMAC_HASH_OUTPUT_SIZE];
+    unsigned int i;
+
+    /* if no data has been entered perform a null data phase        */
+    if(cx->klen != HMAC_IN_DATA)
+        hmac_sha_data((const unsigned char*)0, 0, cx);
+
+    sha_end(dig, cx->ctx);         /* complete the inner hash      */
+
+    /* set outer key value using opad and removing ipad */
+    for(i = 0; i < HMAC_HASH_INPUT_SIZE / sizeof(unsigned long); ++i)
+        ((unsigned long*)cx->key)[i] ^= HMAC_OPAD ^ HMAC_IPAD;
+
+    /* perform the outer hash operation */
+    sha_begin(cx->ctx);
+    sha_hash(cx->key, HMAC_HASH_INPUT_SIZE, cx->ctx);
+    sha_hash(dig, HMAC_HASH_OUTPUT_SIZE, cx->ctx);
+    sha_end(dig, cx->ctx);
+
+    /* output the hash value            */
+    for(i = 0; i < mac_len; ++i)
+        mac[i] = dig[i];
+}
+
+/* 'do it all in one go' subroutine     */
+void hmac_sha(const unsigned char key[], unsigned long key_len,
+          const unsigned char data[], unsigned long data_len,
+          unsigned char mac[], unsigned long mac_len)
+{   hmac_ctx    cx[1];
+
+    hmac_sha_begin(cx);
+    hmac_sha_key(key, key_len, cx);
+    hmac_sha_data(data, data_len, cx);
+    hmac_sha_end(mac, mac_len, cx);
+}
+