react-native-mmkv 3.2.0 → 4.0.0-beta.0

package/MMKV/Core/ScopedLock.hpp

@@ -1,69 +0,0 @@
-/*
- * Tencent is pleased to support the open source community by making
- * MMKV available.
- *
- * Copyright (C) 2018 THL A29 Limited, a Tencent company.
- * All rights reserved.
- *
- * Licensed under the BSD 3-Clause License (the "License"); you may not use
- * this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- *       https://opensource.org/licenses/BSD-3-Clause
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MMKV_SCOPEDLOCK_HPP
-#define MMKV_SCOPEDLOCK_HPP
-#ifdef __cplusplus
-
-namespace mmkv {
-
-template <typename T>
-class ScopedLock {
-    T *m_lock;
-
-    void lock() {
-        if (m_lock) {
-            m_lock->lock();
-        }
-    }
-
-    void unlock() {
-        if (m_lock) {
-            m_lock->unlock();
-        }
-    }
-
-public:
-    explicit ScopedLock(T *oLock) : m_lock(oLock) {
-        MMKV_ASSERT(m_lock);
-        lock();
-    }
-
-    ~ScopedLock() {
-        unlock();
-        m_lock = nullptr;
-    }
-
-    // just forbid it for possibly misuse
-    explicit ScopedLock(const ScopedLock<T> &other) = delete;
-    ScopedLock &operator=(const ScopedLock<T> &other) = delete;
-};
-
-} // namespace mmkv
-
-#include <type_traits>
-
-#define SCOPED_LOCK(lock) _SCOPEDLOCK(lock, __COUNTER__)
-#define _SCOPEDLOCK(lock, counter) __SCOPEDLOCK(lock, counter)
-#define __SCOPEDLOCK(lock, counter)                                                                                    \
-    mmkv::ScopedLock<std::remove_pointer<decltype(lock)>::type> __scopedLock##counter(lock)
-
-#endif
-#endif //MMKV_SCOPEDLOCK_HPP

package/MMKV/Core/ThreadLock.cpp

@@ -1,75 +0,0 @@
-/*
- * Tencent is pleased to support the open source community by making
- * MMKV available.
- *
- * Copyright (C) 2018 THL A29 Limited, a Tencent company.
- * All rights reserved.
- *
- * Licensed under the BSD 3-Clause License (the "License"); you may not use
- * this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- *       https://opensource.org/licenses/BSD-3-Clause
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "ThreadLock.h"
-#include "MMKVLog.h"
-
-#if MMKV_USING_PTHREAD
-
-using namespace std;
-
-namespace mmkv {
-
-ThreadLock::ThreadLock() : m_lock({}) {
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-
-    pthread_mutex_init(&m_lock, &attr);
-
-    pthread_mutexattr_destroy(&attr);
-}
-
-ThreadLock::~ThreadLock() {
-    pthread_mutex_unlock(&m_lock);
-
-    pthread_mutex_destroy(&m_lock);
-}
-
-void ThreadLock::lock() {
-    auto ret = pthread_mutex_lock(&m_lock);
-    if (ret != 0) {
-        MMKVError("fail to lock %p, ret=%d, errno=%s", &m_lock, ret, strerror(errno));
-    }
-}
-
-void ThreadLock::unlock() {
-    auto ret = pthread_mutex_unlock(&m_lock);
-    if (ret != 0) {
-        MMKVError("fail to unlock %p, ret=%d, errno=%s", &m_lock, ret, strerror(errno));
-    }
-}
-
-bool ThreadLock::try_lock() {
-    auto ret = pthread_mutex_trylock(&m_lock);
-    return (ret == 0);
-}
-
-void ThreadLock::initialize() {
-    return;
-}
-
-void ThreadLock::ThreadOnce(ThreadOnceToken_t *onceToken, void (*callback)()) {
-    pthread_once(onceToken, callback);
-}
-
-} // namespace mmkv
-
-#endif // MMKV_USING_PTHREAD

package/MMKV/Core/ThreadLock.h

@@ -1,81 +0,0 @@
-/*
- * Tencent is pleased to support the open source community by making
- * MMKV available.
- *
- * Copyright (C) 2018 THL A29 Limited, a Tencent company.
- * All rights reserved.
- *
- * Licensed under the BSD 3-Clause License (the "License"); you may not use
- * this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- *       https://opensource.org/licenses/BSD-3-Clause
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MMKV_THREADLOCK_H
-#define MMKV_THREADLOCK_H
-
-#ifdef  __cplusplus
-
-#include "MMKVPredef.h"
-
-#ifndef MMKV_WIN32
-#    include <pthread.h>
-#    define MMKV_USING_PTHREAD 1
-#endif
-
-#ifndef MMKV_USING_PTHREAD
-#    include <atomic>
-#endif
-
-namespace mmkv {
-
-#if MMKV_USING_PTHREAD
-#    define ThreadOnceToken_t pthread_once_t
-#    define ThreadOnceUninitialized PTHREAD_ONCE_INIT
-#else
-enum ThreadOnceTokenEnum : int32_t { ThreadOnceUninitialized = 0, ThreadOnceInitializing, ThreadOnceInitialized };
-using ThreadOnceToken_t = std::atomic<ThreadOnceTokenEnum>;
-#endif
-
-class ThreadLock {
-#if MMKV_USING_PTHREAD
-    pthread_mutex_t m_lock;
-#else
-    CRITICAL_SECTION m_lock;
-#endif
-
-public:
-    ThreadLock();
-    ~ThreadLock();
-
-    void initialize();
-
-    void lock();
-    void unlock();
-
-#ifndef MMKV_WIN32
-    bool try_lock();
-#endif
-
-    static void ThreadOnce(ThreadOnceToken_t *onceToken, void (*callback)(void));
-
-#ifdef MMKV_WIN32
-    static void Sleep(int ms);
-#endif
-
-    // just forbid it for possibly misuse
-    explicit ThreadLock(const ThreadLock &other) = delete;
-    ThreadLock &operator=(const ThreadLock &other) = delete;
-};
-
-} // namespace mmkv
-
-#endif
-#endif //MMKV_THREADLOCK_H

package/MMKV/Core/ThreadLock_Win32.cpp

@@ -1,89 +0,0 @@
-/*
- * Tencent is pleased to support the open source community by making
- * MMKV available.
- *
- * Copyright (C) 2019 THL A29 Limited, a Tencent company.
- * All rights reserved.
- *
- * Licensed under the BSD 3-Clause License (the "License"); you may not use
- * this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- *       https://opensource.org/licenses/BSD-3-Clause
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "ThreadLock.h"
-
-#if !(MMKV_USING_PTHREAD)
-
-#    include "MMKVLog.h"
-#    include <atomic>
-#    include <cassert>
-
-namespace mmkv {
-
-ThreadLock::ThreadLock() : m_lock{0} {
-}
-
-ThreadLock::~ThreadLock() {
-    DeleteCriticalSection(&m_lock);
-}
-
-void ThreadLock::initialize() {
-    // TODO: a better spin count?
-    if (!InitializeCriticalSectionAndSpinCount(&m_lock, 1024)) {
-        MMKVError("fail to init critical section:%d", GetLastError());
-    }
-}
-
-void ThreadLock::lock() {
-    EnterCriticalSection(&m_lock);
-}
-
-void ThreadLock::unlock() {
-    LeaveCriticalSection(&m_lock);
-}
-
-void ThreadLock::ThreadOnce(ThreadOnceToken_t *onceToken, void (*callback)()) {
-    if (!onceToken || !callback) {
-        assert(onceToken);
-        assert(callback);
-        return;
-    }
-    while (true) {
-        auto expected = ThreadOnceUninitialized;
-        atomic_compare_exchange_weak(onceToken, &expected, ThreadOnceInitializing);
-        switch (expected) {
-            case ThreadOnceInitialized:
-                return;
-            case ThreadOnceUninitialized:
-                callback();
-                onceToken->store(ThreadOnceInitialized);
-                return;
-            case ThreadOnceInitializing: {
-                // another thread is initializing, let's wait for 1ms
-                ThreadLock::Sleep(1);
-                break;
-            }
-            default: {
-                MMKVError("should never happen:%d", expected);
-                assert(0);
-                return;
-            }
-        }
-    }
-}
-
-void ThreadLock::Sleep(int ms) {
-    ::Sleep(ms);
-}
-
-} // namespace mmkv
-
-#endif // MMKV_USING_PTHREAD

package/MMKV/Core/aes/AESCrypt.cpp

@@ -1,273 +0,0 @@
-/*
- * Tencent is pleased to support the open source community by making
- * MMKV available.
- *
- * Copyright (C) 2018 THL A29 Limited, a Tencent company.
- * All rights reserved.
- *
- * Licensed under the BSD 3-Clause License (the "License"); you may not use
- * this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- *       https://opensource.org/licenses/BSD-3-Clause
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "AESCrypt.h"
-#include "openssl/openssl_aes.h"
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
-#include "../MMKVLog.h"
-#include "../MemoryFile.h"
-
-namespace mmkv {
-
-// assuming size in [1, 5]
-uint32_t AESCrypt::randomItemSizeHolder(uint32_t size) {
-    constexpr uint32_t ItemSizeHolders[] = {0, 0x80, 0x4000, 0x200000, 0x10000000, 0};
-    auto ItemSizeHolderMin = ItemSizeHolders[size - 1];
-    auto ItemSizeHolderMax = ItemSizeHolders[size] - 1;
-
-    srand((unsigned) time(nullptr));
-    auto result = static_cast<uint32_t>(rand());
-    result = result % (ItemSizeHolderMax - ItemSizeHolderMin + 1);
-    result += ItemSizeHolderMin;
-    return result;
-}
-
-#ifndef MMKV_DISABLE_CRYPT
-
-using namespace openssl;
-
-AESCrypt::AESCrypt(const void *key, size_t keyLength, const void *iv, size_t ivLength) {
-    if (key && keyLength > 0) {
-        memcpy(m_key, key, (keyLength > AES_KEY_LEN) ? AES_KEY_LEN : keyLength);
-
-        resetIV(iv, ivLength);
-
-        m_aesKey = new AES_KEY;
-        memset(m_aesKey, 0, sizeof(AES_KEY));
-        int ret = AES_set_encrypt_key(m_key, AES_KEY_BITSET_LEN, m_aesKey);
-        MMKV_ASSERT(ret == 0);
-    }
-}
-
-AESCrypt::AESCrypt(const AESCrypt &other, const AESCryptStatus &status) : m_isClone(true), m_number(status.m_number) {
-    //memcpy(m_key, other.m_key, sizeof(m_key));
-    memcpy(m_vector, status.m_vector, sizeof(m_vector));
-    m_aesKey = other.m_aesKey;
-}
-
-AESCrypt::~AESCrypt() {
-    if (!m_isClone) {
-        delete m_aesKey;
-        delete m_aesRollbackKey;
-    }
-}
-
-void AESCrypt::resetIV(const void *iv, size_t ivLength) {
-    m_number = 0;
-    if (iv && ivLength > 0) {
-        memcpy(m_vector, iv, (ivLength > AES_KEY_LEN) ? AES_KEY_LEN : ivLength);
-    } else {
-        memcpy(m_vector, m_key, AES_KEY_LEN);
-    }
-}
-
-void AESCrypt::resetStatus(const AESCryptStatus &status) {
-    m_number = status.m_number;
-    memcpy(m_vector, status.m_vector, AES_KEY_LEN);
-}
-
-void AESCrypt::getKey(void *output) const {
-    if (output) {
-        memcpy(output, m_key, AES_KEY_LEN);
-    }
-}
-
-void AESCrypt::encrypt(const void *input, void *output, size_t length) {
-    if (!input || !output || length == 0) {
-        return;
-    }
-    AES_cfb128_encrypt((const uint8_t *) input, (uint8_t *) output, length, m_aesKey, m_vector, &m_number);
-}
-
-void AESCrypt::decrypt(const void *input, void *output, size_t length) {
-    if (!input || !output || length == 0) {
-        return;
-    }
-    AES_cfb128_decrypt((const uint8_t *) input, (uint8_t *) output, length, m_aesKey, m_vector, &m_number);
-}
-
-void AESCrypt::fillRandomIV(void *vector) {
-    if (!vector) {
-        return;
-    }
-    srand((unsigned) time(nullptr));
-    int *ptr = (int *) vector;
-    for (uint32_t i = 0; i < AES_KEY_LEN / sizeof(int); i++) {
-        ptr[i] = rand();
-    }
-}
-
-static inline void
-Rollback_cfb_decrypt(const uint8_t *input, const uint8_t *output, size_t len, AES_KEY *key, AESCryptStatus &status) {
-    auto ivec = status.m_vector;
-    auto n = status.m_number;
-
-    while (n && len) {
-        auto c = *(--output);
-        ivec[--n] = *(--input) ^ c;
-        len--;
-    }
-    if (n == 0 && (status.m_number != 0)) {
-        AES_decrypt(ivec, ivec, key);
-    }
-    while (len >= 16) {
-        len -= 16;
-        output -= 16;
-        input -= 16;
-        for (; n < 16; n += sizeof(size_t)) {
-            size_t t = *(size_t *) (output + n);
-            *(size_t *) (ivec + n) = *(size_t *) (input + n) ^ t;
-        }
-        n = 0;
-        AES_decrypt(ivec, ivec, key);
-    }
-    if (len) {
-        n = 16;
-        do {
-            auto c = *(--output);
-            ivec[--n] = *(--input) ^ c;
-            len--;
-        } while (len);
-    }
-
-    status.m_number = n;
-}
-
-void AESCrypt::statusBeforeDecrypt(const void *input, const void *output, size_t length, AESCryptStatus &status) {
-    if (length == 0) {
-        return;
-    }
-    if (!m_aesRollbackKey) {
-        m_aesRollbackKey = new AES_KEY;
-        memset(m_aesRollbackKey, 0, sizeof(AES_KEY));
-        int ret = AES_set_decrypt_key(m_key, AES_KEY_BITSET_LEN, m_aesRollbackKey);
-        MMKV_ASSERT(ret == 0);
-    }
-    getCurStatus(status);
-    Rollback_cfb_decrypt((const uint8_t *) input, (const uint8_t *) output, length, m_aesRollbackKey, status);
-}
-
-void AESCrypt::getCurStatus(AESCryptStatus &status) {
-    status.m_number = static_cast<uint8_t>(m_number);
-    memcpy(status.m_vector, m_vector, sizeof(m_vector));
-}
-
-AESCrypt AESCrypt::cloneWithStatus(const AESCryptStatus &status) const {
-    return AESCrypt(*this, status);
-}
-
-#    ifdef MMKV_DEBUG
-
-void testRandomPlaceHolder() {
-    for (uint32_t size = 1; size < 6; size++) {
-        auto holder = AESCrypt::randomItemSizeHolder(size);
-        MMKVInfo("holder 0x%x for size %u", holder, size);
-    }
-}
-
-// check if AESCrypt is encrypt-decrypt full-duplex
-void AESCrypt::testAESCrypt() {
-    testRandomPlaceHolder();
-
-    const uint8_t plainText[] = "Hello, OpenSSL-mmkv::AESCrypt::testAESCrypt() with AES CFB 128.";
-    constexpr size_t textLength = sizeof(plainText) - 1;
-
-    const uint8_t key[] = "TheAESKey";
-    constexpr size_t keyLength = sizeof(key) - 1;
-
-    uint8_t iv[AES_KEY_LEN];
-    srand((unsigned) time(nullptr));
-    for (uint32_t i = 0; i < AES_KEY_LEN; i++) {
-        iv[i] = (uint8_t) rand();
-    }
-    AESCrypt crypt1(key, keyLength, iv, sizeof(iv));
-    AESCrypt crypt2(key, keyLength, iv, sizeof(iv));
-
-    auto encryptText = new uint8_t[DEFAULT_MMAP_SIZE];
-    auto decryptText = new uint8_t[DEFAULT_MMAP_SIZE];
-    memset(encryptText, 0, DEFAULT_MMAP_SIZE);
-    memset(decryptText, 0, DEFAULT_MMAP_SIZE);
-
-    /* in-place encryption & decryption
-    memcpy(encryptText, plainText, textLength);
-    crypt1.encrypt(encryptText, encryptText, textLength);
-    crypt2.decrypt(encryptText, encryptText, textLength);
-    return;
-    */
-    AES_KEY decryptKey;
-    AES_set_decrypt_key(crypt1.m_key, AES_KEY_BITSET_LEN, &decryptKey);
-
-    size_t actualSize = 0;
-    bool flip = false;
-    for (const uint8_t *ptr = plainText; ptr < plainText + textLength;) {
-        auto tokenPtr = (const uint8_t *) strchr((const char *) ptr, ' ');
-        size_t size = 0;
-        if (!tokenPtr) {
-            size = static_cast<size_t>(plainText + textLength - ptr);
-        } else {
-            size = static_cast<size_t>(tokenPtr - ptr + 1);
-        }
-
-        AESCrypt *decrypter;
-        uint32_t oldNum;
-        uint8_t oldVector[sizeof(crypt1.m_vector)];
-
-        flip = !flip;
-        if (flip) {
-            crypt1.encrypt(plainText + actualSize, encryptText + actualSize, size);
-
-            decrypter = &crypt2;
-            oldNum = decrypter->m_number;
-            memcpy(oldVector, decrypter->m_vector, sizeof(oldVector));
-            crypt2.decrypt(encryptText + actualSize, decryptText + actualSize, size);
-        } else {
-            crypt2.encrypt(plainText + actualSize, encryptText + actualSize, size);
-
-            decrypter = &crypt1;
-            oldNum = decrypter->m_number;
-            memcpy(oldVector, decrypter->m_vector, sizeof(oldVector));
-            crypt1.decrypt(encryptText + actualSize, decryptText + actualSize, size);
-        }
-        // that's why AESCrypt can be full-duplex
-        assert(crypt1.m_number == crypt2.m_number);
-        assert(0 == memcmp(crypt1.m_vector, crypt2.m_vector, sizeof(crypt1.m_vector)));
-
-        // how rollback works
-        AESCryptStatus status;
-        decrypter->statusBeforeDecrypt(encryptText + actualSize + size, decryptText + actualSize + size, size, status);
-        assert(oldNum == status.m_number);
-        assert(0 == memcmp(oldVector, status.m_vector, sizeof(oldVector)));
-
-        actualSize += size;
-        ptr += size;
-    }
-    MMKVInfo("AES CFB decode: %s", decryptText);
-
-    delete[] encryptText;
-    delete[] decryptText;
-}
-
-#    endif // MMKV_DEBUG
-#endif     // MMKV_DISABLE_CRYPT
-
-} // namespace mmkv

package/MMKV/Core/aes/AESCrypt.h

@@ -1,112 +0,0 @@
-/*
- * Tencent is pleased to support the open source community by making
- * MMKV available.
- *
- * Copyright (C) 2018 THL A29 Limited, a Tencent company.
- * All rights reserved.
- *
- * Licensed under the BSD 3-Clause License (the "License"); you may not use
- * this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- *       https://opensource.org/licenses/BSD-3-Clause
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef AES_CRYPT_H_
-#define AES_CRYPT_H_
-#ifdef __cplusplus
-
-#include "../MMKVPredef.h"
-#include <cstddef>
-#include <cstdint>
-
-#ifdef MMKV_DISABLE_CRYPT
-
-namespace mmkv {
-class AESCrypt {
-public:
-    static uint32_t randomItemSizeHolder(uint32_t size);
-};
-}
-
-#else
-
-namespace openssl {
-struct AES_KEY;
-}
-
-namespace mmkv {
-
-#pragma pack(push, 1)
-
-struct AESCryptStatus {
-    uint8_t m_number;
-    uint8_t m_vector[AES_KEY_LEN];
-};
-
-#pragma pack(pop)
-
-class CodedInputDataCrypt;
-
-// a AES CFB-128 encrypt-decrypt full-duplex wrapper
-class AESCrypt {
-    bool m_isClone = false;
-    uint32_t m_number = 0;
-    openssl::AES_KEY *m_aesKey = nullptr;
-    openssl::AES_KEY *m_aesRollbackKey = nullptr;
-    uint8_t m_key[AES_KEY_LEN] = {};
-
-public:
-    uint8_t m_vector[AES_KEY_LEN] = {};
-
-private:
-    // for cloneWithStatus()
-    AESCrypt(const AESCrypt &other, const AESCryptStatus &status);
-
-public:
-    AESCrypt(const void *key, size_t keyLength, const void *iv = nullptr, size_t ivLength = 0);
-    AESCrypt(AESCrypt &&other) = default;
-
-    ~AESCrypt();
-
-    void encrypt(const void *input, void *output, size_t length);
-
-    void decrypt(const void *input, void *output, size_t length);
-
-    void getCurStatus(AESCryptStatus &status);
-    void statusBeforeDecrypt(const void *input, const void *output, size_t length, AESCryptStatus &status);
-
-    AESCrypt cloneWithStatus(const AESCryptStatus &status) const;
-
-    void resetIV(const void *iv = nullptr, size_t ivLength = 0);
-    void resetStatus(const AESCryptStatus &status);
-
-    // output must have [AES_KEY_LEN] space
-    void getKey(void *output) const;
-
-    static void fillRandomIV(void *vector);
-    static uint32_t randomItemSizeHolder(uint32_t size);
-
-    // just forbid it for possibly misuse
-    explicit AESCrypt(const AESCrypt &other) = delete;
-    AESCrypt &operator=(const AESCrypt &other) = delete;
-
-    friend CodedInputDataCrypt;
-
-#ifdef MMKV_DEBUG
-    // check if AESCrypt is encrypt-decrypt full-duplex
-    static void testAESCrypt();
-#endif
-};
-
-} // namespace mmkv
-
-#endif // MMKV_DISABLE_CRYPT
-#endif // __cplusplus
-#endif /* AES_CRYPT_H_ */