text,label "function foo(bug) { function C(z) { Error.prepareStackTrace = function(t, B) { return B[z].getThis(); }; let p = Error().stack; Error.prepareStackTrace = null; return p; } function J() {} var optim = false; var opt = new Function( 'a', 'b', 'c', 'if(typeof a===\'number\'){if(a>2){for(var i=0;i<100;i++);return;}b.d(a,b,1);return}' + 'g++;'.repeat(70)); var e = null; J.prototype.d = new Function( 'a', 'b', '""use strict"";b.a.call(arguments,b);return arguments[a];'); J.prototype.a = new Function('a', 'a.b(0,a)'); J.prototype.b = new Function( 'a', 'b', 'b.c();if(a){' + 'g++;'.repeat(70) + '}'); J.prototype.c = function() { if (optim) { var z = C(3); var p = C(3); z[0] = 0; e = {M: z, C: p}; } }; var a = new J(); // jit optim if (bug) { for (var V = 0; 1E4 > V; V++) { opt(0 == V % 4 ? 1 : 4, a, 1); } } optim = true; opt(1, a, 1); return e; } e1 = foo(false); console.log(e1.M === e1.C); // prints true. e2 = foo(true); console.log(e2.M === e2.C); // should be true as above but prints false.",0 (vulnerable) " ",0 (vulnerable) "__int64 __fastcall CClfsBaseFilePersisted::RemoveContainer(CClfsBaseFilePersisted *this, unsigned int a2) { ... v11 = CClfsBaseFilePersisted::FlushImage((PERESOURCE *)this); v9 = v11; v16 = v11; if ( v11 >= 0 ) { pContainer = *((_QWORD *)containerContext + 3); if ( pContainer ) { *((_QWORD *)containerContext + 3) = 0i64; ExReleaseResourceForThreadLite(*((PERESOURCE *)this + 4), (ERESOURCE_THREAD)KeGetCurrentThread()); v4 = 0; (*(void (__fastcall **)(__int64))(*(_QWORD *)pContainer + 0x18i64))(pContainer); // remove method (*(void (__fastcall **)(__int64))(*(_QWORD *)pContainer + 8i64))(pContainer); // release method v9 = v16; goto LABEL_20; } goto LABEL_19; } ... } v44 = *((_DWORD *)containerContext + 5); // to trigger RemoveContainer one should set this field to -1 if ( v44 == -1 ) { *((_QWORD *)containerContext + 3) = 0i64; // pContainer is set to NULL v20 = CClfsBaseFilePersisted::RemoveContainer(this, v34); v72 = v20; if ( v20 < 0 ) goto LABEL_134; v23 = v78; v34 = (unsigned int)(v34 + 1); v79 = v34; } ... // Obtain all container contexts represented in blf // save pContainer class pointer for each valid container context for ( i = 0; i < 0x400; ++i ) { v20 = CClfsBaseFile::AcquireContainerContext(this, i, &v22); v15 = (char *)this + 8 * i; if ( v20 >= 0 ) { v16 = v22; *((_QWORD *)v15 + 56) = *((_QWORD *)v22 + 3); // for each valid container save pContainer *((_QWORD *)v16 + 3) = 0i64; // and set the initial pContainer to zero CClfsBaseFile::ReleaseContainerContext(this, &v22); } else { *((_QWORD *)v15 + 56) = 0i64; } } // Stage [1] enode block, prepare it for writing ClfsEncodeBlock( (struct _CLFS_LOG_BLOCK_HEADER *)v9, *(unsigned __int16 *)(v9 + 4) << 9, *(_BYTE *)(v9 + 2), 0x10u, 1u); // write modified data v10 = CClfsContainer::WriteSector( *((CClfsContainer **)this + 19), *((struct _KEVENT **)this + 20), 0i64, *(void **)(*((_QWORD *)this + 6) + 24 * v8), *(unsigned __int16 *)(v9 + 4), &v23); ... if ( v7 ) { // Stage [2] Decode file again for futher processing in clfs.sys ClfsDecodeBlock((struct _CLFS_LOG_BLOCK_HEADER *)v9, *(unsigned __int16 *)(v9 + 4), *(_BYTE *)(v9 + 2), 0x10u, &v21); // optain new pContainer class pointer v17 = (_QWORD *)((char *)this + 448); do { // Stage [3] for each valid container // update pContainer field if ( *v17 && (int)CClfsBaseFile::AcquireContainerContext(this, v6, &v22) >= 0 ) { *((_QWORD *)v22 + 3) = *v17; CClfsBaseFile::ReleaseContainerContext(this, &v22); } ++v6; ++v17; } while ( v6 < 0x400 ); } ...",0 (vulnerable) "static struct kbase_va_region *kbase_mem_from_user_buffer( struct kbase_context *kctx, unsigned long address, unsigned long size, u64 *va_pages, u64 *flags) { [...] + int write; [...] + write = reg->flags & (KBASE_REG_CPU_WR | KBASE_REG_GPU_WR); + #if KERNEL_VERSION(4, 6, 0) > LINUX_VERSION_CODE faulted_pages = get_user_pages(current, current->mm, address, *va_pages, #if KERNEL_VERSION(4, 4, 168) <= LINUX_VERSION_CODE && \ KERNEL_VERSION(4, 5, 0) > LINUX_VERSION_CODE - reg->flags & KBASE_REG_CPU_WR ? FOLL_WRITE : 0, - pages, NULL); + write ? FOLL_WRITE : 0, pages, NULL); #else - reg->flags & KBASE_REG_CPU_WR, 0, pages, NULL); + write, 0, pages, NULL); #endif #elif KERNEL_VERSION(4, 9, 0) > LINUX_VERSION_CODE faulted_pages = get_user_pages(address, *va_pages, - reg->flags & KBASE_REG_CPU_WR, 0, pages, NULL); + write, 0, pages, NULL); #else faulted_pages = get_user_pages(address, *va_pages, - reg->flags & KBASE_REG_CPU_WR ? FOLL_WRITE : 0, - pages, NULL); + write ? FOLL_WRITE : 0, pages, NULL); #endif",0 (vulnerable) "input = document.body.appendChild(document.createElement(""input"")); foo = document.body.appendChild(document.createElement(""a"")); foo.id = ""foo""; // Go to state1 when history.back is called // The URL needs to be to trigger loadInSameDocument during the call to back() // Since the foo's element id=""foo"", focus will change to that element history.pushState(""state1"", """", location + ""#foo""); // Current state = state2 history.pushState(""state2"", """"); setTimeout(() => { // Set the focus on the input element. // During the call to back() the focus will change to the foo element // and therefore triggering the blur event on the input element input.focus(); input.onblur = () => history.replaceState(""state3"", """"); setTimeout(() => history.back(), 1000); }, 1000);",0 (vulnerable) "var initKey = {init : 1}; var level = 4; var map1 = new WeakMap(); function hideWeakMap(map, level, initKey) { let prevMap = map; let prevKey = initKey; for (let i = 0; i < level; i++) { let thisMap = new WeakMap(); prevMap.set(prevKey, thisMap); let thisKey = {'h' : i}; thisMap.set(prevKey, thisKey); prevMap = thisMap; prevKey = thisKey; if (i == level - 1) { let retMap = new WeakMap(); map.set(thisKey, retMap); return thisKey; } } } function getHiddenKey(map, level, initKey) { let prevMap = map; let prevKey = initKey; for (let i = 0; i < level; i++) { let thisMap = prevMap.get(prevKey); let thisKey = thisMap.get(prevKey); prevMap = thisMap; prevKey = thisKey; if (i == level - 1) { return thisKey; } } } function setUpWeakMap(map) { let hk = hideWeakMap(map, level, initKey); let hiddenMap = map.get(hk); let map7 = new WeakMap(); let map8 = new WeakMap(); let k5 = {k5 : 1}; let map5 = new WeakMap(); let k7 = {k7 : 1}; let k9 = {k9 : 1}; let k8 = {k8 : 1}; let v9 = {}; map.set(k7, map7); map.set(k9, v9); hiddenMap.set(k5, map5); hiddenMap.set(hk, k5); map5.set(hk, k7); map7.set(k8, map8); map7.set(k7, k8); map8.set(k8,k9); } function main() { setUpWeakMap(map1); new ArrayBuffer(0x7fe00000); let hiddenKey = getHiddenKey(map1, level, initKey); let hiddenMap = map1.get(hiddenKey); let k7 = hiddenMap.get(hiddenMap.get(hiddenKey)).get(hiddenKey); let k8 = map1.get(k7).get(k7); let map8 = map1.get(k7).get(k8); console.log(map1.get(map8.get(k8))); } while (true) { try { main(); } catch (err) {} }",0 (vulnerable) "function store(y) { x = y; } function load() { return x.b; } var x = {a : 1}; var x1 = {a : 2}; var x2 = {a : 3}; var x3 = {a : 4}; store(x1); %PrepareFunctionForOptimization(store); store(x2); x1.b = 1; %OptimizeFunctionOnNextCall(store); store(x2); x.b = 1; %PrepareFunctionForOptimization(load); load(); %OptimizeFunctionOnNextCall(load); load(); store(x3); %DebugPrint(load());",0 (vulnerable) "global_object = {}; setPropertyViaEmbed = (object, value, handler) => { const embed = document.createElement('embed'); embed.onload = handler; embed.type = 'text/html'; Object.setPrototypeOf(global_object, embed); document.body.appendChild(embed); object.corrupted_prop = value; embed.remove(); } createCorruptedPair = (value_1, value_2) => { const object_1 = { __proto__: global_object }; object_1.regular_prop = 1; setPropertyViaEmbed(object_1, value_2, () => { Object.setPrototypeOf(global_object, null); object_1.corrupted_prop = value_1; }); const object_2 = { __proto__: global_object }; object_2.regular_prop = 1; setPropertyViaEmbed(object_2, value_2, () => { Object.setPrototypeOf(global_object, null); object_2.corrupted_prop = value_1; object_1.regular_prop = 1.1 }); return [object_1, object_2]; } const array = [1.1]; array.prop = 1; const [object_1, object_2] = createCorruptedPair(array, 2261620.509803918); jit = (object) => { return object.corrupted_prop[0]; } for (var i = 0; i < 100000; ++i) jit(object_1); jit(object_2);",0 (vulnerable) "int SetBlendDesignPositions(void *arg) { int num_master; Fixed16_16 values[16][15]; for (num_master = 0; ; num_master++) { if (GetToken() != TOKEN_OPEN) { break; } int values_read = GetOpenFixedArray(&values[num_master], 15); SetNumAxes(values_read); } SetNumMasters(num_master); for (int i = 0; i < num_master; i++) { procs->BlendDesignPositions(i, &values[i]); } return 0; }",0 (vulnerable) "#include #include #include #include const char* MANIFEST_CONTENTS = """" """" """" """"; const WCHAR* NULL_BYTE_STR = L""\x00\x00""; const WCHAR* MANIFEST_NAME = L""msil_system.data.sqlxml.resources_b77a5c561934e061_3.0.4100.17061_en-us_"" L""d761caeca23d64a2.manifest""; const WCHAR* PATH = L""\\\\.\\c:Windows\\""; const WCHAR* MODULE = L""System.Data.SqlXml.Resources""; typedef PVOID(__stdcall* f_CsrAllocateCaptureBuffer)(ULONG ArgumentCount, ULONG BufferSize); f_CsrAllocateCaptureBuffer CsrAllocateCaptureBuffer; typedef NTSTATUS(__stdcall* f_CsrClientCallServer)(PVOID ApiMessage, PVOID CaptureBuffer, ULONG ApiNumber, ULONG DataLength); f_CsrClientCallServer CsrClientCallServer; typedef NTSTATUS(__stdcall* f_CsrCaptureMessageString)(LPVOID CaptureBuffer, PCSTR String, ULONG Length, ULONG MaximumLength, PSTR OutputString); f_CsrCaptureMessageString CsrCaptureMessageString; NTSTATUS CaptureUnicodeString(LPVOID CaptureBuffer, PSTR OutputString, PCWSTR String, ULONG Length = 0) { if (Length == 0) { Length = lstrlenW(String); } return CsrCaptureMessageString(CaptureBuffer, (PCSTR)String, Length * 2, Length * 2 + 2, OutputString); } int main() { HMODULE Ntdll = LoadLibrary(L""Ntdll.dll""); CsrAllocateCaptureBuffer = (f_CsrAllocateCaptureBuffer)GetProcAddress( Ntdll, ""CsrAllocateCaptureBuffer""); CsrClientCallServer = (f_CsrClientCallServer)GetProcAddress(Ntdll, ""CsrClientCallServer""); CsrCaptureMessageString = (f_CsrCaptureMessageString)GetProcAddress( Ntdll, ""CsrCaptureMessageString""); char Message[0x220]; memset(Message, 0, 0x220); PVOID CaptureBuffer = CsrAllocateCaptureBuffer(4, 0x300); std::string Manifest = MANIFEST_CONTENTS; Manifest.replace(Manifest.find('@'), 1, 0x2000, 'A'); // There's no public definition of the relevant CSR_API_MSG structure. // The offsets and values are taken directly from the exploit. *(uint32_t*)(Message + 0x40) = 0xc1; *(uint16_t*)(Message + 0x44) = 9; *(uint16_t*)(Message + 0x59) = 0x201; // CSRSS loads the manifest contents from the client process memory; // therefore, it doesn't have to be stored in the capture buffer. *(const char**)(Message + 0x80) = Manifest.c_str(); *(uint64_t*)(Message + 0x88) = Manifest.size(); *(uint64_t*)(Message + 0xf0) = 1; CaptureUnicodeString(CaptureBuffer, Message + 0x48, NULL_BYTE_STR, 2); CaptureUnicodeString(CaptureBuffer, Message + 0x60, MANIFEST_NAME); CaptureUnicodeString(CaptureBuffer, Message + 0xc8, PATH); CaptureUnicodeString(CaptureBuffer, Message + 0x120, MODULE); // Triggers the issue by setting ApplicationName.MaxLength to a large value. *(uint16_t*)(Message + 0x122) = 0x8000; CsrClientCallServer(Message, CaptureBuffer, 0x10017, 0xf0); }",0 (vulnerable) "#include ""gtest/internal/gtest-filepath.h"" #include #include ""gtest/gtest-message.h"" #include ""gtest/internal/gtest-port.h"" #if GTEST_OS_WINDOWS_MOBILE #include #elif GTEST_OS_WINDOWS #include #include #else #include #include // Some Linux distributions define PATH_MAX here. #endif // GTEST_OS_WINDOWS_MOBILE #include ""gtest/internal/gtest-string.h"" #if GTEST_OS_WINDOWS #define GTEST_PATH_MAX_ _MAX_PATH #elif defined(PATH_MAX) #define GTEST_PATH_MAX_ PATH_MAX #elif defined(_XOPEN_PATH_MAX) #define GTEST_PATH_MAX_ _XOPEN_PATH_MAX #else #define GTEST_PATH_MAX_ _POSIX_PATH_MAX #endif // GTEST_OS_WINDOWS namespace testing { namespace internal { #if GTEST_OS_WINDOWS // On Windows, '\\' is the standard path separator, but many tools and the // Windows API also accept '/' as an alternate path separator. Unless otherwise // noted, a file path can contain either kind of path separators, or a mixture // of them. const char kPathSeparator = '\\'; const char kAlternatePathSeparator = '/'; const char kAlternatePathSeparatorString[] = ""/""; #if GTEST_OS_WINDOWS_MOBILE // Windows CE doesn't have a current directory. You should not use // the current directory in tests on Windows CE, but this at least // provides a reasonable fallback. const char kCurrentDirectoryString[] = ""\\""; // Windows CE doesn't define INVALID_FILE_ATTRIBUTES const DWORD kInvalidFileAttributes = 0xffffffff; #else const char kCurrentDirectoryString[] = "".\\""; #endif // GTEST_OS_WINDOWS_MOBILE #else const char kPathSeparator = '/'; const char kCurrentDirectoryString[] = ""./""; #endif // GTEST_OS_WINDOWS // Returns whether the given character is a valid path separator. static bool IsPathSeparator(char c) { #if GTEST_HAS_ALT_PATH_SEP_ return (c == kPathSeparator) || (c == kAlternatePathSeparator); #else return c == kPathSeparator; #endif } // Returns the current working directory, or """" if unsuccessful. FilePath FilePath::GetCurrentDir() { #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \ GTEST_OS_XTENSA || GTEST_OS_QURT // These platforms do not have a current directory, so we just return // something reasonable. return FilePath(kCurrentDirectoryString); #elif GTEST_OS_WINDOWS char cwd[GTEST_PATH_MAX_ + 1] = {'\0'}; return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? """" : cwd); #else char cwd[GTEST_PATH_MAX_ + 1] = {'\0'}; char* result = getcwd(cwd, sizeof(cwd)); #if GTEST_OS_NACL // getcwd will likely fail in NaCl due to the sandbox, so return something // reasonable. The user may have provided a shim implementation for getcwd, // however, so fallback only when failure is detected. return FilePath(result == nullptr ? kCurrentDirectoryString : cwd); #endif // GTEST_OS_NACL return FilePath(result == nullptr ? """" : cwd); #endif // GTEST_OS_WINDOWS_MOBILE }",1 (secure) "#pragma once #include #include #include #include #include #include namespace DB { template class DataTypeNumber; namespace ErrorCodes { extern const int DECIMAL_OVERFLOW; extern const int ARGUMENT_OUT_OF_BOUND; } namespace DecimalUtils { inline constexpr size_t min_precision = 1; template inline constexpr size_t max_precision = 0; template <> inline constexpr size_t max_precision = 9; template <> inline constexpr size_t max_precision = 18; template <> inline constexpr size_t max_precision = 18; template <> inline constexpr size_t max_precision = 38; template <> inline constexpr size_t max_precision = 76; template inline auto scaleMultiplier(UInt32 scale) { if constexpr (std::is_same_v || std::is_same_v) return common::exp10_i32(scale); else if constexpr (std::is_same_v || std::is_same_v || std::is_same_v) return common::exp10_i64(scale); else if constexpr (std::is_same_v || std::is_same_v) return common::exp10_i128(scale); else if constexpr (std::is_same_v || std::is_same_v) return common::exp10_i256(scale); } /** Components of DecimalX value: * whole - represents whole part of decimal, can be negative or positive. * fractional - for fractional part of decimal, always positive. */ template struct DecimalComponents { using T = typename DecimalType::NativeType; T whole; T fractional; }; /// Traits used for determining final Type/Precision/Scale for certain math operations on decimals. template struct DataTypeDecimalTrait { using FieldType = T; const UInt32 precision; const UInt32 scale; DataTypeDecimalTrait(UInt32 precision_, UInt32 scale_) : precision(precision_), scale(scale_) {} /// @returns multiplier for U to become T with correct scale template T scaleFactorFor(const DataTypeDecimalTrait & x, bool) const { if (scale < x.scale) throw Exception(""Decimal result's scale is less than argument's one"", ErrorCodes::ARGUMENT_OUT_OF_BOUND); const UInt32 scale_delta = scale - x.scale; /// scale_delta >= 0 return DecimalUtils::scaleMultiplier(scale_delta); } }; ",1 (secure) "#include #include #include namespace sf { namespace priv { //////////////////////////////////////////////////////////// SensorManager& SensorManager::getInstance() { static SensorManager instance; return instance; } //////////////////////////////////////////////////////////// bool SensorManager::isAvailable(Sensor::Type sensor) { return m_sensors[sensor].available; } //////////////////////////////////////////////////////////// void SensorManager::setEnabled(Sensor::Type sensor, bool enabled) { if (m_sensors[sensor].available) { m_sensors[sensor].enabled = enabled; m_sensors[sensor].sensor.setEnabled(enabled); } else { err() << ""Warning: trying to enable a sensor that is not available (call Sensor::isAvailable to check it)"" << std::endl; } } //////////////////////////////////////////////////////////// bool SensorManager::isEnabled(Sensor::Type sensor) const { return m_sensors[sensor].enabled; } //////////////////////////////////////////////////////////// Vector3f SensorManager::getValue(Sensor::Type sensor) const { return m_sensors[sensor].value; } //////////////////////////////////////////////////////////// void SensorManager::update() { for (Item& item : m_sensors) { // Only process available sensors if (item.available) item.value = item.sensor.update(); } } //////////////////////////////////////////////////////////// SensorManager::SensorManager() { // Global sensor initialization SensorImpl::initialize(); // Per sensor initialization for (int i = 0; i < Sensor::Count; ++i) { // Check which sensors are available m_sensors[i].available = SensorImpl::isAvailable(static_cast(i)); // Open the available sensors if (m_sensors[i].available) { if (m_sensors[i].sensor.open(static_cast(i))) { m_sensors[i].sensor.setEnabled(false); } else { m_sensors[i].available = false; err() << ""Warning: sensor "" << i << "" failed to open, will not be available"" << std::endl; } } } } //////////////////////////////////////////////////////////// SensorManager::~SensorManager() { // Per sensor cleanup for (Item& item : m_sensors) { if (item.available) item.sensor.close(); } // Global sensor cleanup SensorImpl::cleanup();",1 (secure) "#pragma once #include #include #include #include #ifdef _WIN32 #include #else #include #include #include #include #endif #include #include #include #include #define STD_PORT 9777 #define MS_ABSOLUTE 0x01 //#define MS_RELATIVE 0x02 #define BTN_USE_NAME 0x01 #define BTN_DOWN 0x02 #define BTN_UP 0x04 #define BTN_USE_AMOUNT 0x08 #define BTN_QUEUE 0x10 #define BTN_NO_REPEAT 0x20 #define BTN_VKEY 0x40 #define BTN_AXIS 0x80 #define PT_HELO 0x01 #define PT_BYE 0x02 #define PT_BUTTON 0x03 #define PT_MOUSE 0x04 #define PT_PING 0x05 #define PT_BROADCAST 0x06 #define PT_NOTIFICATION 0x07 #define PT_BLOB 0x08 #define PT_LOG 0x09 #define PT_ACTION 0x0A #define PT_DEBUG 0xFF #define ICON_NONE 0x00 #define ICON_JPEG 0x01 #define ICON_PNG 0x02 #define ICON_GIF 0x03 #define MAX_PACKET_SIZE 1024 #define HEADER_SIZE 32 #define MAX_PAYLOAD_SIZE (MAX_PACKET_SIZE - HEADER_SIZE) #define MAJOR_VERSION 2 #define MINOR_VERSION 0 #define LOGDEBUG 0 #define LOGINFO 1 #define LOGNOTICE 2 #define LOGWARNING 3 #define LOGERROR 4 #define LOGSEVERE 5 #define LOGFATAL 6 #define LOGNONE 7 #define ACTION_EXECBUILTIN 0x01 #define ACTION_BUTTON 0x02 class CAddress { private: struct sockaddr_in m_Addr; public: CAddress(int Port = STD_PORT) { m_Addr.sin_family = AF_INET; m_Addr.sin_port = htons(Port); m_Addr.sin_addr.s_addr = INADDR_ANY; memset(m_Addr.sin_zero, '\0', sizeof m_Addr.sin_zero); } CAddress(const char *Address, int Port = STD_PORT) { m_Addr.sin_port = htons(Port); struct hostent *h; if (Address == NULL || (h=gethostbyname(Address)) == NULL) { if (Address != NULL) printf(""Error: Get host by name\n""); m_Addr.sin_addr.s_addr = INADDR_ANY; m_Addr.sin_family = AF_INET; } else { m_Addr.sin_family = h->h_addrtype; m_Addr.sin_addr = *((struct in_addr *)h->h_addr); } memset(m_Addr.sin_zero, '\0', sizeof m_Addr.sin_zero); } void SetPort(int port) { m_Addr.sin_port = htons(port); } const sockaddr *GetAddress() { return ((struct sockaddr *)&m_Addr); } bool Bind(int Sockfd) { return (bind(Sockfd, (struct sockaddr *)&m_Addr, sizeof m_Addr) == 0); } }; class XBMCClientUtils { public: XBMCClientUtils() = default; ~XBMCClientUtils() = default; static unsigned int GetUniqueIdentifier() { static time_t id = time(NULL); return id; } static void Clean() { #ifdef _WIN32 WSACleanup(); #endif } static bool Initialize() { #ifdef _WIN32 WSADATA wsaData; if (WSAStartup(MAKEWORD(1, 1), &wsaData)) return false; #endif return true; } }; class CPacket",1 (secure) "#ifndef BOOST_BEAST_WEBSOCKET_OPTION_HPP #define BOOST_BEAST_WEBSOCKET_OPTION_HPP #include namespace boost { namespace beast { namespace websocket { /** permessage-deflate extension options. These settings control the permessage-deflate extension, which allows messages to be compressed. @note Objects of this type are used with @ref beast::websocket::stream::set_option. */ struct permessage_deflate { /// `true` to offer the extension in the server role bool server_enable = false; /// `true` to offer the extension in the client role bool client_enable = false; /** Maximum server window bits to offer @note Due to a bug in ZLib, this value must be greater than 8. */ int server_max_window_bits = 15; /** Maximum client window bits to offer @note Due to a bug in ZLib, this value must be greater than 8. */ int client_max_window_bits = 15; /// `true` if server_no_context_takeover desired bool server_no_context_takeover = false; /// `true` if client_no_context_takeover desired bool client_no_context_takeover = false; /// Deflate compression level 0..9 int compLevel = 8; /// Deflate memory level, 1..9 int memLevel = 4; /// The minimum size a message should have to be compressed std::size_t msg_size_threshold = 0; }; } // websocket } // beast } // boost #endif",1 (secure) "#include #include #include using namespace std; void build_code(int max_args) { stringstream ss; ss << ""#define NLOHMANN_JSON_EXPAND( x ) x"" << endl; ss << ""#define NLOHMANN_JSON_GET_MACRO(""; for (int i = 0 ; i < max_args ; i++) ss << ""_"" << i + 1 << "", ""; ss << ""NAME,...) NAME"" << endl; ss << ""#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \\"" << endl; for (int i = max_args ; i > 1 ; i--) ss << ""NLOHMANN_JSON_PASTE"" << i << "", \\"" << endl; ss << ""NLOHMANN_JSON_PASTE1)(__VA_ARGS__))"" << endl; ss << ""#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)"" << endl; for (int i = 3 ; i <= max_args ; i++) { ss << ""#define NLOHMANN_JSON_PASTE"" << i << ""(func, ""; for (int j = 1 ; j < i -1 ; j++) ss << ""v"" << j << "", ""; ss << ""v"" << i-1 << "") NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE"" << i-1 << ""(func, ""; for (int j = 2 ; j < i-1 ; j++) ss << ""v"" << j << "", ""; ss << ""v"" << i-1 << "")"" << endl; } cout << ss.str() << endl; } int main(int argc, char** argv) { int max_args = 64; build_code(max_args); return 0; }",1 (secure) "#ifndef RAPIDJSON_FILEWRITESTREAM_H_ #define RAPIDJSON_FILEWRITESTREAM_H_ #include ""stream.h"" #include #ifdef __clang__ RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_OFF(unreachable-code) #endif RAPIDJSON_NAMESPACE_BEGIN //! Wrapper of C file stream for output using fwrite(). /*! \note implements Stream concept */ class FileWriteStream { public: typedef char Ch; //!< Character type. Only support char. FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { RAPIDJSON_ASSERT(fp_ != 0); } void Put(char c) { if (current_ >= bufferEnd_) Flush(); *current_++ = c; } void PutN(char c, size_t n) { size_t avail = static_cast(bufferEnd_ - current_); while (n > avail) { std::memset(current_, c, avail); current_ += avail; Flush(); n -= avail; avail = static_cast(bufferEnd_ - current_); } if (n > 0) { std::memset(current_, c, n); current_ += n; } } void Flush() { if (current_ != buffer_) { size_t result = std::fwrite(buffer_, 1, static_cast(current_ - buffer_), fp_); if (result < static_cast(current_ - buffer_)) { // failure deliberately ignored at this time // added to avoid warn_unused_result build errors } current_ = buffer_; } } // Not implemented char Peek() const { RAPIDJSON_ASSERT(false); return 0; } char Take() { RAPIDJSON_ASSERT(false); return 0; } size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; } private: // Prohibit copy constructor & assignment operator. FileWriteStream(const FileWriteStream&); FileWriteStream& operator=(const FileWriteStream&); std::FILE* fp_; char *buffer_; char *bufferEnd_; char *current_; }; //! Implement specialized version of PutN() with memset() for better performance. template<> inline void PutN(FileWriteStream& stream, char c, size_t n) { stream.PutN(c, n); } RAPIDJSON_NAMESPACE_END #ifdef __clang__ RAPIDJSON_DIAG_POP #endif #endif // RAPIDJSON_FILESTREAM_H_",1 (secure) " #include #include #include #include #include //#define DEBUG_MULTIBOOT #ifdef DEBUG_MULTIBOOT #undef debug #define debug(X,...) kprintf(X,##__VA_ARGS__); #define MYINFO(X,...) kprintf("""" X ""\n"", ##__VA_ARGS__) #undef INFO2 #define INFO2(X,...) kprintf(""\t"" X ""\n"", ##__VA_ARGS__) #else #define debug(X,...) #define MYINFO(X,...) INFO(""Kernel"", X, ##__VA_ARGS__) #endif using namespace util::bitops; using namespace util::literals; extern uintptr_t _end; #if defined(ARCH_aarch64) uint32_t dummy[24]; uintptr_t __multiboot_addr=(uintptr_t)&dummy[0]; #else extern uint32_t __multiboot_addr; #endif static inline multiboot_info_t* bootinfo(uint32_t addr) { // NOTE: the address is 32-bit and not a pointer return (multiboot_info_t*) (uintptr_t) addr; } multiboot_info_t* kernel::bootinfo() { return (multiboot_info_t*) (uintptr_t) __multiboot_addr; } uintptr_t _multiboot_memory_end(uintptr_t boot_addr) { auto* info = bootinfo(boot_addr); if (info->flags & MULTIBOOT_INFO_MEMORY) { return 0x100000 + (info->mem_upper * 1024); } return os::Arch::max_canonical_addr; } // Deterimine the end of multiboot provided data // (e.g. multiboot's data area as offset to the _end symbol) uintptr_t _multiboot_free_begin(uintptr_t boot_addr) { const auto* info = bootinfo(boot_addr); uintptr_t multi_end = reinterpret_cast(&_end); debug(""* Multiboot begin: 0x%x \n"", info); if (info->flags & MULTIBOOT_INFO_CMDLINE and info->cmdline > multi_end) { debug(""* Multiboot cmdline @ 0x%x: %s \n"", info->cmdline, (char*)info->cmdline); // We can't use a cmdline that's either insde our ELF or pre-ELF area Expects(info->cmdline > multi_end or info->cmdline < 0x100000); if (info->cmdline > multi_end) { auto* cmdline_ptr = (const char*) (uintptr_t) info->cmdline; // Set free begin to after the cmdline string, // but only if the cmdline is placed after image end const uintptr_t cmdline_end = info->cmdline + strlen(cmdline_ptr) + 1; if (cmdline_end > multi_end) multi_end = cmdline_end; } } debug(""* Multiboot end: 0x%x \n"", multi_end); if (info->mods_count == 0) { return multi_end; } auto* mods_list = (multiboot_module_t*) (uintptr_t) info->mods_addr; debug(""* Module list @ %p \n"",mods_list); for (auto* mod = mods_list; mod < mods_list + info->mods_count; mod ++) { debug(""\t * Module @ %#x \n"", mod->mod_start); debug(""\t * Args: %s \n "", (char*) (uintptr_t) mod->cmdline); debug(""\t * End: %#x \n "", mod->mod_end); if (mod->mod_end > multi_end) multi_end = mod->mod_end; } debug(""* Multiboot end: 0x%x \n"", multi_end); return multi_end; } void kernel::multiboot_mmap(void* start, size_t size) { const gsl::span mmap { (multiboot_memory_map_t*) start, (int) (size / sizeof(multiboot_memory_map_t)) }; for (const auto& map : mmap) { const char* str_type = map.type & MULTIBOOT_MEMORY_AVAILABLE ? ""FREE"" : ""RESERVED""; const uintptr_t addr = map.addr; const uintptr_t size = map.len; INFO2("" 0x%010zx - 0x%010zx %s (%zu Kb.)"", map.addr, map.addr + map.len - 1, str_type, map.len / 1024 ); if ((map.type & MULTIBOOT_MEMORY_AVAILABLE) == 0) { if (util::bits::is_aligned<4_KiB>(map.addr)) { os::mem::map({addr, addr, os::mem::Access::read | os::mem::Access::write, size}, ""Reserved (Multiboot)""); continue; } // For non-aligned addresses, assign os::mem::vmmap().assign_range({map.addr, map.addr + map.len-1, ""Reserved (Multiboot)""}); } else { // Map as free memory } } }",1 (secure)