@zerodensity/smb-cpp 0.0.0-bootstrap.0 → 0.1.0

package/win32_x64/third-party/libsmb2/source/lib/timestamps.c

@@ -0,0 +1,70 @@
+/* -*-  mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil;  -*- */
+/*
+   Copyright (C) 2016 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation; either version 2.1 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#ifdef STDC_HEADERS
+#include <stddef.h>
+#endif
+
+#include "compat.h"
+
+#include "portable-endian.h"
+
+#include <smb2.h>
+#include <libsmb2.h>
+#include "libsmb2-private.h"
+
+uint64_t
+smb2_timeval_to_win(struct smb2_timeval *tv)
+{
+        return ((uint64_t)tv->tv_sec * 10000000) +
+                116444736000000000 + tv->tv_usec * 10;
+}
+
+void
+smb2_win_to_timeval(uint64_t smb2_time, struct smb2_timeval *tv)
+{
+        tv->tv_usec = (smb2_time / 10) % 1000000;
+        tv->tv_sec  = (smb2_time - 116444736000000000) / 10000000;
+}

package/win32_x64/third-party/libsmb2/source/lib/unicode.c

@@ -0,0 +1,307 @@
+/* -*-  mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil;  -*- */
+/*
+   Copyright (C) 2016 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation; either version 2.1 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#ifdef STDC_HEADERS
+#include <stddef.h>
+#endif
+
+#include "compat.h"
+
+#include "portable-endian.h"
+
+#include <smb2.h>
+#include <libsmb2.h>
+#include "libsmb2-private.h"
+
+/* Count number of leading 1 bits in the char */
+static int
+l1(char c)
+{
+        int i = 0;
+        while (c & 0x80) {
+                i++;
+                c <<= 1;
+        }
+        return i;
+}
+
+/* Validates that utf8 points to a valid utf8 codepoint.
+ * Will update **utf8 to point at the next character in the string.
+ * return 1 if the encoding is valid and requires one UTF-16 code unit,
+ * 2 if the encoding is valid and requires two UTF-16 code units
+ * -1 if it's invalid.
+ * If the encoding is valid the codepoint will be returned in *cp.
+ */
+static int
+validate_utf8_cp(const char **utf8, uint16_t *ret)
+{
+        int c = *(*utf8)++;
+        int l, l_tmp;
+        uint32_t cp;
+        l = l_tmp = l1(c);
+ 
+        switch (l) {
+        case 0:
+                /* 7-bit ascii is always ok */
+                *ret = c & 0x7f;
+                return 1;
+        case 1:
+                /* 10.. .... can never start a new codepoint */
+                return -1;
+        case 2:
+        case 3:
+        case 4:
+                cp = c & (0x7f >> l);
+                /* 2, 3 and 4 byte sequences must always be followed by exactly
+                 * 1, 2 or 3 chars matching 10.. ....
+                 */
+                while(--l_tmp) {
+                        c = *(*utf8)++;
+                        if (l1(c) != 1) {
+                                return -1;
+                        }
+                        cp <<= 6;
+                        cp |= (c & 0x3f);
+                }
+
+                /* Check for overlong sequences */
+                switch (l) {
+                case 2:
+                        if (cp < 0x80) return -1;
+                        break;
+                case 3:
+                        if (cp < 0x800) return -1;
+                        break;
+                case 4:
+                        if (cp < 0x10000) return -1;
+                        break;
+                default: break;
+                }
+
+                /* Write the code point in either one or two UTC-16 code units */
+                if (cp < 0xd800 || (cp - 0xe000) < 0x2000) {
+                        /* Single UTF-16 code unit */
+                        *ret = cp;
+                        return 1;
+                } else if (cp < 0xe000) {
+                        /* invalid unicode range */
+                        return -1;
+                } else if (cp < 0x110000) {
+                        cp -= 0x10000;
+                        *ret = 0xd800 | (cp >> 10);
+                        *(ret+1) = 0xdc00 | (cp & 0x3ff) ;
+                        return 2;
+                } else {
+                        /* invalid unicode range */
+                        return -1;
+                }
+        }
+        return -1;
+}
+
+/* Validate that the given string is properly formatted UTF8.
+ * Returns >=0 if valid UTF8 and -1 if not.
+ */
+static int
+validate_utf8_str(const char *utf8)
+{
+        const char *u = utf8;
+        int i = 0;
+        int cp_length;
+        uint16_t cp[2];
+
+        while (*u) {
+                cp_length = validate_utf8_cp(&u, cp);
+                if (cp_length < 0) {
+                        return -1;
+                }
+                i += cp_length;
+        }
+        return i;
+}
+
+/* Convert a UTF8 string into UTF-16LE */
+struct smb2_utf16 *
+smb2_utf8_to_utf16(const char *utf8)
+{
+        struct smb2_utf16 *utf16;
+        int i, len;
+
+        len = validate_utf8_str(utf8);
+        if (len < 0) {
+                return NULL;
+        }
+
+        utf16 = (struct smb2_utf16 *)(malloc(offsetof(struct smb2_utf16, val) + 2 * len));
+        if (utf16 == NULL) {
+                return NULL;
+        }
+
+        utf16->len = len;
+        i = 0;
+        while (i < len) {
+                switch(validate_utf8_cp(&utf8, &utf16->val[i])) {
+                case 1:
+                    utf16->val[i] = htole16(utf16->val[i]);
+                    i += 1;
+                    break;
+                case 2:
+                    utf16->val[i] = htole16(utf16->val[i]);
+                    utf16->val[i+1] = htole16(utf16->val[i+1]);
+                    i += 2;
+                    break;
+                default:
+                    /* Won't happen since we wouldn't have gotten here if the UTF-8 string was invalid */
+                    break;
+                }
+        }
+
+        return utf16;
+}
+
+static int
+utf16_size(const uint16_t *utf16, size_t utf16_len)
+{
+        int length = 0;
+        const uint16_t *utf16_end = utf16 + utf16_len;
+        while (utf16 < utf16_end) {
+                uint32_t code = le16toh(*utf16++);
+
+                if (code < 0x80) {
+                        length += 1; /* One UTF-16 code unit maps to one UTF-8 code unit */
+                } else if (code < 0x800) {
+                        length += 2; /* One UTF-16 code unit maps to two UTF-8 code units */
+                } else if (code < 0xd800 || code - 0xe000 < 0x2000) {
+                        length += 3;
+                } else if (code < 0xdc00) { /* Surrogate pair */
+                        uint32_t trail;
+                        if (utf16 == utf16_end) { /* It's possible the stream ends with a leading code unit, which is an error */
+                                return length + 3; /* Replacement char */
+                        }
+
+                        trail = le16toh(*utf16);
+                        if (trail - 0xdc00 < 0x400) { /* Check that 0xdc00 <= trail < 0xe000 */
+                                code = 0x10000 + ((code & 0x3ff) << 10) + (trail & 0x3ff);
+                                if (code < 0x10000) {
+                                        length += 3; /* Two UTF-16 code units map to three UTF-8 code units */
+                                } else {
+                                        length += 4; /* Two UTF-16 code units map to four UTF-8 code units */
+                                }
+                                utf16++;
+                        } else { /* Invalid trailing code unit. It's still valid on its own though so only the first unit gets replaced */
+                                length += 3; /* Replacement char */
+                        }
+                } else { /* 0xdc00 <= code < 0xe00, which makes code a trailing code unit without a leading one, which is invalid */
+                        length += 3; /* Replacement char */
+                }
+        }
+
+        return length;
+}
+
+/*
+ * Convert a UTF-16LE string into UTF8
+ */
+const char *
+smb2_utf16_to_utf8(const uint16_t *utf16, size_t utf16_len)
+{
+        int utf8_len = 1;
+        char *str, *tmp;
+        const uint16_t *utf16_end;
+        
+        /* How many bytes do we need for utf8 ? */
+        utf8_len += utf16_size(utf16, utf16_len);
+        str = tmp = (char*)malloc(utf8_len);
+        if (str == NULL) {
+                return NULL;
+        }
+        str[utf8_len - 1] = 0;
+
+        utf16_end = utf16 + utf16_len;
+        while (utf16 < utf16_end) {
+                uint32_t code = le16toh(*utf16++);
+
+                if (code < 0x80) {
+                        *tmp++ = code; /* One UTF-16 code unit maps to one UTF-8 code unit */
+                } else if (code < 0x800) {
+                        *tmp++ = 0xc0 |  (code >> 6);         /* One UTF-16 code unit maps to two UTF-8 code units */
+                        *tmp++ = 0x80 | ((code     ) & 0x3f);
+                } else if (code < 0xD800 || code - 0xe000 < 0x2000) {
+                        *tmp++ = 0xe0 |  (code >> 12);         /* All other values where we only have one UTF-16 code unit map to 3 UTF-8 code units */
+                        *tmp++ = 0x80 | ((code >>  6) & 0x3f);
+                        *tmp++ = 0x80 | ((code      ) & 0x3f);
+                } else if (code < 0xdc00) { /* Surrogate pair */
+                        uint32_t trail;
+                        if (utf16 == utf16_end) { /* It's possible the stream ends with a leading code unit, which is an error */
+                                *tmp++ = 0xef; *tmp++ = 0xbf; *tmp++ = 0xbd; /* Replacement char */
+                                return str;
+                        }
+
+                        trail = le16toh(*utf16);
+                        if (trail - 0xdc00 < 0x400) { /* Check that 0xdc00 <= trail < 0xe000 */
+                                code = 0x10000 + ((code & 0x3ff) << 10) + (trail & 0x3ff);
+                                if (code < 0x10000) {
+                                        *tmp++ = 0xe0 |  (code >> 12);
+                                        *tmp++ = 0x80 | ((code >>  6) & 0x3f);
+                                        *tmp++ = 0x80 | ((code      ) & 0x3f);
+                                } else {
+                                        *tmp++ = 0xF0 | (code >> 18);
+                                        *tmp++ = 0x80 | ((code >> 12) & 0x3F);
+                                        *tmp++ = 0x80 | ((code >> 6) & 0x3F);
+                                        *tmp++ = 0x80 | (code & 0x3F);
+                                }
+                                utf16++;
+                        } else {
+                                /* Invalid trailing code unit. It's still valid on its own though so only the first unit gets replaced */
+                                *tmp++ = 0xef; *tmp++ = 0xbf; *tmp++ = 0xbd; /* Replacement char */
+                        }
+                } else {
+                        /* 0xdc00 <= code < 0xe00, which makes code a trailing code unit without a leading one, which is invalid */
+                        *tmp++ = 0xef; *tmp++ = 0xbf; *tmp++ = 0xbd; /* Replacement char */
+                }
+        }
+
+        return str;
+}

package/win32_x64/third-party/libsmb2/source/lib/usha.c

@@ -0,0 +1,345 @@
+/**************************** usha.c ****************************/
+/******************** See RFC 4634 for details ******************/
+/*
+ *  Description:
+ *     This file implements a unified interface to the SHA algorithms.
+ */
+
+#include "compat.h"
+
+#include "sha.h"
+
+/*
+ *  USHAReset
+ *
+ *  Description:
+ *      This function will initialize the SHA Context in preparation
+ *      for computing a new SHA message digest.
+ *
+ *  Parameters:
+ *      context: [in/out]
+ *          The context to reset.
+ *      whichSha: [in]
+ *          Selects which SHA reset to call
+ *
+ *  Returns:
+ *      sha Error Code.
+ *
+ */
+int
+USHAReset (USHAContext * ctx, enum SHAversion whichSha)
+{
+  if (ctx)
+    {
+      ctx->whichSha = whichSha;
+      switch (whichSha)
+	{
+#if defined(USE_SHA1) && USE_SHA1
+	case SHA1:
+	  return SHA1Reset ((SHA1Context *) & ctx->ctx);
+#endif
+#if defined(USE_SHA224) && USE_SHA224
+	case SHA224:
+	  return SHA224Reset ((SHA224Context *) & ctx->ctx);
+#endif
+	case SHA256:
+	  return SHA256Reset ((SHA256Context *) & ctx->ctx);
+#if defined(USE_SHA384_SHA512) && USE_SHA384_SHA512
+	case SHA384:
+	  return SHA384Reset ((SHA384Context *) & ctx->ctx);
+	case SHA512:
+	  return SHA512Reset ((SHA512Context *) & ctx->ctx);
+#endif
+	default:
+	  return shaBadParam;
+	}
+    }
+  else
+    {
+      return shaNull;
+    }
+}
+
+/*
+ *  USHAInput
+ *
+ *  Description:
+ *      This function accepts an array of octets as the next portion
+ *      of the message.
+ *
+ *  Parameters:
+ *      context: [in/out]
+ *          The SHA context to update
+ *      message_array: [in]
+ *          An array of characters representing the next portion of
+ *          the message.
+ *      length: [in]
+ *          The length of the message in message_array
+ *
+ *  Returns:
+ *      sha Error Code.
+ *
+ */
+int
+USHAInput (USHAContext * ctx, const uint8_t * bytes, size_t bytecount)
+{
+  if (ctx)
+    {
+      switch (ctx->whichSha)
+	{
+#if defined(USE_SHA1) && USE_SHA1
+	case SHA1:
+	  return SHA1Input ((SHA1Context *) & ctx->ctx, bytes, bytecount);
+#endif
+#if defined(USE_SHA224) && USE_SHA224
+	case SHA224:
+	  return SHA224Input ((SHA224Context *) & ctx->ctx, bytes, bytecount);
+#endif
+	case SHA256:
+	  return SHA256Input ((SHA256Context *) & ctx->ctx, bytes, bytecount);
+#if defined(USE_SHA384_SHA512) && USE_SHA384_SHA512
+	case SHA384:
+	  return SHA384Input ((SHA384Context *) & ctx->ctx, bytes, bytecount);
+	case SHA512:
+	  return SHA512Input ((SHA512Context *) & ctx->ctx, bytes, bytecount);
+#endif
+	default:
+	  return shaBadParam;
+	}
+    }
+  else
+    {
+      return shaNull;
+    }
+}
+
+/*
+ * USHAFinalBits
+ *
+ * Description:
+ *   This function will add in any final bits of the message.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The SHA context to update
+ *   message_bits: [in]
+ *     The final bits of the message, in the upper portion of the
+ *     byte. (Use 0b###00000 instead of 0b00000### to input the
+ *     three bits ###.)
+ *   length: [in]
+ *     The number of bits in message_bits, between 1 and 7.
+ *
+ * Returns:
+ *   sha Error Code.
+ */
+int
+USHAFinalBits (USHAContext * ctx, const uint8_t bits, size_t bitcount)
+{
+  if (ctx)
+    {
+      switch (ctx->whichSha)
+	{
+#if defined(USE_SHA1) && USE_SHA1
+	case SHA1:
+	  return SHA1FinalBits ((SHA1Context *) & ctx->ctx, bits, bitcount);
+#endif
+#if defined(USE_SHA224) && USE_SHA224
+	case SHA224:
+	  return SHA224FinalBits ((SHA224Context *) & ctx->ctx, bits,
+				  bitcount);
+#endif
+	case SHA256:
+	  return SHA256FinalBits ((SHA256Context *) & ctx->ctx, bits,
+				  bitcount);
+#if defined(USE_SHA384_SHA512) && USE_SHA384_SHA512
+	case SHA384:
+	  return SHA384FinalBits ((SHA384Context *) & ctx->ctx, bits,
+				  bitcount);
+	case SHA512:
+	  return SHA512FinalBits ((SHA512Context *) & ctx->ctx, bits,
+				  bitcount);
+#endif
+	default:
+	  return shaBadParam;
+	}
+    }
+  else
+    {
+      return shaNull;
+    }
+}
+
+/*
+ * USHAResult
+ *
+ * Description:
+ *   This function will return the 160-bit message digest into the
+ *   Message_Digest array provided by the caller.
+ *   NOTE: The first octet of hash is stored in the 0th element,
+ *      the last octet of hash in the 19th element.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The context to use to calculate the SHA-1 hash.
+ *   Message_Digest: [out]
+ *     Where the digest is returned.
+ *
+ * Returns:
+ *   sha Error Code.
+ *
+ */
+int
+USHAResult (USHAContext * ctx, uint8_t Message_Digest[USHAMaxHashSize])
+{
+  if (ctx)
+    {
+      switch (ctx->whichSha)
+	{
+#if defined(USE_SHA1) && USE_SHA1
+	case SHA1:
+	  return SHA1Result ((SHA1Context *) & ctx->ctx, Message_Digest);
+#endif
+#if defined(USE_SHA224) && USE_SHA224
+	case SHA224:
+	  return SHA224Result ((SHA224Context *) & ctx->ctx, Message_Digest);
+#endif
+	case SHA256:
+	  return SHA256Result ((SHA256Context *) & ctx->ctx, Message_Digest);
+#if defined(USE_SHA384_SHA512) && USE_SHA384_SHA512
+	case SHA384:
+	  return SHA384Result ((SHA384Context *) & ctx->ctx, Message_Digest);
+	case SHA512:
+	  return SHA512Result ((SHA512Context *) & ctx->ctx, Message_Digest);
+#endif
+	default:
+	  return shaBadParam;
+	}
+    }
+  else
+    {
+      return shaNull;
+    }
+}
+
+/*
+ * USHABlockSize
+ *
+ * Description:
+ *   This function will return the blocksize for the given SHA
+ *   algorithm.
+ *
+ * Parameters:
+ *   whichSha:
+ *     which SHA algorithm to query
+ *
+ * Returns:
+ *   block size
+ *
+ */
+int
+USHABlockSize (enum SHAversion whichSha)
+{
+  switch (whichSha)
+    {
+#if defined(USE_SHA1) && USE_SHA1
+    case SHA1:
+      return SHA1_Message_Block_Size;
+#endif
+#if defined(USE_SHA224) && USE_SHA224
+    case SHA224:
+      return SHA224_Message_Block_Size;
+#endif
+    case SHA256:
+      return SHA256_Message_Block_Size;
+#if defined(USE_SHA384_SHA512) && USE_SHA384_SHA512
+    case SHA384:
+      return SHA384_Message_Block_Size;
+    case SHA512:
+      return SHA512_Message_Block_Size;
+#endif
+    default:
+      return SHA512_Message_Block_Size;
+    }
+}
+
+/*
+ * USHAHashSize
+ *
+ * Description:
+ *   This function will return the hashsize for the given SHA
+ *   algorithm.
+ *
+ * Parameters:
+ *   whichSha:
+ *     which SHA algorithm to query
+ *
+ * Returns:
+ *   hash size
+ *
+ */
+int
+USHAHashSize (enum SHAversion whichSha)
+{
+  switch (whichSha)
+    {
+#if defined(USE_SHA1) && USE_SHA1
+    case SHA1:
+      return SHA1HashSize;
+#endif
+#if defined(USE_SHA224) && USE_SHA224
+    case SHA224:
+      return SHA224HashSize;
+#endif
+    case SHA256:
+      return SHA256HashSize;
+#if defined(USE_SHA384_SHA512) && USE_SHA384_SHA512
+    case SHA384:
+      return SHA384HashSize;
+    case SHA512:
+      return SHA512HashSize;
+#endif
+    default:
+      return SHA512HashSize;
+    }
+}
+
+/*
+ * USHAHashSizeBits
+ *
+ * Description:
+ *   This function will return the hashsize for the given SHA
+ *   algorithm, expressed in bits.
+ *
+ * Parameters:
+ *   whichSha:
+ *     which SHA algorithm to query
+ *
+ * Returns:
+ *   hash size in bits
+ *
+ */
+int
+USHAHashSizeBits (enum SHAversion whichSha)
+{
+  switch (whichSha)
+    {
+#if defined(USE_SHA1) && USE_SHA1
+    case SHA1:
+      return SHA1HashSizeBits;
+#endif
+#if defined(USE_SHA224) && USE_SHA224
+    case SHA224:
+      return SHA224HashSizeBits;
+#endif
+    case SHA256:
+      return SHA256HashSizeBits;
+#if defined(USE_SHA384_SHA512) && USE_SHA384_SHA512
+    case SHA384:
+      return SHA384HashSizeBits;
+    case SHA512:
+      return SHA512HashSizeBits;
+#endif
+    default:
+      return SHA512HashSizeBits;
+    }
+}